函数
- 变长参数 类型为元组(元素不可变) 位置在形参最后
def self_print(name,*a):
print(a)
print(type(a))
print(len(a))
self_print(1,2,1,3)
- **将参数放到字典中
def d_self_print(**name):
print(name)
d_self_print(first_name = 'anja',last_name = 'adsf')
- 形参顺序：位置参数->元组->字典
def mix(name,*t,**kit):
print(name)
print(t)
print(kit)
mix('ajdsfn',1,1,nae = 'name',sex = 'male')
- *有拆元组、列表和字典的作用
t = [1,2,3,4,5]
print(t)
print(*t)
def f(*t):
print(t)
f(*t)
- **有拆字典的作用
def dit(**d):
print(d)
dit(**{'name':'jans','age':12})
- 元组的声明可以不用()
def avg(*num):
print(*num)
total = sum(num)
print(total)
avge = total / len(num)
print(avge)
avg(1,2,3,4,5)
数据分为普通类型和引用类型
python中的基本数据类型都是普通类型。数、布尔型和字符串型
除此之外的类型都是引用类型
普通类型赋值的时候，传的是值
引用类型赋值的时候，传的是量
l1 = [1,2,3,4,5,6]
l2 = l1
l2[2] = 4
print(l1)
传参的本质是赋值操作，如果传递的是引用类型的数据，则需要注意是否在函数中对其做了修改
def power(number):
numbers = number[:]
# 创建数据副本
numbers = [x**2 for x in numbers]
print(numbers)
number = [1,2,3,4]
power(number)
print(number)
闭包
- 函数名代表的是函数的地址
def fun():
print('asds')
f = fun
f()
print(fun)
内层函数可以访问外层函数的值，但不能修改
内层函数访问变量时，会先从内部找，如果找不到，会层层向上查找
python 中，变量的作用域是以函数为单位
global 修改变量时，说明使用的是最外层全局变量
nonlocal 修改变量时，说明使用的是嵌套函数层的变量
闭包 闭包的本质是函数嵌套函数，外层函数返回内层函数的地址
a = 10
def outter():
a = 10
def inner():
# 说明使用的是全局变量
# global a
nonlocal a
print(a)
a = a-1
print(a)
return inner
fo = outter()
fo()
print(a)
递归
函数自己调用自己，编写递归或循环时，一般先考虑出口（结束条件）问题
def factorial(n):
mm =1
for num in range(1,n+1):
mm *= num
return mm
print(factorial(5))
def factorial1(n):
if n == 1:
return 1
return n * factorial1(n-1)
print(factorial1(5))
- 菲波那切数列
list1 = []
k = 0
def list(n):
global k
global list1
if k == 0 or k == 1:
list1.append(1)
else:
list1.append(list1[k-2] + list1[k-1])
if k == n-1:
return list1
k += 1
return list(n)
n = input('请输入个数：')
print(list(n))
高阶函数
函数的参数或函数的返回值是函数的函数
def handle(func,*p):
return func(*p)
def my_sum(*p):
sum = 0
for i in p:
sum += i
return sum
print(handle(my_sum,1,2,3,4,5))
def my_mul(*p):
mul = 1;
for i in p:
mul *= i
return mul
print(handle(my_mul,1,2,3,4,5))
- map(func,interable)
函数会把interable中的数据依次传递给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])
print(list(result))
result = map(lambda x : x*x,[1,2,3,4,5,6])
print(list(result))
- reduce(func,interable)
函数累计操作，func函数必须接受两个参数，reduce会把func的运行结果做一个参数，然后从interable中再取一个数据当做func的另一个参数
from functools import reduce
li = [1,2,3,4,5,6]
result = reduce(lambda x,y : x*y,li)
print(result)
- filter(func,interable)
根据函数func来过滤interable，将interable中的数据传入函数func中，如果函数返回True，就保留该数据，否则不保留
li = [1,2,3,4,5,6,7,8]
result = list(filter(lambda x:x%2 ==1,li))
print(result)
- sort(interable,key=None,reverse)
对数据进行排序，key可用来指定排序的规则，值是一个函数，reverse是来指定排序的顺序-->升序和降序
li = [1,-2,43,24,-10]
# li.sort() 影响原数列
print(li)
rs = sorted(li,key=abs,reverse=True)
# 不影响原始数列
print(rs)
print(li)
模块
模块就是一个文件，我们在编写程序时，可以把功能相似的代码放到一个模块中
导入模块的方法：
1、from 模块名 import 函数名(*为通配符)
2、import 模块名
可以使用as 给模块或函数起别名
from p17 import make_pizza as mp
from p16 import make_pizza
mp()
make_pizza()
import p17
p17.make_pizza()
p17.make_bun()
import p17 as p
p.make_bun()
p.make_pizza()
- print(ff.doc)和help(ff)可以查看函数的注释
- 元组数据不可改变
# 地址不变 a[1]位置储存的是列表地址
a = (1,[1,2],3)
a[1].append(3)
