0225函数。LEGB，lambda

def jisuan(a,b):
    c=a+b
    d=a-b
    e=a*b
    f=a/b
    return c,d,e,f
x=jisuan(9,3)
print(x,type(x))
j,k,l,m=jisuan(9,3)
print(j,k,l,m)
# 函数返回多个值，就是返回一个tuple。
(12, 6, 27, 3.0) <class 'tuple'>
12 6 27 3.0
#

def hanshu(a):
    a+=2
    print(a)
b=4
hanshu(b)
print(b)
#整型，字符串，元组。不可变量。b不变。
6
4
#

def hanshu(a):
    a.append(4)
    a=6
b=[]
hanshu(b)
print(b)
# 可变数据类型。列表，字典。
[4]
#

def pt(name,age,sex):
    print("我叫",name)
    print('年龄',age)
    print('性别',sex)
pt(sex='female',name='alice',age=88)
# 关键字参数。调用函数时，在实参中，括关系号里面顺序没有
我叫 alice
年龄 88
性别 female
#

def pt(name,age,sex='男'):
    print("我叫",name,end='\t\t')
    print('年龄',age,end='\t\t')
    print('性别',sex)
pt("张三",2)
pt(3,'李四')  # 顺序赋值
pt('王五',11,'女')
pt(sex='female',name='alice',age=99)
pt(name='alice',age=99)
# 默认参数
我叫 张三     年龄 2      性别 男
我叫 3      年龄 李四     性别 男
我叫 王五     年龄 11     性别 女
我叫 alice      年龄 99     性别 female
我叫 alice      年龄 99     性别 男
#

def pt(*args):
    print(args,type(args))
    for i in args:
        print(i)
pt(1,2,3,5,6)
# 可变参数。 *args结果类型是元组。传递值是任意类型
(1, 2, 3, 5, 6)<class 'tuple'>
1
2
3
5
6
#

def sxh(**kwargs):
    print(kwargs,type(kwargs))
    for k,v in kwargs.items():
        print(k,v,end=' ')
    print()
sxh(name='zhang',age=18,sex='男')
sxh(name='李四',age=28,sex='女',address='湖北')
# 可变参数。**kwargs结果类型是字典，传递值是以key=value方式传入
{'name': 'zhang', 'age': 18, 'sex': '男'} <class 'dict'>
name zhang age 18 sex 男
{'name': '李四', 'age': 28, 'sex': '女', 'address': '湖北'} <class 'dict'>
name 李四 age 28 sex 女 address 湖北
#

def sxh(a,b,d=[]):
    d.append('x')
    print(d)
sxh(1,2)
sxh(10,20)
# 默认参数 一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误。
#上面默认参数用list，导致每调用函数一次，列表加一个'x',而这并不是作者想要实现的功能，也就是产生逻辑错误。
['x']
['x', 'x']
#

def waibu():
    print('111')
    def neibu():
        print('2222')
    neibu()
waibu()
# python 允许在定义函数中，再定义函数。外部无法调用内部的函数。
111
2222
#

a=0
def hanshu():
    a=2
    print(a)
hanshu()
print(a)
# 在函数里面的变量，叫局部变量。在函数外面的变量，叫全局变量。函数用完，资源回收。
# 当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用，在其他地方全局变量起作用
2
0
#

a=[]
def hanshu():
    a.append(1)
hanshu()
print(a)
# 如果全局变量是可变的数据类型，函数可以对全局变量内部直接进行修改。
[1]
#

a=3
def hanshu():
    a=a+5
    print(a)
hanshu()
print(a)
# a=a+5 表示声明一个a了，但函数中并没有声明。函数外面声明了a=3,，函数优先 读取 局部变量，能 读 全局变量，无法对全局变量重新复制操作。
# 函数内能够 读取 外部的 a=3，但不能在内部给a重新赋值，而a+=5是表示赋值。
local variable 'a' referenced before assignment  局部变量a没声明，就在引用了。外部变量有a，但无法对全局变量赋值。
#

a=3
def hanshu():
    a+=5
    print(a)
hanshu()
print(a)

a=3
def hanshu():
    a+=5
hanshu()
print(a)

a=3
def hanshu(a):
    a+=5
    print(a)
hanshu(a)
print(a)
# 全局变量和局部变量同名时，在定义局部变量的子程序内，局部变量起作用，在其他地方全局变量起作用。
#整型
8
3
#
a=3
def hanshu(a):
    a+=5
    print(a)
hanshu(a)
print(a)

a=3
def hanshu(a):
    a+=5
    print(a)
hanshu(a)
print(a)

a=3
def hanshu():
    a=5
    print(a)
hanshu()
print(a)

a=3
def hanshu():
    global a
    a=5
    print(a)
hanshu()
print(a)
# global 定义全局变量。全局改动。
5
5
#

a=3
def hanshu():
    global a
    a=5
    print(a)
hanshu()
print(a)

a=3
def hanshu():
    global a
    a=5
    print(a)
hanshu()
print(a)


def hanshu():
    a=30
    def neibu():
        nonlocal a #nonlocal关键字使用外层非全局变量，相当于把a=30的a拿来用。
        a=40
    print(a)
    neibu()
    print(a)
hanshu()
#
30
40
#

def hanshu():
    a=30
    def neibu():
        nonlocal a
        a=40
    print(a)
    neibu()
    print(a)
