Python Cheat Sheet

Info

本手册是 Python cheat sheet 的中文翻译版。原作者：Arianne Colton and Sean Chen (data.scientist.info@gmail.com) 编译：ucasFL 以 MIT License 分发转载后二次修改，主要是版面细节调整，以增强阅读体验。

Guys，我们虽然在高中一年级已经学了一些 Python 知识，但经过后面两年的折磨，如果你没有继续投入，想必早就忘记了它的语法了吧。没关系，我们接下来会快速过一遍 Python 的语法知识点。

惯例#

Python 对大小写敏感；
Python 的索引从 0 开始（几乎所有编程语言均如此）；
Python 使用空白符（制表符或空格）来缩进代码，而不是使用花括号。

获取帮助#

获取主页帮助： help()
获取函数帮助： help(str.replace)
获取模块帮助： help(re)

模块#

模块亦称库，它只是一个简单地以 .py 为后缀的文件。

列出模块内容：dir(module1)
导入模块：import module
调用模块中的函数：module1.func1()

Tip

import 语句会创建一个新的命名空间，并且在该命名空间内执行 .py 文件中的所有语句。如果你想把模块内容导入到当前命名空间，请使用 from module1 import * 语句。

数值类类型#

查看变量的数据类型：type(variable)

六种经常使用的数据类型#

int/long：过大的 int 类型会被自动转化为 long 类型。
float：64 位，Python 中没有 double 类型。
bool：真或假。
str：在 Python 2 中默认以 ASCII 编码，而在 Python 3 中默认以 Unicode 编码；
- 字符串可置于单/双/三引号中；
- 字符串是字符的序列，因此可以像处理其他序列一样处理字符串；
- 特殊字符可通过 \ 或者前缀 r 实现：
```
1
str1 = r'this\f?ff'
```
- 字符串可通过多种方式格式化：
```
1
template = '%.2f %s haha $%d';
2
str1 = template % (4.88, 'hola', 2)
```
NoneType(None)：Python null 值（只有 None 对象的一个实例中存在）。
- None 不是一个保留关键字，而是 NoneType 的一个唯一实例。
- None 通常是可选函数参数的默认值：
```
1
def func1(a, b, c = None)
```
- None 的常见用法：
```
1
if variable is None :
```
datetime：Python 内建的 datetime 模块提供了 datetime、date 以及 time 类型。
- datetime 组合了存储于 date 和 time 中的信息。

1
#从字符串中创建 datetime
2
dt1 = datetime.strptime('20091031', '%Y%m%d')
3
#获取 date 对象
4
dt1.date()
5
#获取 time 对象
6
dt1.time()
7
#将 datetime 格式化为字符串
8
dt1.strftime('%m/%d/%Y%H:%M')
9
#更改字段值
10
dt2 = dt1.replace(minute = 0, second = 30)
11
#做差, diff 是一个 datetime.timedelta 对象
12
diff = dt1 - dt2

Tip

Python 中的绝大多数对象都是可变的，只有字符串和元组例外

数据结构#

Tip

所有的 non-Get 函数调用，比如下面例子中的 list1.sort() 都是原地操作，即不会创建新的对象，除非特别声明。

元组#

元组是 Python 中任何类型的对象的一个一维、固定长度、不可变的序列。

1
#创建元组
2
tup1 = 4, 5, 6
3
# or
4
tup1 = (6, 7, 8)
5
#创建嵌套元组
6
tup1 = (4, 5, 6), (7, 8)
7
#将序列或迭代器转化为元组
8
tuple([1, 0, 2])
9
#连接元组
10
tup1 + tup2
11
#解包元组
12
a, b, c = tup1

元组应用：

1
#交换两个变量的值
2
a, b = b, a

列表#

列表是 Python 中任何类型的对象的一个一维、非固定长度、可变（比如内容可以被修改）的序列。

1
#创建列表
2
list1 = [1, 'a', 3]
3
#or
4
list1 = list(tup1)
5
#连接列表
6
list1 + list2
7
#or
8
list1.extend(list2)
9
#追加到列表的末尾
10
list1.append('b')
11
#插入指定位置
12
list1.insert(PosIndex, 'a')
13
#反向插入，即弹出给定位置的值/删除
14
ValueAtIdx = list1.pop(PosIndex)
15
#移除列表中的第一个值, a 必须是列表中第一个值
16
list1.remove('a')
17
#检查成员资格
18
3 in list1 => True or False
19
#对列表进行排序
20
list1.sort()
21
#按特定方式排序
22
list1.sort(key = len) # 按长度排序

使用 + 连接列表会有比较大的开支，因为这个过程中会创建一个新的列表，然后复制对象。因此，使用 extend() 是更明智的选择；
insert 和 append 相比会有更大的开支（时间/空间）；
在列表中检查是否包含一个值会比在字典和集合中慢很多，因为前者需要进行线性扫描，而后者是基于哈希表的，所以只需要花费常数时间。

内建的 `bisect` 模块#

