1.变量
在编写变量尽量要让其清晰只给，让人清除搞清楚代码的意图
下方两段代码作用完全一样，但第二段代码是不是更容易让人理解
value = s.strip() username = input_string.strip()
1.1变量的基础知识
1.1.1变量的交换
作为一门动态语言，我们不仅可以无需预先声明变量类型直接赋值
同时还可以在一行内操作多个变量，比如交换
parent, child = "father", "son" parent, child = child, parent print(parent)#son
1.1.2变量解包
fruit = ["red apple","green apple","orange"] *apple, orange =fruit print(apple) #['red apple', 'green apple']
1.1.3变量用单下划线命名
它常作为一个无意义的占位符出现在赋值语句中，例如你想在解包时候忽略某些变量
fruit = ["red apple","green apple","orange"] *_, orange =fruit #这里的_就意味着这个变量后续不太会使用的，可以忽略的 print(orange) #orange
1.1.4给变量注明类型
虽然Pyhton无需声明变量，声明了变量也无法起到校验的作用
但我们还是需要去注明类型来提高我们代码的可读性
最常见的做法是写函数文档，把参数类型与说明写在函数文档内
def hello_world(items): """ 这是进入编程大门的入口 :param items: 待入门的对象 :type items: 包含字符串的列表,[string,...] """ pass
或者添加类型注解
from typing import List def hello_world(items: List[str]): """ 这是进入编程大门的入口 """
2.数值和字符串
2.1数值
2.1.1浮点数的精度问题
print(0.1+0.2)#0.30000000000000004 为了解决上述的精度问题我们可以用decimal这个内置函数 from decimal import Decimal print(Decimal('0.1')+Decimal('0.2'))#必须用字符串表示数字
2.2字符串
2.2.1拼接多个字符串
最常见的做法是创建一个空列表，然后把需要拼接的字符串都放进列表中
最后使用str.join来拼接
除此之外也可以通过+号来拼接
3容器类型
最常见的内置容器类型有四种：列表、元组、字典、集合
3.1具名元祖
元组经常用来存放结构化数据，但只能通过数字来访问元组成员其实特别不方便
- 初始化具名函数
- 可以通过数字索引来访问
- 也可以通过名称来访问
from collections import namedtuple FruitColor = namedtuple('FruitColor','apple,orange') fruitColor = FruitColor("RED","GREEN") print(fruitColor[0])#RED print(fruitColor.apple)#RED
Python3.6以后我们还可以用类型注解语法和typing.NameTuple来定义具名函数
from typing import NamedTuple class FruitColor(NamedTuple): apple: str orange: str fruitColor = FruitColor("RED","GREEN") print(fruitColor[0]) print(fruitColor.apple)
3.2访问不存在的字典键
当用不存在的键访问字典内容时，程序会抛出KeyError异常
通常的做法：读取内容前先做一次条件判断，只有判断通过的情况下才继续执行其他操作
if "first" in example: num = example["first"] else: num = 0
或者
try: num = example["first"] except KeyError: num = 0
如果只是“提供默认值的读取操作”，其实可以直接使用字典的.get()方法
#dict.get(key, default)方法接收一个default参数 example.get("first",0)
3.3使用setdefault取值并修改
比如我们有一个字典，这个字典内我们不知道有没有这个键
example = {"first":[1],"second":[2]}
try: example["third"].append(3) except KeyError: example["third"] = [3]
除了上述写法还有一个更合适的写法
调用dict.setdefault(key, default)会产生两种结果：
当key不存在时，该方法会把default值写入字典的key位置，并返回该值；
假如key已经存在，该方法就会直接返回它在字典中的对应值
example.setdefault("third",[]).append(3)
3.4认识字典的有序性
在Python 3.6版本以前，几乎所有开发者都遵从一条常识：“Python的字典是无序的。
”这里的无序指的是：当你按照某种顺序把内容存进字典后，就永远没法按照原顺序把它取出来了。
这种无序现象，是由字典的底层实现所决定的
Python里的字典在底层使用了哈希表（hash table）数据结构。当你往字典里存放一对key: value时，Python会先通过哈希算法计算出key的哈希值——一个整型数字；然后根据这个哈希值，决定数据在表里的具体位置
因此，最初的内容插入顺序，在这个哈希过程中被自然丢掉了，字典里的内容顺序变得仅与哈希值相关，与写入顺序无关
字典变为有序只是作为3.6版本的“隐藏特性”存在。但到了3.7版本，它已经彻底成了语言规范的一部分
4.条件分支
4.1分支基础注意事项
4.1.1不要显式地和布尔值做比较
#不推荐的写法 if example.is_deleted() == True: # 推荐写法 if example.is_deleted():
4.1.2省略0值判断
在if分支里时，解释器会主动对它进行“真值测试”，也就是调用bool()函数获取它的布尔值
if containers_count == 0: pass if fruits_list != []: pass
所以我们可以把代码改成如下：
if not containers_count: pass if fruits_list: pass
4.1.3三元表达式
一种浓缩版的条件分支——三元表达式
#语法： # true_value if <expression> else false_value
4.1.4修改对象的布尔值
from typing import List class Length: def __init__(self,items: List[str]): self.items = items lengthList = Length(["2","3"]) if len(lengthList.items) > 0 : pass
只要给UserCollection类实现__len__魔法方法，实际上就是为它实现了Python世界的长度协议
from typing import List class Length: def __init__(self,items: List[str]): self.items = items def __len__(self): return len(self.items)
或者可以在类中实现__bool__
from typing import List class Length: def __init__(self,items: List[str]): self.items = items def __bool__(self): return len(self.items)>2 lengthList = Length(["2","3"]) print(bool(lengthList)) #Fales
注：
假如一个类同时定义了__len__和__bool__两个方法，解释器会优先使用__bool__方法的执行结果
4.2优化分支代码
4.2.1优化枚举代码
class Movie: """电影对象数据类""" @property def rank(self): """按照评分对电影分级： - S: 8.5 分及以上 - A：8 ~ 8.5 分 - B：7 ~ 8 分 - C：6 ~ 7 分 - D：6 分以下 """ rating_num = float(self.rating) if rating_num >= 8.5: return 'S' elif rating_num >= 8: return 'A' elif rating_num >= 7: return 'B' elif rating_num >= 6: return 'C' else: return 'D'
这就是一个普通的枚举代码，根据电影评分给予不同的分级，但是代码冗余
使用二分法模块进行优化
import bisect @property def rank(self): # 已经排好序的评级分界点 breakpoints = (6, 7, 8, 8.5) # 各评分区间级别名 grades = ('D', 'C', 'B', 'A', 'S') index = bisect.bisect(breakpoints, float(self.rating)) return grades[index]
4.2.2 使用字典优化分支
def get_sorted_movies(movies, sorting_type): if sorting_type == 'name': sorted_movies = sorted(movies, key=lambda movie: movie.name.lower()) elif sorting_type == 'rating': sorted_movies = sorted( movies, key=lambda movie: float(movie.rating), reverse=True ) elif sorting_type == 'year': sorted_movies = sorted( movies, key=lambda movie: movie.year, reverse=True ) elif sorting_type == 'random': sorted_movies = sorted(movies, key=lambda movie: random.random()) else: raise RuntimeError(f'Unknown sorting type: {sorting_type}') return sorted_movies
我们发现每一个分支都基本一样：
都是对sorting_type做等值判断（sorting_type == 'name'）
逻辑也大同小异——都是调用sorted()函数，只是key和reverse参数略有不同
所以我们考虑用字典去优化：
sorting_algos = { # sorting_type: (key_func, reverse) 'name': (lambda movie: movie.name.lower(), False), 'rating': (lambda movie: float(movie.rating), True), 'year': (lambda movie: movie.year, True), 'random': (lambda movie: random.random(), False), }
4.3建议
4.3.1尽量避免多层嵌套
这些多层嵌套可以用一个简单的技巧来优化——“提前返回”。
“提前返回”指的是：当你在编写分支时，首先找到那些会中断执行的条件，把它们移到函数的最前面，然后在分支里直接使用return或raise结束执行。
4.3.2别写太复杂的表达式
如果表达式很长很复杂：
我们需要对条件表达式进行简化，把它们封装成函数或者对应的类方法，这样才能提升分支代码的可读性
4.3.3使用德摩根定律
简单来说，“德摩根定律”告诉了我们这么一件事：not A or not B等价于not (A and B)。
if not A or not B: pass #可以改写成 if not (A and B): pass
这样写少了一个not变成更容易理解
4.3.4使用all（） any（）函数构建条件表达式
· all(iterable)：仅当iterable中所有成员的布尔值都为真时返回True，否则返回False。
· any(iterable)：只要iterable中任何一个成员的布尔值为真就返回True，否则返回False。
def all_numbers_gt_10(numbers): """仅当序列中所有数字都大于10 时，返回 True""" if not numbers: return False for n in numbers: if n <= 10: return False return True #改写后 def all_numbers_gt_10_2(numbers): return bool(numbers) and all(n > 10 for n in numbers)
4.3.5 or的短路特性
#or最有趣的地方是它的“短路求值”特性。比如在下面的例子里，1 / 0永远不会被执行，也就意味着不会抛出ZeroDivisionError异常 True or (1 / 0)
所以我们利用这个特性可以简化一些分支
context = {} # 仅当 extra_context 不为 None 时，将其追加进 context 中 if extra_context: context.update(extra_context) #优化后 context.update(extra_context or {})
5异常处理
5.1获取原谅比许可更简单
在Python世界里，EAFP指不做任何事前检查，直接执行操作，但在外层用try来捕获可能发生的异常。
def changeInt(value): """Try to convert the input to an integer""" try: return int(value) except TypeError: print(f'type error:{type(value)} is invalid') except ValueError: print(f'value error:{value} is invalid') finally: print('function completed')
5.1.1把最小的报错更精确的except放在最前面
如果把最大的报错放在最前面会导致所有的报错都报的同一个异常，其他都不会被触发
5.1.2使用else注意点
try: oneBranch() except Exception as e: print("error") else: print("branch succeeded")
- 异常捕获语句里的else表示：仅当try语句块里没抛出任何异常时，才执行else分支下的内容，效果就像在try最后增加一个标记变量一样
- 和finally语句不同，假如程序在执行try代码块时碰到了return或break等跳转语句，中断了本次异常捕获，那么即便代码没抛出任何异常，else分支内的逻辑也不会被执行。
5.1.3使用空raise语句
当一个空raise语句出现在except块里时，它会原封不动地重新抛出当前异常
try: oneBranch() except Exception as e: print("error") raise else: print("branch succeeded")
5.1.4使用上下文管理器
有一个关键字和异常处理也有着密切的关系，它就是with
with是一个神奇的关键字，它可以在代码中开辟一段由它管理的上下文，并控制程序在进入和退出这段上下文时的行为。
比如在上面的代码里，这段上下文所附加的主要行为就是：进入时打开某个文件并返回文件对象，退出时关闭该文件对象。
class DummyContext: def __init__(self, name): self.name = name def __enter__(self): #enter会在进入管理器被调用 #返回接口 return f'{self.name}' def __exit__(self, exc_type, exc_val, exc_tb): #退出会被调用 print('Exiting DummyContext') return False
with DummyContext('HelloWorld') as name: print(f'Name:{name}') #Name:HelloWorld #Exiting DummyContext
上下文管理器功能强大、用处很多，其中最常见的用处之一，就是简化异常处理工作
正如上方5.1的例子我们用with来简化finally
def changeInt(value): """Try to convert the input to an integer""" with DummyContext(): try: return int(value) except TypeError: print(f'type error:{type(value)} is invalid') except ValueError: print(f'value error:{value} is invalid') class DummyContext: def __enter__(self): #enter会在进入管理器被调用 #返回接口 return True def __exit__(self, exc_type, exc_val, exc_tb): #退出会被调用 print('function completed') return False print(changeInt(3)) #function completed #3
5.1.5使用with用于忽略异常
try: func() except : pass
虽然这样的代码很简单，但没法复用。当项目中有很多地方要忽略这类异常时，这些try/except语句就会分布在各个角落，看上去非常凌乱。
class DummyContext: def __enter__(self): #enter会在进入管理器被调用 #返回接口 pass def __exit__(self, exc_type, exc_val, exc_tb): #退出会被调用 if exc_type == NameError: return True return False with DummyContext() as c: func()
当你想忽略NameError异常时，只要把代码用with语句包裹起来即可
在代码执行时，假如with管辖的上下文内没有抛出任何异常，那么当解释器触发__exit__方法时，上面的三个参数值都是None；
但如果有异常抛出，这三个参数就会变成该异常的具体内容。
（1） exc_type：异常的类型。
（2） exc_value：异常对象。
（3） traceback：错误的堆栈对象。
此时，程序的行为取决于__exit__方法的返回值。如果__exit__返回了True，那么这个异常就会被当前的with语句压制住，不再继续抛出，达到“忽略异常”的效果；如果__exit__返回了False，那这个异常就会被正常抛出，交由调用方处理。
5.1.6使用contextmanager装饰器
虽然上下文管理器很好用，但定义一个符合协议的管理器对象其实挺麻烦的——得首先创建一个类，然后实现好几个魔法方法。
为了简化这部分工作，Python提供了一个非常好用的工具：@contextmanager装饰器
from contextlib import contextmanager @contextmanager def create_conn_obj(host, port, timeout=None): """创建连接对象，并在退出上下文时自动关闭""" conn = create_conn() try: yield conn finally: conn.close()
以yield关键字为界，yield前的逻辑会在进入管理器时执行（类似于__enter__），yield后的逻辑会在退出管理器时执行（类似于__exit__）
如果要在上下文管理器内处理异常，必须用try语句块包裹yield语句在日常工作中，我们用到的大多数上下文管理器，可以直接通过“生成器函数+@contextmanager”的方式来定义，这比创建一个符合协议的类要简单得多。
6循环和可迭代对象
在编写for循环时，不是所有对象都可以用作循环主体——只有那些可迭代（iterable）对象才行
说到可迭代对象，你最先想到的肯定是那些内置类型，比如字符串、生成器以及第3章介绍的所有容器类型，等等。
6.1iter()与next()的内置函数
当你使用for循环遍历某个可迭代对象时，其实是先调用了iter()拿到它的迭代器，然后不断地用next()从迭代器中获取值。
所以我们可以自己实现迭代器起到循环效果
intList = [1,2,3,4] num = iter(intList) while True: try: _int = next(num) print(_int) except StopIteration: break
6.2自定义迭代器
class Range7: #生产一个包含7或者可以被7整除 def __init__(self,start,end): self.start = start self.end = end #当前位置 self.current = start #__iter__：调用iter()时触发，迭代器对象总是返回自身。 def __iter__(self): return self # __next__：调用next()时触发，通过return来返回结果 # 没有更多内容就抛出StopIteration异常，会在迭代过程中多次触发 def __next__(self): while True: if self.current >= self.end: raise StopIteration if self.num_is_vaild(self.current): ret = self.current self.current += 1 return ret self.current += 1 def num_is_vaild(self,num): #判断数字是否满足 if not num : return False return num % 7 ==0 or '7' in str(num) r = Range7(0,20) for num in r: print(num)
6.3区分迭代器与可迭代对象
一个合法的迭代器，必须同时实现__iter__和__next__两个魔法方法。
可迭代对象只需要实现__iter__方法，不一定得实现__next__方法。
class Range7: def __init__(self,start,end): self.start = start self.end = end def __iter__(self): #返回一个新的迭代器对象 return Range7Iterator(self) class Range7Iterator: #生产一个包含7或者可以被7整除 def __init__(self,range_obj): self.end = range_obj.end self.start = range_obj.start #当前位置 self.current = range_obj.start #__iter__：调用iter()时触发，迭代器对象总是返回自身。 def __iter__(self): return self # __next__：调用next()时触发，通过return来返回结果 # 没有更多内容就抛出StopIteration异常，会在迭代过程中多次触发 def __next__(self): while True: if self.current >= self.end: raise StopIteration if self.num_is_vaild(self.current): ret = self.current self.current += 1 return ret self.current += 1 def num_is_vaild(self,num): #判断数字是否满足 if not num : return False return num % 7 ==0 or '7' in str(num) r = Range7(0,20) print(tuple(r),1) print(tuple(r),2)
6.4生成器是迭代器
生成器还是一种简化的迭代器实现，使用它可以大大降低实现传统迭代器的编码成本。
因此在平时，我们基本不需要通过__iter__和__next__来实现迭代器，只要写上几个yield就行。
还是用上面的例子。我们用生成器来简化代码
def isRang7(num: int): return True if num !=0 and (num % 7 ==0 or '7' in str(num)) else False def rang7(start: int, end: int): num = start while num < end : if isRang7(num): yield num num += 1
6.5使用itertools模块
看下面这个例子我们如何简化
def find_twelve(num_list1, num_list2, num_list3): """从3 个数字列表中，寻找是否存在和为 12 的3 个数""" for num1 in num_list1: for num2 in num_list2: for num3 in num_list3: if num1 + num2 + num3 == 12: return num1, num2, num3
我们可以使用product()函数来优化它。product()接收多个可迭代对象作为参数，然后根据它们的笛卡儿积不断生成结果
from itertools import product print(list(product([1,2],[3,4])))#[(1, 3), (1, 4), (2, 3), (2, 4)]
from itertools import product def find_twelve_v2(num_list1, num_list2, num_list3): for num1, num2, num3 in product(num_list1, num_list2, num_list3): if num1 + num2 + num3 == 12: return num1, num2, num3
相比之前，新函数只用了一层for循环就完成了任务，代码变得更精练了。
7.函数
7.1常用函数模块
7.1.1functools.partial
functools是一个专门用来处理函数的内置模块，其中有十几个和函数相关的有用工具
def multiply(x, y): return x * y #假设我们有很多地方需要调用上面这个函数 #result = multiply(2, value) #val = multiply(2, number) #这些代码有一个共同的特点，这些代码有一个共同的特点 #为了简化代码 def double(value): # 返回 multiply 函数调用结果 return multiply(2, value) # 调用代码变得更简单 # result = double(value) # val = double(number)
针对这类场景，我们其实不需要像前面一样，用def去完全定义一个新函数——直接使用functools模块提供的高阶函数partial()就行。
def multiply(x, y): return x * y import functools double = functools.partial(multiply,2) print(double(3))#6
7.1.2functools.lru_cache()
为了提高效率，给这类慢函数加上缓存是比较常见的做法。
lru即“最近最少使用”（least recently used，LRU）算法丢掉旧缓存，释放内存
下面模拟一个慢函数
import time from functools import lru_cache @lru_cache(maxsize=None) def slow_func(): time.sleep(10) return 1
第一次缓存没有命中，耗时比较长
第二个调用相同函数，就不会触发函数内部逻辑，结果直接返回
在使用lru_cache()装饰器时，可以传入一个可选的maxsize参数，该参数代表当前函数最多可以保存多少个缓存结果。
默认情况下，maxsize的值为128。如果你把maxsize设置为None，函数就会保存每一个执行结果，不再剔除任何旧缓存。这时如果被缓存的内容太多，就会有占用过多内存的风险。
