python基础之函数详解(一)

1.函数参数

1.1参数分类

• 必须参数
• 默认参数
• 关键字参数
• 可变参数

# 1.必需参数
# 注意1：形参和实参的数量，类型，顺序的匹配
def add(n1,n2):
    print("%d + %s = %d" % (n1,n2,n1 + n2))
add(2,3)
# add(2)        数量
# add(3,"ab")   类型
# add("afs",10)  顺序

# 2.默认参数
# 注意1：默认参数体现在形参部分
#[形参可以理解为等待传参的变量]
def test(name="aaa",age=0):
    print("姓名：%s,年龄：%d" % (name,age))
# 注意2：默认参数的作用就是为了简化函数的调用，最多体现在系统函数的使用中，print(sep,end)
test("zhangsan",10)
test()
test("hello")
#注意下面的写法调用
def test1(name,age=0):
    print("姓名：%s,年龄：%d" % (name,age))
test1("zzz")
test1("hhh",20)

# 注意3：在形参列表中，默认参数个数不限制，可以全部都是默认参数，也可以部分是默认参数，
# 但是，如果部分是默认参数，则默认参数需要出现在形参列表的最后【例如下面的test2(name,age=0,score=100)】
# def test2(name='aaa',age):  #SyntaxError: non-default argument follows default argument
#     print("姓名：%s,年龄：%d" % (name,age))
# test2(10)
def test2(name,age=0,score=100):
    print("姓名：%s,年龄：%d" % (name,age))

# print(int("110"))
# print(int("110",2))


# 3.关键字参数
# 注意1：关键字参数体现在实参部分
def test(name,age):
    print("姓名：%s,年龄：%d" % (name,age))
test("hahha",10)
# 注意2：变量名 = 值，此处的变量名不能随意定义，一定要和形参列表中的变量名完全一致
# 注意3：关键字参数的好处：可以不按照形参的顺序进行传参
test(age=10,name="hahhha")
test(name="hahhha",age=10)
# test(name1="hahhha",age=10)  # TypeError: test() got an unexpected keyword argument 'name1'

def test(name='aaa',age=0):
    print("姓名：%s,年龄：%d" % (name,age))
test()
test('www')
test('qqq',7)
test(age=8)
test(name='ttt')
test(name="uuu",age=38)
test('ggg',age=19)
# 注意4：在实参列表中，实参可以全部是关键字参数，也可以部分是关键字参数，
# 但是，如果部分是关键字参数，则关键字参数必须出现在实参列表的最后
# test(name='jjj',24)  # SyntaxError: positional argument follows keyword argument
#默认参数：形参，关键字参数：实参
# 4.不定长参数/可变参数
# 注意：调用函数的时候，遇到不定长参数，可以传参，也可以不传参，也可以传多个
# 4.1  *：元组
# 注意1:当形参列表中出现   *变量名  ，则该变量表示元组（那么下面的都讲num当作元组来处理就行）
def test(num):
    print(num)
test(10)#num类型就是保存的10的地址
def test(*num):
    print(num)
test(10)
test(4,65,6,56,5,5,7,5,7)#这里可以叫打包，讲一堆零散的数据给他全部放到一个容器里面了
test()

# 注意2：不定长参数可以和必需参数或者默认参数结合使用
def test(num1,num2,num3=10,*num4):#这里传参最起码要三个，给前三个传第就行
    print(num1,num2,num3,num4)
test(5,6,6)
test(6,7,8,45,6,5,76,7,6,8)#6 7 8（45,6,5,76,7,6,8）

# 注意3：在形参列表中，同种不定长参数只能出现一个
# def test(num1,num2,*num3,*num4):
#     print(num1,num2,num3,num4)
# test(6,7,8,45,6,5,76,7,6,8)#问题：6 7给了前两个，其余的给了第三个，与第四个冲突了到底该咋放，所以出问题了

# 【problem】阅读下面这段代码，输出结果
# 注意4：在形参列表中，不定长参数最好出现在最后（最好）
# 如果出现在形参列表的中间位置，则可以在实参列表中借助于关键字参数解除歧义
def test(num1,num2,*num3,num4):
    print(num1,num2,num3,num4)
#test(6,7,8,45,6,5,76,7,6)#num4没有值付给它，所以报错
test(6,7,8,45,6,5,76,7,6,num4=8)

# 结果 6 7 (8,45,6,5,76,7,6)
# 4.2  **：字典
def test(**num):
    print(num)
test()
# 注意1：**表示字典，所以实参需要通过键值对的方式传参
# test("fad",5,6,5,75)#报错，因为不是键值对
# 注意2：key=value,此处的key必须是一个标识符，在生成的字典中会被识别为字符串
test(name='fdf',age=18,score=100,a="aaa")#这种情况下字典中只能是字符串

# argument:参数 keywordargument:关键字参数
# 注意3：一般情况下，如果*和**结合使用，则建议形式为：*args,**kwargs
def test(num1,*num2,**num3):
    print(num1,num2,num3)
