Effective Python(原书第二版) -2023年10月25日

---

前言

Python ; Effective Python ; 编程语言 ; 笔记

---

零、目录

1.列表与字典 : 11 - 18条

2.函数 : 19 - 26条

3.推导与生成 : 27 - 36条

4.类与接口 : 37 - 43条

5.元类与属性 : 44 - 51条

6.并发与并行 : 52-64条

7.稳定与性能 : 65 -74条

8.调试与测试 : 75 - 81条

9.协作开发 : 82 - 90条

一、11条.对序列切片

重复的任务 -> 自动处理程序

列表(list)类型整理重复任务 : 每项任务当成列表中的一个元素

列表的互补结构 : 字典(dict) : 键值对 (哈希表/关键矩阵) 
//访问与赋值耗费时间为常量, 适合保存动态信息

1.Somelist[start : end]

从头取省略起始下标0, 选到序列末尾, 则省略终止下标
切片允许 起始/终止 下标越界 // 取开头n个元素 : a[:n], 取末尾n个元素 : a[-n:]

// a is b; a,b指向同一个对象 ; 开发时有风险, 建议再创一个对象防止维护麻烦
a = b

---

---

二、12条.不要在切片里同时指定起止下标与步长

1.somelist[start : end : stride]

字符串反转 : a[::-1]
#如果字符串的内容都是 ASCII 字符，那么直接在字符串前面添加 b 前缀就可以转换成 bytes
1.bytes类型
2.Unicode
// UTF-8 不能

三、13条.通过带*的 unpacking 表达式捕获多个元素, 不用切片

优点 : 动态更新?
// 带星号(*)的表达式
*args // 元组
**k // 字典, 会吃掉提示 -> any

---

---

四、14条.sort方法中的key参数表示复杂排序

默认从小到大

1.lambda表达式（匿名函数）

语法格式 : name = lambda [list] : 表达式
# 定义 lambda 表达式，必须使用 lambda 关键字；
# [list] 作为可选参数，等同于定义函数是指定的参数列表；
# value 为该表达式的名称。

等价于 : 

def name(list):
	return 表达式
name(list)

# Eg
def add(x, y):
    return x+ y
print(add(3,4))

# add = lambda x,y:x+y
# print(add(3,4))

优势 :
1. 对于单行函数，使用 lambda 表达式可以省去定义函数的过程，让代码更加简洁；
2. 对于不需要多次复用的函数，使用 lambda 表达式可以在用完之后立即释放，提高程序执行的性能。

2._ repr _

这个函数是一个特殊方法（special method）_ _repr_ _，它在Python中用于定义对象的字符串表示形式。
当你使用print()函数或者在交互式环境中直接输入对象名时，Python会调用__repr__方法来获取对象的可打印表示形式。

这个_ _repr_ _方法返回一个字符串，用于表示Tool类的对象。在返回的字符串中，使用了f-string格式化字符串的语法，它允许在字符串中嵌入表达式。
!r表示将self.name的值使用repr()函数进行转换，确保以可打印的形式显示字符串，并将其插入到格式化字符串中。

所以，__repr__方法的返回值将类似于Tool('工具名称', 权重)的形式，其中'工具名称'是self.name的值，权重是self.weight的值。

通过定义__repr__方法，你可以为你的自定义类提供一个可读性良好的字符串表示形式，便于调试和输出对象信息。

3._ init _

这个函数是一个特殊方法（special method）_ _init_ _，在Python中用于初始化对象的方法。
当你创建一个类的新实例时，_ _init_ _方法会被自动调用。

self参数表示类的实例对象本身。

在__init__方法的内部，使用self.name = name和self.weight = weight的语句
将传入的name和weight参数的值赋给了对象的属性name和weight。
这样，在创建类的实例时，你可以提供具体的名称和重量值来初始化对象的这两个属性。

4.sort方法排序 类的对象 构成的列表

class Tool :
	def __init__(self, name, weight):
		self.name = name
		self.weight = weight

	def __repr__(self) :
		return f'Tool({self.name!r}, {self.weight})'

# 按间距中的绿色按钮以运行脚本。
if __name__ == '__main__':
    tools = [
        Tool('C', 6),
        Tool('A',3.5),
        Tool('B', 88),
    ]

    print('Unsorted : ', repr(tools))

    tools.sort(key = lambda x : x.name) # 输入的值为 x 返回值为 x.name

    print('\nsorted1 : ', repr(tools))

    tools.sort(key=lambda x: x.weight) # 输入的值为 x 返回值为 x.weight

    print('\nsorted2 : ', repr(tools))


'''''''''''
执行结果 :
Unsorted :  [Tool('C', 6), Tool('A', 3.5), Tool('B', 88)]

sorted1 :  [Tool('A', 3.5), Tool('B', 88), Tool('C', 6)]

sorted2 :  [Tool('A', 3.5), Tool('C', 6), Tool('B', 88)]
'''''''''''

5.sort方法排序 字符串 构成的列表

# 按间距中的绿色按钮以运行脚本。
if __name__ == '__main__':
    words = ['A', 'b', 'C', 'd']
    
    words.sort()
    print('case sensitive :', words)
    
    words.sort(key = lambda x : x.lower())
    print('case insensitive :', words)
    
'''''''''
case sensitive : ['A', 'C', 'b', 'd']   # 大写 比 小写的 ASCII码小
case insensitive : ['A', 'b', 'C', 'd']
'''''''''

6.sort方法排序 元组 构成的列表

需要多标准排序  # (A, B), 当A项相同时 比较B项 :
1. 尝试转换成 : 元组(tuple) # 优先
	tuple 本身就是可比较的
2. 拆分成多轮排序, 权重的放在后轮

class Tool :
	def __init__(self, name, weight):
		self.name = name
		self.weight = weight

	def __repr__(self) :
		return f'Tool({
   self.name!r}, {
   self.weight})'

# 按间距中的绿色按钮以运行脚本。
if __name__ == '__main__':
    tools = [
        Tool('C', 6),
        Tool('A',6),
        Tool('B', 88),
    ]
    tools.sort(key = lambda x: (x.weight, x.name)) # 先对比权重, 再对比名字
    print(tools)

'''
执行结果 :