python函数基础
2019-05-18
--张伯羽
1.变长参数
- 一个*： 将参数都放在一个元组中
def self_print(*a):
print(a)
print(type(a))
self_print(1,2,3,4,5,6)
(1, 2, 3, 4, 5, 6)
- 两个*： 将参数都放在一个字典中
def d_self_print(**kwargs):
print(kwargs)
d_self_print(last_name='张', first_name='伯羽')
{'last_name': '张', 'first_name': '伯羽'}
- 形参顺序: 位置参数－>元组－>字典
def mix(name, *t, **kw):
print(name)
print(t)
print(kw)
mix('张', 20, 'dongqin', gender='男')
张
(20, 'dongqin')
{'gender': '男'}
- 一个*可以拆开元组和列表
t = (1,2,3,4,5)
print(*t)
def f(*tt):
print(tt)
f(*[1,2,3,4,5])
1 2 3 4 5
(1, 2, 3, 4, 5)
- 两个*可以拆开字典
def ff(**kwargs):
print(kwargs)
ff(**{'name':'zhang', 'age':20})
{'name': 'zhang', 'age': 20}
- return 返回值
def sum_and_avg(*numbers):
total = sum(numbers)
avg_number = total/len(numbers)
return total, avg_number
sum, avg = sum_and_avg(1,2,3,4,5,6,7,8,9,10)
print("总和是%f" % sum)
print("平均值是%f" % avg)
2.函数的传参问题
数据分为引用类型， 普通类型
python中的基本数据类型都是普通类型，数，布尔型，字符串型
除此之外类型都是引用类型
普通类型赋值时传的是值，引用类型赋值时传的是地址
l1 = [1,2,3,4,5]
l2 = l1
# 指向同一块内存
l2[1] = 5
print(l1)
[1, 5, 3, 4, 5]
传参的本质是赋值操作，如果传递的是引用类型数据，则需要注意是否在函数中对其做出了修改
- 可以用numbers[:]复制
def power(numbers):
# numbers = {x**2 for x in numbers}
numbers = numbers[:]
# 复制一份
numbers = list(numbers)
#复制一份
numbers[3] = 10
return numbers
nums = [1,2,3,4,5,6]
print(power(nums))
print(nums)
[1, 2, 3, 10, 5, 6]
[1, 2, 3, 4, 5, 6]
3.函数的闭包
- 函数名本质代表的是函数的地址
def fun():
print('Hello World!')
fx = fun()
fx
Hello World!
- 内层函数可以访问外层函数的变量，但不能修改
- 内层函数访问变量时会先从自己查找，如果找不到，就会层层向上查找
- python中变量的作用域是以函数为单位的
- global修饰变量时，说明使用的是最外层的全局变量
- nolocal修饰变量时，说明使用的是嵌套层函数的变量
闭包的本质是函数嵌套函数，外层函数返回内层函数的地址
aa = 10
def outter():
aa = 10
def inner():
# 说明使用的是外全局变量
# global a
nonlocal aa
aa -= 1
print(aa)
print('hello inner')
return inner
fo = outter()
fo()
fo()
fo()
9
hello inner
8
hello inner
7
hello inner
4.递归
函数自己调用自己，编写递归或循环一般先考虑出口（结束的条件）问题
- 求阶乘的问题
def factorial(n):
res = 1
for num in range(1, n+1):
res *= num
return res
print(factorial(5))
120
- 斐波那契数列
1.递归
# 递归
def feibonaqi2(n):
if n==1 or n==2:
return 1
else:
return feibonaqi2(n-1) + feibonaqi2(n-2)
list = []
for i in range(1, num+1):
list.append(feibonaqi2(i))
print(list)
[1, 1, 2, 3, 5]
2.循环
# 使用for循环
def feibonaqi3(n):
before = 0
after = 1
if n==1:
return 1
for i in range(2, n+1):
tmp = before + after
# before = after
# after = tmp
before, after = after, tmp
return tmp
list2 = []
for i in range(1, num+1):
list2.append(feibonaqi3(i))
print(list2)
[1, 1, 2, 3, 5]
- 高阶函数，参数或返回值是函数的函数
- 累加
def handle(func, *param):
return func(*param)
def my_sum(*param):
sum = 0
for i in range(len(param)):
sum += param[i]
return sum
print(my_sum(1,2,3,4,5))
# 函数的参数还是一个函数
print(handle(my_sum, 1, 2, 3, 4, 5))
15
15
- 累乘
print(handle(my_sum, 1, 2, 3, 4, 5))
def my_mul(*param):
"""
累乘
:param param:
:return:
"""
mul = 1
for v in param:
mul *= v
return mul
print(handle(my_mul, 1,2,3,4,5))
120
- map(func,inteable)
该函数会把inteable中的数据依次传递给func函数处理，最后把处理的结果返回
# [1,2,3,4,5]－>[1,4,9,16,25]
def power(x):
return x * x
# result = map(power, [1,2,3,4,5,6])
result = map(lambda x:x*x, [1,2,3,4,5,6])
# for i in result:
# print(i)
print(list(result))
[1, 4, 9, 16, 25, 36]
- reduce(func,interable) 函数
累计操作，func函数必须接收两个参数，reduce会把func的运行结果作为一个参数，然后从inteable中再取出一个数据作为另一个参数
from functools import reduce
li = [1,2,3,4,5,6]
result = reduce(lambda x,y:x*y,li)
#1*2=2 2*3=6 6*4=24...
print(result)
720
- filter(func,interable)
根据函数func来过滤interable,将interable中的数据传入函数func中，如果函数返回True，就保留该数据，否则就不保留
li = [1, 2, 4, 5, 6, 9, 10, 15]
result = list(filter(lambda x: x % 2 == 1, li))
print(result)
[1, 5, 9, 15]
- sort(interablen, kry = none, reverse = False)
对数据进行排序，key可以用来指定排序的规则，值是一个函数，reverse是来指定排序的顺序－>升序或降序
li = [1, 2, -4, -10, 12]
# rs = li.sort() # 就地排序
res = sorted(li[:], key=abs, reverse=True)
print(res)
print(li)
[12, -10, -4, 2, 1]
[1, 2, -4, -10, 12]