day11函数进阶

1.函数的参数

1.位置参数和关键参数

"""
根据调用函数的时候实参的传递方式不同，可以将实参分为位置参数和关键字参数两种：
1）位置参数：直接多个数据用逗号隔开，让实参和形参从位置上一一对应。

2）关键字参数：以'形参名1=数据1, 形参名2=数据2, ....'的形式存在，直接让形参名和数据对应。

3）位置参数和关键字参数混用：位置参数必须在关键字参数前面。
"""


def func1(x, y, z):
    print(f'x:{x}, y:{y}, z:{z}')


# 位置参数
func1(10, 20, 30)   # x:10, y:20, z:30
func1(20, 10, 30)   # x:20, y:10, z:30

# 关键字参数
func1(x=10, y=20, z=30)  # x:10, y:20, z:30
func1(y=20, x=10, z=30)  # x:10, y:20, z:30

# 混用
func1(10, y=20, z=30)   # x:10, y:20, z:30
func1(10, z=30, y=20)   # x:10, y:20, z:30
func1(10, 20, z=30)     # x:10, y:20, z:30
# func1(10, y=20, 30)     # 报错

2.参数默认值

"""
定义函数的时候，可以以'形参名=数据'的方式给参数赋默认值；有默认值的参数在调用的时候可以不用传参。
定义函数的时候可以有的参数有默认值有的参数没有默认值，但是没有默认值的参数必须在有默认值参数的前面。
"""


def func2(x=10, y=20, z=30):
    print(f'x:{x}, y:{y}, z:{z}')


func2()               # x:10, y:20, z:30
func2(100)            # x:100, y:20, z:30
func2(100, 200)       # x:100, y:200, z:30
func2(100, 200, 300)  # x:100, y:200, z:300
func2(z=300)          # x:10, y:20, z:300


def func3(x, y=10, z=20):
    print(f'x:{x}, y:{y}, z:{z}')


func3(100)         # x:100, y:10, z:20

3.参数类型说明

"""
定义函数的时候如果对参数进行类型说明，可以让函数体在使用参数的时候有对应类型的代码提示。
类型说明的方式有两种：
1）没有默认值的参数的类型说明：形参名：类型名
2）给参数赋默认值，默认值的类型就是对应形参的类型

"""


def func4(x: str, y='abc') -> int:   # -> int 返回值类型说明
    x.split('a')
    y.join('d')
    print(type(x), type(y))


func4('jds')   # <class 'str'> <class 'str'>

4.不定长参数

"""
1)带*的不定长参数
在形参前面加*就可以让这个形参变成一个不定长参数，可以同时就收多个实参;
带*的不定长参数会变成一个元组，接受到的实参会变成元组中的元素。

注意：a.带*的不定长参数只能用位置参数传参
      b.同一个函数中既有定长参数也有带*号的不定长参数，那么*前面的定长参数必须用位置参数传参，带*后面的定长参数必须用关键字参数传参

2)带**的不定长参数
"""


def func5(*x):
    print(x)


func5()         # ()
func5(10)       # (10,)  # 元组：只有一个数据的时候，后面必须加逗号
func5(10, 20)   # (10, 20)

# 补充：只有一个元素的元组，唯一的元素后面必须加逗号
t2 = (10,)
print(t2, type(t2))    # (10,) <class 'tuple'>
t1 = (10)
print(t1, type(t1))    # 10 <class 'int'>

# 案例：定义一个函数求多个数的和。
def sum1(*nums):
    s = 0
    for x in nums:
        s += x
    print(s)


sum1(10, 20)           # 30
sum1(10, 20, 30)       # 30
sum1(10, 20, 30, 40)   # 100


# 注意：带*的前面用位置参数，y也要用位置参数，带*后面的用关键字参数
def func6(x, *y, z):
    print(x, y, z)


func6(100, 10, 20, 30, z=300)   # 100 (10, 20, 30) 300


# 参数中独立存在的*的作用：让*前面的参数用位置参数传参，*后面的参数用关键字参数传参
def func7(x, *, y):   # * 约束x用位置参数，y用关键字参数
    print(x, y)



"""
2)带**的不定长参数(了解)
定义函数的时候在某个参数前面加**，让这个参数变成不定长参数，可以同时接受多个关键字参数对应的实参。
"""


def func8(**x):
    print(x)


func8()             # {}
func8(a=10)         # {'a': 10}
func8(a=10, b=20)   # {'a': 10, 'b': 20}