test(10,20,30)
test(10,20,30,x=40)#此处x是变长参数，能任意写值，若是关键字参数的话就不能任意写值了

1.2参数的传递

"""
【problem]，简述值传递和引用传递的区别
值传递：实参是不可变的数据类型,当形参发生改变，对实参没有影响
[相当于数据拷贝了一份，我现在不指向此数，指向了其他的数，但是
原来的数不变]
引用传递：实参的是可变的数据类型,当形参的内容发生改变，实参会
随着发生改变【就是看地址一样不，地址要是不一样，那传进去之后
不影响原来的，若是传进去地址一样，那么就会跟着修改的】
"""

# 1.不可变
def text(num):
    print("地址：",id(num))
    print("传递进来的num=:%d" % (num))
    num = 100
    print("修改之后的num=:%d" % (num))#这保存的是100的数据
    print("地址：", id(num))

temp = 23
text(temp)   # num = temp  --->num = 23
print("函数调用完成之后temp=%d" % (temp))
#传进来的num = 23
#修改之后的num=100
#地址：140723236364416
#函数调用完之后temp = 23


# 2，可变
def text(numlist):
    print("地址：", id(numlist))
    print("传递进来的num=:%s" % (numlist))
    numlist[1] = 100
    print("修改之后的num=:%s" % (numlist))#这的地址和上面的地址一样，篮子还是之前的篮子就只是给那里面的数据换了一下，这会出现问题：上一行代码修改了数据之后，因为下面调用时候temp保存的地址是和他同一个地址，所以会影响
    print("地址：", id(numlist))

temp = [11,22,33]
print("temp的地址：",id(temp))
text(temp)   # num = temp--->num = []
print("函数调用完成之后temp=%s" % (temp))

#temp的地址：2637259297480
#地址：     2637259297480
#传进来的num =:[11,22,33]
#修改之后的num = :[11,100,33]
#函数调用完成之后temp = [11,100,33]

2.打包和拆包

# pack:打包
# unpack:拆包

# a.定义多个变量
# 注意：=两边的变量和数据的数量必须保持一致
num1,num2 = 10,20
print(num1,num2)
num1,num1 = 23,4
print(num1)

# b.
num1 = 39
num2 = 10
num1,num2 = num2,num1
print(num1,num2)

# c.
# 在变量的前面添加*，则表示打包【封包】，得到的结果为列表，和函数形参列表中的*区别，函数形参的最后放这个，而且是元组
num1,num2,num3 = 4,5,6#左边，右边的数量要一致
print(num1,num2,num3)

num1,num2,*num3 = 4,5,6,6,7,8,10
print(num1,num2,num3)#
num1,*num2,num3 = 4,5,6,6,7,8,10
print(num1,num2,num3)
*num1,num2,num3 = 4,5,6,6,7,8,10
print(num1,num2,num3)

# 注意：在进行打包的时候，*只能出现一次
# num1,*num2,*num3 = 4,5,6,6,7,8,10
# print(num1,num2,num3)

# d.拆包（元组列表集合都可以进行拆包）
num1,num2 = (45,7)
print(num1,num2)
num1,num2 = [45,7]
print(num1,num2)
num1,num2 = {45,7}
print(num1,num2)

# 注意：=两边的变量和可迭代对象中元素的数量必须保持一致
# num1,num2 = (45,7,56,0)
# print(num1,num2)

3.函数返回值

• return关键字的使用

• 封装【设计】一个函数，考虑两点：

  1)是否设置参数，根据需求中是否有未知项参与运算

  2)是否设置返回值，根据需求运算完是否有结果

"""
返回值：函数运算完成之后的结果，本质是return的使用
注意：
    a.返回值可以选择性的省略
    b.谁调用，返回给谁；在哪里调用，返回到哪里
    c.如果函数由返回值，则函数调用完毕之后，可以使用变量获取
    结果
语法：变量 = 函数(实参列表)
"""
# 1.没有返回值
# 注意：如果函数没有返回值，则默认返回None
def func1():
    print("11111")
r1 = func1()#没有rutern的话，返回的是None所以：r1 = None
print(r1)

# def func1():
#     print("11111")
#     return None
# r1 = func1()
# print(r1)

# 2.没有返回值但是使用了return
# 注意：在函数体中出现了return，但是没有返回值，
# 此时return可以单独作为一条语句，表示结束函数,后面的语句【和return平级的】没有执行的机会

# 在平级的情况下，一般在return的后面不会书写更多的代码
def func2():
    print("2222")
    return   #表示结束函数，下面的语句就没有机会执行，所以编辑器会报警告
    # print("over")
r2 = func2()
print(r2)#默认None

def func2():
    print("2222")
    n = 0
    if n < 10:
        return    #缩进之后，下面的print("over")有执行的机会，所以，代码不会报警
    print("over")
