函数参数类型和返回值、嵌套、内置函数

函数参数类型

参数类型分为：
可变数据类型：例如 list dict
不可变数据类型：例如 int、str、float

可变数据类型

a = [1, 2, 3]


def func(b):
    print(b)  # [1, 2, 3]
    b.append(4)
    print(b)  # [1,2,3,4]


func(a)
print(a)  # [1,2,3,4]

不可变数据类型

c = 1000


def num_c(d):
    print(d)  # 1000
    d = 200
    print(d)  # 200


num_c(c)
print(c)  # 1000

参数的返回值

格式

def 函数名(参数1，参数2)：
…函数体…
return 值1,值2,…
注意：
1.如果函数不写返回值，默认返回None
2.return 关键字有两个作用，一个作用是返回内容，另一个作用是结束此方法。
3.return 关键字后面不允许在写代码。

# 一、return返回内容
def sum_num(aa, bb):
    num3 = aa + bb
    return num3


ret = sum_num(10, 2)  # 将num返回给ret
print(ret)


# 二、return结束此方法
def func(c):
    print('func....')
    a = 10
    b = c
    if b < a:
        return
    print('xxx')


func(11)

函数的嵌套

函数的嵌套如普通函数一样就是在内部调用其他函数

def line1(row, char, num):
    temp = 1
    while temp <= row:
        line(char, num)
        temp += 1


line1(5, '-', 20)

内置函数

abs()：求函数绝对值

max():求最大值（第一个参数是可迭代内容）

map():求每个元素的平方值。。。有两个参数第一个参数是函数，第二个参数是可迭代内容
函数会依次作用在可迭代内容的每一个元素上进行计算，然后返回一个新的可迭代内容。

filter() 函数:用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进判，
然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

zip()函数:zip函数接受任意多个可迭代对象作为参数,将对象中对应的元素打包成一个tuple,
然后返回一个可迭代的zip对象.这个可迭代对象可以使用循环的方式列出其元素
若多个可迭代对象的长度不一致,则所返回的列表与长度最短的可迭代对象相同

# abs()
a = (-4)
ret = abs(a)
print(ret)

# max()
lst = [-5, 1, 2, 4]
ret = max(lst, key=abs)  # 使用key关键字指定比较规则
print(ret)

lst = [
    {'name': 'egon', 'price': 100},
    {'name': 'rdw', 'price': 666},
    {'name': 'zat', 'price': 1}
]


def max_price(dic):
    return dic['price']  # 返回字典price对应的值


print(max(lst, key=max_price))  # 指定比较内容

#  map()求每个元素的平方值。。。
lst1 = [1, 3, 5]


def ping_fang(num):
    return num * num


ret = map(ping_fang, lst1)
for i in ret:
    print(i)

# filter()接受一个新的列表
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


def new_lst(num):
    if num % 2 == 1:
        return num


ret = filter(new_lst, lst)
for a in ret:
    print(a)

# zip()函数
a = [1, 2, 3]
b = [4, 5, 6]
ret = zip(a, b)
for i in ret:
    print(i)
# (1, 4)
# (2, 5)
# (3, 6)

"""
现有两个元组(('a'),('b')),(('c'),('d')),转化为[{'a':"c"},{'c':'d'}]
"""
tup1 = (('a'), ('b'))
tup2 = (('c'), ('d'))
ret = zip(tup1, tup2)  # 使用zip函数转化
"""('a', 'c')
   ('b', 'd')"""


def zu_he(tup):
    return {tup[0]: tup[1]}  # 根据索引将输出 的元组组合成：{'a': 'c'}, {'b': 'd'}


lis = []
ret2 = map(zu_he, ret)
for i in ret2:
    lis.append(i)
print(lis)