# 定义函数获取学生信息
def get_student_info(name, age, **scores):
    print(name, age, scores)


get_student_info('小明', 18, english=88, math=90, c=68)   # 小明 18 {'english': 88, 'math': 90, 'c': 68}
get_student_info('小兰', 19, python=86)                   # 小兰 19 {'python': 86}


# 问题：函数参数中的'*args,**kwargs'是什么意思？
# 答案：让这个函数调用的时候既可以传多个位置参数，又可以传多个关键字参照，还可以位置参数和关键字参数一起使用
def func9(*args, **kwargs):
    pass


func9()
func9(10, 20, 30)
func9(a=1, b=3, c=5)
func9(10, 20, 30, a=10, b=20)

2.函数的返回值

1.什么是返回值

返回值就是从函数内部传递到函数外部的数据。python中的函数有且只有一个返回值，默认情况下函数的返回值是None。

2.怎么确定函数返回值

"""
语法：return 返回值
执行函数体的时候，如果遇到了return，return后面的值就是函数的返回值

初学者添加函数返回值的原则：看实现函数的功能有没有产生新的数据，如果有就将产生的新数据作为函数的返回值返回。
"""


# 案例：定义函数求两个数的和
def sum2(num1, num2):
    # num1=10, num2=20
    return num1 + num2  # return = 30


# 案例：定义函数提取字符串中所有的字母
def get_letter(str1: str):
    new_str = ''
    for x in str1:
        if x.islower() or x.isupper():
            new_str += x
    return new_str


result = get_letter('as加逗号dahjdk')
print(result, len(result), '+'.join(result))   # asdahjdk 8 a+s+d+a+h+j+d+k

for x in get_letter('澳抗江口街道ishsdkjsa'):
    print(x)

# 案例：定义函数删除数字列表中所有小于0的数
def del_minus(nums: list):
    # 方法1：
    # return [x for x in nums if x >= 0]

    # 方法2:
    for x in nums.copy():
        if x < 0:
            nums.remove(x)

3.怎么获取函数返回值

"""
函数调用表达式的值就是函数的返回值(返回值能做的事情，函数调用表达式都可以做)
如果需要在函数外部使用函数的返回值，直接获取函数调用表达式的值。

函数调用表达式 - 调用函数的语句

补充：函数调用过程
第一步：回到函数定义的位置
第二步：传参(用实参给形参赋值)
第三步：执行函数体
第四步：执行完函数体，确定函数的返回值(如果遇到return，return后面的值就是函数的返回值，否则返回值是None)
第五步：回到函数调用的位置(这个时候函数调用表达式的结果就是函数的返回值)
"""
print('xxx:', sum2(10, 20))   # xxx: 30

x = sum2(100, 200)
print(x)        # 300

list1 = [10, 20, sum2(5, 3)]
print(list1)     # [10, 20, 8]

list2 = [10, -20, 28, -2, -8]
del_minus(list2)
print(list2)

list2 = [10, -20, 28, -2, -8]
result = sorted(list2)   # 有返回值
print(result)            # [-20, -8, -2, 10, 28]

list2 = [10, -20, 28, -2, -8]
result = list2.sort()        # 没有返回值
print(list2, result)         # [-20, -8, -2, 10, 28] None

4. return的作用

# 1)返回数据(将数据作为函数返回值返回)
# 2)提前结束函数(执行函数体的时候，什么时候遇到return，函数什么时候结束)
def func1():
    for x in range(5):
        print('====')
        print('+++')
        return
        print('---')


func1()

3.匿名函数

# 1.匿名函数
"""
语法：
函数名 = lambda 形参列表:返回值

相当于：
def 函数名(形参列表):
    return 返回值
    
注意：a.匿名函数的调用和普通函数没有区别
     b.匿名函数至少需要一个形参
"""

# 案例：写一个匿名函数求两个数的和
sum2 = lambda num1, num2: num1+num2

print(sum2(10, 20))
print(sum2(num1=100, num2=200))


# 练习：定义一个匿名函数，判断指定的年是否是闰年
is_leap_year = lambda year: (year % 4 == 0 and year % 100 != 0) or year % 400 == 0

print('是否是闰年：', is_leap_year(2000))

def a(year):
    t = (year % 4 == 0 and year % 100 != 0) or year % 400 == 0
    return t

print(a(2000))

4.实参高阶函数

1.什么是实参高阶函数

如果一个函数有一个参数也是函数，那么这个函数就是实参高阶函数

