函数:
格式:
def 函数的名字():
函数体
例如:
def playgame():
print("I am playing!")
函数调用:
playgame()
调用的方法: 函数名()
函数的定义只是定义函数,调用了才会有结果
函数的参数
分类: 1.形参:在函数定义的时候,需要准备一些变量来接收信息 1.位置参数,按照位置一个一个声明变量 2.默认值参数,在函数声明的时候给变量一个默认值,如果实参不传递信息,此时默认值生效,否则就不生效
def luru(name, age, gender="男"):
print(name, age, gender)
luru("张三", 18) # 张三 18 男
luru("李四", 18)
luru("王二麻子", 18)
luru("赵敏", 18, "女") # 赵敏 18 女
luru("周芷若", 18, "女")
luru("吴老二", 18)
3.动态传参 1. * 参数名(args) 表示接收所有的位置参数的动态传参,接收到的值被统一放在元组里 2. ** 参数名(kwargs) 表示接收所有的关键字的动态传参,接收到的值统一放在字典里
def chi(*food): # * 表示位置参数的动态传参,*接收到的值会被统一放在一个元组里面
print(food)
chi('大米饭', "烧茄子", "紫菜蛋花汤") # ('大米饭', '烧茄子', '紫菜蛋花汤')
chi("大米饭") # ('大米饭',)
# 关键字参数的动态接收
def chi(**food): # ** 表示接收关键字的动态传参,接收到的所有参数都会被处理成字典
print(food)
chi(zhu="小米饭", tang="胡辣汤", ) # {'zhu': '小米饭', 'tang': '胡辣汤'}
混合使用的顺序:位置参数 > *args > 默认值 > **kwargs
上述参数可以随意搭配使用;位置参数 在 默认值参数之前
2.实参:实际调用的时候传递信息
1.位置参数,按照位置进行参数传递
2.关键字参数,按照参数的名字进行传递参数
def chi(zhu, fu, tang, tian):
print(zhu, fu, tang, tian)
chi("大米饭", '西红柿炒鸡蛋', "紫菜蛋花汤", "哈根达斯") # 位置参数
chi(zhu="小米饭", tang="胡辣汤", fu="西红柿炒鸡蛋", tian="老冰棍") # 关键字参数
chi("小米饭","胡辣汤", tang="西红柿炒鸡蛋", tian="老冰棍") # 混合参数
3.混合参数 (位置参数放前面,关键字参数放后面---> 否则报错) 实参在执行的时候,必须保障形参有数据
open(xxxx,mode="xx",encoding="xxxx") # xxxx是文件名,这个就是混合参数
* 在实参位置,是把列表打散成位置参数进行传递 ** 在实参位置,可以把字典自动转化成关键字参数进行传递
def func(*args):
print(args)
# list少量元素
func(stu_lst[0], stu_lst[1], stu_lst[2], stu_lst[3],) # ('流川枫', '樱木', '大老王', '隔壁二老王')
# list 大量元素
func(*stu_lst) # * 在实参位置,是把列表打散成位置参数进行传递
# ** 在实参位置,可以把字典自动转化成关键字参数进行传递
# ('流川枫', '樱木', '大老王', '隔壁二老王')
返回值
返回值:函数执行之后,会给调用方一个结果,这个结果就是返回值 关于return: 函数只要执行到了return,函数就会立即停止并返回内容,函数内的return后续代码不会执行
def func(a, b):
# print(a + b)
return a + b
ret = func(10, 30)
print( ret * 3) # 90
# 不写return
def func():
pass
ret = func()
print(ret) # None
# 写了return但没有返回值
def fun():
print(1223)
return # 不管return有没有返回值,只要读到return就会让程序停止,后续代码不会执行,有点像循环里的break
print(234)
ret = fun()
print(ret) # 1223 None
1.如果函数里没有return,此时函数收到的是什么? 默认收到的时None 2.如果写了return 1.只写了return 后面不跟数据 (充当的break情况) 2.return 值,此时表示函数有一个返回值,外界能收到一个数据 (用的最多) 3.return 值1,值2,值3.... 此时函数有多个返回值,外界收到的是什么呢 外界收到的是元组,且该元组内存放所有返回值
内置函数(上)
内置函数: 直接拿来用的函数 例:print, input 和数学运算相关 数据类型: bool、 int、 float、 complex(复数) 进制转换:bin(二进制)、oct(八进制), int(十进制),hex(十六进制) 数学运算:sum, min, max, pow(次方)
# 进制
a = 18
print(bin(a)) # 0b10010 二进制
print(oct(a)) # 0o22 八进制
print(hex(a)) # 0x12 十六进制
b = 0b10011
print(int(b)) # 19 二进制转十进制
# 数学运算
# pow
c = 10
d = 3
print(pow(c, d)) # 1000
print(c ** d) # 1000 表示的也是次方
# max , min , sum
lst = [12, 32, 57, 789, 1000]
print(max(lst)) # 1000
print(min(lst)) # 12
print(sum(lst)) # 1890
和数据结构相关 列表和元组: list, tuple 相关内置函数:slice(切片) 字符串:str,format,bytes,ord(把文字转化成unicode编码中的码位), chr(把unicode编码的码位转化为文字), repr 相关内置函数:len, enumerate(能够直接拿到索引和元素), all(当作and看), any(当作or看), zip, filter, map, sorted,
# 列表
s = {1, 3, 4}
lst = list("呵呵哒") # list 内部有个for循环
print(lst) # [1, 3, 4] ['呵', '呵', '哒']
# list的原理
for item in s:
lst.append(item)
lst = list("呵呵哒")
print(lst) # ['呵', '呵', '哒']
s = slice(1, 4, 3) # [1: 4:3] 从1切到4,每3个出来一个
print("呵呵呵呵呵呵"[s]) # 呵
# format, ord, chr
# format 格式化
a = 18
print(format(a, "b")) # 二进制 10010
print(format(a, "08b")) # 需要一个由0补充的8位的二进制 00010010 只能补齐,不能切割
c = 12000
print(format(c, "08b")) # 10111011100000
print(format(a, "o")) # 八进制 22
print(format(a, "x")) # 十六进制 12
# ord, chr
a = '中' # python的内存是unicode
print(ord(a)) # 20013 “中”在unicode中码位是20013
print(chr(20013)) # 中 给出编码位置,展示出文字
# enumerate, all, any,
# all, any
print(all([12, "呵呵", "豆沙包"])) # 把all当作and来看 True
print(all([0, "呵呵", "豆沙包"])) # False,有一个空就是false
print(any([0, "呵呵", "豆沙包"])) # True 把any当作or来看
print(any([0, "", ""])) # False,全是空就是false
lst = ["张无忌", "张翠山", "张三丰","张大大"]
for item in enumerate(lst):
print(item)
'''
(0, '张无忌')
(1, '张翠山')
(2, '张三丰')
(3, '张大大')
'''
for index,item in enumerate(lst):
print(index,item)
# # 等价于下面
for i in range(len(lst)):
print(i, lst[i])
'''
0 张无忌
1 张翠山
2 张三丰
3 张大大
'''
其他 id (字符串的内存地址) help() dir() (告诉当前数据能执行的操作)print(dir(s))
python进阶
作用域
作用域:变量的访问权限 全局变量:顶格写,全局作用域 局部变量:内侧 ,局部作用域 总结: 里面访问外面没问题,外面访问里面不能直接访问
def func():
c = 199
return c # 想要在函数外面访问到函数里面的东西,必须要return,必须!
c1 = func() # 此时调用的func是c的值
print(c1) # 199
函数的嵌套
结论(*): 1.函数可以作为返回值进行返回 2.函数可以作为参数进行相互传递 函数实际上就是一个变量名,都表示一个内存地址
def fun1():
pass
def fun2():
fun1() # 这个叫函数的调用,不叫嵌套
fun2()
def func1():
b = 20
def func2(): # 函数的嵌套
print(b)
func2() # 20 局部的东西,一般都是在局部自己访问使用的
# func1内部的func2函数访问了局部变量b,并且在调用func1()时输出了20。
# 外部无法直接访问b和func2,因为它们是在func1内部定义的局部变量和函数。
func1() # 20 这算直接调用func1()
print(func1()) # None
# 输出 None 是因为函数 func1 没有明确地返回任何值。在 Python 中,如果函数没有显式使用 return 语句返回一个值,它将默认返回 None。
print(b) # 访问不了,外面没办法访问里面
print(func2) # 访问不了,外面没办法访问里面
# 函数嵌套执行过程
def func1():
print(123)
def func2():
print(234)
def func3():
print(345)
print(1)
func3()
print(2)
print(3)
func2()
print(4)
func1()
"""
只有调用了才会执行
123
3
234
1
345
2
4
"""
def func():
def inner():
print(123)
print(inner) # <function func.<locals>.inner at 0x000001C7CD54B520> 打印出来的是函数func的局部变量inner的地址
return inner # 返回的是函数,如果返回inner(),返回的是None,把函数当成一个变量进行返回
b1 = func() # b1是func的返回值,此时是b1内部的inner
print(b1) # <function func.<locals>.inner at 0x000001A8F892B520> 和inner一样
b1() # 123
# 在外部调用局部变量
def an():
print(123)
an() # 123
bn = an # 把an赋值给了bn
bn() # 123 此时的bn()就是an()
# 函数就是一个变量!
# 代理模式
def func(an):
# print(an) # 传入func的变量,打印该变量本身
an() # 传入func的函数,执行该函数
# 实参可以是函数
def target():
print("我是target")
c = 123
func(c) # 123 给func传变量c,调用func,输出123
func(target) # <function target at 0x000001FDC715B520> 给func()传函数,调用func,返回的是传入函数的地址
# 用的是 print(an)
func(target) # 我是target 说明实参可以是函数
两个关键字global,nonlocal
global:在局部引入全局变量 nonlocal: 在局部,引入外层的局部变量
a = 10
def func():
# 此时就想要在函数内部修改全局变量a,怎么办?
global a # 把外面的全局变量引入到局部
a = 20 # 创建一个局部变量,并没有改变全局变量中的a
func()
print(a) # 10 为什么还是10(按理说应该是20)? 只写了a = 20不行
# 有了global a ,a的结果变成20 20
def func():
a = 10
def func2():
nonlocal a # 向外找一层,看有没有该变量,如果有就引入,如果没有,继续向外扩一层,直到全局(不包括)
a = 20
func2()
print(a)
func() # 10
# 20 (nonlocal a)
闭包
闭包:本质:内层函数对外层函数的局部变量的使用,此时内层函数被称为闭包函数 1. 可以让一个变量常驻于内存 2. 避免全局变量被修改
def func():
a = 10 # 把成员变量变成局部变量,将其保护起来
def inner():
nonlocal a
a += 1
return a
return inner # 此时inner构成闭包函数
ret = func() # inner ==> ret ==> 什么时候执行
r1 = ret()
print(r1) # 11
r2 = ret()
print(r2) # 12
装饰器
函数回顾:
1. 函数可以作为参数进行传递 2. 函数可以作为返回值进行返回 3. 函数名称可以当成变量一样进行赋值
# 1.函数可以作为参数传递
def func():
print("我是函数")
def gggg(fn):
fn()
gggg(func) # 我是函数
# 2.函数可以作为返回值进行返回
def func():
def inner():
print("123")
return inner
ret = func()
ret() # 123
# 3.函数名称可以当成变量一样进行赋值
def func1():
print("我是函数1")
def func2():
print("我是函数2")
func1 = func2
func1() # 我是函数2
装饰器: --> 要求记住最后的结论 装饰器本质上是一个闭包 作用: 在不改变原有函数调用的情况下,给函数增加新功能 直白:可以在函数前后添加新功能,但不改原代码 应用: 在用户登录的地方,日志, 通用装饰器写法: def wrapper(fn): wrapper: 装饰器,fn:目标函数 def inner(* args, **kwargs): # 在目标函数执行之前 ret = fn(* args, **kwargs) # 执行目标函数 # 在目标函数执行之后 return ret return inner # 千万不能加小括号 @wrapper def target(): pass target() # ==> inner() 一个函数可以被多个装饰器装饰 @wrapper1 @wrapper2 def target(): print('我是目标') target() 作用顺序: wrapper1 wrapper2 target wrapper2 wrapper1y
一个函数被两个装饰器装饰
def wrapper1(fn): # fn: wrapper2.inner
def inner(*args, **kwargs):
print("这里是wrapper1,进") # 1
ret = fn(*args,**kwargs) # 调用 fn : wrapper2.inner
print("这里是wrapper1,出") # 4
return ret
return inner
def wrapper2(fn): # fn : target
def inner(*args, **kwargs):
print("这里是wrapper2,进") # 2
ret = fn(*args,**kwargs) # target
print("这里是wrapper2,出") # 4
return ret
return inner
@wrapper1 # target = wrapper1(wrapper2.inner) ==> target:wrapper1.inner
@wrapper2 # target = wrapper2(target) 此时的target是wrapper2的inner
def target():
print('我是目标')
target()
wrapper1 wrapper2 target wrapper2 wrapper1
"""
这里是wrapper1,进
这里是wrapper2,进
我是目标
这里是wrapper2,出
这里是wrapper1,出
"""
装饰器实战
login_flag = False
def login_verify(fn):
def inner(*args, **kwargs):
global login_flag
if login_flag == False:
# 这里完成登录校验
print("还未完成用户登录操作")
while 1:
username = input("用户名:")
password = input("密码:")
if username == "admin" and password == "1234":
print("登陆成功!")
login_flag = True
break
else:
print("登陆失败,用户名或密码错误")
# print(1223)
ret = fn(*args, **kwargs) # 后续的程序
return ret
return inner
@login_verify
def add():
print("添加员工信息")
@login_verify
def delete():
print("删除员工信息")
@login_verify
def upd():
print("修改员工信息")
@login_verify
def search():
print("查询员工信息")
add()
delete()
upd()
search()
迭代器
for 变量 in 可迭代: pass iterable: 可迭代的东西 str, list, tuple, dict, set, open() 可迭代的数据类型都会提供一个叫迭代器的东西,这个迭代器可以帮我们把数据类型中的所有数据逐一拿到 获取迭代器的两种方案: 1.iter() 内置函数可以直接拿到迭代器 2.__iter__() 从迭代器中拿到数据: 1.next() 内置函数 2.__next__() 特殊方法 for 里面一定是要拿迭代器的,所以所有不可迭代的东西不能用for循环 for 循环里面一定有__next__()或next() 出现 总结:迭代器本身统一了不同数据类型的遍历工作 迭代器本身也是可迭代 迭代器本身的特性: 1.只能向前,不能反复 2.特别省内存 3.惰性机制(只要不访问next就不挪)
# next
it = iter("你叫什么名字啊")
print(it) # <str_iterator object at 0x0000016C2FC766B0>
print(next(it)) # 你
print(next(it)) # 叫
print(next(it)) # 什
print(next(it)) # 么
print(next(it)) # 名
print(next(it)) # 字
print(next(it)) # 啊
print(next(it)) # StopIteration:迭代已经停止了,不能再从迭代器中拿东西了
#__iter__()
it = "呵呵哒".__iter__()
# print(it) # <str_iterator object at 0x000001A9F41266B0>
print(it.__next__()) # 呵
print(it.__next__()) # 呵
print(next(it)) # 哒
# 模拟for循环的工作原理
s = "我是数据"
it = s.__iter__() # 拿到迭代器
while 1:
try: # 异常值处理
data = it.__next__()
print(data) # for循环的循环体
except StopIteration:
break
print(12345)
"""
我
是
数
据
12345
"""
迭代器本身就是可迭代的
# 迭代器本身也是可迭代的
s = "你好啊,我叫tom"
it = s.__iter__()
for mm in it:
print(mm)
"""
你
好
啊
,
我
叫
t
o
m
"""
生成器
生成器(generator): 生成器的本质就是迭代器 创建生成器的两种方案: 1.生成器函数 2.生成器表达式 生成器函数: 关键字:yield 生成器函数执行的时候,并不会执行函数,得到的是生成器 yield:只要函数中出现了yield,他就是一个生成器函数 作用: 1.可以返回数据 2.可以分段的执行函数中的内容,通过__next__()可以执行到下一个yield的位置 优势: 用好了,特别省内存 生成器的表达式:------> 一次性的 语法:(数据表达式 for循环 if判断)
def func():
print(123456)
yield 999 # yield也有返回的意思,只有执行到next的时候才会返回数据
ret = func()
print(ret) # <generator object func at 0x000001D1BEBB43C0>
print(ret.__next__()) # yield只有执行到next才会返回数据
print(ret.__next__()) # StopIteration
# yield可以分段的执行函数中的内容
def func():
print(123)
yield 555
print(234)
yield 212
ret = func()
print(ret.__next__()) # 123 555
print(ret.__next__()) # 234 212
# 用yeild的好处
# 省内存
def order():
lst = []
for i in range(10000):
lst.append(f"衣服{i}")
if len(lst) == 50:
yield lst
# 下一次拿数据
lst = []
gen = order()
print(gen.__next__()) # ['衣服0',...'衣服49']
print(gen.__next__()) # ['衣服50',...'衣服99']
推导式
推导式: 简化代码。 语法: 列表推导式:[数据表达式 for循环 if判断] 集合推导式:{数据表达式 for循环 if判断} 字典推导式:{k:v for循环 if判断} 不要把推导式妖魔化 元组推导式??? 元组没有推导式,他不能增加数据 (数据表达式 for循环 if判断) -----> 不是元组表达式,根本没有元组表达式,这是生成器表达式
lst = []
for i in range(10):
lst.append(i)
print(lst) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 上下等价
lst = [i for i in range(10)]
print(lst) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 1.创建一个列表[1,3,5,7,9]
lst = [i for i in range(1, 10, 2)] # [1, 3, 5, 7, 9]
lst = [i for i in range(10) if i % 2 == 1] # [1, 3, 5, 7, 9]
print(lst)
# 2.生成50件衣服
lst = [f"衣服{i}" for i in range(50)]
print(lst)
# 3.将如下列表中所有英文字母修改为大写
lst1 = ["allen", "tony", "jerry", "tom"]
lst2 = [item.upper() for item in lst1]
print(lst2) # ['ALLEN', 'TONY', 'JERRY', 'TOM']
# 集合推导式
s = {i for i in range(10)}
print(s) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
# 请将下列的列表修改成字典,要求:索引作为key,数据作为value
lst = ['赵本山', '蜜蜂', '狄仁杰', '奥特曼']
dic = {i:lst[i] for i in range(len(lst))}
print(dic) # {0: '赵本山', 1: '蜜蜂', 2: '狄仁杰', 3: '奥特曼'}
生成器表达式
# 生成器的表达式
gen = (i**2 for i in range(10))
print(gen.__next__()) # 0
print(gen.__next__()) # 1
print(gen.__next__()) # 4
print(gen.__next__()) # 9
# 拿出gen的所有元素
for item in gen:
print(item)
lst = list(gen)
print(lst) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 再运行一次为[] 生成器表达式是一次性的东西
# s = list("周杰伦") # list() ==> for ==> next()
# print(s) # ['周', '杰', '伦']
匿名函数
匿名函数: lambda表达式 语法: 变量 = lambda 参数,参数2,参数3...:返回值
# def func(a, b):
# return a + b
#
# ret = func(23, 45)
# print(ret) # 68
fn = lambda a, b: a + b
print(fn) # <function <lambda> at 0x0000017324AFB520> 说明他本质是个函数
ret = fn(12, 13)
print(ret) # 25
内置函数(下)
zip:可以把多个可迭代内容合并
lst1 = ["赵本山", "范伟", "苏有朋"]
lst2 = [40, 38, 42]
lst3 = ["卖拐", "耳朵大有福", "情深深雨蒙蒙"]
result = []
for i in range(len(lst1)):
first = lst1[i]
second = lst2[i]
third = lst3[i]
# result = result.append((first, second, third))
# list.append()方法会原地修改列表并返回None,
# 因此在循环中将其结果分配给result会导致result变成None。应该将元组添加到result列表而不是使用append()方法修改result。
result.append((first, second, third))
print(result) # [('赵本山', 40, '卖拐'), ('范伟', 38, '耳朵大有福'), ('苏有朋', 42, '情深深雨蒙蒙')]
result = zip(lst1, lst2, lst3)
for item in result:
print(item)
"""
('赵本山', 40, '卖拐')
('范伟', 38, '耳朵大有福')
('苏有朋', 42, '情深深雨蒙蒙')
"""
locals:查看当前位置局部变量的内容 globals: 查看全局
a = 144
print(locals()) # 此时locals被写在全局作用域范围内,此时看到的就是全局作用域中的内容
def func():
a = 334
print(locals()) # 此时locals放在局部作用域范围,看到的是局部作用域的内容
func() # {'a': 334}
c = 12
print(globals()) # globals看到的是全局作用域中的内容
def func():
a = 334
print(globals()) # 此时看到的仍然是全局作用域的内容
func()
sorted: 排序(默认从小到大)
lst = [13, 45, 65, 77, 787, 21, 38, 60]
s = sorted(lst)
s1 = sorted(lst, reverse=True)
print(s1) # [787, 77, 65, 60, 45, 38, 21, 13]
print(s) # [13, 21, 38, 45, 60, 65, 77, 787] 正常排序,由小到大
lst = ["湫", "狄仁杰", "李元芳", "超级狠人武则天", "爱因斯坦"]
# sorted(lst, key=排序函数)
# sorted工作原理是:先读取lst的东西,根据排序函数返回的值进行排序
# def func(item): # 此时item对应的是列表中的每一项数据
# return len(item)
# s = sorted(lst,key=func)
# print(s)
s = sorted(lst, key=lambda x: len(x))
print(s) # ['湫', '狄仁杰', '李元芳', '爱因斯坦', '超级狠人武则天'] 一般lambda配合sorted使用
lst = [
{"id": 1, "name": "周杰伦", "age": "17", "salary": "56700"},
{"id": 2, "name": "周润发", "age": "57", "salary": "56720"},
{"id": 3, "name": "周海媚", "age": "37", "salary": "34560"},
{"id": 4, "name": "周波通", "age": "23", "salary": "56740"},
{"id": 5, "name": "周大生", "age": "56", "salary": "24350"},
{"id": 6, "name": "周生生", "age": "77", "salary": "86540"},
{"id": 7, "name": "周洲洲", "age": "45", "salary": "45670"},
]
# 1,根据每个人年龄排序
s = sorted(lst, key=lambda d: d['age'])
print(s)
# 2,根据工工资从大到小排序
s = sorted(lst, key=lambda d: d["salary"], reverse=True)
print(s)
filter: 筛选filter(筛选的条件,筛选对象),根据筛选条件来判断该值是否保留
lst = ["张无忌", "张三丰", "张翠山", "马保国", "灭绝大师太", "小狐仙"]
f = filter(lambda x:not x.startswith("张"), lst)
print(list(f)) # ['马保国', '灭绝大师太', '小狐仙']
map: 映射,对数据批量处理map(筛选的条件,筛选对象),根据筛选条件直接保留
st = [1, 2, 3, 4, 5, 6, 7, 8, 9]
result = [item * item for item in lst]
print(result) # [1, 4, 9, 16, 25, 36, 49, 64, 81]
r = map(lambda x: x*x,lst)
print(list(r)) # [1, 4, 9, 16, 25, 36, 49, 64, 81]