func2()

print("*" * 30)

# 3.有返回值，但是只有一个
# 注意：return  xxx的作用有两个：一是结束函数，二是将函数的运算结果返回
def func3():
    print("3333")
    num = 100
    # 返回值存在的意义：如果函数运算的结果在函数的外面需要使用，则通过返回值返回
    # 因为函数内部的定义的变量只在函数内部有被访问的权限
    return  num
r3 = func3()
print(r3)

# 练习:求两个数的和并将结果返回
def add(x,y):
    # 局部变量
    total = x + y
    return total

r31 = add(4,6)
print(r31)
# 全局变量
# 注意：因为局部变量和全局变量的被访问的权限不同，所以二者可以重名
total = 100
print(total)

# 4.有返回值，而且返回多个
# 多个被返回的数据被进行了打包的处理，结果为一个元组
def func4(a,b,c,d):
    return a,b,c,d
r4 = func4(6,3,2,6)
print(r4)

# 5.一个函数中可以出现多个return，一般结合if语句
# 注意：在同一个函数中，如果有if分支，不同的分支可以返回不同的数据类型，不同的分支可以选择返回值的有无
def func5(num):
    if num > 0:
        return "正数"
    elif num < 0:
        return "负数"
    else:
        # return 0
        print(0)

r5 = func5(0)
print(r5)
#建议：要是有返回值就都写返回值，要是没有返回值的话就都没有返回值（自己添加）
# 6.return和break之间的区别
"""
break:结束当前循环
return：结束函数
"""
def func6():
    while True:
        data = input("请输入：")
        if data == "q":
            # break#这个也可以因为后面没有代码了，当循环在函数内部时候可以用return代替break
            return
func6()

# a
def func61():
    for i in range(3):
        for j in range(5):
            print("%d=%d" % (i,j))
            if j == 2:
                break
    print("Over~~~~~61")
func61()

def func62():
    for i in range(3):
        for j in range(5):
            print("%d=%d" % (i,j))
            if j == 2:
                return
    print("Over~~~~~62")
func62()#[为了告诉你：在某些情况中可以用return代替break]

4.空函数和主函数

# import  textdemo
from textdemo import  *

# 1.空函数
def test():
    pass

# 2.主函数：整个程序执行的入口
# def check():
#     print("check")

check()

def check():
    print("check")

print(__name__)

"""
a 一个py文件实际上就是一个模块
b 每个模块都自带了一个__name__属性，当运行的是当前文件，则__name__的值(默认)为__main__
  如果运行的是其他文件，当前文件被其他文件导入使用了，则__name__的值为文件名
c 当一个py文件被当做模块使用时，可以将测试的代码书写到if语句中，当其他文件导入该文件时，该部分代码会被屏蔽
"""
if __name__ == "__main__":
    print("text测试文件")
    check()
  

5.匿名函数

• 概念：不再使用def这种标准形式定义函数，而是使用lambda表达式来创建函数，该函数没有函数名，被称为匿名函数

• 语法：lambda 形参列表:函数体 返回值

• 说明：

  a）lambda只是一个表达式，用一行代码实现一个简单的逻辑，可以达到对函数的简化【优点】

  b）lambda主体是一个表达式，而不是一个代码块，只能封装有限的逻辑【缺点】

  c）lambda拥有自己的命名空间，不能访问自有列表之外或者全局命名空间里的参数

"""
【problem】什么是匿名函数，优缺点
    是一个lambda表达式，本质上还是一个函数，可以设置参数，也可以进行调用，
    表达式本身就是函数的运算结果
    
    优点：
        简化代码
        减少内存空间的使用
    缺点：
        只能实现简单的逻辑，逻辑一旦复杂，代码的可读性会降低，则不建议使用
"""

# 定义语法：变量名  = lambda 形参列表:函数体  返回值
# 调用语法：变量名(实参列表)

# 1.基本用法
def func1():
    print("111")
print(func1())

f1 = lambda :print("111")
print(f1())

# 2.需求：求两个数的和
def add(x,y):
    return x + y
print(add(3,5))
# 注意：匿名函数中的返回值直接书写，不需要借助于return
a1 = lambda x,y:x + y
print(a1(4,8))

# 3.默认参数和关键字参数，不定长参数
# 注意：匿名函数本质还是一个函数，所以除了函数声明部分和函数体做了简化 ，其他用法和普通函数完全相同
r3 =lambda a,b,c:a ** 2 + b ** 2 + c ** 2
print(r3(1,2,3))

r3 =lambda a,b=0,c=0:a ** 2 + b ** 2 + c ** 2
print(r3(1,2))#默认参数也可以从外面传参进行替换
print(r3(1))
print(r3(c=3,b=5,a=2))#关键字参数

r3 =lambda *a:a[0]#a是元组，返回的是元组的第0个元素，参数**a也可以用
print(r3(43,6,6,45,75))

