“””
函数参数传递机制和赋值机制是一样的,其本质就是传递内存地址,这就是引用传递
a传进来的时候传进来的是内存地址
如果实在不理解,你可以以为是 x= a
“””
def isid(x):
#打印参数的内存地址
print(id(x))
a = 10
#变量的内存地址
print(id(a)) #140731588047408
#a变成的参数,打印参数内存地址
isid(a) #140731588047408
#定义一个带有默认参数的函数
def add(x,y=10):
sum01 = x+y
return sum01
“””
1.add(2) x=2 y=10
2.add(2,3) x=2 y=3
“””
print(add(2)) #12
print(add(2,3)) #5
“””
能不能传参传入一个序列类型,比如list,让他默认是[]
“””
def add(list01 = []):
list01.append(1)
return list01
#第一调用
print(add()) #[1]
#第二次调用
print(add()) #[1, 1]
#第三次调用
print(add()) #[1, 1, 1]
“””
一个* :代表的是可变参数(就是可以是多个值)
“””
def add(x,*y):
sum01 = x
for i in y:
sum01 += i
return sum01
print(add(1,2,3,4,5)) #15
“””
**y代表可以使用任意 键值(字典) 作为参数
**y就相当于字典类型
“””
def func_add(x,**y):
sum01 = x
#切记这里是字典的循环
for k,v in y.items():
print(k,v)
#把v(值)进行和x相加
sum01 += v
return sum01
“””
调用
a=3,b=4,c=5 —-> {“a”:3,”b”:4,”c”:5}
“””
print(func_add(1,a=3,b=4,c=5)) #13
练习“””
定义一个函数,传入一个参数1,传入一个字典{a:2,b:4,c:1,d:3},把每个值进行累乘,返回累乘的结果
“””
name执行本文件的时候,name==main
#打印name这个属性
#执行本文件的时候,打印的是main,__name__ == __main__
print(“1、”+__name__) #1、__main__
“””
一个文件就是一个模块,导入模块,就相当于导入文件,可以直接写
import 文件名字
“””
import 本文件 as bwj
#在其他类中运行导入的文件名字,__name__==文件名字
print(bwj.__name__) #本文件
#高阶函数高阶函数是一个( 以函数为参数,或者以函数为返回值的)函数
函数可以是参数,参数是变量,那么函数可以是变量吗
参数其实就是变量进行了赋值,函数能不能是变量
函数为变量并不是高阶函数,只是和大家补充这个知识点
“””
函数为变量
“””
#定义一个函数,传入一个参数,求这个参数的平方
def func_pf(x):
return pow(x,2)
#字典
#已知李四的年龄是5的平方,求李四的年龄
dict01 = {“张三”:20,”李四”:func_pf}
“””
调用
1.func_pf = dict01[“李四”] 根据key获取value,vaule是一个函数对象
2.age02 = func_pf(5) #调用函数就能获取年龄
“””
#字典的特点是根据key获取value
age01 = dict01[“张三”]
print(age01) #20
#顾名思义,通过李四,我们可以拿到函数func_pf
#拿到的是函数对象,我们不能直接打印
func_pf = dict01[“李四”]
print(func_pf) #
age02 = func_pf(5)
print(age02) #25
#普通函数
def func_pf(x):
return x**2
#高阶函数,以函数为参数
def func_add(func_pf):
#x**2+10
return func_pf+10
#2**2+10
a = func_add(func_pf(2))
print(a) #14
这些常用的高阶函数是以函数为参数的高阶函数
map()
定义
“””
map(fun,x) 转换,接受一个序列,按照fun的函数逻辑转换成新的序列,返回一个map对象
x必须是一个序列
返回一个map对象
“””
执行流程
代码
“””
map(fun,x) 转换,接受一个序列,按照fun的函数逻辑转换成新的序列,返回一个map对象
1. x必须是一个序列
2.返回一个map对象
“””
def func_add(x):
return x+1
“””
把原来的数据,经过func_add函数以后,每一个都加1,然后输出新的列表
“””
m = map(func_add,[1,2,3,4,5])
print(m) #
print(list(m)) #[2, 3, 4, 5, 6]
练习
“””
把列表中的每个元素进行乘2并输出
“””
filter()
定义
“””
filter(func,x) 过滤,接受一个序列x,按照func函数要求进行转换,
func函数返回 True 或 False,最后将返回 True 的元素放到新列表中。
返回filter对象
“””
执行流程
代码
“””
filter(func,x) 过滤,接受一个序列x,按照func函数要求进行转换,
func函数返回 True 或 False,最后将返回 True 的元素放到新列表中。
返回filter对象
“””
def func_ifScore(x):
#比较运算符,本身就是返回布尔值的
#如果大于等于60就是Ture,否则就是False
return x>=60
f = filter(func_ifScore,[80,98,70,34,60,59,10])
print(f) #
print(list(f)) #[80, 98, 70, 60]
练习
“””
定义一个列表[1,9,-10,8,3,-2,-6,4]
过滤掉负数,输出正数
“””
reduce()
定义
“””
reduce(func,x) 计算,接受一个序列,把列表中的每一个值按照函数进行累加或者别的运算
返回一个计算数值
1.因为是计算,所以我们的func是两个参数
2.必须要导包
“””
执行流程
代码
from functools import reduce
“””
reduce(func,x) 计算,接受一个序列,把列表中的每一个值按照函数进行累加或者别的运算
返回一个计算数值
1.因为是计算,所以我们的func是两个参数
2.必须要导包
“””
#累加 1+2+3+4+5
def func_add(x,y):
return x+y
a = reduce(func_add,[1,2,3,4,5])
print(a) #15
练习
“””
声明一个list,为[80,9,5,2]
进行取余计算,比如 80%9%5%2,类似累余,这是取余
“””
zip()
定义
“””
zip(list01,list02) 拉链、压缩
用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,返回一个对象
1.参数必须是可迭代的序列类型
2.对象里面放的是一个一个的元组
3.返回一个zip对象
“””
代码
ist01 = [1,3,5,7,9]
list02 = [2,4,6,8,10]
z = zip(list01,list02)
print(z) #
#print(list(z)) #[(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
“””
数据不一样多了,拉链不一样长了,结果该怎么办呢
以短的为基础
“””
list03 = [1,3,5,7,9,11,13]
list04 = [2,4,6]
a = zip(list03,list04)
#print(list(a)) #[(1, 2), (3, 4), (5, 6)]
“””
a是一个压缩、拉链数据,能不能解压呢,
1.符号是*
2.zip(*list类型)
3.声明两个变量去承接
4.zip对象如果执行过了,就不存在了
“””
b = list(a)
list05,list06 = zip(*b)
print(list05) #(1, 3, 5)
print(list06) #(2, 4, 6)
练习
“””
定义两个列表[“张三”,”李四”,”王五”,”赵六”,”翠花”] [20,30,18,90,80]
把名字和年龄进行拼接
“””
sorted()
定义
“””
sorted(序列类型的对象,key=函数,reverse=True/False) 排序
1.reverse=True/False 升序是False 降序是Ture
“””
执行流程
代码
#list里面可以放任何数据类型
list01 = [{“name”:”张三”,”age”:20},
{“name”:”李四”,”age”:30},
{“name”:”王五”,”age”:18},
{“name”:”小明”,”age”:8}
]
#按照年龄进行排序
#定义一个函数,返回一个年龄
def func_age(list01):
#根据key(age)获取value(年龄)
age01 = list01[“age”]
return age01
s = sorted(list01,key=func_age,reverse=False)
print(s)
#[{‘name’: ‘小明’, ‘age’: 8}, {‘name’: ‘王五’, ‘age’: 18}, {‘name’: ‘张三’, ‘age’: 20}, {‘name’: ‘李四’, ‘age’: 30}]
练习
“””
定义一个列表,里面是字典类型,是每一个学生的成绩
list01 = [{“语文”:20,”数学”:80,”英语”:10,”总分”:110},
{“语文”:50,”数学”:30,”英语”:90,”总分”:170},
{“语文”:80,”数学”:90,”英语”:90,”总分”:260},
{“语文”:10,”数学”:0,”英语”:0,”总分”:10},
{“语文”:30,”数学”:60,”英语”:60,”总分”:150}]
按照总成绩进行降序排序
“””
“””
def func_name01(参数1):
def func_name02(参数2):
return 逻辑
return fun_name02
“””
#x的y次方
def func01(x,y):
return x**y
#x=2不变,y不断在改变
#print(func01(2,2)) #4
#print(func01(2,3)) #8
#print(func01(2,4)) #16
#print(func01(2,5)) #32
#print(func01(2,6)) #64
“””
简化1
以函数为返回值进行简化
1.闭包。函数里面的子函数,叫做闭包
“””
#f01 高阶函数
def f01(x):
#f02是f01的子函数,又叫做闭包函数
def f02(y):
return x**y
#把闭包函数返回出来
return f02
“””
调用
1.f = f01(2) f是谁,f就是f02(y),相当于f=f02(y)
“””
f = f01(2) #意义就是x=2
a = f(3) #意义就是y=3
#a=x**y=2**3 = 8
print(a) #8
“””
定义一个函数,传入x参数
定义一个子函数,传入y参数,返回x//y
把子函数进行返回
以上是利用的闭包进行写的,可以修改成偏函数吗
“””
“””
from functools import partial
partial(fun,x)
fun:你的函数
x:你要固定的函数中参数
“””
#x的y次方
def func01(x,y):
return x**y
“””
简化2
上面的这种这能固定x,没办法固定y,使用偏函数解决这个bug
偏函数
1.partial(fun,你要固定的那个参数x) 可以固定函数中的任意一个参数
2.导包 from functools import partial
def func01(x,y=2):
return x**y
“””
from functools import partial
#func = func01(x,y=2)
func = partial(func01,y=2)
a = func(3) #x=3
#a = x**2=3**2=9
print(a) #9
#可以固定多个参数,可以把x和y都固定住
from functools import partial
#func = func01(x=10,y=2)
func = partial(func01,y=2,x=10)
a = func()
print(a) #100
#lambda表达式lambda表达式是一行函数。在其他语言中叫做匿名函数
“””
lambda 参数1,参数2,参数n : 逻辑
“””
“””
lambda表达式:一行函数
理解为函数的简写
“””
def func01(x,y):
return x**y
lambda x,y:x**y
“””
定义一个
让lsit01里面的每一个参数进行加1,返回一个新的list
能lambda表达式写
“””
list01 = [1,2,3,4]
“””
第一种普通函数
“””
def func_add01(list01):
list02 = []
for i in list01:
list02.append(i+1)
return list02
“””
第二种生成器
“””
def func_add02(list01):
for i in list01:
yield i+1
“””
第三种高阶函数
map(func,list01) 转换
“””
def func_add04(x):
return x+1
map(func_add04,list01)
“””
第四种lambda表达式
1.把函数进行简写
2.利用高阶函数map()
“””
#把add04进行简写—lambda x:x+1
A = map(lambda x:x+1,list01)
List(A)
studentStringList = [‘张三,男,20’, ‘李四,男,22’, ‘周梅,女,19’, ‘王五,男,19’, ‘吴兰,女,21’]
# 2.1 遍历 list,分割字符串,生成 Tuple(‘张三’, ‘男’, 20)
def createTuple(text):
textList = text.split(‘,’)
return tuple(textList)
studentTupleList = list(map(createTuple, studentStringList))
print(studentTupleList)
“””
利用lambda进行简写
主要是对函数createTuple进行简写
“””
list01 = [1,2,-3,4,5,-6,8,-2,9]
def fun(x):
if x>0:
return x+1
else:
return x*2
a = map(fun,list01)
print(list(a)) #[2, 3, -6, 5, 6, -12, 9, -4, 10]
“””
把上面的函数转换成lambad表达式
重点在lambda只能一行函数,你得把逻辑代码变成一行
“””