如何写出Pythonic风格的代码
索引
>>> my_numbers = (4, 5, 3, 9)
>>> my_numbers[0]
4
>>> my_numbers[1]
5
>>> my_numbers[-1]
9
>>> my_numbers[-2]
3
切片
>>> my_numbers = (4, 5, 3, 9)
>>> my_numbers[0:2]
(4, 5)
>>> my_numbers[0:3:2] # 步长为可选参数
(4, 3)
>>> my_numbers[0:-2] # 只能从左往右
(4, 5)
>>> my_numbers[0:-1:2]
(4, 3)
>>> my_numbers[2:] # 可以缺省起始和终止索引
(3, 9)
>>> my_numbers[:2]
(4, 5)
>>> my_numbers[:] # 相当于浅拷贝
(4, 5, 3, 9)
>>> my_numbers[::]
(4, 5, 3, 9)
>>> interval = slice(0, 3, 2)
>>> my_numbers[interval] # => my_numbers[0:3:2]
(4, 3)
>>> interval = slice(None, 3)
>>> my_numbers[interval] == my_numbers[:3]
True
创建自定义序列类型
class Items:
def __init__(self, *values):
self._values = list(values)
def __len__(self):
return len(self._values)
def __getitem__(self, item):
return self._values.__getitem__(item)
上面的例子封装了内置的list结构。另外一种是使用继承，通过拓展基类collections.UserList。
当你需要完完全全实现自己的序列结构时，请牢记两点：
- 按照范围切片时，结果应该是相同类型的实例序列。
- 在切片提供的范围内，请尊重Python使用的语义，排除最后的元素。
另外range也可以进行切片
>>> range(1, 100)[25:50]
range(26, 51)
上下文管理
上下文管理器是Python提供的独特功能，它十分有用，非常适合这样的模式：运行一些代码，需要前置和后置条件。例如处理文件：open->处理->close。
fd = open(filename)
try:
process_file(fd)
finally:
fd.close()
使用with
with open(filename) as fd:
process_file(fd)
上下文管理器依赖两个魔法方法__enter__和__exit__，分别对应前置和后置处理逻辑。
通过类实现上下文管理器
def stop_database():
print("systemctl stop postgresql.service")
def start_database():
print("systemctl start postgresql.service")
def db_backup():
print("pg_dump database")
class DBHandler:
def __enter__(self):
stop_database()
return self # "with xxx as obj" obj is self here.
def __exit__(self, exc_type, ex_value, ex_traceback):
start_database()
def main():
with DBHandler():
db_backup()
通过方法实现上下文管理器，需要使用contextlib.contextmanager装饰器
import contextlib
@contextlib.contextmanager
def db_handler():
stop_database()
yield # "with xxx as obj" obj is "yield {obj}".
start_database()
with db_handler():
db_backup()
甚至连with也不用，需要使用contextlib.ContextDecorator基类
import contextlib
class dbhandler_decorator(contextlib.ContextDecorator):
def __enter__(self):
stop_database()
def __exit__(self, ext_type, ex_value, ex_traceback):
start_database()
@dbhandler_decorator()
def offline_backup():
print("pg_dump database")
但是这种用法你没法使用__enter__函数的返回值
使用上下文管理器处理异常
import contextlib
with contextlib.suppress(DataConversionException):
parse_data(input_json_or_dict)
如果引发DataConversionException，直接跳过。
属性
单下划线表示只会从内部访问（保护）的属性和方法。对象只应该公开那些外部调用者关心的属性和方法，也就是接口，一切不是严格属于接口的都应该使用单下划线。
双下划线并非定义私有变量的方式，访问双下划线会导致AttributeError，这是因为双下划线会导致重命名：
class Connector:
def __init__(self):
self.__timeout = 60 # ___
def __run(self):
print('Run')
conn = Connector()
print(conn.__timeout) # raise AttributeError
print(conn._Connector__timeout) # 60
print(conn.__run) # raise AttributeError
print(conn._Connector__run) # function
双下划线是非Pythonic方法。如果您需要将属性定义为私有的，使用单个下划线，并遵守Pythonic约定，即它是私有的属性。
使用@properties和@xxxx.setter装饰器
class User:
def __init__(self, username):
self.username = username
self._email = None
@property
def email(self):
return self._email
@email.setter
def email(self, new_email):
self._email = new_email
迭代对象
python确定对象是否可迭代的，主要依据两点：
- 是否实现了__next__或__iter__迭代方法
- 是否是一个序列，实现了__len__和__getitem__
python会依照顺序尝试调用这些方法来迭代对象
class A:
def __init__(self, count=0):
self._count = count
def __iter__(self):
return self
def __next__(self):
if self._count >= 5:
raise StopIteration
self._count += 1
return self._count
class B:
def __iter__(self):
return A(1)
a = list(A())
b = list(B())
print(a) # [1, 2, 3, 4, 5]
print(b) # [2, 3, 4, 5]
调用__iter__返回的值再调用__next__
或者__iter__直接返回生成器
from datetime import date, timedelta
class DateRangeContainerIterable:
def __init__(self, start_date, end_date):
self.start_date = start_date
self.end_date = end_date
def __iter__(self):
current_day = self.start_date
while current_day < self.end_date:
yield current_day
current_day += timedelta(days=1)
d = DateRangeContainerIterable(date(2018, 1, 1), date(2018, 1, 5))
print(", ".join(map(str, d))) # '2018-01-01, 2018-01-02, 2018-01-03, 2018-01-04'
包含对象
flag = element in container
# => flag = container.__contains__(element)
动态获取属性
python调用存在的属性会调用__getattribute__，当属性不存在时，会调用__getattr__。
可调用对象
当我们调用一个对象object(*args, *kwargs)时，实际上转换为了object.__call__(args, **kwargs)
from collections import defaultdict
class CallCount:
def __init__(self):
self._counts = defaultdict(int)
def __call__(self, argument):
self._counts[argument] += 1
return self._counts[argument]
cc = CallCount()
print(cc(1)) # 1
print(cc(2)) # 1
print(cc(1)) # 2
print(cc(1)) # 3
print(cc(3)) # 1
魔法方法总结
[图片上传失败...(image-bd2aa1-1571013774916)]
Python注意事项
不要将引用类型的对象作为函数的默认参数，否则结果不可预期
def wrong_user_display(user_metadata: dict = {"name": "John", "age": 30}):
name = user_metadata.pop("name")
age = user_metadata.pop("age")
return f"{name} ({age})"
print(wrong_user_display()) # 'John (30)
print(wrong_user_display({"name": "Jane", "age": 25})) # John (25)
print(wrong_user_display()) # raise KeyError: 'name'
拓展内置数据类型
拓展内置数据类型的正确方式是使用collections模块