hanshu()

def hanshu():
    a=30
    def neibu():
        nonlocal a
        a=40
    print(a)
    neibu()
    print(a)
hanshu()

def hanshu():
    a=30
    def neibu():
        nonlocal a
        a=40
    print(a)
    neibu()
    print(a)
hanshu()

a=100
b=30
c=1
def waibu():
    b=200
    c=2
    def neibu():
        c=300
        print(c) # LOCAL 局部作用域
        print(b) # ENCLOSE 嵌套作用域
        print(a) # GLOBAL 全局变量
        print(max) # BUILD-IN 内置作用域
    neibu()
waibu()
#变量的查找顺序。LEGB法则
300
200
100
<built-in function max>
#
a=100
b=300
c=1
def waibu():
    b=200
    c=2
    def neibu():
        c=300
        print(c)
        print(b)
        print(a)
        print(max)
    neibu()
waibu()

def jiecheng(n):
    if n==1:
        return 1
    else:
        return n*jiecheng(n-1)
print(jiecheng(5))

def jiecheng(n):
    if n==1:
        return 1
    else:
        return n*jiecheng(n-1)
print(jiecheng(4))

def jiecheng(n):
    if n==1:
        return 1
    else:
        return n*jiecheng(n-1)
print(jiecheng(6))

def fbnq(n):
    if n==1 or n==2:
        return 1
    else:
        return fbnq(n-1)+fbnq(n-2)
print("斐波那契数列如下所示：")
for i in range(1,13):
    print(fbnq(i),end=' ')

def fbnq(n):
    if n==1 or n==2:
        return 1
    else:
        return fbnq(n-1)+fbnq(n-2)
print("斐波那契数列如下：")
for i in range(1,13):
    print(fbnq(i),end=' ')

def fbnq(n):
    if n==1 or n==2:
        return 1
    else:
        return fbnq(n-1)+fbnq(n-2)
for i in range(1,13):
    print(fbnq(i),end=' ')

def fbnq(n):
    if n==1 or n==2:
        return 1
    else:
        return fbnq(n-1)+fbnq(n-2)
print("斐波那契数列：")
for i in range(1,13):
    print(fbnq(i),end=' ')

def fbnq(n):
    if n==1 or n==2:
        return 1
    else:
        return fbnq(n-1)+fbnq(n-2)
print(""斐波那契数列:)
for i in range(1,13):
    print(fbnq(i),end=' ')


x=lambda x:x*2+3
print(x(10))
print(x(5))
y=lambda a,b:a*2+b
print(y(3,5))
# lambda 函数的使用
23
13
11
#

a={'name':"张三",'age':18,'address':'北京'}
x=lambda b:b['age']
print(x(a))  # x(a) -> a['age']
# 注意准确的替换
18
#

a=abs(-4)
print(a)
a=[1,21,-22]
b=max(a,key=abs)  # max用法的。返回绝对值最大的数。
print(b)
#
4
-22
#
a=abs(-4)
print(a)
a=[1,21,-32]
b=max(a,key=abs)
print(b)

a=abs(-4)
print(a)
a=[1,21,-32]
b=max(a,key=abs)
print(b)

a=abs(-1)
print(a)
a=[1,21,-32]
b=max(a,key=abs)
print(b)

a=[-2,-3,4,1,9,7]
a.sort(key=abs) # 按照绝对值的大小来排
print(a)

a=[
    {'name':1,'age':18,'address':'山东'},
    {'name':2,'age':28,'address':'山西'},
    {'name':3,'age':38,'address':'广东'},
    {'name':4,'age':48,'address':'广西'}
]
c=max(a,key=lambda x:x['age']) # a里面选最大的，选的标准是a['age']
print(c)
#
{'name': 4, 'age': 48, 'address': '广西'}
#
c=min(a,key=lambda x:x['name']) # 在a里面选个最小的，选的标准是啊a['name']
print(c)
#
{'name': 1, 'age': 18, 'address': '山东'}
#
c=max(a,key=lambda x:x['age'])
print(c)
c=min(a,key=lambda x:x['age'])


i=10
def a(x):
    print(x*i)
i=20
def b(x):
    print(x*i)
i=30
def c(x):
    print(x*i)
print(a(3)) # i=30 -> print(3*i=90) -> a(x) 没有return，返回None
print(b(3)) #
print(c(3))
#
90
None
90
None
90
None
#

i=10
def a(x):
    print(x*i)
i=20
def b(x):
    print(x*i)
i=30
def c(x):
    print(x*i)
print(a(3))
print(b(3))
print(c(3))

i=10
def a(x):
    print(x*i)
i=20
def b(x):
    print(x*i)
i=30
def c(x):
    print(x*i)
print(a(3))
print(b(3))
print(c(3))

a=[lambda x:x*i for i in range(3)]  #声明lambda函数，列表a有三个元素
print(a[0](3)) #调用函数时，i=2,x=3
print(a[1](3))
print(a[2](3))

a=[lambda x:x*i for i in range(3)]
print(a[0](3))


a=[lambda x:x*i for i in range(3)]
print(a[1](3))


a=[lambda x:x*i for i in range(3)]
print(a[0](3))

a=[lambda x:x*i for i in range(3)]
print(a[2](3))

lambda x:x*i for i in range()