# 4.匿名函数的函数体部分可以使用if语句
r4 = lambda m,n:m if m >= n else n#三元运算符（注释是自己添加）
print(r4(6,80))

# 5.应用：sort
"""
sort自定义排序的工作原理：将列表中的每个元素依次作用于指定的函数，然后用该函数的返回值进行比较然后排序
# 注意：函数的返回值必须支持>   <  运算
"""
list1 = ['534','gsgrsgsh','shhsh','2']
list1.sort(reverse=True,key=len)

# 练习：将列表按学生成绩从大到小排序
students = [
{'name': '小花', 'age': 19, 'score': 90, 'gender': '女', 'tel':
'15300022839'},
{'name': '明明', 'age': 20, 'score': 40, 'gender': '男', 'tel':
'15300022838'},
{'name': '华仔', 'age': 18, 'score': 90, 'gender': '女', 'tel':
'15300022839'},
{'name': '静静', 'age': 16, 'score': 90, 'gender': '不明', 'tel':
'15300022428'},
{'name': 'Tom', 'age': 17, 'score': 59, 'gender': '不明', 'tel':
'15300022839'},
{'name': 'Bob', 'age': 18, 'score': 90, 'gender': '男', 'tel':
'15300022839'}
]

# 法一
# for i in range(len(students) - 1):
#     for j in range(len(students) - 1 - i):
#         if students[j]['score'] < students[j + 1]['score']:
#             students[j], students[j + 1] =  students[j + 1],students[j]

#法二
# 自定义排序规则：成绩
# def标准形式的函数
def rule(x):
    return x['score']
students.sort(reverse=True,key=rule)
print(students)

# 法三
# 匿名函数
students.sort(reverse=True,key=lambda x:x["score"])


# 【problem】阅读下面的代码，写出执行结果[有点难度]
def func():
    a = []
    for i in range(5):
        a.append(lambda x:i * x)#加的是函数方面考虑，循环一次，加一次函数，然后给他添加到列表中，列表里面添加的不是函数的本身，而是函数的地址，这个是函数的定义，只有在下面传实参的时候才会调用匿名函数
    return a
result = func() # result = a
print(result)#
print(result[0])#将函数取出来相当于是函数的名
print(result[0](2))#将函数取出来之后再调用匿名函数（又因为此时调用时候，上面的含数都已经调用走完了，循环的之后的最后i是4，所以下面所有的调用i==4，所以结果都为8）
print(result[1](2))
print(result[2](2))
print(result[3](2))
print(result[4](2))
"""
>>> def func():
...     a = []
...     for i in range(5):
...         a.append(lambda x: i * x)
...     return a
...
>>> result = func()
>>> print(result)
[. at 0x0136F4F8>, . at 0x0136F540>, . at 0x0136F588>, . at 0x0136F5D0>, . at 0x0136F618>]
>>> print(result[0])
. at 0x0136F4F8>
>>> print(result[0](2))
8
>>> print(result[1](2))
8
>>> print(result[2](2))
8
>>> print(result[3](2))
8
>>> print(result[4](2))
8
"""

6.高阶函数
一个函数可以接受另一个函数作为参数，同样，还可以把一个函数作为另一个函数的返回值，这种函数的使用方式称为高阶函数

1.map()#[相当于列表推导式，通过一个容器生成另一个容器]

"""
map(fn,seq)，映射
    fn:函数，可以是def定义的标准函数，也可以是匿名函数
    seq:序列，
功能：将函数fn依次作用于序列seq中的每一个元素，根据函数的返回值生成一个新的序列
"""
# 1.需求：[1,4,9,16,25]
# 法一:列表推导式
list1 = [i ** 2 for i in range(1,6)]

# 法二：map和def
def test(x):
    return x ** 2
r1 = map(test,range(1,6))#[map是一种单独的数据类型，返回的值存储在同一个地址中][通过一个已知的容器，根据你给的规则，给他转化成（生成）一个新的序列，这个序列的规律就是def返回值的那块的表达式了]
print(list(r1))#将地址转化为熟悉的数据类型列表就可以看到里面的数据了

# 法三：map和lambda
r2 = map(lambda x:x ** 2,range(1,6))

# 2.需求：[1,2,3,4]---->['1','2','3','4']
numlist = [1,2,3,4]
list1 = [str(num) for num in numlist]
r3 = list(map(str,numlist))

# 3.seq序列可以书写多个
# 注意：函数的形参个数必须和序列的个数保持一致
r4 = map(lambda x,y:x + y,[1,2,3],[4,5,6])#[自己添加：将相同位置下标的数字相加]
print(list(r4))

# 根据list1,生成一个新的序列，其中的元素为全大写
list1 = ['faf',"Htuaf","HFFF","fahgh"]
list2 = [word.upper() for word in list1]
r5 = map(lambda x:x.upper(),list1)

7.大练兵

