函数进阶知识整理

闭包函数

把函数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

装饰器

用来给函数加功能的,他的本质也是函数

为什么用装饰器

假设我们已经上线了一个项目，我们需要修改某一个方法，但是我们不想修改方法的使用方法，这个时候可以使用装饰器。因为软件的维护应该遵循开放封闭原则，即软件一旦上线运行后，软件的维护对修改源代码是封闭的，对扩展功能是开放的。

注意:

1. 不改变被装饰函数的源代码
2. 不改变被装饰函数的调用方式

装饰器语法糖

**在被装饰函数正上方，并且是单独一行写上@装饰器名**</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的英文单词意思是生产，在函数中但凡出现yield关键字，再调用函数，就不会继续执行函数体代码，而是会返回一个值。

yield和return:

1. 相同点：两者都是在函数内部使用，都可以返回值，并且返回值没有类型和个数的限制
2. 不同点：return只能返回一次值,终止函数；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.

递归

函数调用函数本身,但是必须得有结束条件

递归必须要有两个明确的阶段：

1. 递推：一层一层递归调用下去，进入下一层递归的问题规模都将会减小
2. 回溯：递归必须要有一个明确的结束条件，在满足该条件开始一层一层回溯。

递归的精髓在于通过不断地重复逼近一个最终的结果。

匿名函数

没有名字的函数 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'))
65

3.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

了解;

1. abs #求绝对值。
2. all #可迭代对象内元素全为真，则返回真。False : 0、空、None、False
3. any #可迭代对象中有一元素为真，则为真。False : 0、空、None、False
4. bin/oct/hex #二进制、八进制、十六进制转换。
5. dir #函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
6. frozenset #返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
7. gloabals/locals #函数会以字典类型返回当前位置的全部全局变量；函数会以字典类型返回当前位置的全部局部变量。
8. pow
9. round
10. slice
11. sum
12. import

面向对象编程

面向过程编程是解决问题的一种思想,基于该思想编写程序就好比在设计一条流水线，面向对称编程其实是一种机械式的思维方式。

• 优点: 思路清晰
• 缺点: 可扩展性差 ; 功能与功能之间不独立 ; 调试麻烦

原文地址：https://www.cnblogs.com/asyouwish/p/11650683.html