对一个排序好的列表进行二分查找或插入；
bisect.bisect找到元素在列表中的位置，bisect.insort将元素插入到相应位置。用法：

1
import bisect
2
list1 = list(range(10))
3
#找到 5 在 list1 中的位置，从 1 开始，因此 position = index + 1
4
bisect.bisect(list1, 5)
5
#将 3.5 插入 list1 中合适位置
6
bisect.insort(list1, 3.5)

Tip

bisect 模块中的函数并不会去检查列表是否排序好，因为这会花费很多时间。所以，对未排序好的列表使用这些函数也不会报错，但可能会返回不正确的结果

针对序列类型的切片#

序列类型包括 str、array、tuple、list 等。

用法：

1
list1[start:stop]
2
#如果使用 step
3
list1(start:stop:step)

Tip

切片结果包含 start 索引，但不包含 stop 索引；start/stop 索引可以省略，如果省略，则默认为序列从开始到结束，如 list1 == list1[:]

step 的应用：

1
#取出奇数位置的元素
2
list1[::2]
3
#反转字符串
4
str1[::-1]

字典（哈希映射）#

1
#创建字典
2
dict1 = {'key1': 'value1', 2: [3,2]}
3
#从序列创建字典
4
dict(zip(KeyList, ValueList))
5
#获取/设置/插入元素
6
dict1['key1']
7
dict1['key1'] = 'NewValue'
8
#get 提供默认值
9
dict1.get('key1', DefaultValue)
10
#检查键是否存在
11
'key1' in dict1
12
#获取键列表
13
dict1.keys()
14
#获取值列表
15
dict1.values()
16
#更新值
17
dict1.update(dict2)#dict1 的值被 dict2 替换

如果键不存在，则会出现 KeyError Exception 。
当键不存在时，如果 get()不提供默认值则会返回 None 。
以相同的顺序返回键列表和值列表，但顺序不是特定的，又称极大可能非排序。

有效字典键类型#

键必须是不可变的，比如标量类型(int、float、string)或者元组（元组中的所有对象也必须是不可变的）。
这儿涉及的技术术语是 hashability。可以用函数 hash()来检查一个对象是否是可哈希的，比如 hash('This is a string') 会返回一个哈希值，而 hash([1,2]) 则会报错（不可哈希）。

集合#

一个集合是一些无序且唯一的元素的聚集；
你可以把它看成只有键的字典；

1
#创建集合
2
set([3, 6, 3])
3
#or
4
{3, 6, 3}
5
#子集测试
6
set1.issubset(set2)
7
#超集测试
8
set1.issuperset(set2)
9
#测试两个集合中的元素是否完全相同
10
set1 == set2

集合操作#

并（又称或）：set1 | set2
交（又称与）：set1 & set2
差：set1 - set2
对称差（又称异或）：set1 ^ set2

函数#

Python 的函数参数传递是通过引用传递。

基本形式

1
def func1(posArg1, keywordArg1 = 1, ..)

Tip

关键字参数必须跟在位置参数的后面；默认情况下，Python 不会“延迟求值”，表达式的值会立刻求出来。

函数调用机制#

所有函数均位于模块内部作用域。见“模块”部分。
在调用函数时，参数被打包成一个元组和一个字典，函数接收一个元组 args 和一个字典 kwargs，然后在函数内部解包。

“函数是对象”的常见用法：

1
def func1(ops = [str.strip, user_define_func, ..], ..):
2
  for function in ops:
3
    value = function(value)

返回值#

如果函数末尾没有 return 语句，则不会返回任何东西。
如果有多个返回值则通过一个元组来实现。

1
return (value1, value2)
2
value1, value2 = func1(..)

匿名函数（又称 LAMBDA 函数）#

什么是匿名函数？

匿名函数是一个只包含一条语句的简单函数。

1
lambda x : x * 2
2
# def func1(x) : return x * 2

匿名函数的应用：‘curring’，又称利用已存在函数的部分参数来派生新的函数。

1
ma60 = lambda x : pd.rolling_mean(x, 60)

一些有用的函数（针对数据结构）#

enumerate() 返回一个序列(i, value)元组，i 是当前 item 的索引。

1
for i, value in enumerate(collection):

应用：创建一个序列中值与其在序列中的位置的字典映射（假设每一个值都是唯一的）。

sort()可以从任意序列中返回一个排序好的序列。

1
sorted([2, 1, 3]) => [1, 2, 3]

应用：

1
sorted(set('abc bcd')) => [' ',
2
'a', 'b', 'c', 'd']
3
# 返回一个字符串排序后无重复的字母序列

zip()函数可以把许多列表、元组或其他序列的元素配对起来创建一系列的元组。

1
zip(seq1, seq2) => [('seq1_1', 'seq2_1'), (..), ..]

zip()可以接收任意数量的序列作为参数，但是产生的元素的数目取决于最短的序列。

应用：多个序列同时迭代：

1
for i, (a, b) in enumerate(zip(seq1, seq2)):

unzip：另一种思考方式是把一些行转化为一些列：

1
seq1, seq2 = zip(zipOutput)

