Python16

Python16

函数的参数类型

• 引用类型与普通类似
• 引用类型：存储的时候存的不是值，而是地址

l1 = [1, 2, 3, 4]
l2 = l1  # 将l1的地址赋予l2# 普通类型：浮点、bool、字符串，整数
# 除了这些之外，都是引用类型
# 普通类型赋值的时候传的是值本身，而引用类型赋值的时候传的是地址
# 注意引用类型和普通类型作为参数时，引用类型操作为原数据，可以直接改变，而普通类型操作的是拷贝，所以如果要对普通类型在函数体内更改数据，要注意返回，或者如果是全局变量，注意用global声明（如果局部没有同名的变量，这里的global只是起到方便阅读的作用）a = 1
b = a
print(id(a), id(b))
b = 3
print(id(a), id(b))def power(numbers):numbers = [x ** 2 for x in numbers]return numbersnumbers = [1, 2, 3, 4, 5]
numbers = power(numbers)
print(numbers)# caution:为了避免在函数内改变函数外的数据，往往在函数内部复制一份，然后用复制后的数据进行操作

闭包

def fun():print("hello woirld")fun()
print(fun)
f = fun
f()# 函数名就是函数的地址，函数相当与一个变量# 函数的嵌套
# 闭包的前提是函数的嵌套
# 闭包：一个函数的内部又定义了一个函数，而我们反而要用的是内部的函数，且通常内部函数会用到外部函数的变量，此种方式我们称之为闭包
# 建议：对于全局变量，加g_，eg：如果有全局变量a，则命名为g_a
# caution:如果是列表或者字典等作为全局变量，则在函数中可以不加关键字，直接进行使用def outer():a = 10def inner():# 在python中内部函数不能直接修改外部的数，但是可以读；内层函数访问变量时会先从自己查找，如果找不到，就会层层向上查找print("hello inner")global a  # 说明使用的是全局变量，此时就可以对全局变量进行修改# nonlocal 表明非局部变量# 建议：如果使用的是全局变量或非局部变量，建议加上关键字，便于阅读；或在函数的文档说明里面进行说明a = 10print(a)return innerf = outer()
f()

递归

def factorial(n):if n == 1:return 1else:return n * factorial(n - 1)print(factorial(10))print("-" * 50)# 斐波拉契数列
def fib(n):if n == 1 or n == 2:return 1else:pre = fib(n - 1)rail = fib(n - 2)return pre + raildef fib_cycle(n):pre_number = 1rail_number = 1print(pre_number, end=" ")if n == 1 or n == 2:return 1for _ in range(n - 2):pre_number, rail_number = rail_number, pre_number + rail_number  # 元组的操作print(pre_number, end=" ")return rail_numberprint(fib(6))
print(fib_cycle(6))

高阶函数

• 函数的参数或函数的返回值是函数的函数

def handle(func, *param):return func(*param)def my_sum(*param):sum = 0for i in param:sum += ireturn sumprint(handle(my_sum, 1, 2, 3, 4, 5))

• 系统中自带的高阶函数

# map(func,interable)   #该函数会把iterable中的数据一次传递给func函数处理，最后把处理的结果返回
# 需求：将列表[1,2,3,4,5]中的每个元素平方
def power(n):return n ** 2res = map(power, [1, 2, 3, 4, 5])print(list(res))
print("-" * 50)
res = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
for v in res:  # res是一个迭代器，内部相当于一个指针，用一次指针往后移一次，所以遍历后print(list(res))为空print(v, end=" ")
print()
print(res)# reduce(func, iteralbe) # 需要 from functools import reduce 。累积操作，func函数必须接收两个参数，reduce会把运行结果当作一个参数，然后从iterable再取出一个数据当作另一个参数
# 工作原理：最开始把列表中的1和2当作参数传入，然后将1*2的结果当作参数1，列表中的3当作参数2，依次迭代
from functools import reducemylist = [1, 2, 3, 4, 5]
res = reduce(lambda x, y: x * y, mylist)
print(res)# filter(func,iteralbe) 过滤器,根据func来过滤iterable,将iterable中的数据传入函数，如果函数返回True，就保留该数据，否则就不保留，即func的返回值为bool类型
list_one = [1, 2, 3, 4, 5, 6, 7, 8, 9]
res = list(filter(lambda x: x % 2 == 1, list_one))
print(res)# sorted(iterable,key=None,reverse=False) #对数据进行排序，key用来制定排序的规则，值是一个函数，reverse用来指定是否降序
list_two = [1,3,234,-34,1,24,-234,3,3,6,]
# res = list_two.sort()   #就地排序，会对原数据进行更改
# print(res)
new_list = sorted(list_two,key=abs) ps：可变类型与不可变类型
a = 100
def test(num):num += numprint(num)
test(a)	#会发现两次的输入不一样，因为整数是不可变类型，所以在函数内部新建了个变量
print(a)a = [100]
test(a)	#会发现两次的输出一样，因为列表是可变类型，所以直接改变原数据
print(a)