今天有点晚了，把代码附上

局部变量与全局变量的问题

a=100
def hanshu_1():
global a			#将函数内的变量a变成了全局变量
a=200
print(a)
hanshu_1()
#a在这已经变成了全局变量，第2行的a已经被覆盖了
print(a)

函数嵌套

def waibuhs_1():
b=30
def neibuhs_1():
global b#
b=40
print(b,'属于内层')		#40，下面调用了neibuhs_1 那么对于变量来说，先调用内部的局部变量b=40
neibuhs_1()
print(b,'属于外层')			#30，你是waibush_1的，那么你应该是输出对应的局部变量b=30
waibuhs_1()
#此时，b=40已经在这了，并且变成了全局变量
print(b,'最后输出')				#40，输出全局变量b=40

函数的接收问题

def hanshu_2(a,b):
c=a+b
d=a-b
e=a*b
f=a/b
return c,d,e,f
c=hanshu_2(1,2)
print(c,'|')					#变量个数少于输出的值可以可以，多了不行，输出元组
a,b,d,e=hanshu_2(3,4)
print(a,'|',b,'|',d,'|',e)		#输出的是int
x,*y=hanshu_2(5,6)
print(x,'|',y)					#输出一个int 一个元组
# n,**m=hanshu_2(7,8)，会报错，所以不能用字典接收

看清楚a值的变化

a=100
def hanshu_3(d):
c=a+d
print(c,'上面的函数')
a=200
def hanshu_4(d):
c=a+d
print(c,'下面的函数')
hanshu_3(5)				#205 上面的函数
hanshu_4(5)				#205 下面的函数

函数中的实参、形参、默认参数

def hanshu_5(name,age,sex='男'):
print('我叫',name,end='')
print('今年%d'%age,end='')
print('性别',sex)
hanshu_5('张三',18)
hanshu_5('李四',19,'女')
# hanshu_5('王五',10,'男',jiguan='中国')  输出不了

函数参数是可变类型，可变类型发生迭代

def hanshu_6(b,a=[]):
a.append(100)
print(b,a)
hanshu_6(10)		#10 [100]，函数调用一次，那么a就增加了一次
hanshu_6(12)		#12 [100, 100] 函数已经是第二次调用了，那么a原来已经有啦上一个的值，这次就再增加一个  即可变类型发生迭代

函数定义可变类型之元组

def hanshu_7(*args):		#你给元组多大，元组就多大
print(args)
hanshu_7(1,3,4,5,6,7)		#(1, 3, 4, 5, 6, 7)
hanshu_7(2,'77')			#(2, '77')
hanshu_7()					#()

函数定义可变类型之字典

def hanshu_8(**kwargs):
print(kwargs)
hanshu_8(name='张三',age='18')		#{'name': '张三', 'age': '18'}
hanshu_8()							#{}

lambda函数——简化函数结构体，这样做的好处是减少了代码量

a_1=lambda x,y:x+y
print(a_1(5,6))				#11

用lambda得到字典中的value

zd_1={'name':'小明','age':10,'年级':'一年级'}
hs_9=lambda y:y.values()
hs_10=lambda y:y['年级']
print(hs_9(zd_1))					#dict_values(['小明', 10, '一年级'])
print(hs_10(zd_1))					#一年级

按照元素列表中的绝对值排序

lb_1=[1,3,-2,5,-6]
lb_1.sort()		#[-6, -2, 1, 3, 5]，只是对列表1进行排序，没有改变列表1元素原来的位置
print(lb_1)
lb_1.sort(key=abs)	#[1, -2, 3, 5, -6]，这个key=abs是讲的元素按照绝对值的大小排序
print(lb_1)

用max求列表中某一项的最大值

lb_2=[{'name':'ls','age':18,'sex':'nan'},
{'name':'ls','age':27,'sex':'nan'},
{'name':'ls','age':36,'sex':'nan'}]
def hs_11(a):
print('已经调用')
return a['age']
# hs_11(lb_2)
lb_3=max(lb_2,key=hs_11)		#函数加（）标志着是调用，不加（）标志着函数作为一个参数传入
print(lb_3)

将前面的函数用lambda实现

lb_2=[{'name':'ls','age':18,'sex':'nan'},
{'name':'ls','age':27,'sex':'nan'},
{'name':'ls','age':36,'sex':'nan'}]

print(max(lb_2,key=lambda lb_2:lb_2['age']))
#{'name': 'ls', 'age': 36, 'sex': 'nan'}，注意找字典的值的方式 a['#']

列表的花式传入

a=[i for i in range(50) if i%2==0 and i%3==0 ]
print(a)

二维列表

a=[[1,2,3],[4,5,6],[7,8,9]]
print(a[1][2])
print(a[0][0])
b=[a[i][i] for i in range(3)]
print(b)
# c=[a[i][j] for i in range(-2) for j in range(3)]
#这种方法实现不了,这样的话是可以输出六个数的，range的增长可以是负的
# print(c)

