函数的参数类型
- 引用类型与普通类似
- 引用类型：存储的时候存的不是值，而是地址
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 numbers
numbers = [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 = 10
def inner():
# 在python中内部函数不能直接修改外部的数，但是可以读；内层函数访问变量时会先从自己查找，如果找不到，就会层层向上查找
print("hello inner")
global a # 说明使用的是全局变量，此时就可以对全局变量进行修改
# nonlocal 表明非局部变量
# 建议：如果使用的是全局变量或非局部变量，建议加上关键字，便于阅读；或在函数的文档说明里面进行说明
a = 10
print(a)
return inner
f = outer()
f()
递归
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n - 1)
print(factorial(10))
print("-" * 50)
# 斐波拉契数列
def fib(n):
if n == 1 or n == 2:
return 1
else:
pre = fib(n - 1)
rail = fib(n - 2)
return pre + rail
def fib_cycle(n):
pre_number = 1
rail_number = 1
print(pre_number, end=" ")
if n == 1 or n == 2:
return 1
for _ in range(n - 2):
pre_number, rail_number = rail_number, pre_number + rail_number # 元组的操作
print(pre_number, end=" ")
return rail_number
print(fib(6))
print(fib_cycle(6))
高阶函数
def handle(func, *param):
return func(*param)
def my_sum(*param):
sum = 0
for i in param:
sum += i
return sum
print(handle(my_sum, 1, 2, 3, 4, 5))
# map(func,interable) #该函数会把iterable中的数据一次传递给func函数处理，最后把处理的结果返回
# 需求：将列表[1,2,3,4,5]中的每个元素平方
def power(n):
return n ** 2
res = 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 reduce
mylist = [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 += num
print(num)
test(a) #会发现两次的输入不一样，因为整数是不可变类型，所以在函数内部新建了个变量
print(a)
a = [100]
test(a) #会发现两次的输出一样，因为列表是可变类型，所以直接改变原数据
print(a)