Python备忘录（一）

在此纪录一些Python中比力常用到的方法本事（连续更新）
 
天生器

通过列表天生式构建一个天生器

 

1. a = [x * x for x in range(10)]    # 列表生成式子生成一个list
2. print(a)
3. # 打印：
4. # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
6. g = (x * x for x in range(10))    # 列表生成式生成一个生成器，只需将[]替换为()
7. print(g)
8. # 打印：
9. # <generator object <genexpr> at 0x1022ef630>

复制代码

 
编写一个简单的天生器

 

1. def fib(max):
2.     n, a, b = 0, 0, 1
3.     while n < max:
4.         yield b    # 经过迭代操作后生成一个迭代值
5.         a, b = b, a + b
6.         n = n + 1
7.     return 'done'  # 如果已无迭代值，则输出'done'
8.    
9. f1 = fib(10)
11. # 最后一个迭代值出来后，将停止迭代，跳出for语句
12. for i in f1:
13.     print(i)
14. # 打印:
15. # 1 1 2 3 5 8 13 21 34 55
16.             
17. f2 = fib(10)
19. # 如果想单个迭代，可使用next函数
20. print(next(f2))
21. # 打印：
22. # 1
24. print(next(f2))   
25. # 打印：
26. # 1
28. print(next(f2))   
29. # 打印：
30. # 2
32. # 这里因为每次fib被next调用时都会生成一个临时的生成器对象，所以输出只会打印第一次的迭代值“1”。
33. print(next(fib(10)))
34. print(next(fib(10)))
35. print(next(fib(10)))

复制代码

 
map/reduce

 
map

 

1. def f(i):
2.         return i * i
4. x = [1, 2, 3, 4, 5, 6, 7, 8]
6. # map()函数接收两个参数，一个是函数，一个是Iterable。map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回
7. y = map(f, x)
9. # 需将Iterator转换为list才能打印出里面的元素
10. print(list(y))
11. # 打印：
12. # [1, 4, 9, 16, 25, 36, 49, 64]

复制代码

 
reduce

 

1. # reduce包含在functools包中，使用时需导入
2. from functools import reduce   
4. def fn(x, y):
5.     return x * 10 + y
7. def str2int(x):
8.     strDict = {
9.         "0": 0,
10.         "1": 1,
11.         "2": 2,
12.         "3": 3,
13.         "4": 4,
14.         "5": 5,
15.         "6": 6,
16.         "7": 7,
17.         "8": 8,
18.         "9": 9,
19.     }
20.     return strDict[x]
22. # reduce接受两个参数，一个是执行函数（需2个参数），一个是Iterable，其大概运行逻辑是：将Iterable按顺序分别传入执行函数中进行操作，然后将返回值执行函数的一个参数后继续与Iterable后面的元素进行操作，直到Iterable没有元素可迭代为止。
23. ans = reduce(fn, map(str2int, "13579"))
24. print(ans)
25. # 打印：
26. # 13579

复制代码

 
filter

 

1. def is_odd(n):
2.     return n % 2 == 1
4. # 和map()类似，filter()也接收一个函数和一个序列。不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。filter返回值是一个Iterator，不方便打印其中的元素，所以将其转换为一个Iterable
5. print(list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])))
6. # 打印：
7. # [1, 5, 9, 15]

复制代码

 
装饰器

 

1. from functools import wraps
3. # 一、装饰器的基本语法
5. def log(f):
6.     # 如果需要打印真正执行操作的函数名而不是wrapper函数名，则需要导入functiools里的wraps
7.     @wraps(f)
8.    
9.     # 如果需要添加装饰器的函数含有参数，则wrapper也需要填入参数（*args, **kw）。
10.     def wrapper(*args, **kw):
11.         print('call %s():' % f.__name__)
12.         return f(*args, **kw)
13.     return wrapper
15. # 这个函数用来筛出序列中的偶数，我们如果要针对这个操作插入一些测试/信息说明的话可以使用装饰器来实现。
16. @log
17. def func(nums: list) -> list:
18.     return list(filter(lambda x: x % 2 == 0, nums))
20. print(func.__name__)
21. print(func([x for x in range(10)]))
22. # 打印：
23. # call func():
24. # [0, 2, 4, 6, 8]
26. # 二、带参数的装饰器语法
28. # 如果装饰器想要接受参数，则需要额外嵌套一层函数。
29. def log2(text):
30.     def decorator(f):
31.         @wraps(f)
32.         def wrapper(*args, **kw):
33.             print('%s %s():' % (text, f.__name__))
34.             return f(*args, **kw)
35.         return wrapper
36.     return decorator
38. @log2('execute')
39. def func(nums: list) -> list:
40.     return list(filter(lambda x: x % 2 == 0, nums))
42. print(func.__name__)
43. print(func([x for x in range(10)]))
44. # 打印：
45. # func
46. # execute func():
47. # [0, 2, 4, 6, 8]

复制代码

 
偏函数

 

