列表生成式
通俗理解使用for循环快速生成列表
列表推导式，目的是快速创建一个列表
列表推导式语法
my_list=[value for value in range(1,6)]
print(my_list)
my_list=[value*2 for value in range(1,6)]
print(my_list)
实现双层循环
my_list=[(x,y) for value in range(1,6) for y in range(1,4)]
print(my_list)
实现判断
my_list=[value for value in range(1,6) if value%2==0]
print(my_list)
引用
程序中的数据在内存中的地址，简称内存地址
a=10 #a 存储的是10在内存中的一个地址
b=a # b存储的是a保存的内存地址，现在a和b存储的内存地址是同一个
id(a)获取的是内存地址是一个十进制的数据
print("a保存的数据内存地址：",id(a))
print("b保存的数据内存地址：",id(b))b
hex(a)获取的是内存地址是一个十六进制的数据
print("a保存的数据内存地址：",hex(a))
print("b保存的数据内存地址：",hex(b))b
#a保存的数据内存地址： 10771808
#b保存的数据内存地址： 10771808
#a保存的数据内存地址： 0xa
#b保存的数据内存地址： 0xa
可变类型和不可变类型
可变类型：可以在原有数据的基础上对数据进行修改：添加，删除，修改数据，修改后内存地址不变
不可变类型：不能在原有数据的基础上对数据进行修改，当然直接赋值一个新值，那么内存地址会发生改变
可变类型：列表，集合，字典，对数据修改后内存地址不变
不可变类型：字符串，数字，元组，不能在原有数据的基础上对数据进行修改
my_list=[1,5,6]
print(my_list,id(my_list))
my_list[0]=2
print(my_list,id(my_list))
[1, 5, 6] 140219880850632
[2, 5, 6] 140219880850632
my_set={4,5}
print(my_set,id(my_set))
my_set.add("55")
print(my_set,id(my_set))
{4, 5} 140671855459240
{'55', 4, 5} 140671855459240
不可变数据
my_str="hello"
print(my_str,id(my_str))
my_str[0]="a" ##不可以这样使用 TypeError: 'str' object does not support item assignment
my_str="word"
print(my_str,id(my_str))
hello 139830844866040
word 139830844865816
global 的使用-扩展
定义全局变量
不可变类型的全局变量
g_num=10
print("函数外 ",id(g_num))
def modify():
global g_num # 变量是不可变类型全局变量，表示要修改全局变量的内存地址
g_num=1
print("modify:",g_num)
print("函数内 :",id(g_num))
modify()
函数外 10771808
modify: 1
函数内 : 10771520
可变类型的全局变量、
g_num=[3,5]
print("函数外 ",id(g_num))
def modify():
#如果只是修改数据，在这可以不需要加上global
g_num[0]=3
print("modify:",g_num)
print("函数内 :",id(g_num))
modify()
函数外 139753170761032
modify: [3, 5]
函数内 : 139753170761032
可变类型，加global 表示内存地址要发生改变
g_num=[3,5]
print("函数外 ",id(g_num))
def modify():
global g_num
g_num=[1,2]
print("modify:",g_num)
print("函数内 :",id(g_num))
modify()
这是外部全局变量和内部局部变量 ，是两个变量所以地址不同
g_num=[3,5]
print("函数外 ",id(g_num))
def modify():
g_num=[1,2]
print("modify:",g_num)
print("函数内 :",id(g_num))
modify()
公共运算符的操作
“+” 运算符可以完成列表、元组、字符串的拼接
my_list1=[1,3]
my_list2=[5,6]
result=my_list2+my_list1
print(result)
my_tule1=(1,3)
my_tule2=(5,6)
result=my_tule1+my_tule2
print(result)
“*” 运算符，可以完成列表、元组、字符串的复制
my_str="*" *30
print(my_str)
******************************
元组、列表、集合三种可以相互转换
my_list=[1,3]
my_tuple=(4,5,6)
my_set={4,5}
#把列表转成集合
result=set(my_list)
print(result,type(result))
#把元组转成集合
result=set(my_tuple)
print(result,type(result))
#把列表转成元组
result=tuple(my_list)
print(result,type(result))
#把集合转成元组
result=tuple(my_set)
print(result,type(result))
#把集合转列表
result=list(my_set)
print(result,type(result))
#把元组转成列表
result=list(my_tuple)
print(result,type(result))
函数的文档说明
help(函数名) 可以查看函数的功能
偏函数
通俗理解指明函数的参数偏爱某个值
def add(a,b):
return a+b;
add(3,5)
add(4,7)
以上两个是我们正常调用，那么如果我们知道一个已知的参数a= 100，我们如何利用偏函数呢？
from functools import partial as pto
def add(a,b):
print("a",a,"b",b)
return a+b
puls = pto(add,b=100) #更改b的偏好值
puls = pto(add,100) #更改a的偏好值
result = puls(9)
print(result)
result的结果就是109。
在这里偏函数表达的意思就是，在函数add的调用时，我们已经知道了其中的一个参数，我们可以通过这个参数，重新绑定一个函数，就是pto(add,100)，然后去调用即可。
对于有很多可调用对象，并且许多调用都反复使用相同参数的情况，使用偏函数比较合适
——————————————————_————————————
而对于有关键字参数的情况下，就可以不按照原函数的参数位置和个数了。下面再看一个例子，讲的是如何进行不同的进制转换。
from functools import partial
bin2dec = partial( int, base=2 )
print bin2dec( '0b10001' ) # 17
print bin2dec( '10001' ) # 17
hex2dec = partial( int, base=16 )
print hex2dec( '0x67' ) # 103
print hex2dec( '67' ) # 103
返回函数
def fun1(n):
def fun2(x):
return pow(x,n)
return fun2
pow2=fun1(2)
print(pow2)
print(pow2(9))
<function fun1.<locals>.fun2 at 0x7fddae797950>
81
高阶函数
高阶函数：当一个函数的参数可以接收另外一个函数，或者还可以返回一个函数，那么这个函数就是高阶函数。
闭包函数
再嵌套函数的情况下，内部函数使用了外部函数的变量或者参数，
并把内部函数返回，那么返回的内部函数可以称为闭包
def out():
print("hello world in foo")
name="python"
def inner():
print(name)
print("hello world in bar")
return inner
f1=out()
f1()
闭包的应用场景，可以根据参数生成不同的返回参数
通过闭包可以生成不同的函数
闭包的好处可以根据条件生成不同的函数
装饰器
装饰器本质上就是一个函数，可以给原函数的功能进行扩展，这样的好处是：不改变原函数的定义和调用的前提下操作
def show():
print("AAAA")
#装饰器--通过闭包完成装饰器
def decorator(new_func):
def inner():
print("-"*10)
new_func()
#返回的函数是闭包
return inner
show=decorator(show)
show()
----------
AAAA
使用装饰器可以用下面的函数
def decorator(new_func):
def inner():
print("-"*10)
new_func()
return inner
@decorator #在使用@decorator的时候装饰器的代码就会执行
#等价于show=decorator(show)
def show():
print("AAAA")
# show=decorator(show)
show()
装饰带有参数的函数
注意每个函数都的传值
def decorator(new_func):
def inner(num1,num2):
print("-"*10)
new_func(num1,num2)
#
return inner
@decorator
def show(num1,num2):
print(num1+num2)
# show=decorator(show)
show(1,2)
有返回值的函数
def decorator(new_func):
def inner(num1,num2):
print("-"*10)
return new_func(num1,num2) #注意这里需要返回函数的值，否者结果为None
return inner
@decorator
def show(num1,num2):
print(num1+num2)
return num1+num2
# show=decorator(show)
result = show(1,2)
print(result)
3
实现了有参数有返回值的函数和有参数返回值为None的函数
def decorator(func):
def inner(num1,num2):
print("计算结果如下:")
return func(num1,num2)
return inner
@decorator ##有参数有返回值
def show1(num1,num2):
result=num1+num2
return result
# show=decorator(show)
result=show1(1,2)
print(result)
@decorator #右参数无返回值
def show2(num1,num2):
print(num1+num2)
# show=decorator(show)
result=show2(1,6)
print(result)
通用的装饰器
def decorator(func):
def inner(*args,**kwargs):
print("计算结果如下:")
#这里是对不定长参数进行拆包
return func(*args,**kwargs)
return inner
@decorator
def show1(num1,num2):
result=num1+num2
return result
# show=decorator(show)
result=show1(1,2)
print(result)
@decorator
def show2(num1,num2):
print(num1+num2)
# show=decorator(show)
result=show2(1,6)
print(result)
@decorator
def show3():
print("我是一个无参数无无返回的函数")
传参数的装饰器
def get_decorator(char):
def decorator(func):
def inner():
print("-"*10)
func()
return inner
return decorator
#把@get_decorator后面的操作相当于执行了一个函数，返回了一个装饰器
@get_decorator("B") #有参数的装饰器
def show():
print("11111")
show()
函数用了多个装饰器
1302
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
