1. Python 速查表中文版
  2. 本手册是 Python cheat sheet 的中文翻译版。原作者：Arianne Colton and Sean Chen(data.scientist.info@gmail.com)
  3. 编译：ucasFL
  4. 惯例
  5. 获取帮助
  6. 模块
  7. 数值类类型
  8. 数据结构
  9. 函数
  10. 控制流
  11. 面向对象编程
  12. 常见字符串操作
  13. 异常处理
  14. 对列表、字典和元组的深入理解
  15. 惯例
  16. Python 对大小写敏感；
  17. Python 的索引从 0 开始（所有编程语言均如此）；
  18. Python 使用空白符（制表符或空格）来缩进代码，而不是使用花括号。
  19. 获取帮助
  20. 获取主页帮助： help()
  21. 获取函数帮助： help(str.replace)
  22. 获取模块帮助： help(re)
  23. 模块
  24. 模块亦称库，它只是一个简单地以 .py 为后缀的文件。
  25. 列出模块内容：dir(module1)
  26. 导入模块：import module
  27. 调用模块中的函数：module1.func1()
  28. 注：import 语句会创建一个新的名字空间，并且在该名字空间内执行 .py 文件中的所有语句。如果你想把模块内容导入到当前名字空间，请使用 from module1 import * 语句。
  29. 数值类类型
  30. 查看变量的数据类型：type(variable)
  31. 六种经常使用的数据类型
  32. int/long：过大的 int 类型会被自动转化为 long 类型。
  33. float：64 位，Python 中没有 double 类型。
  34. bool：真或假。
  35. str：在 Python 2 中默认以 ASCII 编码，而在 Python 3 中默认以 Unicode 编码；
  36. 字符串可置于单/双/三引号中；
  37. 字符串是字符的序列，因此可以像处理其他序列一样处理字符串；
  38. 特殊字符可通过 \ 或者前缀 r 实现：

  • 字符串可通过多种方式格式化：
    1. template = '%.2f %s haha $%d';
    2. str1 = template % (4.88, 'hola', 2)

  1. NoneType(None)：Python null 值（只有 None 对象的一个实例中存在）。

    • None 不是一个保留关键字，而是 NoneType 的一个唯一实例。

    • None 通常是可选函数参数的默认值：

      1. def func1(a, b, c = None)

    • None 的常见用法：

      1. if variable is None :

  2. datatime：Python 内建的 datetime 模块提供了 datetime、data 以及 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

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

数据结构

注：所有的 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)

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

针对序列类型的切片

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

用法：

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

注：切片结果包含 **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, ..)

注

  • 关键字参数必须跟在位置参数的后面；
  • 默认情况下，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'), (..), ..]
  1. zip()可以接收任意数量的序列作为参数，但是产生的元素的数目取决于最短的序列。

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

  1. for i, (a, b) in enumerate(zip(seq1, seq2)):
  1. 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

注：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'
  4. #格式化字符串
  5. string1 = 'My name is {0}　{name}'
  6. newString1 = string1.format('Sean', name =　'Chen')
  8. #分裂字符串
  9. sep = '-';
  10. stringList1 =　string1.split(sep)
  12. #获取子串
  13. start = 1;
  14. string1[start:8]
  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]