作者:半载流殇 链接:https://zhuanlan.zhihu.com/p/35219750 来源:知乎 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。 Pythonic,简言之就是以Python这门语言独特的方式写出既简洁又优美的代码!笔者精心整理了许多实用的Python tricks,想要提高效率、写出高质量的Python代码的话此文必看。 注:请将Python更新到3.6版,方能完美运行本文的所有代码。字符串格式化字符串在字符串前加f,就可以在里面用大括号嵌入变量了(可以代替format函数)>>> a = 5 >>> b = 10 >>> f'Five plus ten is {a + b} and not {2 * (a + b)}.' 'Five plus ten is 15 and not 30.' 字符串拼接>>> text = ['I', ' Love ', 'Python!'] >>> print(''.join(text)) I Love Python! 字符串的contains>>> 'ov' in 'love' True 反转元素>>> 'Love'[::-1] 'evoL' >>> for e in reversed([1,3,5]): print(e) 5 3 1 去除非法字符串保存文件时,我们必须去除一些非法字符串,此处利用any函数实现def rectify(name): if any(symbol in name for symbol in ['?', '<', '>', '|', '*', '"', ":"]): name = ''.join([c for c in name if c not in ['?', '<', '>', '|', '*', '"', ":"]]) return name HTML转义>>> import html >>> html.unescape('<') '<' >>> html.escape('<') '<' 函数可变参数*args:任意数量的位置参数,可被打包成元组。**kwargs:任意数量的关键词参数,可被打包成字典。打包def foo(*args, **kwargs): print(f"args: {args}") print(f"kwargs: {kwargs}") >>> foo(1,2,3,4, a=1,b=2,c=3) args: (1, 2, 3, 4) kwargs: {'a': 1, 'b': 2, 'c': 3} 解包def foo(x, y): print(x, y) alist = [1, 2] adict = {'x': 1, 'y': 2} >>> foo(*alist) 1, 2 >>> foo(**adict) 1, 2 装饰器装饰器的主要用途:打印日志、检测性能、数据库事务、URL路由它本质上就是一个高阶函数,它接收一个函数作为参数,然后,返回一个新函数。想理解装饰器,就得知道以下两点:1. 函数皆对象2. 闭包特性(内函数能捕捉到外函数的环境变量)简单的日志函数from datetime import datetime import functools def log(f): @functools.wraps(f) def wr(*args, **kwargs): print(f'call {f.__name__}() at {datetime.now()}') return f(*args, **kwargs) return wr @log def square(x): return x ** 2 >>> square(2) call square() at 2018-01-24 11:01:19.547516 4 注意到为了让@deco自适应任何参数定义的函数,我们将可变参数args, *kwargs作为了wr的参数@functools.wraps(f)为了防止wr的函数属性覆盖掉原函数的属性,我们必须利用@functools.wraps(f)来把原函数的所有属性复制到新函数里# 不加@functools.wraps(f)的情况下 >>> square.__name__ 'wr' # 加了@functools.wraps(f)的情况下 >>> square.__name__ 'square' 如果想给装饰器传递参数,那么你必须利用闭包特性再嵌套一层函数,不过这并不常用。函数性能检测def perf(f): @functools.wraps(f) def wr(*args, **kwargs): start = time.time() r = f(*args, **kwargs) end = time.time() print(f'call {f.__name__}() in {end - start}') return r return wr @perf def test(x): time.sleep(2) return x >>> test(5) call test() in 2.0007083415985107 5 数据库的cursordef link_mysql(fun): def wr(*args, **kwargs): with pymysql.connect(host=host, port=port, user=user, passwd=passwd, db=dbname, charset=charset) as cur: fun(cur, *args, **kwargs) return wr @link_mysql def insert_data(cur, ...): # execute your sql here. 上下文管理器应用文件操作(超常用)、进程互斥锁和支持上下文的其他对象目的是为了代替try语句和简化语法以文件操作为例:利用它,文件会自动打开和关闭with open('/path/to/file', 'r') as f: handle_f 上下文语句支持嵌套(nested)例如将a文件的源数据写入b文件里:with open('a.txt') as i, open('b.txt') as o: o.write(i.read()) 实质通过上下文管理协议__enter__和__exit__来实现Python有个库contextlib利用生成器简化了这种实现,以下是大体框架from contextlib import contextmanager @contextmanager def make_context() : # enter try: yield <value> except Exception as e: # handle_err finally: # exit with make_context() as <value>: # handle_value 以下是with语句操作文件的实质由于自定义,函数名用my_open,但功能和open几乎一样@contextmanager def my_open(filename, mode): f = open(filename, mode) try: yield f except Exception as e: raise e finally: f.close() with my_open('/path/to/file', 'r') as f: handle_f 偏函数partial()用于把一个函数的某些参数给固定住(也就是设置默认值),并返回一个新的函数。def int2(x, base=2): return int(x, base) 相当于:import functools int2 = functools.partial(int, base=2) 数据结构元组元组是一个immutable对象,有以下重要性:- 性能优化- 线程安全- 可以作为dict的key(hashable)- 拆包特性元组拆包a, b = b, a两个数字交换的原理就是它。以下是利用它来获取文件名及其扩展名>>> import os >>> filename, ext = os.path.splitext('patch.exe') >>> filename 'patch' >>> ext 'exe' 更多的解包方式(_代表舍弃,*代表可变长元组)>>> t = (1, 2, 3, 4) >>> first, *middle, last = t >>> middle [2, 3] >>> _, *rest = t >>> rest [2, 3, 4] 列表切片如果想要获取列表的多个元素,就得用到切片list[start:stop:step] 你甚至可以给切片命名,增强复用性和可读性:s = slice(start,stop,step) list[s] 切片的原理是序列协议class Seq: def __getitem__(self, index): return index >>> s = Seq() >>> s[1:5:2] slice(1, 5, 2) 以上实现的是不可变序列协议,如果可变的话还要添加__setitem__()如果在运行时添加协议的话也行,这叫猴子补丁>>> def set_item(self, key, value): self[key] = value >>> classname.__setitem__ = set_item 列表推导式这是Python最强大的几个特征之一。格式也很简单,其中if条件可以省略,for循环可以有多个[i for i in iterable if condition] 10-20所有偶数的平方:[i*i for i in range(10, 21) if i % 2 == 0 ] 一行实现快排def qsort(arr): return arr if len(arr) <= 1 else qsort([x for x in arr[1:] if x<arr[0]]) + [arr[0]] + qsort([x for x in arr[1:] if x>=arr[0]]) 索引迭代enumerate()可以把一个list变成索引-元素对。for i, value in enumerate(['A', 'B', 'C']): print(i, value) 0 A 1 B 2 C zipzip()可以将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,并返回一个迭代器,常用于同时遍历两个可迭代对象。>>> li1 = ['Python' ,'JavaScript', 'Java'] >>> li2 = [1, 2, 3] >>> nl = zip(li1, li2) <zip object at memory> >>> list(nl) [('Python', 1), ('JavaScript', 2), ('Java', 3)] 配合dict可以生成字典>>> l1 = ['A', 'B', 'C'] >>> l2 = [1, 2, 3] >>> dict(zip(l1, l2)) {'A': 1, 'B': 2, 'C': 3} append和extend>>> x = [1, 2, 3] >>> x.extend([4, 5]) >>> x [1, 2, 3, 4, 5] >>> x.append([6, 7]) >>> x [1, 2, 3, 4, 5, [6, 7]] 集合运算首先将要比较的两个list转换为set,再转回list就行了>>> l1 = [1, 2, 3, 4] >>> l2 = [2, 3, 5, 7] >>> list(set(l1) & set(l2)) [2, 3] >>> list(set(l1) | set(l2)) [1, 2, 3, 4, 5, 7] >>> list(set(l1) ^ set(l2)) [1, 4, 5, 7] 字典本质是键值对哈希表get用来获取某个键的值,不存在的话就用设置的default(默认为None)>>> d = dict(a=1, b=2) >>> d.get('a') 1 >>> d.get('c') >>> d.get('d', 2) 2 合并>>> d1 = {'a':1, 'b':2} >>> d2 = {'c':3, 'd':4} >>> nd = {**d1, **d2} >>> nd {'a': 1, 'b': 2, 'c': 3, 'd': 4} 类似的,列表也可以这样合并>>> l1 = [1, 2] >>> l2 = [3, 4] >>> l3 = [*l1, *l2] >>> l3 [1, 2, 3, 4] 键值对反转>>> kv = {'a': 1, 'b':2 , 'c': 3} >>> vk = zip(kv.values(), kv.keys()) >>> dict(vk) {1: 'a', 2: 'b', 3: 'c'} >>> min(vk) (1, 'a') >>> sorted(vk) [(1, 'a'), (2, 'b'), (3, 'c')] 键值排序>>> rows = [{k1: v1, k2: v2 ...}, ...] >>> from operator import itemgetter # 根据k1排序 >>> sorted(rows, key=itemgetter(k1)) # 类似的,对于class的对象可以用attrgetter进行排序 集合运算>>> a = {'a': 1, 'b': 2, 'c': 3} >>> b = {'x': 1, 'b': 2, 'c': 4} >>> a.keys() & b.keys() {'b', 'c'} >>> a.keys() - b.keys() {'a'} >>> a.items() & b.items() {('b', 2)} 其他数据结构具名元组常用于构建简单的类>>> from collections import namedtuple >>> Point = namedtuple('Point', ['x', 'y']) >>> p = Point(x=11, y=22) >>> p Point(x=11, y=22) >>> p.x + p.y 33 >>> coord = (33, 44) >>> q = Point(*coord) >>> q Point(x=33, y=44) 默认值字典常用于统计数目>>> from collections import defaultdict >>> words = ('python', 'java', 'ruby', 'python', 'C', 'java', 'C++', 'C') >>> counts = defaultdict(int) >>> for word in words: ... counts[word] += 1 >>> counts defaultdict(<class 'int'>, {'python': 2, 'java': 2, 'ruby': 1, 'C': 2, 'C++': 1}) 双向队列>>> from collections import deque >>> q = deque(["Eric", "John", "Michael"]) >>> q.append("Terry") >>> q deque(['Eric', 'John', 'Michael', 'Terry']) >>> q.popleft() Eric' >>> q.pop() 'Terry' >>> q deque(['John', 'Michael']) 计数器>>> from collections import Counter >>> c = Counter('hello world') >>> c Counter({'l': 3, 'o': 2, ' ': 1, 'e': 1, 'd': 1, 'h': 1, 'r': 1, 'w': 1}) >>> c.most_common(2) [('l', 3), ('o', 2)] 堆>>> import heapq >>> a = [1, 2, 3] >>> b = [4, 5, 6] >>> c = list(heapq.merge(a, b)) >>> c [1, 2, 3, 4, 5, 6] >>> heapq.nlargest(3, c) [6, 5, 4] >>> heapq.nsmallest(3, c) [1, 2, 3] OOP只读属性可以通过在变量名前加__来使其变成私有变量,外部无法直接访问,但可以通过类定义的方法来访问。class Person(object): def __init__(self, name): self.__name = name def get_name(self): return self.__name def set_name(self, name): self.__name = name >>> p = Person('alphardex') >>> p.name Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'Person' object has no attribute 'name' >>> p.get_name() 'alphardex' >>> p.set_name('wang') >>> p.get_name() 'wang' @property肯定有的人不习惯通过方法来访问私有变量,那么如何用属性来访问私有变量呢?这时就要用到@property了,它可以把一个方法变成属性调用class Person(object): def __init__(self, name): self.__name = name @property def name(self): return self.__name @name.setter def name(self, value): self.__name = value >>> p = Person('alphardex') >>> p.name 'alphardex' >>> p.name = 'wang' >>> p.name 'wang' slots当我们定义了一个class并用其创建了一个实例后,可以动态地给其绑定属性,如果要限制这一点,可以利用__slots__class Person(object): __slots__ = ('name', 'age') >>> p = Person('wang') >>> p.name = 'wang' >>> p.age = 21 >>> p.skill = 'Python' Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'Person' object has no attribute 'skill' 魔术方法魔术方法可以用来定制类的功能。比如__repr__用来调试时打印类的字符串class Person(object): def __init__(self, name, age): self.name = name self.age = age def __repr__(self): return f'<Person {self.name} age: {self.age}>' >>> p = Person('alphardex', 21) >>> p <Person alphardex age: 21> 想了解更多魔术方法请参见官方文档元类type俗话说道生一,一生二,二生三,三生万物。在Python里可以这么说:type生元类,元类生类,类生实例。用一个数字变量的创建来说明这一点吧>>> age = 21 >>> age.__class__ <class 'int'> >>> age.__class__.__class__ <class 'type'> age可以看作为int类的实例,而int类又可以看做type类的实例。也就是说,type创建了int类,实际上诸如str和bool等类也是由type创建的。>>> help(type) Help on class type in module builtins: class type(object) | type(object_or_name, bases, dict) | type(object) -> the object's type | type(name, bases, dict) -> a new type def say_hello(self, name='world'): print(f'Hello, {name}') >>> Hello = type('Hello', (object,), dict(hello=say_hello)) >>> h = Hello() >>> type(Hello) <class 'type'> >>> type(h) <class '__main__.Hello'> 通过用help查看type,可以发现它确实能动态地创建类:第一个参数是类名name,第二个参数是基类bases,第三个参数是dict,里面包含着类的所有方法。实际上,type是Python的一个内置元类。自定义元类当然,你也可以利用type来定义自己的元类。class JSArrayMeta(type): def __new__(cls, name, bases, attrs): attrs['push'] = lambda self, value: self.append(value) attrs['shift'] = lambda self: self.pop(0) attrs['includes'] = lambda self, value: value in self return type.__new__(cls, name, bases, attrs) class JSList(list, metaclass=JSArrayMeta): def __init__(self, value): self.extend(value) >>> l = JSList([1, 2, 3]) >>> l [1, 2, 3] >>> l.push('a') >>> l [1, 2, 3, 'a'] >>> l.shift() 1 >>> l [2, 3, 'a'] >>> l.includes(3) True 我们首先定制了一个元类,叫JSArrayMetaclass(没错就是JS里的数组XD)注意元类的命名规则:结尾一定要有Meta作为识别__new__方法用来创建JSList类,它接受4个参数JSList继承了list类,同时获得了元类的所有方法其他加载内置模块利用-m参数,我们可以直接加载Python的模块# 搭建http服务器 $ python -m http.server # 创建虚拟环境 $ python -m venv <name> # 性能测试 $ python -m cProfile <file.py> # 查看JSON $ cat <file.json> | python -m json.tool 数据序列化import pickle data = ... # Some Python object # 存储 with open(f'{file}.pickle', 'wb') as f: pickle.dump(data, f) # 读取 with open(f'{file}.pickle', 'rb') as f: data = pickle.load(f) 数据分析利用pandas模块可以对数据进行分析$ pip install pandas >>> import pandas as pd >>> data = pd.read_csv(...) # 数据查看 >>> data.columns # 查看数据结构 >>> data.describe() # 简要数据分析 >>> data.sort_values(by=...) # 对数据排序 # 数据选取 >>> data.head() # 查看前五条数据 >>> data.iloc[n] # 选择位置为n的数据,支持切片 >>> data[data.A > 0] # 选择A栏大于0的数据 >>> data[data.B.isin([...])] # 利用in过滤数据 >>> data[~data.B.isin([...])] # 上一句的取反,相当于not in # 缺失值处理 >>> pd.isna(data) # 获取缺失值的布尔标记 >>> data.dropna(how='any') # 去除所有含有缺失值的栏 >>> data.fillna(value=5) # 填充所有含有缺失值的栏 # 数据保存(可以相互转换格式,支持excel、csv和json) >>> data.to_json(...)
链接:https://zhuanlan.zhihu.com/p/35219750
来源:知乎
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
Pythonic,简言之就是以Python这门语言独特的方式写出既简洁又优美的代码!笔者精心整理了许多实用的Python tricks,想要提高效率、写出高质量的Python代码的话此文必看。
注:请将Python更新到3.6版,方能完美运行本文的所有代码。
字符串
格式化字符串
在字符串前加f,就可以在里面用大括号嵌入变量了(可以代替format函数)
>>> a = 5
>>> b = 10
>>> f'Five plus ten is {a + b} and not {2 * (a + b)}.'
'Five plus ten is 15 and not 30.'
字符串拼接
>>> text = ['I', ' Love ', 'Python!']
>>> print(''.join(text))
I Love Python!
字符串的contains
>>> 'ov' in 'love'
True
反转元素
>>> 'Love'[::-1]
'evoL'
>>> for e in reversed([1,3,5]): print(e)
5 3 1
去除非法字符串
保存文件时,我们必须去除一些非法字符串,此处利用any函数实现
def rectify(name):
if any(symbol in name for symbol in ['?', '<', '>', '|', '*', '"', ":"]):
name = ''.join([c for c in name if c not in ['?', '<', '>', '|', '*', '"', ":"]])
return name
HTML转义
>>> import html
>>> html.unescape('<')
'<'
>>> html.escape('<')
'<'
函数
可变参数
*args:任意数量的位置参数,可被打包成元组。
**kwargs:任意数量的关键词参数,可被打包成字典。
打包
def foo(*args, **kwargs):
print(f"args: {args}")
print(f"kwargs: {kwargs}")
>>> foo(1,2,3,4, a=1,b=2,c=3)
args: (1, 2, 3, 4)
kwargs: {'a': 1, 'b': 2, 'c': 3}
解包
def foo(x, y):
print(x, y)
alist = [1, 2]
adict = {'x': 1, 'y': 2}
>>> foo(*alist)
1, 2
>>> foo(**adict)
1, 2
装饰器
装饰器的主要用途:打印日志、检测性能、数据库事务、URL路由
它本质上就是一个高阶函数,它接收一个函数作为参数,然后,返回一个新函数。
想理解装饰器,就得知道以下两点:
1. 函数皆对象
2. 闭包特性(内函数能捕捉到外函数的环境变量)
简单的日志函数
from datetime import datetime
import functools
def log(f):
@functools.wraps(f)
def wr(*args, **kwargs):
print(f'call {f.__name__}() at {datetime.now()}')
return f(*args, **kwargs)
return wr
@log
def square(x):
return x ** 2
>>> square(2)
call square() at 2018-01-24 11:01:19.547516
4
注意到为了让@deco自适应任何参数定义的函数,我们将可变参数args, *kwargs作为了wr的参数
@functools.wraps(f)
为了防止wr的函数属性覆盖掉原函数的属性,我们必须利用@functools.wraps(f)来把原函数的所有属性复制到新函数里
# 不加@functools.wraps(f)的情况下
>>> square.__name__
'wr'
# 加了@functools.wraps(f)的情况下
>>> square.__name__
'square'
如果想给装饰器传递参数,那么你必须利用闭包特性再嵌套一层函数,不过这并不常用。
函数性能检测
def perf(f):
@functools.wraps(f)
def wr(*args, **kwargs):
start = time.time()
r = f(*args, **kwargs)
end = time.time()
print(f'call {f.__name__}() in {end - start}')
return r
return wr
@perf
def test(x):
time.sleep(2)
return x
>>> test(5)
call test() in 2.0007083415985107
5
数据库的cursor
def link_mysql(fun):
def wr(*args, **kwargs):
with pymysql.connect(host=host, port=port, user=user, passwd=passwd, db=dbname, charset=charset) as cur:
fun(cur, *args, **kwargs)
return wr
@link_mysql
def insert_data(cur, ...):
# execute your sql here.
上下文管理器
应用
文件操作(超常用)、进程互斥锁和支持上下文的其他对象
目的是为了代替try语句和简化语法
以文件操作为例:利用它,文件会自动打开和关闭
with open('/path/to/file', 'r') as f:
handle_f
上下文语句支持嵌套(nested)
例如将a文件的源数据写入b文件里:
with open('a.txt') as i, open('b.txt') as o:
o.write(i.read())
实质
通过上下文管理协议__enter__和__exit__来实现
Python有个库contextlib利用生成器简化了这种实现,以下是大体框架
from contextlib import contextmanager
@contextmanager
def make_context() :
# enter
try:
yield <value>
except Exception as e:
# handle_err
finally:
# exit
with make_context() as <value>:
# handle_value
以下是with语句操作文件的实质
由于自定义,函数名用my_open,但功能和open几乎一样
@contextmanager
def my_open(filename, mode):
f = open(filename, mode)
try:
yield f
except Exception as e:
raise e
finally:
f.close()
with my_open('/path/to/file', 'r') as f:
handle_f
偏函数
partial()用于把一个函数的某些参数给固定住(也就是设置默认值),并返回一个新的函数。
def int2(x, base=2):
return int(x, base)
相当于:
import functools
int2 = functools.partial(int, base=2)
数据结构
元组
元组是一个immutable对象,有以下重要性:
- 性能优化
- 线程安全
- 可以作为dict的key(hashable)
- 拆包特性
元组拆包
a, b = b, a
两个数字交换的原理就是它。
以下是利用它来获取文件名及其扩展名
>>> import os
>>> filename, ext = os.path.splitext('patch.exe')
>>> filename
'patch'
>>> ext
'exe'
更多的解包方式(_代表舍弃,*代表可变长元组)
>>> t = (1, 2, 3, 4)
>>> first, *middle, last = t
>>> middle
[2, 3]
>>> _, *rest = t
>>> rest
[2, 3, 4]
列表
切片
如果想要获取列表的多个元素,就得用到切片
list[start:stop:step]
你甚至可以给切片命名,增强复用性和可读性:
s = slice(start,stop,step)
list[s]
切片的原理是序列协议
class Seq:
def __getitem__(self, index):
return index
>>> s = Seq()
>>> s[1:5:2]
slice(1, 5, 2)
以上实现的是不可变序列协议,如果可变的话还要添加__setitem__()
如果在运行时添加协议的话也行,这叫猴子补丁
>>> def set_item(self, key, value):
self[key] = value
>>> classname.__setitem__ = set_item
列表推导式
这是Python最强大的几个特征之一。
格式也很简单,其中if条件可以省略,for循环可以有多个
[i for i in iterable if condition]
10-20所有偶数的平方:
[i*i for i in range(10, 21) if i % 2 == 0 ]
一行实现快排
def qsort(arr):
return arr if len(arr) <= 1 else qsort([x for x in arr[1:] if x<arr[0]]) + [arr[0]] + qsort([x for x in arr[1:] if x>=arr[0]])
索引迭代
enumerate()可以把一个list变成索引-元素对。
for i, value in enumerate(['A', 'B', 'C']):
print(i, value)
0 A 1 B 2 C
zip
zip()可以将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,并返回一个迭代器,常用于同时遍历两个可迭代对象。
>>> li1 = ['Python' ,'JavaScript', 'Java']
>>> li2 = [1, 2, 3]
>>> nl = zip(li1, li2)
<zip object at memory>
>>> list(nl)
[('Python', 1), ('JavaScript', 2), ('Java', 3)]
配合dict可以生成字典
>>> l1 = ['A', 'B', 'C']
>>> l2 = [1, 2, 3]
>>> dict(zip(l1, l2))
{'A': 1, 'B': 2, 'C': 3}
append和extend
>>> x = [1, 2, 3]
>>> x.extend([4, 5])
>>> x
[1, 2, 3, 4, 5]
>>> x.append([6, 7])
>>> x
[1, 2, 3, 4, 5, [6, 7]]
集合运算
首先将要比较的两个list转换为set,再转回list就行了
>>> l1 = [1, 2, 3, 4]
>>> l2 = [2, 3, 5, 7]
>>> list(set(l1) & set(l2))
[2, 3]
>>> list(set(l1) | set(l2))
[1, 2, 3, 4, 5, 7]
>>> list(set(l1) ^ set(l2))
[1, 4, 5, 7]
字典
本质是键值对哈希表
get
用来获取某个键的值,不存在的话就用设置的default(默认为None)
>>> d = dict(a=1, b=2)
>>> d.get('a')
1
>>> d.get('c')
>>> d.get('d', 2)
2
合并
>>> d1 = {'a':1, 'b':2}
>>> d2 = {'c':3, 'd':4}
>>> nd = {**d1, **d2}
>>> nd
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
类似的,列表也可以这样合并
>>> l1 = [1, 2]
>>> l2 = [3, 4]
>>> l3 = [*l1, *l2]
>>> l3
[1, 2, 3, 4]
键值对反转
>>> kv = {'a': 1, 'b':2 , 'c': 3}
>>> vk = zip(kv.values(), kv.keys())
>>> dict(vk)
{1: 'a', 2: 'b', 3: 'c'}
>>> min(vk)
(1, 'a')
>>> sorted(vk)
[(1, 'a'), (2, 'b'), (3, 'c')]
键值排序
>>> rows = [{k1: v1, k2: v2 ...}, ...]
>>> from operator import itemgetter
# 根据k1排序
>>> sorted(rows, key=itemgetter(k1))
# 类似的,对于class的对象可以用attrgetter进行排序
集合运算
>>> a = {'a': 1, 'b': 2, 'c': 3}
>>> b = {'x': 1, 'b': 2, 'c': 4}
>>> a.keys() & b.keys()
{'b', 'c'}
>>> a.keys() - b.keys()
{'a'}
>>> a.items() & b.items()
{('b', 2)}
其他数据结构
具名元组
常用于构建简单的类
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(x=11, y=22)
>>> p
Point(x=11, y=22)
>>> p.x + p.y
33
>>> coord = (33, 44)
>>> q = Point(*coord)
>>> q
Point(x=33, y=44)
默认值字典
常用于统计数目
>>> from collections import defaultdict
>>> words = ('python', 'java', 'ruby', 'python', 'C', 'java', 'C++', 'C')
>>> counts = defaultdict(int)
>>> for word in words:
... counts[word] += 1
>>> counts
defaultdict(<class 'int'>, {'python': 2, 'java': 2, 'ruby': 1, 'C': 2, 'C++': 1})
双向队列
>>> from collections import deque
>>> q = deque(["Eric", "John", "Michael"])
>>> q.append("Terry")
>>> q
deque(['Eric', 'John', 'Michael', 'Terry'])
>>> q.popleft()
Eric'
>>> q.pop()
'Terry'
>>> q
deque(['John', 'Michael'])
计数器
>>> from collections import Counter
>>> c = Counter('hello world')
>>> c
Counter({'l': 3, 'o': 2, ' ': 1, 'e': 1, 'd': 1, 'h': 1, 'r': 1, 'w': 1})
>>> c.most_common(2)
[('l', 3), ('o', 2)]
堆
>>> import heapq
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = list(heapq.merge(a, b))
>>> c
[1, 2, 3, 4, 5, 6]
>>> heapq.nlargest(3, c)
[6, 5, 4]
>>> heapq.nsmallest(3, c)
[1, 2, 3]
OOP
只读属性
可以通过在变量名前加__来使其变成私有变量,外部无法直接访问,但可以通过类定义的方法来访问。
class Person(object):
def __init__(self, name):
self.__name = name
def get_name(self):
return self.__name
def set_name(self, name):
self.__name = name
>>> p = Person('alphardex')
>>> p.name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Person' object has no attribute 'name'
>>> p.get_name()
'alphardex'
>>> p.set_name('wang')
>>> p.get_name()
'wang'
@property
肯定有的人不习惯通过方法来访问私有变量,那么如何用属性来访问私有变量呢?这时就要用到@property了,它可以把一个方法变成属性调用
class Person(object):
def __init__(self, name):
self.__name = name
@property
def name(self):
return self.__name
@name.setter
def name(self, value):
self.__name = value
>>> p = Person('alphardex')
>>> p.name
'alphardex'
>>> p.name = 'wang'
>>> p.name
'wang'
slots
当我们定义了一个class并用其创建了一个实例后,可以动态地给其绑定属性,如果要限制这一点,可以利用__slots__
class Person(object):
__slots__ = ('name', 'age')
>>> p = Person('wang')
>>> p.name = 'wang'
>>> p.age = 21
>>> p.skill = 'Python'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Person' object has no attribute 'skill'
魔术方法
魔术方法可以用来定制类的功能。
比如__repr__用来调试时打印类的字符串
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __repr__(self):
return f'<Person {self.name} age: {self.age}>'
>>> p = Person('alphardex', 21)
>>> p
<Person alphardex age: 21>
想了解更多魔术方法请参见官方文档
元类
type
俗话说道生一,一生二,二生三,三生万物。
在Python里可以这么说:type生元类,元类生类,类生实例。
用一个数字变量的创建来说明这一点吧
>>> age = 21
>>> age.__class__
<class 'int'>
>>> age.__class__.__class__
<class 'type'>
age可以看作为int类的实例,而int类又可以看做type类的实例。
也就是说,type创建了int类,实际上诸如str和bool等类也是由type创建的。
>>> help(type)
Help on class type in module builtins:
class type(object)
| type(object_or_name, bases, dict)
| type(object) -> the object's type
| type(name, bases, dict) -> a new type
def say_hello(self, name='world'):
print(f'Hello, {name}')
>>> Hello = type('Hello', (object,), dict(hello=say_hello))
>>> h = Hello()
>>> type(Hello)
<class 'type'>
>>> type(h)
<class '__main__.Hello'>
通过用help查看type,可以发现它确实能动态地创建类:第一个参数是类名name,第二个参数是基类bases,第三个参数是dict,里面包含着类的所有方法。
实际上,type是Python的一个内置元类。
自定义元类
当然,你也可以利用type来定义自己的元类。
class JSArrayMeta(type):
def __new__(cls, name, bases, attrs):
attrs['push'] = lambda self, value: self.append(value)
attrs['shift'] = lambda self: self.pop(0)
attrs['includes'] = lambda self, value: value in self
return type.__new__(cls, name, bases, attrs)
class JSList(list, metaclass=JSArrayMeta):
def __init__(self, value):
self.extend(value)
>>> l = JSList([1, 2, 3])
>>> l
[1, 2, 3]
>>> l.push('a')
>>> l
[1, 2, 3, 'a']
>>> l.shift()
1
>>> l
[2, 3, 'a']
>>> l.includes(3)
True
- 我们首先定制了一个元类,叫JSArrayMetaclass(没错就是JS里的数组XD)
- 注意元类的命名规则:结尾一定要有Meta作为识别
- __new__方法用来创建JSList类,它接受4个参数
- JSList继承了list类,同时获得了元类的所有方法
其他
加载内置模块
利用-m参数,我们可以直接加载Python的模块
# 搭建http服务器
$ python -m http.server
# 创建虚拟环境
$ python -m venv <name>
# 性能测试
$ python -m cProfile <file.py>
# 查看JSON
$ cat <file.json> | python -m json.tool
数据序列化
import pickle
data = ... # Some Python object
# 存储
with open(f'{file}.pickle', 'wb') as f:
pickle.dump(data, f)
# 读取
with open(f'{file}.pickle', 'rb') as f:
data = pickle.load(f)
数据分析
利用pandas模块可以对数据进行分析
$ pip install pandas
>>> import pandas as pd
>>> data = pd.read_csv(...)
# 数据查看
>>> data.columns # 查看数据结构
>>> data.describe() # 简要数据分析
>>> data.sort_values(by=...) # 对数据排序
# 数据选取
>>> data.head() # 查看前五条数据
>>> data.iloc[n] # 选择位置为n的数据,支持切片
>>> data[data.A > 0] # 选择A栏大于0的数据
>>> data[data.B.isin([...])] # 利用in过滤数据
>>> data[~data.B.isin([...])] # 上一句的取反,相当于not in
# 缺失值处理
>>> pd.isna(data) # 获取缺失值的布尔标记
>>> data.dropna(how='any') # 去除所有含有缺失值的栏
>>> data.fillna(value=5) # 填充所有含有缺失值的栏
# 数据保存(可以相互转换格式,支持excel、csv和json)
>>> data.to_json(...)