reversed() 将一个序列的元素以逆序迭代。

1
list(reversed(range(10)))

reversed() 会返回一个迭代器，list() 使之成为一个列表。

控制流#

用于 if-else 条件中的操作符：

1
#检查两个变量是否是相同的对象
2
var1 is var2
3
#检查两个变量是否是不同的对象
4
var1 is not var2
5
#检查两个变量的值是否相等
6
var1 == var2

Warning

Python 中使用 and、or、not 来组合条件，而不是使用 &&、||、!

for循环的常见用法：

1
#可迭代对象（list、tuple）或迭代器
2
for element in iterator:
3
#如果元素是可以解包的序列
4
for a, b, c in iterator:

pass：无操作语句，在不需要进行任何操作的块中使用。
三元表达式，又称简洁的 if-else，基本形式：

1
value = true-expr if condition else false-expr

Python 中没有 switch/case 语句，请使用 if/elif。

面向对象编程#

对象是 Python 中所有类型的根。
万物（数字、字符串、函数、类、模块等）皆为对象，每个对象均有一个类型（type）。对象变量是一个指向变量在内存中位置的指针。
所有对象均为引用计数。

1
sys.getrefcount(5) => x
2
a = 5, b = a
3
#上式会在等号的右边创建一个对象的引用，因此 a 和 b 均指向 5
4
sys.getrefcount(5)
5
=> x + 2
6
del(a); sys.getrefcount(5) => x + 1

类的基本形式：

1
class MyObject(object):
2
  # 'self' 等价于 Java/C++ 中的 'this'
3
  def __init__(self, name):
4
    self.name = name
5
  def memberFunc1(self, arg1):
6
      ..
7
  @staticmethod
8
  def classFunc2(arg1):
9
    ..
10
obj1 = MyObject('name1')
11
obj1.memberFunc1('a')
12
MyObject.classFunc2('b')

有用的交互式工具：

1
dir(variable1) #列出对象的所有可用方法

常见字符串操作#

1
#通过分隔符连接列表/元组
2
', '.join([ 'v1', 'v2', 'v3']) => 'v1, v2, v3'
3

4
#格式化字符串
5
string1 = 'My name is {0}　{name}'
6
newString1 = string1.format('Sean', name =　'Chen')
7

8
#分裂字符串
9
sep = '-';
10
stringList1 =　string1.split(sep)
11

12
#获取子串
13
start = 1;
14
string1[start:8]
15

16
#补 '0' 向右对齐字符串
17
month = '5';
18
month.zfill(2) => '05'
19
month = '12';
20
month.zfill(2) => '12'
21
month.zfill(3) => '012'

对列表和字典以及元组的深入理解

异常处理#

基本形式：

1
try:
2
  ..
3
except ValueError as e:
4
  print e
5
except (TypeError, AnotherError):
6
  ..
7
except:
8
  ..
9
finally:
10
  .. # 清理，比如 close db;

手动引发异常：

1
raise AssertionError # 断言失败
2
raise SystemExit
3
# 请求程序退出
4
raise RuntimeError('错误信息 :..')

对列表和字典以及元组的深入理解#

语法糖（syntactic sugar）会使代码变得更加易读易写。

对列表的理解#

将一些元素通过一个简短的语句传入一个过滤器进行过滤和转化，然后可以组成一个新的列表。

1
#基本形式
2
[expr for val in collection if condition]
3
#ShortCut
4
result = []
5
for val in collection:
6
  if condition:
7
    result.append(expr)

可以省略过滤条件，只留下表达式。

对字典的理解#

基本形式：

1
{key-expr : value-expr for value in collection if condition}

对集合的理解#

基本形式：和列表一样，只是应该使用 () 而不是 [] 。

嵌套列表#

基本形式：

1
[expr for val in collection for innerVal in val if condition]

音乐

惯例#

获取帮助#

模块#

数值类类型#

六种经常使用的数据类型#

数据结构#

元组#

列表#

内建的 `bisect` 模块#

针对序列类型的切片#

字典（哈希映射）#

有效字典键类型#

集合#

集合操作#

函数#

函数调用机制#

返回值#

匿名函数（又称 LAMBDA 函数）#

一些有用的函数（针对数据结构）#

控制流#

面向对象编程#

常见字符串操作#

异常处理#

对列表和字典以及元组的深入理解#

对列表的理解#

对字典的理解#

对集合的理解#

嵌套列表#

文章分享

评论区

惯例#

获取帮助#

模块#

数值类类型#

六种经常使用的数据类型#

数据结构#

元组#

列表#

内建的 bisect 模块#

针对序列类型的切片#

字典（哈希映射）#

有效字典键类型#

集合#

集合操作#

函数#

函数调用机制#

返回值#

匿名函数（又称 LAMBDA 函数）#

一些有用的函数（针对数据结构）#

控制流#

面向对象编程#

常见字符串操作#

异常处理#

对列表和字典以及元组的深入理解#

对列表的理解#

对字典的理解#

对集合的理解#

嵌套列表#

文章分享

评论区

内建的 `bisect` 模块#