4.28笔记+day6作业

#关于ID的问题

a="1qew"
b="1qew"
print(a==b)
print(a is b)
print(id(a))
print(id(b))

x=[1,2,3]
y=x.copy()
print(x==y)
print(x is y)#copy 虽然数据是一样的，但地址是不同的
print(id(x))
print(id(y))

def jisuan(a,b):
    print(id(a),2)
    a=20
    print(id(a),3)
    c=a+b
    return c
x=5
print(id(x),1)
y=6
z=jisuan(x,y)
print(z)
print(x)

a=[1,2,3,4]
y=[4,5,6]
def modify(b,c):
    print(id(b))
    c=[5,6,7]
    b.append(5)#列表的修改不会影响地址
    print(id(b))
print(id(a))
modify(a,y)
print(a)
print(y)

def hanshu(a=[]):  #可变类型作为默认函数，不建议使用，因为会造成歧义
    a.append("q")
    print(a)
hanshu()
hanshu()

def hanshu(a,b):
    xy=4
    xz=5
    print(locals())
x=0
y=1
hanshu(x,y)
sss=111
print(globals())
#locals 和globals分别提供了基于字典的访问局部和全局变量的方式。

a=[1,2,3]   #全局变量
def hanshu():
    x=3     #局部变量，只能内部调用
    y=45
    print(a)
hanshu()
print(a)
y=3456
print(y)

#全局变量和局部变量可以重名
a=3
def hanshu():
    a=5
    print(a)
hanshu()
print(a)

#全局变量是不可变类型，函数无法修改全局变量的值，函数中一旦出现等号，那么变量就是局部变量
a=3
def hanshu():
    a=4
    print(a)
hanshu()
print(a)
#全局变量是可变类型，那么函数可以修改全局变量值
a=[1,2,3,4]
def hanshu():
    a.append(5)
hanshu()
print(a)

#函数里面再调用一个函数
def hanshu():
    a=2
    def hanshu2(x,y):
        z=x+y
        return z
    b=3
    d=hanshu2(a,b)
    return d
print(hanshu())

#global 将局部变量变为全局变量
def hanshu():
    global a
    a=10
hanshu()
print(a)

#nonlocal 可以修改外层（非全局）变量
b=3
def hanshu1():
    a=1
    b=2
    def hanshu2():
        nonlocal a
        nonlocal b
        a=4
        b=5
    print(a)
    hanshu2()
    print(a)#调用hanshu2时，a变量发生改变
hanshu1()
print(b)#b是全局变量，所以不能改变

#作用域按照变量的定义位置可以分为四类，即LEGB:
#L:Local(函数内部)局部作用域
#E:Encolosing(嵌套函数的外层函数的内部）嵌套作用域（闭包）
#G:Global（模块全局）全局作用域
#B:Built-in(内建）内建作用域。（指的是builtins.py模块）

 a=1
    b=2
    c=3
    def hanshu1():
        a=4
        b=5
        def hanshu2():
            a=6
            print(a)#本地
            print(b)#嵌套
            print(c)#全局
            print(__name__)#内置
        hanshu2()
    hanshu1()
    
    #lambda作为表达式，定义一个匿名函数
    a=lambda x,y,z:x+y*z
    b=a(1,2,3)
    print(b)
    
    #绝对值 abs()
    a=-5
    b=20
    print(abs(a))
    print(abs(b))

# key=

a=[1,2,3,-5]
b=max(a,key=abs)#求绝对值最大的
print(b)

def hanshu(a):
    return a*-1
a=[1,2,3,-5]
b=max(a,key=hanshu)
print(b)

def hanshu(a):
    return a*-1
a=[1,2,3,4,-5]
b=max(a,key=lambda a:a*-1)
print(b)


#map :map() 会根据提供的函数对指定序列做映射
def a(d):
    return d*d
x=(1,2,3)
y=map(lambda e:e*e,x)
print(y)
for d in y:
    print(d)
#结果：1  4  9

#filter 过滤作用
def func(i):
    if i%3==0:
        return True
x=[1,2,3,4,5,6,7,8,9,10]
d=filter(func,x)
for x in d:
    print(x)

#zip:zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，
# 然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，
# 则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
a=[1,2,3,4]
b=[“a”,“b”,“c”]
c=zip(a,b)
print©
for i in c:
print(i)

a=("a","c")
b=("b","d")
c=zip(a,b)
def func(x):
    return {x[0]:x[1]}
lb=[]
for x in c:
    lb.append(func(x))
print(lb)

#第二种方法
a=("a","c")
b=("b","d")

c=list(map(lambda e:{e[0]:e[1]},zip(a,b)))
#先使用zip()，将两个列表的数一一对应，然后再转换成字典的格式，最后在输出为列表
print(c)    

#将[1,10,2,20,3,30,4,40]变为[{11:22},{33:44}]
a=[1,10,2,20,3,30,4,40]
b=[]
c=[]
for i in range(0,len(a),2):
    if i==0 or i==4:
        b.append(a[i]+a[i+1])
    else:
        c.append(a[i]+a[i+1])

d=list(map(lambda x:{x[0]:x[1]},zip(b,c)))
print(d)

a={"a":18,"b":33,"c":12}
def xxx(x):
    return a[x]
d=max(a,key=xxx)
print(d)

a={"a":18,"b":33,"c":12}
def xxx(x):
    return a[x]
d=max(a,key=lambda k:a[k])
print(d)

a=[{"name":"张三",'age':18},
{"name":"李四",'age':28},
{"name":"王五",'age':48},
{"name":"小明",'age': 8},
   ]
def hanshu(a):
    return a["age"]
m=max(a,key=hanshu)
print(m)
k=max(a,key=lambda a:a["age"])
print(k)
a.sort(key=hanshu)
print(a)


def hanshux():
    x=3
    def hanshunei(n):
        return x**n
    return hanshunei
b=hanshux()
print(b(2))

def hanshux():
    x=3
    z=lambda n:x*n
    return z
x=9
b=hanshux()
print(b(2))

def xx():
    lb=[]
    for i in range(4):
        lb.append(lambda x:x*i)
    return lb
a=xx()
print(a[0](2))
print(a[1](2))
print(a[2](2))
print(a[3](2))
#
a=lambda x:x*i
i=2
b=lambda x:x*i
print(a(3))
print(b(3))

作业

**# 1. 判断gl_num和gl_list的值**
def func(num, num_list):
    num += num
    num_list += num_list
    print(num)
    print(num_list)
    print("函数完成")
gl_num = 9
gl_list = [1, 2, 3]
func(gl_num, gl_list)
print(gl_num)
print(gl_list)

**# 2.请说出 list1,list2,list3 的值是什么，并且说明为什么**
def extendlist(val, lis=[]):
    lis.append(val)
    return lis

list1 = extendlist(10)

list2 = extendlist(123, [])

list3 = extendlist('a')

print(list1)  # [10,'a']

print(list2)  # [123]

print(list3)  # [10,'a']

**# 3.请说出acts[0](2)的值，并且说明为什么**
def makeActions():
    acts = []
    for i in range(5):
        acts.append(lambda x: i ** x)
    return acts
acts = makeActions()
print(acts[0](2))
print(acts[1](2))
print(acts[2](2))
print(acts[3](2))
print(acts[4](2))

#因为会先在函数内部遍历，遍历完的i是4，所以不管下表是几，最后的结果都是4的平方。