#关于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的平方。