# 封装函数，完成下面的操作
# 1.判断年份的平润性
def isleapyear(year):
    if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
        return  True
    return False

# 2.统计2~某个数范围内素数的个数
# a。判断一个数是否是素数
def isprime(num):
    if num < 2:
        return False
    else:
        result = True
        for i in range(2,num):
            if num % i == 0:
                result = False
                break
        # result中保存了是否是素数的结果
        return result

# b.统计个数
def getcount(x):
    count = 0
    for n in range(2,x + 1):
        if isprime(n):
            count += 1
    return count
r = getcount(100)

# 3.自定义函数，模拟sort的用法，默认升序，也可以降序
# list1 = []
# list1.sort()
# list1.sort(reverse=True)

def custom_sort(numlist,reverse=False):
    if reverse:
        # 降序
        for i in range(len(numlist) - 1):
            for j in range(i + 1,len(numlist)):
                if numlist[i] < numlist[j]:
                    numlist[i],numlist[j] = numlist[j],numlist[i]
    else:
        # 升序
        for i in range(len(numlist) - 1):
            for j in range(i + 1,len(numlist)):
                if numlist[i] > numlist[j]:
                    numlist[i],numlist[j] = numlist[j],numlist[i]
list1 = [34,65,6,57,100]
custom_sort(list1)
custom_sort(list1,True)
custom_sort(list1,reverse=True)

# 简单的会员管理系统
"""
功能：
    增加会员
    删除会员
    查看会员信息
    退出系统
"""

# 定义一个字典，用于存储会员信息，会员名作为key，会员密码作为value
user_dict = {}

# 当管理员的用户名和密码都为root的时候，才能操作会员管理系统
admin = pwd = "root"

# 一、封装函数
# 增加会员
def add_user():
    username = input("请输入你的用户名：")
    if username not in user_dict:
        password = input("请输入你的密码：")
        user_dict[username] = password
        print("添加成功！")
    else:
        print("用户名已经存在，无法添加")

# 删除会员
def del_user():
    username = input("请输入需要删除的用户名：")
    if username in user_dict:
        user_dict.pop(username)
        print("删除成功！")
    else:
        print("用户名不存在，无法删除")

# 查看单个会员信息
def find_single_user():
    username = input("请输入需要查询的用户名：")
    print(f"会员{username}的信息如下：")
    for key,value in user_dict.items():
        if key == username:
            print(f"用户名：{key},密码：{value}")
            break
    else:
        print(f"被查询的{username}不存在")

# 查看所有会员信息
def find_all_user():
    if len(user_dict) == 0:
        print("该系统中还没有会员信息，请先添加")
    else:
        print("所有会员的信息如下：")
        for key, value in user_dict.items():
            print(f"用户名：{key},密码：{value}")

# 二、调用函数
if __name__ == "__main__":
    print("欢迎进入xxx会员管理系统".center(40, "="))

    # 引导输入管理员的用户名和密码
    admin_username = input("请输入管理员的用户名：")
    admin_pwd = input("请输入管理员的密码：")

    if admin_username == admin and admin_pwd == pwd:
        print("登录成功！")
        while True:
            print("操作菜单".center(30, "*"))
            print("""
            1.添加会员
            2.删除会员
            3.查询单个会员信息
            4.查询所有会员信息
            5.退出系统""")
            choice = input("请输入需要进行的操作：")
            if choice.isdigit():
                choice = int(choice)
                if choice in range(1, 6):
                    if choice == 1:
                        add_user()
                    elif choice == 2:
                        del_user()
                    elif choice == 3:
                        find_single_user()
                    elif choice == 4:
                        find_all_user()
                    else:
                        print("欢迎下次光临")
                        break
                else:
                    print("没有此功能")
            else:
                print("输入有误")
    else:
        print("管理员用户名或者密码错误")
```




==8.大练兵==

python
#温故知新
""""
已知字典 dic = {"k1": "v1", "k2": "v2", "k3": "v3"}，实现以
下功能

a.遍历字典 dic 中所有的key
b.遍历字典 dic 中所有的value
c.循环遍历字典 dic 中所有的key和value
d.添加一个键值对"k4","v4",输出添加后的字典 dic
e.删除字典 dic 中的键值对"k1","v1",并输出删除后的字典 dic
f.删除字典 dic 中 'k5' 对应的值，若不存在，使其不报错，
并返回None
g.获取字典 dic 中“k2”对应的值
h.已知字典dic2 = {'k1':"v111",'a':"b"} 编写程序，
使得dic2 = {'k1':"v111",'k2':"v2",'k3':"v3",'k4': 'v4','a':"b"}

"""
dic = {"k1": "v1", "k2": "v2", "k3": "v3"}

#a
for key in dic:
    print(key)

#b
for value in dic.values():
    print(value)

#c
for key,value in dic.items():
    print(key,value)

#d
dic["k4"] = "v4"
print(dic)

#e
dic.pop("k1")
print(dic)

#f
if dic.get("k5"):
    result = dic.pop("k5")
    print(result)
else:
    print(None)

#g
value = dic["k2"]

#h
dic2 = {'k1':"v111",'a':"b"}
for key,value in dic2.items():
    dic[key] = value

print(dic)

"""
.已知列表list1 = [11,22,11,33,44,55,66,55,66],统计列表中每个元素出现的次数，生成一个字典，结果为{11:2,22:1.....}
"""
list1 = [11,22,11,33,44,55,66,55,66]
dict1 = {}
for num in list1:
  if num not in dict1:
    dict1[num] = 1
  else:
    dict1[num] += 1
```