# 另一种方法
print('另一种方式')
d=[a[i][2-i] for i in range(3)]#很明显这种算法时间复杂度更小
print(d)

两层循环将a列表中的所有元素都输出出来

a=[[1,2,3],[4,5,6],[7,8,9]]
for i in range(len(a)):			#遍历a的长度
for j in range(len(a[i])):	#遍历a元素的长度
print(a[i][j],end=',')	#1,2,3,4,5,6,7,8,9,

不用下标的那种，两层循环将a的元素输出出来

a=[[1,2,3],[4,5,6],[7,8,9]]
for i in a:
for j in i:
print(j,end=',')		#1,2,3,4,5,6,7,8,9,

a的所有元素放在一个列表中，一行实现

a=[[1,2,3],[4,5,6],[7,8,9]]
b=[j for i in a for j in i]
print(b)					#[1, 2, 3, 4, 5, 6, 7, 8, 9]

字典 一行将字典中的键值对互换

c={'a':1,'b':2 ,'c':3}
d={j:i for i,j in c.items() }
print(d)					#{1: 'a', 2: 'b', 3: 'c'}

zip函数

a_3=[1,2,3,4]
a_4=['a','b','c','d','e']
c=zip(a_4,a_3)		#已经做好了一个包，并且这个包没有办法直接输出，只能遍历
print(c)
for i in c:
print(i)

map函数，重新加工映射

a=[1,2,3,4]
def hanshu(a):
return a*2
b=map(hanshu,a)			#使用map函数，将列表a按照hanshu的形式重新加工
print(b)				#<map object at 0x00000000028F93C8>
for i in b:
print(i,type(i))	#8 <class 'int'>  ，其中一种情况

filter 将符合条件的数留下

a=[1,2,3,4]
def hanshu(a):
if a%2==0:
return True
b=filter(hanshu,a)
#这个hanshu作为形参，并且这个括号已经将函数调用，将列表a传入进去了
for i in a:
#前面已经准备好了所有的条件，就已经准备要输出了
print(i)

整体代码

以下就不用看了，很烂了

'''
a=10#前者
def hanshu_1():
global a
a=2000#后者
print(a)#10在未声明a之前，a是第一个，即前者
hanshu_1()#声明了a，调用了后者
print(a)#2000，打印后者

'''

#※※※※※※※※※※
"""
def waibu_1():
x=30#变量1
def neibu_1():
# nonlocal x
global x#将变量2变成了全局变量，也就是说，变量2被拿到了最外面
x=300#变量2
print(x)#肯定是30，先使用函数内
neibu_1()#因为变量2变成了全局变量，所以先调用局部变量1
print(x)#30，若这条输出是在neibu_1那么应该是300，可惜它是在waibu_1所以应该先输出外部的
waibu_1()#在这里以及调用输出完了内部的参数
#变量2在这，因为行17    =300，
print(x)#先调用局部变量2，那么在这就是调用全局变量了，跟函数关系不大

"""

"""
def hanshu_2(a,b):
c=a+b
d=a-b
e=a*b
f=a/b
return c,d,e,f#---------

d=hanshu_2(1,3)
print(d)
e,f,g,h=hanshu_2(2,4)#表明用四个参数接受
print(e,f,g,h)
n,*m=hanshu_2(5,6)#加个*，表面生成一个列表
print(n,m)
# x,y=hanshu_2(7,8)#报错了
# print(x,y)
"""

"""
a=100
def hanshu_3(d):
c=d+a
print(c)
a=200#将a=100给覆盖掉了，变成了200
def hanshu_4(d):
c=d+a
print(c)
hanshu_3(6)#206,因为函数再次之前还没调用
hanshu_4(6)#206
"""

#※
'''
def hanshu_10(name,age,sex='man'):#默认参数要用不可变类型，否则会保存上一次状态
print('我叫',name,end='')
print('年龄',age,end='')
print('性别',sex)

hanshu_10('刘德华','18')#没有输入参数，使用默认参数
hanshu_10('张三','100','woman')#有实参，则不用默认参数，用实参
hanshu_10(age='30',sex='男',name='赵四')#

'''

#若函数默认是可变类型，那么多次调用时，可变类型会发生迭代
"""
def hanshu_11(b,a=[]):
a.append(10)
print(a,b)
hanshu_11(10)#[10] 10
hanshu_11(12)#[10, 10] 12

"""

#函数定义可变类型，元组
"""
def hanshu_15(*args):#可变类型
print(args)
for i in args:
print(i,end='|')
print()
hanshu_15(1,2,3,3,4)
hanshu_15(2,3,3,4,4,5,5,9,6,7,7)
hanshu_15()
"""