1. from functools import partial
3. # 当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。
5. # 普通写法：
6. # def int2(x, base=2)
7. #     return int(x, base)
9. # 使用partial
10. int2 = partial(int, base=2)
11. print(int2('10010'))
12. # 打印：
13. # 18

复制代码

 
__slots__

 

1. # python的灵活性可以使类中的属性能够随意添加，为了保证代码的工整和已读可在类中添加一个__slots__变量
2. class Student:
3.     __slots__ = ('name', 'age')
4.    
6. s = Student()
8. s.name = 'Sam'
9. s.age = 16
10. print(s.name, s.age)
11. # 打印：
12. # Sam 16
14. s.university = "CMU"
15. print(s.university)
16. # 报出AttributeError异常，提示Student类中没有"university"属性，也无法设置新属性

复制代码

 
@property

 

1. # python中对于类的属性getter/setter方法可用@property来代替，可读性更高。
2. class Student(object):
3.     @property
4.     def birth(self):
5.         return self._birth
7.     @birth.setter
8.     def birth(self, value):
9.         self._birth = value
11.         # age属性没有设置setter，所以如果对其赋值会报错
12.     @property
13.     def age(self):
14.         return 2026 - self._birth

复制代码

 
罗列类

 

1. from enum import Enum
3. # 构建一个枚举类后，可以直接使用Month.Jan......来引用一个常量，也可以像字典一样遍历它们（需访问__members__）
4. Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
6. for k, v in Month.__members__.items():
7.     print(k, v.value)
8. # 打印（value属性则是自动赋给成员的int常量，默认从1开始计数）：
9. # Jan 1
10. # Feb 2
11. # Mar 3
12. # Apr 4
13. # May 5
14. # Jun 6
15. # Jul 7
16. # Aug 8
17. # Sep 9
18. # Oct 10
19. # Nov 11
20. # Dec 12
22. print(Month.Jan)
23. # 打印:
24. # Month.Jan
26. print(Month['Feb'])
27. # 打印：
28. # Month.Feb
30. print(Month.Mar.value)
31. # 打印：
32. # 3
34. print(Month['Feb'] == Month.Feb)
35. # 打印：
36. # True

复制代码

 
StringIO和BytesIO

 

1. from io import StringIO, BytesIO
3. # 一、StringIO
5. f = StringIO()
7. # 向内存中写入值
8. f.write("Hello, World !")
9. print(f.getvalue())
10. # 打印：
11. # Hello, World !
13. # StringIO可设置初始值
14. f = StringIO("Hello!\nHi!\nGoodbye!")
15. while True:
16.     # readline遇到换行符停止读取
17.     s = f.readline()
18.     if s == '':
19.         break
20.     print(s.strip())
21.     # 打印：
22.     # Hello!
23.     # Hi!
24.     # Goodbye!
25.    
26. # 二、BytesIO
28. b = BytesIO()
29. b.write('中文'.encode('utf-8'))
30. print(b.getvalue())
31. # 打印：
32. # b'\xe4\xb8\xad\xe6\x96\x87'

复制代码

 
JSON

 

1. # 如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML。但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
3. import json
5. # 一、序列化
7. d = dict(name="Bob", age=20, score=88)
8. print(json.dumps(d))
9. # 打印（输出字符串）：
10. # {"name": "Bob", "age": 20, "score": 88}
13. # 类的序列化需要自定义一个转换函数，否则json无法解析类的序列化操作，反序列化下同。
14. class Student(object):
15.     def __init__(self, name, age, score):
16.         self.name = name
17.         self.age = age
18.         self.score = score
20. # 类的序列化函数
21. def student2dict(stu: Student):
22.     return {"name": stu.name, "age": stu.age, "score": stu.score}
25. stu = Student("Sam", 20, 88)
26. print(json.dumps(stu, default=student2dict))
27. # 打印（输出字符串）：
28. # {"name": "Sam", "age": 20, "score": 88}
30. # 因为通常class的实例都有一个__dict__属性，它就是一个dict，用来存储实例变量。也有少数例外，比如定义了__slots__的class。
31. print(json.dumps(stu, default=lambda x: x.__dict__))
32. # 打印（输出字符串）：
33. # {"name": "Sam", "age": 20, "score": 88}
35. # 二、反序列化
37. # 注意在Python中进行反序列化操作时，反序列化字符串（即JSON对象）中的成员必须是双引号
38. d = json.loads('{"name": "Bob", "age": 20, "score": 88}')
39. print(d)
40. # 打印（输出字典）：
41. # {'name': 'Bob', 'age': 20, 'score': 88}
43. # 类的反序列化函数
44. def dict2Student(d: dict[str, any]):
45.     return Student(d["name"], d["age"], d["score"])
47. stu_dict = json.loads('{"name": "Bob", "age": 20, "score": 88}')
48. stu = dict2Student(stu_dict)
49. print(stu.name, stu.name, stu.score)
50. # 打印：
51. # Bob Bob 88

复制代码

 

免责声明：如果侵犯了您的权益，请联系站长及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金.