"""
.已知如下列表students，在列表中保存了6个学生的信息，
根据要求完成下面的题目

打印手机尾号是8的学生的名字
删除性别不明的所有学生
"""
students = [
{'name': '小花', 'age': 19, 'score': 90, 'gender': '女', 'tel':
'15300022839'},
{'name': '明明', 'age': 20, 'score': 40, 'gender': '男', 'tel':
'15300022838'},
{'name': '华仔', 'age': 18, 'score': 90, 'gender': '女', 'tel':
'15300022839'},
{'name': '静静', 'age': 16, 'score': 90, 'gender': '不明', 'tel':
'15300022428'},
{'name': 'Tom', 'age': 17, 'score': 59, 'gender': '不明', 'tel':
'15300022839'},
{'name': 'Bob', 'age': 18, 'score': 90, 'gender': '男', 'tel':
'15300022839'}
]

#打印手机尾号是8的学生的名字
for stu_dict in students:
    if stu_dict["tel"][-1] == "8":
        print(stu_dict["name"])

#删除性别不明的所有学生
# 法一
for stu_dict in students[::]:
    if stu_dict["gender"] == "不明":
        students.remove(stu_dict)
print(students)

# 法二
new_students = []
for stu_dict in students:
    if stu_dict["gender"] != "不明":
        new_students.append(stu_dict)
print(new_students)


"""
.写一个学生作业情况录入并查询的小程序
"""
a.录入学生作业情况：字典添加
b.查看学生作业情况：字典查询
c.录入时允许输入3次，3次输入不正确提示失败次数过多，禁止继续录入

homeworks = {
        'Amy':{'2018.3.22':'未交','2018.3.23':'已交'},
        'Lily':{'2018.3.22':'未交','2018.3.23':'未交'},
        }
chioce = {'1':'查询','2':'录入'} #定义字典，可以避免输入‘0’或‘1’以外的选择时报错
#user_chioce input是字符串，如果用int转化非数字的字符串会报错，所以将key定义为字符串‘1’，而非数字1
user_chioce = input('请输入您的选择：1为查询学生作业情况，2为录入学生作业情况').strip()
if chioce.get(user_chioce) == '查询': #用get方法，输入key不在字典中不会报错。用chioce[user_choice]，输入key不在字典中会报错
    name = input('请输入要查询的学生姓名').strip()
    if name == '':
        print('查询学生姓名不能为空')
    elif name in homeworks: #判断key是否在字典中存在
        print('%s的作业情况是%s'%(name,homeworks[name]))#字典查询
    else:
        print('查询学生不存在')
elif chioce.get(user_chioce) == '录入':
    state = {'0':'未交','1':'已交'} #定义字典，可以避免输入‘0’或‘1’以外的选择时报错
    #放在循坏外，避免多次初始化，优化性能
    for i in range(3):
        enter_name = input('请输入要录入的学生姓名').strip()
        enter_date = input('请输入要录入学生作业的日期').strip()
        enter_state = input('请输入学生作业状态：0为未交，1为已交').strip()
        if state.get(enter_state):  #只要有状态就可以，不需要判断状态等于‘已交’或‘未交’
            if enter_name == '' or enter_date == '':
                print('学生姓名及作业日期不能为空')
            else:
                if enter_name in homeworks:
                    homeworks[enter_name].update({enter_date:state[enter_state]})#学生已存在，更新子字典
                else:
                    homeworks[enter_name] = {enter_date:state[enter_state]}#学生不存在，直接添加新k-v
                print('%s的作业情况是%s'%(enter_name,homeworks[enter_name]))
                print('所有学生作业情况为%s' % homeworks)
                break
        else:
            print('输入学生状态有误')
else:
    print('选择输入有误')


"""
用三个元组表示三门学科的选课学生姓名(一个学生可以同时选多门课)
a.求选课学生总共有多少人
b.求只选了第一个学科的人的数量和对应的名字
c.求只选了一门学科的学生的数量和对应的名字
d.求只选了两门学科的学生的数量和对应的名字
"""
#用三个元组表示三门学科的选课学生姓名(一个学生可以同时选多门课)
subject1 = ('stu1','stu2','stu4','stu5','stu7','stu9')
subject2 = ('stu1','stu3','stu4','stu6','stu8','stu9')
subject3 = ('stu3','stu2','stu6','stu8','stu9')