#函数
20000
可变类型 ，字典
"""
def hanshu_16(**haha):
print(haha)
for k,v in haha.items():
print(k,v,end='|')
print()
hanshu_16(name='jake',age=17)
hanshu_16(name='jake')
hanshu_16()
"""

#只不过是个小型的默认函数
"""
u_1=lambda x,y:x*10+y
u_2=u_1(1,2)
print(u_2)
"""

#得到字典中的值
"""
zidian_1={'name':'Python','age':50}
zidian_2=lambda y:y['name']#可以作为简化版的函数，但是参数要定义准确，冒号前面接受的是伪参数，后面是要返回的值
print(zidian_2(zidian_1))

"""

#按照列表元素的绝对值排序
"""
a=[1,-2,3,-4]
a.sort()
print(a)
a.sort(key=abs)#只能这样写，key代表的是元素，abs是求绝对值，但是不修改原来的列表，只不过用绝对值排序罢了
print(a)
"""

# def hs_1(a):
#     print('调用过了')
#     return a['age']
# zuida_1=max(zd_1,key=hs_1)#这个max是求关键字1的最大值，条件是用到age的值
# print(zuida_1)

#lambda 的骚操作
'''
zd_1=[{'name':'ls','age':18,'sex':'nan'},
{'name':'ls','age':27,'sex':'nan'},
{'name':'ls','age':36,'sex':'nan'}]
print(max(zd_1,key=lambda zd_1:zd_1['age']))
'''

"""
a=[i*3 for i in range(1,20) if i%5==0 or i%7==0]
print(a)#[2, 4, 6, 8]
"""

b=[[1,2,3],[4,5,6],[7,8,9]]
# print(b[0][0])
# print(b[2][2])
#
# b_1=[b[0][i] for i in range(3)]
# b_2=[b[i][0] for i in range(3)]
# b_3=[b[i][i] for i in range(3)]
# print(b_1)
# print(b_2)
# print(b_3)

# b_4=[b
[2-n] for n in range(3) ]
# print(b_4)
# b_5=[b
[m] for n in range(-2) for m in range(3)]#[3, 5, 7]  实现不了
# print(b_5)
for i in range(len(b)):
for j in range(len(b[i])):
print(b[i][j],end='|')
print('不用下标')
for i in b :#range只不过是数，这个想到于遍历元素而已
for j in i:
print(j,end='-')
print( )

b_7=[j for i in b for j in i]#前面的j 想到于把二层的j给输出了出来
print(b_7)

c={'a':1,'b':2 ,'c':3}
c_1={v:k for k,v in c.items()}#外层得是大括号，键值对互换了，并且键必须是不可变类型
print(c_1)

a={'a':10,'A':20,'b':2,'c':3,'B':30,'D':40}
b={k.lower():(a.get(k.lower(),0)+a.get(k.upper(),0)) for k in a.keys()}
print(b)#字典的元素不可重复，键值对可以重新被赋值

d=['a','b']
b={k.lower():(a.get(k.lower(),0)+a.get(k.upper(),0)) for k in a.keys() if k in d}#if 后面跟的是True
print(b)

# print('一个zip')
# a_1='abc'
# a_2='123'
# c_0=zip(a_1,a_2)
# # print(c)#打印不出来
# for x,y in c:
#     # print(x)
# # print(y)
# #
#     print(x,y)
#
# # for x in c:
# #     print(x)
print('一个zip')
a_3=[1,2,3,4]
a_4=['a','b','c','d','e']
c_2=zip(a_3,a_4)
for i in c_2 :
print(i)

print('------')
def hanshu_map(x):
return x*x
a=[1,2,3,4]
d=map(hanshu_map,a)#map 是对函数加工重新映射，返回一个新的序列，然后给了a
print(d,type(d))#<class 'map'>
for x in d:
print(x)

print('===========')
def hanshu_filter(a):
if a%2==0:
return True #是False就不显示了，是True就把数字留下
a=[1,2,3,4,5,6]
d=filter(hanshu_filter,a)#filter是将符合函数条件的留下
for i in d:
print(i)

print('`````````````')
def hanshu_1(a):
if a%2==0:
return True
def hanshu_2(b,a):#b接收到了实参hanshu_1
for x in a:
if b(x)==True:#242行元素在hanshu_1中进行判断，如果成立，返回 True，则打印出来列表a[]中符合条件的元素
print(x)
a=[1,2,3,4,5,6]
hanshu_2(hanshu_1,a)#函数名+括号才是意味着要调用函数，否则只是将函数当做参数使用

'''
def hanshu_map(x):
return x*x
a=[1,2,3,4]
d=map(hanshu_map,a)#map 是对函数加工重新映射，返回一个新的序列，然后给了a
print(d,type(d))#<class 'map'>
for x in d:
print(x)
'''

个人拙见请见谅！！