函数
- 传参
1.两种传参方式
#两种传参方式：按位置，关键字
#函数如果有默认值，则必须放在最后
full_name = get_fullname('于','tongtng')
#print(full_name)
print(get_fullname('tongtong')
ps:求全名
def get_fullname(last_name,first_name):
'''
求全名
:param last_name: 姓
:param first_name: 名
:return: 全名
'''
full_name = last_name + first_name
return full_name
2.变长参数
# *将参数都放置到一个元组中
def self_print(name,*a):
print(a)
print(type(a))
self_print(1,2,3,4,5,6)
# **将参数都放到字典中
def d_self_print(**kwargs)
print(kwargs)
d_self_print(last_name='shun',first_name='tong')
#形参顺序：位置参数->元组->字典
def mix(name,*t,*kw)
print(name)
print(t)
print(kw)
mix('shun',20,'tongtong',tongtong='女'
*有拆开元组和列表的作用
**有拆开字典的作用
t = (1,2,3,4,5)
print(*t)
def f(*tt)
print(kw)
f(*[1,2,3,4,5])
def ff(*kwargs)
print(kwargs)
ff(**{'name':'tongtong','age':20})
3.返回值
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)
4.传参问题
函数的传参问题
数据分为引用类型，普通类型
python中的基本数据类型都是普通类型。数，布尔型，字符串型
除了这些之外的类型都是引用类型
普通类型赋值的时候，传的是值
引用类型赋值的时候，传的是址
l1 = [1,2,3,4,5]
l2 = l1
l2[1] = 5
print(l1)
a = 5
b = a
b = 10
print(a)
ps:传参的本质就是赋值操作，如果传递的是引用类型数据，则需要注意是否在函数中对其做出了修改
def power(numbers):
#numbers = [x**2 for x in numbers]
#numbers[9] = 10
#创建数据副本
#numbers = numbers[:]
numbers = list(numbers)
numbers[3] = 10
return numbers
nums = [1,2,3,4,5,6,7,8,9,10]
print(power(nums))
print(nums)
5.闭包
闭包：闭包的本质是函数嵌套函数，外层函数返回内层函数的地址
def fun():
print("hello world")
#函数名的本质是函数的地址
f = fun
f()
def outter():
#a = 10
def inner():
a = 20
print(a)
print("hello world")
print("-------")
print(a)
return inner
fo = outter()
fo()
#内层函数可以访问外层函数的变量，但是不能修改
#内层函数访问变量时会先从自己内部查找，如果找不到，就会层层向上查找
def outter():
#a = 10
def inner():
#说明使用的是外层变量
global aa
aa == 1
'''
print(aa)
print("hello world")
print("-------")
print(a)
'''
return inner
fo = outter()
fo()
内层函数可以访问外层函数的变量，但是不能修改
内层函数访问变量时会先从自己内部查找，如果找不到，就会层层向上查找
python中，变量的作用域是以函数为单位的
global修饰变量时，说明使用的是最外层的全局变量
nonlocal修饰变量时，说明使用的是嵌套层函数的变量
def outter():
#a = 10
def inner():
#说明使用的是外层变量
global aa
aa == 1
'''
print(aa)
print("hello world")
print("-------")
print(a)
'''
return inner
fo = outter()
fo()
def outter():
a = 10
def inner():
#说明使用的是外层变量
nonlocal aa
aa == 1
print(aa)
'''
print(aa)
print("hello world")
print("-------")
print(a)
'''
return inner
fo = outter()
fo()
例：斐波那契数列：1 1 2 3 5 8 13
#用递归实现
def fibonacci(n):
if n == 1 or n == 2:
return 1
return fibonacci(n-1)+fibonacci(n-2)
for i in range(1,6):
print(fibonacci(i))
#用循环实现
def fibonacci_for(n):
before = 0
after = 1
for i in range(1,n+1):
tmp = before + after
before = after
after = tmp
return tmp
for i in range(1,10)
print(fibonacci_for(i))
6.高阶函数：函数的参数或函数的返回值是函数的函数
def handle(func,*param)
return func(param)
def my_sum(*param):
sum = 0
for v 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,6))
def my_mul(*param)
mul = 1
for v in param:
mul = v
return mul
print(handle(my_mul,1,2,3,4,5))
7.系统中已经存在的函数
map(func,inteable)
该函数会把inteable中的数据依次传递给func函数处理，最后把处理的结果返回
ef power(x):
return x * x
result = map(power,[1,2,3,4,5,6])
#for i in result:
# print(i)
result = map(lambda x:x*x,[1,2,3,4,5,6,7])
print(list(result))
reduce(func,inteable) 函数
累计操作，func函数必须接收两个参数，reduce会把func的运行结果做一个参数，然后从inteable中再取出一个数据当做另一个参数
from functools import reduce
li = [1,2,3]
result = reduce(lambda x,y:x * y, li)
print(result)
fitter(func,inteabie)
根据函数func 来过滤interable,将interable中的数据传入函数func中，如果函数返回rue，就保留该数据，否则就不保留
li = [1,2,3,4,5,6,9,10,15]
result = list(filter(lambda x:x % 2 ==1,li))
print(result)
sort(inteable,key=None,reverse=False)
对数据进行排序，key可以用来指定排序的规则，值是一个函数，reverse是用来指定排序的顺序，-->升序或降序
li = [1,2,-4,-10,12]
rs = li.sort() #就地排序
#sorted（li,key=abs）
#print(li)
#list 自带的sort方法会影响原始数据，系统级的sorted函数不会影响原始数据
rs = sorted(li,key=abs,reverse=Ture)
print(rs)
模块
模块就是一个文件，我们在编写程序的时候，可以把功能相似的代码放到一个模快中
导入模块方式：
1.from 开头 from 模块名 import 函数名
- import 开头 import 模块名
可以使用‘as’为模块或函数起一个别名
from food import make_pizza,make_bun()
make_pizza()
make_bun()
from food import make_pizza as mp
from pizza import make_pizza
mp()
make_pizza()
备注：
def ff():
'''
打印test!!
:return:
'''
print("test!!!!")
print(ff.__doc__)
help(ff)
a = (1,[1,2,3],3,4,5)
a[1].append(4)
print(a)
