变量和注释
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语句在日常工作中，我们用到的大多数上下文管理器，可以直接通过“生成器函数[email protected]”的方式来定义，这比创建一个符合协议的类要简单得多。
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，函数就会保存每一个执行结果，不再剔除任何旧缓存。这时如果被缓存的内容太多，就会有占用过多内存的风险。
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/280269.html