标签：col 解决 filter 转换 文件 pass *args 用法 思维
把函数A和变量x包在函数B内部,然后通过函数B的返回值返回出函数A对象
def outter(x):
x = 1
def inner():
print(x)
return inner
f = outter(1)
f()
f()
f()
# 查看闭包的元素
print(F"f.__closure__[0].cell_contents: {f.__closure__[0].cell_contents}")1
1
1
f.__closure__[0].cell_contents: 1用来给函数加功能的,他的本质也是函数
为什么用装饰器
假设我们已经上线了一个项目，我们需要修改某一个方法，但是我们不想修改方法的使用方法，这个时候可以使用装饰器。因为软件的维护应该遵循开放封闭原则，即软件一旦上线运行后，软件的维护对修改源代码是封闭的，对扩展功能是开放的。
注意:
装饰器语法糖
**在被装饰函数正上方，并且是单独一行写上@装饰器名**</font>(用法)
装饰器模板
def outter(func):
def wrapper(*args,**kwrags):
# 逻辑
res = func(*args,**kwargs) # func是被装饰的函数
return res
return wrapper
@outter
def index():
pass
# 三层装饰器模板
def sanceng(engine):
def outter(func):
def wrapper(*args,**kwrags):
# 逻辑
res = func(*args,**kwargs) # func是被装饰的函数
return res
return wrapper
return outter
@sanceng(engine)
def index():
pass迭代器即迭代的工具，那什么是迭代呢？`
迭代是一个重复的过程，每次重复即一次迭代，并且每次迭代的结果都是下一次迭代的初始值
为何要有迭代器
对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器
可迭代对象: 具有iter方法的对象, 可迭代对象不一定是迭代器对象`
迭代器对象: 具有iter和next方法的对象, 迭代器对象一定是可迭代对象, 迭代器对象加上iter方法还是迭代器本身`
#优点：
- 提供一种统一的、不依赖于索引的迭代方式
- 惰性计算，节省内存
#缺点：
- 无法获取长度（只有在next完毕才知道到底有几个值）
- 一次性的，只能往后走，不能往前退for循环称为迭代器循环，in后必须是可迭代的对象。
lis = [1, 2, 3]
for i in lis:
print(i)x = 10
y = 20
print(x if x > y else y)x > y 条件成立时返回x值,不成立返回y值
print(F"[i for i in range(10)]: {[i for i in range(10)]}")
print(F"[i**2 for i in range(10)]: {[i**2 for i in range(10)]}")[i for i in range(10)]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[i**2 for i in range(10)]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]print({i: i**2 for i in range(10)}){0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码
生成器的本质就是迭代器，同时也并不仅仅是迭代器，不过迭代器之外的用途实在是不多，所以我们可以大声地说：生成器提供了非常方便的自定义迭代器的途径。
yield的英文单词意思是生产，在函数中但凡出现yield关键字，再调用函数，就不会继续执行函数体代码，而是会返回一个值。
列表推导式相当于直接给你一筐蛋，而生成器表达式相当于给你一只老母鸡。
# 生成器表达式
with open('52.txt', 'r', encoding='utf8') as f:
nums = [len(line) for line in f]
print(max(nums))
# 列表推导式
with open('52.txt','r',encoding='utf8') as f:
nums = (len(line) for line in f)
print(max(nums)) # ValueError: I/O operation on closed file.函数调用函数本身,但是必须得有结束条件
递归必须要有两个明确的阶段：
递归的精髓在于通过不断地重复逼近一个最终的结果。
没有名字的函数 lambda 参数:代码块
一般不单独使用,与 max/min/map/filter/sorted联用
内置函数是直接用的,属于python解释器的
数据类型的内置函数只有数据类型本身才能使用
掌握:
1.bytes() #解码字符
res = '你好'.encode('utf8') #encode转化为二进制,decode反转
print(res)
b'\xe4\xbd\xa0\xe5\xa5\xbd'
res = bytes('你好', encoding='utf8')
print(res)
b'\xe4\xbd\xa0\xe5\xa5\xbd'2.chr()/ord() #chr()参考ASCII码表将数字转成对应字符；ord()将字符转换成对应的数字。
print(chr(65))
A
print(ord('A'))
653.divmod() #函数把除数和余数运算结果结合起来。
print(divmod(7, 2))
(3, 1)
print(divmod(8, 2))
(4, 0)
print(divmod(1+2j,1+0.5j))
((1+0j), 1.5j)4.enumerate() #带有索引的迭代
l = ['a', 'b', 'c']
for i in enumerate(l):
print(i)
(0, 'a')
(1, 'b')
(2, 'c')5.eval() #eval 可以把 list, tuple, dict 转换成str,返回来也成立；即互转。
# 字符串转成列表
s = '[[1,2,],[3,4,],[5,6,],[8,9]]'
li = eval(s)
print(li)
print(type(s))
print(type(li))
[[1, 2], [3, 4], [5, 6], [8, 9]]
<class 'str'>
<class 'list'>
#字符串转成字典
s = "{1:'a',2:'b'}"
dic = eval(s)
print(dic)
print(type(s))
print(type(dic))
{1: 'a', 2: 'b'}
<class 'str'>
<class 'dict'>
#字符串转成元组
s = '([1,2,],(3,4,),[5,6,],(8,9))'
tu = eval(s)
print(tu)
print(type(s))
print(type(tu))
([1, 2], (3, 4), [5, 6], (8, 9))
<class 'str'>
<class 'tuple'>6.hash() #获取取一个对象（字符串或者数值等）的哈希值。
print(hash('test'))#字符串
print(hash(1))#数字
print(hash(str([1, 2, 3])))#集合
print(hash(str(sorted({'1': 1}))))#字典
3354089792780274255
1
-2610670198615689204
-1768722922849136370
了解;
面向过程编程是解决问题的一种思想,基于该思想编写程序就好比在设计一条流水线，面向对称编程其实是一种机械式的思维方式。
优点: 思路清晰
缺点: 可扩展性差 ; 功能与功能之间不独立 ; 调试麻烦
标签：col 解决 filter 转换 文件 pass *args 用法 思维
原文地址：https://www.cnblogs.com/asyouwish/p/11650683.html
