def test1():
print("我是无参无返回值函数")
test1()
def test2(num):
print(num ** 1)
print(num ** 2)
print(num ** 3)
test2(3)
def test3(num):
a = num +1
return a
result = test3(4)
print(result)
def test4(num1, num2):
print(num1 + num2)
test4(3,4) # 直接输入实参,形参和实参一一对应
test4(num2=5, num1=4) # 按照关键字传递参数,不是按照参数顺序传递参数的
def test5(*t):
print(t, type(t))
result = 0
for i in t:
print(i)
result += i
print(result)
test5(1,2,3,4,5)
def test6(**kwargs):
print(kwargs, type(kwargs))
test6(name="larry", age=18, sex="男")
def mySum(a,b,c,d):
print(a + b + c + d)
def test7(*args):
# 装包, *args代表是拆包,代表一个一个的数据,args代表是装包,代表是一个整体
print(args)
# 拆包,应该使用一个*用于拆包操作, 不用*用于装包操作
print(*args)
print(args[0],args[1], args[2], args[3])
mySum(*args)
test7(1,2,3,4)
def mySum(a,b,c):
print(a)
print(b)
print(c)
def test8(**kwargs):
# 装包, **kwargs代表是拆包,代表一个一个的数据,kwargs代表是装包,代表是一个整体
print(kwargs)
# 拆包,应该使用两个**用于拆包操作, 不用*用于装包操作
# print(**kwargs) # 不可以直接打印这个**kwargs,要有接收对应的函数和参数
mySum(**kwargs)
test8(a="sz", b=18, c="男") # 调用的时候,也要输入对应的keyword才可以,否则会报错,找不到对应的keyword
# 函数返回值
def test9(a,b):
he = a + b
cha = a - b
return (he, cha)
# res是一个集合
res = test9(4, 5)
# 拆包:
he, cha = test9(4, 5)
print(res)
# res集合拆包
print(res[0], res[1])
print(he, cha)
# 一般函数的描述,需要说明如下几个信息:函数的功能,参数的含义、类型、是否可以省略、默认值,返回值的含义、类型
def mySum(a, b=1):
"""
计算两个说的和,以及差
:param a: 数值1,数值类型,不可选,没有默认值
:param b: 数值2,数值类型,可选,默认值:1
:return: 返回计算的结果,元组类型:(和,差)
"""
he = a + b
cha = a - b
return (he, cha)
help(mySum)
#------------------------函数的高级用法------------------------
import functools
def test10(a,b,c,d=1):
res = a + b + c + d
print(res)
# test10(1,2,3)
#
# # 再定义一个偏函数
# def test11(a,b,c,d=2):
# test10(a,b,c,d)
#
# test11(1,2,3)
# 使用python自带的一个功能,通过functools模块的partial类来创建一个偏函数,不指定参数的值
newFunc = functools.partial(test10, c=5, d=2)
newFunc(1,2) # 这个就是新的偏函数,只要输入两个参数就可以了,其他参数使用默认的固定的值
# 偏函数的使用场景,比如int()函数,int()函数有个参数是base,用于指定使用哪个“进制”进行转换成int整数,将数值字符串以某一个进制进行转换
numStr = "10010"
# 导入functools模块,使用里面的partial方法,指定进制base=xx,然后产生一个偏函数
import functools
intTransfer = functools.partial(int, base=16)
res = intTransfer(numStr)
print(res)
l = [{"name":"sz", "age":18}, {"name":"sz2", "age":19}, {"name":"sz3", "age":18.5}]
# 定义个对于l列表选择什么字段进行排序的函数,这个函数会接收l列表中的每个元素
def getKey(x):
return x["name"]
result = sorted(l, key=getKey, reverse=-1)
print(result)
def caculate(num1, num2, caculateFunc):
result = caculateFunc(num1, num2)
print(result)
def sum(a, b):
return a + b
def jianfa(a, b):
return a - b
caculate(num1=6, num2=2, caculateFunc=jianfa)
def getFunc(flag):
# 1.再次定义几个函数
def sum(a, b, c):
return a + b + c
def jian(a, b, c):
return a - b - c
# 2.根据不同的flag的值,来返回不同的操作函数
if flag == "+":
return sum # 返回的是函数sum,而不是调用sum函数,因为没有加()
elif flag == "-":
return jian # 返回的是函数jian,而不是调用jian函数,因为没有加()
backFunc = getFunc("-") # 参数传入flag是“+”,返回的是sum函数,flag是“-”,返回的是jian函数
print(backFunc, type(backFunc))
res = backFunc(1,2,3) # backFunc是个返回函数,那么就可以调用这个函数,并传入参数
print(res)
newFunc2 = lambda x, y : x + y
res = newFunc2(1,2)
print(res)
l = [{"name":"sz", "age":18}, {"name":"sz2", "age":19}, {"name":"sz3", "age":18.5}]
# 定义个对于l列表选择什么字段进行排序的函数,这个函数会接收l列表中的每个元素
# def getKey(x):
# return x["name"]
result = sorted(l, key=lambda x : x["age"])
print(result)
def test11():
a = 10
def test12():
print(a)
return test12
newFunc3 = test11()
newFunc3()
def line_config(content, length):
def line():
print(("-" * (length // 2)) + content + ("-" * (length // 2)))
return line
newFunc4 = line_config("aaaa", 20)
newFunc4()
newFunc5 = line_config("bbbb", 10)
newFunc5()
def test13():
num = 1
def test14():
nonlocal num
num = 6
print(num)
print(num)
test14()
print(num)
return test14
newFunc5 = test13()
newFunc5()
def test15():
a = 1
def test16():
print(a)
a = 2
return test16
newFunc6 = test15()
newFunc6()
def test17():
funcs = []
for i in range(1,4):
def test18(num):
def inner():
print(num)
return inner
funcs.append(test18(i)) # 这个代表,添加的是返回的inner函数,以及对应i的值
return funcs
newFuncs = test17()
print(newFuncs)
newFuncs[0]()
newFuncs[1]()
newFuncs[2]()
def checkLogin(func): # 装饰器函数,为了对于fss()和ftp()函数增加一些额外的小功能,可以定义一个装饰器函数
def inner():
print("登录验证...") # 增加额外的功能代码
func() # 传入的函数
return inner # 返回内部函数,此内部函数为传入的函数增加了额外的功能代码
#python的语法糖模式,其实就是设计模式,类似调用了checkLog(func)函数并反应一个内部函数,
# 且此返回的函数名字与踹人的函数名字是一样的
@checkLogin # @checkLogin语法糖,返回一个与下面函数一样的名字的函数,并将此函数额外增加了其他的功能代码
def fss():
print("发说说")
# fss = checkLogin(fss)
#python的语法糖模式,其实就是设计模式,类似调用了checkLog(func)函数并反应一个内部函数,
# 且此返回的函数名字与踹人的函数名字是一样的
@checkLogin # @checkLogin语法糖,返回一个与下面函数一样的名字的函数,并将此函数额外增加了其他的功能代码
def ftp():
print("发图片")
# ftp = checkLogin(ftp)
# 2.相关的逻辑代码
btnIndex = 1
if btnIndex == 1:
fss()
else:
ftp()
def zsq(func):
def inner(*args, **kwargs):
print("_" * 30)
res = func(*args, **kwargs)
return res
return inner
@zsq
def pnum1(num1, num2, num3):
print(num1, num2, num3)
return num1 + num2 + num3 # 增加功能函数的返回值,那装饰器也要写成一直的形式
@zsq
def pnum2(num):
print(num)
return num
@zsq
def pnum3(*args, **kwargs):
print(*args, **kwargs)
res1 = pnum1(1,2, num3=666) # 执行这里的pnum1()函数,就是执行inner函数
res2 = pnum2(999) # 执行这里的pnum2()函数,就是执行inner函数
res3 = pnum3(1,2,3,4,5,56,6) # 执行这里的pnum3()函数,就是执行inner函数
print(res1,res2,res3) # 打印查看返回值
def getZsq(char): # 返回装饰器函数,是个固定的格式,通过参数来控制,装饰器的内部函数里面的参数值
def zsq(func): # 装饰器函数,也是个固定的格式
def inner(*args, **kwargs): # 闭包返回的函数,也是个固定的格式
print(char * 30)
res = func(*args, **kwargs) # 功能函数有返回值的固定写法,也是个固定的格式
return res # 返回功能函数的值
return inner # 返回增加新功能的内部功能函数,也是个固定的格式
return zsq # 返回里面的装饰器,也是个固定的格式
@getZsq("*_") # 调用返回装饰器的函数,并传入控制装饰器内部函数需要的参数值
def f1(num):
print("666", num)
return num
res1 = f1(2)
res2 = f1(3)
print(res1, res2)
l1 = [i for i in range(1,10) if i % 2 == 0] # 这是列表[]的推导式,会把所有的数据都加载到内存里面
l2 = (i for i in range(1,20) if i % 2 == 0) # 这是列表[]修改成()就变成生成器表达式了,这个表达式的结果就是一个生成器的对象
print(l1)
print(l2)
print(l2.__next__())
print(l2.__next__()) # 迭代器会记录当前的状态位置,知道下次到什么位置,取什么数据,不会一下子把所有的数据都加载到内存里
print(next(l2)) # next(l2)与l2.__next__()是一样的功能,获取下一个的数据
for i in l2:
print("for迭代:",i)
def test():
yield 1
print("a")
yield 2
print("b")
yield 3
print("c")
yield 4
print("d")
g = test()
print(g)
print(g.__next__())
print(g.__next__())
print(g.__next__())
def test():
for i in range(1,10):
yield i
g = test()
print(g)
print(g.__next__())
print(next(g))
print(g.__next__())
print(next(g))
def test():
res1 = yield 1
print(res1)
res2 = yield 2
print(res2)
res3 = yield 3
print(res3)
g = test()
print(g.send(None)) # 首次使用send()方法,参数必须是None,
print(g.__next__())
print(g.send("000"))
# 关闭生成器的方法,g.close()
# 先写一个生成器的函数
def test():
yield 1
print("a")
yield 2
print("b")
yield 3
print("c")
# 通过生成器函数,先生成一个生成器g
g = test()
# 下面可以对于生成器g进行操作
print(g.__next__())
print(g.__next__())
g.close() # 通过生产器的close()方法,意思就是将生成器的状态指导生成器的最后,再调用的时候就会报错StopIteration
print(g.__next__())
def test1():
yield 1
print("aa")
# return 10
yield 2
print("bb")
yield 3
print("cc")
# 通过生成器函数,先生成一个生成器g
g = test1()
# 下面可以对于生成器g进行操作
print(g.__next__())
print(g.__next__()) # 当执行这个代码时就会执行return语句了,就会报错StopIteration 并返回 return 后的值
print(g.__next__())
def test2():
yield 1
print("aaa")
# return 10
yield 2
print("bbb")
yield 3
print("ccc")
# 通过生成器函数,先生成一个生成器g
g = test2()
for i in g: # for遍历生成器时,能够将生成器里面的最后yield语句下面的代码执行完
print(i)
print("当前执行的位置xxxxxxxx,下面代码不会执行")
for i in g: # 当第二次遍历生成器时就不会执行了,前面的print()函数代表是执行的位置,要想使用还需要
print(i) # 再获取一次生成器
:
if n == 1: # 这里就是传递结束的位置条件,也是回归的开始位置条件
return 1
# 下面肯定是 n != 1的情况
return n * jieCheng(n-1)
result = jieCheng(3)
print(result)
a = 10 # a是G,全局变量,作用域是整个文档内
def test3():
b = 9 # b是E,外部嵌套函数的命名空间
print(b)
def test4():
c = 8 # c是L,局部变量
print(b)
return c
return test4
print(__name__) # __name__是B, python内建变量,每个文件里面都可以使用
print(a)
newFunc = test3()
res = newFunc()
print(res)