# a.求选课学生总共有多少人
s1 = set(subject3 + subject2 + subject1)
print("选课学生总共有%d人" % (len(s1)))

# b.求只选了第一个学科的人的数量和对应的名字
s2 = set(subject1) - set(subject2) - set(subject3)
print("只选了第一个学科的人的数量:%d,对应的名字：%s" % (len(s2),s2))

# c.求只选了一门学科的学生的数量和对应的名字
subject = subject3 + subject2 + subject1
# 存储学生的名字和出现的次数
dict1 = {}
for sub in subject:
    if sub not in dict1:
        dict1[sub] = 1
    else:
        dict1[sub] += 1
print(dict1)

# 存储只选了一门学科的学生的名字
one_list = []
for key,value in dict1.items():
    if value == 1:
        one_list.append(key)
print(one_list)

print("选了一门学科的学生的数量:%d,名字：%s" % (len(one_list),one_list))

# d.求只选了两门学科的学生的数量和对应的名字
subject = subject3 + subject2 + subject1
# 存储学生的名字和出现的次数
dict1 = {}
for sub in subject:
    if sub not in dict1:
        dict1[sub] = 1
    else:
        dict1[sub] += 1
print(dict1)

two_list = []
for key,value in dict1.items():
    if value == 2:
        two_list.append(key)
print(two_list)



"""
已知字符串：“this is a test of Python”

a.统计该字符串中字母s出现的次数
b.取出子字符串“test”
c.采用不同的方式将字符串倒序输出
d.将其中的"test"替换为"exam"
"""

str1 = "this is a test of Python"

#a.
#方式一
count1 = 0
for ch in str1:
    if ch == "s":
        count1 += 1
print(count1)

#方式二
count2 = str1.count("s")
print(count2)

#b
str2 = str1[10:14]
print(str2)

#c
#方式一
s1 = str1[::-1]
print(s1)

#方式二
s2 = ""
i = len(str1) - 1    #倒序遍历
while i >= 0:
    s2 += str1[i]   #拼接字符串
    i -= 1
print(s2)

#方式三
list1 = list(str1)
list1.reverse()

#d.将其中的"test"替换为"exam"        
#注意：但凡涉及字符串的更改，都是生成了一个新的字符串
str1 = "this is a test of Python"
str1.replace("test","exam")
print(str1)

"""
输入一个字符串，判断字符串中有多少个字母？多少个数字？多少个其他符号？ 	

例如:'hello, nice to meet you. i am 18. my birthday is 1999-05-23'
  -- 结果: 字母的个数为33个，数字个数为10个， 其他字符为16个
"""

input_str = input("请输入：")
letter_count = 0
digit_count = 0 
other_count = 0

for ch in input_str:
    if ch.isalpha():  #有缺陷，最好还是需要通过(ch >= "a" and ch <= "z") or (ch >= "A" and ch <= "Z")判断
        letter_count += 1
    elif ch.isdigit():
        digit_count += 1
    else:
        other_count += 1


########正式开练############################################
"""
去除指定列表中与指定数据一样的所有元素，
例如: [19, 27, 32, 19, 28, 45, 19] 除去19  
 ----> [27, 32, 28, 45]
"""
#法一
def delete(num,list1):
    for i in list1:
        if i == num :
            list1.remove(num)
    return list1
list1 = [11,22,33,55,22,77,11]
print(delete(11,list1))

#法二
def del_element(list1,key):
  for ele in list1[::]:
    if ele == key:
      list1.remove(ele)
  return list1

"""
将指定字典中的键值交换，例如: {"a":97, "b":98} 
----> {97:"a", 98:"b"}
"""
#法一
def change(dict1):
    dict2 = {}
    for key,value in dict1.items():
        dict2[value] = key
    return dict2
dict1 = {'qef':1,'efq':2}
print(change(dict1))

#法二
def exchange(dict1):
    dict2 = {value:key for key,value in dict1.items()}
    return dict2



"""
求多个数中的最大值，要求：不能使用max系统函数，
例如：17， 28， 32， 45， 67， 57 -----> 67
"""
#法一
def newmax(*num1):
    max_num = 0
    for i in num1:
        if i >= max_num :
            max_num = i
    return max_num
#法二
def get_max(*num):
    max_value = num[0]
    for n in num:
        if n > max_value:
            max_value = n
    return max_value


"""
.写一个函数，默认求10的阶乘，也可以求其他数字的阶乘 
"""


# 法一
def factorial(num=10):
    total = 0
    for i in range(1,num + 1):
        total *= i
    return total
  
# 法二
import  functools
def factorial(num=10):
    result = functools.reduce(lambda x,y:x * y,range(1,num + 1))
    return result