"""
调用实参高阶函数，给函数类型的参数传参的时候两个选择：
a.传普通函数函数名
b.传一个匿名函数
"""


def func1(x):   # func1是实参高阶函数
    # x=t
    # print(x())  # 调用函数 print(t())  -> print(None)
    print(x(10, 20) + 10)  # t(10, 20)


def t(x, y):
    return 100


func1(t)
func1(lambda a, b: 12)

2. Python中常用的实参高阶函数

# 1)max、min、sorted
"""
a.max(序列)            -  直接比较序列中元素的大小，求最大值

b.max(序列, key=函数)   -  按照函数制定的比较规则比较序列中元素的大小，求最大值
函数要求：a.有且只有一个参数(这个参数代表序列中的元素)
         b.有一个返回值(返回值就是比较对象)
"""

# 案例1：求nums中个位数最大的元素
nums = [90, 19, 23, 48, 36]
result = max(nums,key=lambda item: item % 10)
print(result)  # 19


# 案例2：求nums中数值最大的元素
nums = ['19', '90', '99', '78', '132']
result = max(nums, key=lambda x: int(x))
print(result)   # '132'

# 练习1：求nums中十位数最大的元素
nums = [89, 102, 543, 92, 8]
result = max(nums, key=lambda x: x % 100 // 10)
print(result)   # 92

# 练习2：求students中分数最低的学生信息
students = [
    {'name': '小明', 'age': 30, 'score': 87},
    {'name': '张三', 'age': 19, 'score': 67},
    {'name': '小花', 'age': 22, 'score': 90},
    {'name': '李四', 'age': 25, 'score': 83}
]
result = min(students, key=lambda x: x['score'])
print(result)

# 练习3：将students中字典按照年龄值从小到大排序
result = sorted(students, key=lambda y: y['age'])
print(result)

students.sort(key=lambda item:item['age'])
print(students)

# 案例：求nums中各个位数之和最大的元素
nums = [102, 89, 341, 90, 77]


def t(item):
    s = 0
    for x in str(item):
        s += int(x)
    return s


result = max(nums, key=t)
print(result)    # 89


# 2)map
"""
map(函数, 序列)  -  基于序列中的元素按照函数制定的规则创建一个新的序列
函数的要求：a.有且只有一个参数(参数代表序列中的元素)
           b.有一个返回值(返回值就是新序列中的元素)

map(函数, 序列1, 序列2)  -  
函数的要求：a.有且只有两个参数(参数代表两个序列中的元素)
           b.有一个返回值(返回值就是新序列中的元素)


map(函数, 序列1, 序列2, 序列3,....) - 
"""
# 案例1:将nums中所有的元素都乘以2，创建一个新的序列
nums = [10, 23, 4, 8, 11]
result = list(map(lambda item: item*2, nums))
print(result)   # [20, 46, 8, 16, 22]

# 案例2：已知两个列表分别保存的是学生的语文成绩和数学成绩，创建一个列表保存每个学生的总成绩
chinese = [89, 78, 90, 56, 70]
math1 = [99, 82, 56, 77, 69]
result = list(map(lambda x, y: x + y, chinese, math1))
print(result)  # [188, 160, 146, 133, 139]


# 3)reduce
"""
reduce(函数, 序列, 初始值) - 将序列中的元素按照函数制定规则合并成一个数据
a.初始值  -  累计求和初始值为0，累计求乘积初始值为1，字符串拼接初始值为空串
b.函数的要求：有且只有两个参数(第一个参数代表初始值；第二个参数代表序列中的每个元素)
            有一个返回值(代表合并方式)


"""
# 注意：reduce使用之前需要先导入
from functools import reduce

# 案例1：求nums中所有元素的和
nums = [20, 46, 8, 16, 22]
result = reduce(lambda i1, i2: i1 + i2, nums, 0)
print(result)  # 112

# 案例2：求nums中元素中的乘积
nums = [20, 46, 8, 16, 22]
result = reduce(lambda i1, i2: i1 * i2, nums, 1)
print(result)   # 2590720

# 案例3：将nums中所有元素的个位数拼接成一个数字字符串
nums = [20, 46, 8, 16, 22]
result = reduce(lambda i1, i2: i1 + str(i2 % 10), nums, '')
# result = reduce(lambda i1, i2: i1 + str(i2)[-1], nums, '')
print(result)

# 练习：求nums中所有个位数的和
nums = [20, 46, 8, 16, 22]
result = reduce(lambda i1, i2: i1 + i2 % 10, nums, 0)
print(result)