函数
1. 什么函数
可以实现一些特定功能的方法
优点:
简化代码结构,增加代码的复用度
提高代码可读性,方便维护
2. 函数定义
def 函数名():
函数体
函数名: 遵循标示符命名规则
注意:
函数调用，先定义，后调用
同一个模块里, 函数可以重名,但是会被覆盖
函数区分大小写
defspeaker():
print("你们是最棒的~")
3. 函数定义方式
普通定义方式:
defspeak():
print("普通方式")
带有参数函数
defadd(x,y):# x,y 形参
print(x+y)
add(100,200)# x,y 实参
带默认值参数
错误形式:
defadd(x=10,y):# 形参中，不全都带默认值情况下, 默认值参数要靠后
print(x,y)
更正后:
defadd(x,y=10):
print(x+y)
总结:
1. 如果定义函数有形参, 但是没有默认值, 那么调用时候，必须传递实参,且实参个数必须与形参相等
2. 函数定义的时候,如果形参有默认值,那么传递的实参，会将默认值覆盖，不传递，也无所谓
3. 函数形参不全有默认值，那么在定义过程中，默认值参数靠后
关键字参数
定义: 可以使用关键字,来改变形参和实参默认顺序
注意: 要么都给，要么都不给
defkeyArgs(x,y):
print("x的值{},y的值{}".format(x,y))
keyArgs(10,x=20)
TypeError:keyArgs()gotmultiplevaluesforargument'x'
注意:
如果有形参并且没有默认值，实参中如果第一个给了关键字，其他都需要给
defkeyArgs(x,y):
print("x的值{},y的值{}".format(x,y))
keyArgs(x=10,20)
正确形式:
keyArgs(x=10,y=20)
实参赋值时候，如果顺序不固定，形参名 = 实参
def keyArgs(x,y):
print("x的值{},y的值{}".format(x,y))
keyArgs(y=10,x=20)
如果形参都有默认值, 第一个设置形参名=实参，其他不需要给
def keyArgs(x=10,y=20,z=30):
print("x的值{},y的值{},z的值{}".format(x,y,z))
keyArgs(y=90)
4. 函数返回值
关键字: return
def demo():
return "py"
print("hello ai")
没有返回值时候: None
返回多个值
def value():
return [1,2,3,4,5,6,7,8,9,10]
v = value()
print(v)
5. 函数练习
模拟实现pop功能
def pop(l):
new_list = l[:-1]
return new_list
l = [1,2,3,4,5]
l = pop(l)
print(l)
模拟实现popitem()函数功能,并返回被删除键值对
import random
def pop_item(dict):
keys = dict.keys()
klist = list(keys)
# 随机选择key一个效果
key = random.choice(klist)
# 获取key 和 value
key,value = key,dict[key]
del dict[key]
return key,value
d = {"头条":"抖音","阿里巴巴":"闲鱼","腾讯":"微信"}
key,value = pop_item(d)
print(key,value)
定义一个函数,实现字典健值交换
第一种写法:
transDict = {"a":1,"b":2,"c":3}
transDict_new = {}
for key , value in transDict.items():
transDict_new[value] = key
print(transDict_new)
第二种写法：
transDict_new = dict([val,key] for key,val in transDict.items())
print(transDict_new)
# 第三种写法
transDict_new = dict(zip(transDict.values(),transDict.keys()))
# print(transDict_new)
一，函数
作用：封装一段功能
函数定义关键字：def
1.不定长参数
概述：传入参数个数不固定
(1)不确定参数名，以元组形势去接收
如：def print(self , *args,sep="",sep="",end="\n",file=None)
deffunc(*args):
print(args)
func(1,2,3,4,5)
输出结果：(1,2,3,4,5)
deffunc(a,b,*args):
print(a)
print(b)
print(args)
print("*"*10)
pow=a*b
forxinargs:
pow*=x
returnpow
zj=func(1,2,3,4,5)
print(zj)
结果：
1
2
(3,4,5)
**********
120
2.关键字参数
概述：不确定参数接收，必须是[关键字+值],形态是字典
# 关键字参数定义
deffunc(**kwargs):
# 打印关键字参数
print(kwargs)
# 遍历每一个关键字参数
forkeyinkwargs:
print(key,kwargs[key])
func(x=1,y=2,z=3)
3.*和**一起作为形参
# *args 和 **args在一起的时候，*args排在**kwargs前
deffunc(*args,**kwargs):
print(args,kwargs)
func(1,2,3,4,5=2,2=3)
4.实参为*args的情况
deffunc(a,b,c,d):
print(a,b,c,d)
l=[1,2,3,4]
func(*l)
5.实参为**kwargs的情况
deffunc(**dict):
print(dict)
d= {"z":"j","cx":"k"}
func(**d)
二，参数分为可变类型和不可变类型
不可变类型：整数，字符串，元组；不会影响参数本身
defcInt(a):
a=10
n=2
cInt(b)
print(b)
可变数据类型：列表，字典，集合；会影响到参数本身
defchangeList(1):
l.append([1,2,3,4])
print("函数内的列表："l)
l= [66,33,1]
changeList(l)
print("函数外的列表："l)
三，匿名函数
关键字：lambda
注意: 1.lambda只是一个表达式，函数体比def简单的多
2.封装的逻辑有限
实例
1.普通定义
add=lambdaa,b:1+b
print(add(10,20))
2.直接调用
(lambdaa,b:a+b)(a,b)
3.带有默认值参数
a=lambdaa=20,b=30:a+b
4.没有参数
a=2
b=3
c=lambda:a+b
四，递归函数
注意：自己调用自己，注意调用自己的深度，过多，计算机栈空间不足
满足条件终止
deffact(n):
ifn==1:
return1
returnn*fact(n-1)
print(fact(4))
函数
回顾
变量作用域
num=int(10) # 内置变量 B
num=20 # 全局变量 G
defouter():
num=30 # 闭包变量 E
definner():
num=40 # 局部变量 L
print(num)
returninner
i=outer()
i()
注意：访问顺序LEGB
列表中元素大小写转换
l=l= ["pY","IS","eASY"]
bs_list=[x.swapcase()foriinl]
print(bs_list)
迭代器
数据类型看并且可以使用for循环
1> list,set,tuple,dict,string
2> generator[生成器] 【第一种形式: (),函数结合yield】
deflg(num):
foriinrange(1,num):
yieldi
l=lg(10)
# 生成器保存是算法，而列表保存内容是在内存中,列表不占优势,耗内存，生成器节约内存开销
print(sum(l))
# 生成器只被使用一次
print(sum(l))
gs= (xforxinrange(1,10))
判断是否为生成器
fromcollectuons.abcimportiterable
isintance(gs,iterable)
关键字：
['False','None','True','and','as','assert','async','await','break','class','continue','def','del','elif','else','except','finally','for','from','global','if','import','in','is','lambda','nonlocal','not','or','pass','raise','return','try','while','with','yield']
装饰器
作用：程序代码运行时，动态增加功能
本质：就是一个闭包，返回了函数的高阶函数
好处：遵循开闭原则，对修改关闭，对扩展开放
defdemo():
print("demo func")
deffunc():
print("demo func")
print("func")
func()
# y是形参，是函数
defdemo(y):
print("demo func")
y()
@demo
deffunc():
print("func")
func是实参
带参数的装饰器
defdemo(func):
definner(age):
ifage<=10:
mystr="children"
elifage<=20:
mystr="midman"
else:
mystr="oldman"
returnfunc(mystr)
returninner
@demo
deffunc(p):
print("你是一个这样的",p)
# 调用
func(60)
栈和队列
栈
特点:先进后出
具体化:羽毛球筒
my_stack = []
# 向栈进入数据
my_stack.append(23)
my_stack.append(22)
my_stack.append(21)
my_stack.append(20)
my_stack.append(19)
print(my_stack)
my_stack.pop()
print(my_stack)
my_stack.pop()
print(my_stack)
my_stack.pop()
print(my_stack)
my_stack.pop()
print(my_stack)
my_stack.pop()
print(my_stack)
结果:
[23, 22, 21, 20, 19]
[23, 22, 21, 20]
[23, 22, 21]
[23, 22]
[23]
[]
队列
特点:先进先出
import collections
queue = collections.deque([1,20,25,40])
print(queue)
# 入队一年
queue.append(68)
print(queue)
queue.append(77)
print(queue)
# 出队
queue.popleft()
print(queue)
queue.popleft()
print(queue)