"""
判断某个数是否是素数，返回结果
"""
#法一
def isprime(num):
    for i in range(2,num):
        if num % i == 0:
            result = f'{num}不是素数'
            break
    else:
        result = f'{num}是素数'
    return result
print(isprime(111))

#法二
def isprime(num):
    if num < 2:
        return False
    else:
        result = True
        for i in range(2,num):
            if num % i == 0:
                result = False
                break
        return result

"""
写一个函数，将指定字符串的首字母变成大写 
要求：不能使用字符串自带的方法capitalize，
例如： abc ---> Abc     123abc ---> 123abc
"""
#法一
def upfirst(str1=''):
    str1 = input("请输入字符串")
    str2 = ''
    if 97 <= ord(str1[0]) <= 122:
        i = chr(ord(str1[0])-32)
        str2 = i + str1[1:]
    return str2
print(upfirst())
#法二
def cus_capitalize(src_str):
    capital_str = ""
    if 'a' <= src_str[0] <= 'z': 
        capital_str += chr(ord(src_str[0]) - 32) + src_str[1:]
    else:
        capital_str = src_str
    return capital_str


"""
写一个函数，判断一个字符串是否已指定的字符串结束  
不能使用字符串自带的方法endswith，
例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True
"""
#法一
def isends(str1='',str2=''):
    str1 = input("第一个字符串")
    str2 = input("第二个字符串")
    if str1[len(str1)-len(str2):] == str2:
        result = True
    else:
        result = False
    return result
print(isends())


#法二
def cus_ends(src_str, sub_str):
    return src_str[-len(sub_str):] == sub_str


"""
.封装一个函数，验证传入的正整数是几位数 ，
例如：1 ---> 1          18 -----> 2       139 -----> 3
"""

#法一
def long(nums):
    count = 0
    for _ in str(nums):
        count += 1
    return count
print(long(34))

#法二
def get_digit(num):
    digit = 1 
    while num // 10 != 0:
        digit += 1
        num //= 10
    return digit

"""
写一个函数，获取在指定列表中与指定数据相同的所有索引，
例如：[27, 32, 51, 28, 27]  27 ------> [0,4]
"""

‘def get_index(src_list, ele):
    index_list = [] 
    for i in range(len(src_list)):
        if src_list[i] == ele: 
            index_list.append(i)
    return index_list 



#####################训练加强
"""
生成指定长度的验证码，要求：由数字和大小写英文字母构成的
随机字符串
"""
#法一
import  random
def rancode(lenth):
    import random,string
    total_str = string.digits + string.ascii_letters
    code_list = random.sample(total_str,lenth)
    code = ''.join(code_list)
    return code
print(rancode(7))

#法二
import  random
def get_code(num):
    total_list = []
    for i in range(65,91):
        total_list.append(chr(i))
    for j in range(97,123):
        total_list.append(chr(j))
    for k in range(10):
        total_list.append(str(k))
    # sample(),在指定的序列中，随机选择指定个数的元素
    code_list = random.sample(total_list,num)
    code = "".join(code_list)
    return code

"""
对字符串进行加密，默认字符串中只有小写字母和空格，
加密规则是a变d, b变e, c变f, ...., u变x, v变y, w变z,  x变a,
 y变b,  z变c，空格保持不变，例如: ab d ---> de g  
"""
#法一
def secret(str1 = 'abc y'):
    str2 = ''
    for i in str1:
        if 97 <= ord(i) <= 122:
            if ord(i)+3 > 122 :
                newi = chr(ord(i)-23)
                str2 += newi
            elif ord(i)+3 <= 122:
                newi = chr(ord(i) + 3)
                str2 += newi
        else:
            str2 += i
    return str2
print(secret())

#法二
def encryption(code):
    #声明一个字符串用于接收加密之后的结果
    result = ""
    #遍历code,加密前 和 加密后  3
    #chr()   ord()
    for ch in code:
        value = ord(ch)

        if 97 <= value <= 119:
            result += chr(value + 3)
        elif 120 <= value <= 122:
            result += chr(value - 23)
        else:
            result += chr(value)

    return result

print(encryption("45fhgs*"))

"""
.定义函数实现如下要求，例如：输入2，5，
则求2+22+222+2222+22222的和
"""

# 方式一
def get_num(num1,num2):
    sum1 = 0
    sum0 = 0
    for i in range(0,num2):
        sum1 = sum1 * 10 + num1
        sum0 += sum1
        if i == num2 - 1:
            continue
    return sum0

print(get_num(2,5))

# 方式二
def func_sum(x, y):
    c = str(x)
    s = 0
    list_num = []
    # 遍历y项 x，并且把它添加到列表中存储起来
    for i in range(1, y + 1):
        c *= i
        list_num.append(c)
        # 这里需要把c重新复原,否则会有很多c拼接起来
        c = str(x)
    print(list_num)
    for a in list_num:
        # 把提取出来的字符转转换为int型
        b = int(a)
        s += b
    return s

# 调用函数
func_sum(2, 5)