add python cheatsheet

languages/python.md

@@ -0,0 +1,545 @@
+Python 速查表中文版
+===
+
+- 本手册是 [Python cheat sheet](http://datasciencefree.com/python.pdf) 的中文翻译版。原作者：Arianne Colton and Sean Chen(data.scientist.info@gmail.com)
+- 编译：[ucasFL](https://github.com/ucasFL)
+
+[惯例](#惯例)
+
+[获取帮助](#获取帮助)
+
+[模块](#模块)
+
+[数值类类型](#数值类类型)
+
+[数据结构](#数据结构)
+
+[函数](#函数)
+
+[控制流](#控制流)
+
+[面向对象编程](#面向对象编程)
+
+[常见字符串操作](#常见字符串操作)
+
+[异常处理](#异常处理)
+
+[对列表、字典和元组的深入理解](#对列表和字典以及元组的深入理解)
+
+## 惯例
+
+- Python 对大小写敏感；
+- Python 的索引从 0 开始（所有编程语言均如此）；
+- Python 使用空白符（制表符或空格）来缩进代码，而不是使用花括号。
+
+## 获取帮助
+
+- 获取主页帮助： `help()`
+- 获取函数帮助： `help(str.replace)`
+- 获取模块帮助： `help(re)`
+
+## 模块
+
+模块亦称库，它只是一个简单地以 `.py` 为后缀的文件。
+
+- 列出模块内容：`dir(module1)`
+- 导入模块：`import module `
+- 调用模块中的函数：`module1.func1()`
+
+**注：`import` 语句会创建一个新的名字空间，并且在该名字空间内执行 `.py` 文件中的所有语句。如果你想把模块内容导入到当前名字空间，请使用 `from module1 import *` 语句。**
+
+## 数值类类型
+
+查看变量的数据类型：`type(variable)`
+
+### 六种经常使用的数据类型
+
+1. **int/long**：过大的 `int` 类型会被自动转化为 `long` 类型。
+
+2. **float**：64 位，Python 中没有 `double` 类型。
+
+3. **bool**：真或假。
+
+4. **str**：在 Python 2 中默认以 ASCII 编码，而在 Python 3 中默认以 Unicode 编码；
+
+   - 字符串可置于单/双/三引号中；
+   - 字符串是字符的序列，因此可以像处理其他序列一样处理字符串；
+   - 特殊字符可通过 `\` 或者前缀 `r` 实现：
+
+   ```python
+   str1 = r'this\f?ff'
+   ```
+
+   - 字符串可通过多种方式格式化：
+
+   ```python
+   template = '%.2f %s haha $%d';
+   str1 = template % (4.88, 'hola', 2)
+   ```
+
+5. **NoneType(None)**：Python `null` 值（只有 None 对象的一个实例中存在）。
+
+   - `None` 不是一个保留关键字，而是 **NoneType** 的一个唯一实例。
+   - `None` 通常是可选函数参数的默认值：
+
+   ```python
+   def func1(a, b, c = None)
+   ```
+
+   - `None` 的常见用法：
+
+   ```python
+   if variable is None :
+   ```
+
+6. **datatime**：Python 内建的 datetime 模块提供了 `datetime`、`data` 以及 `time` 类型。
+
+   - `datetime` 组合了存储于 `date` 和 `time` 中的信息。
+
+
+```python
+#从字符串中创建 datetime
+dt1 = datetime.strptime('20091031', '%Y%m%d')
+#获取 date 对象
+dt1.date()
+#获取 time 对象
+dt1.time()
+#将 datetime 格式化为字符串
+dt1.strftime('%m/%d/%Y%H:%M')
+#更改字段值
+dt2 = dt1.replace(minute = 0, second = 30)
+#做差, diff 是一个 datetime.timedelta 对象
+diff = dt1 - dt2
+```
+
+**注：Python 中的绝大多数对象都是可变的，只有字符串和元组例外。**
+
+## 数据结构
+
+**注：所有的 non-Get 函数调用，比如下面例子中的 `list1.sort()` 都是原地操作，即不会创建新的对象，除非特别声明。**
+
+### 元组
+
+元组是 Python 中任何类型的对象的一个一维、固定长度、不可变的序列。
+
+```python
+#创建元组
+tup1 = 4, 5, 6 
+# or
+tup1 = (6, 7, 8)
+#创建嵌套元组
+tup1 = (4, 5, 6), (7, 8)
+#将序列或迭代器转化为元组
+tuple([1, 0, 2])
+#连接元组
+tup1 + tup2
+#解包元组
+a, b, c = tup1
+```
+
+元组应用：
+
+```python
+#交换两个变量的值
+a, b = b, a
+```
+
+### 列表
+
+列表是 Python 中任何类型的对象的一个一维、非固定长度、可变（比如内容可以被修改）的序列。
+
+```python
+#创建列表
+list1 = [1, 'a', 3]
+#or
+list1 = list(tup1)
+#连接列表
+list1 + list2 
+#or
+list1.extend(list2)
+#追加到列表的末尾
+list1.append('b')
+#插入指定位置
+list1.insert(PosIndex, 'a')
+#反向插入，即弹出给定位置的值/删除
+ValueAtIdx = list1.pop(PosIndex)
+#移除列表中的第一个值, a 必须是列表中第一个值
+list1.remove('a')
+#检查成员资格
+3 in list1 => True or False
+#对列表进行排序
+list1.sort()
+#按特定方式排序
+list1.sort(key = len) # 按长度排序
+```
+
+- 使用 + 连接列表会有比较大的开支，因为这个过程中会创建一个新的列表，然后复制对象。因此，使用 `extend()` 是更明智的选择；
+- `insert` 和 `append` 相比会有更大的开支（时间/空间）；
+- 在列表中检查是否包含一个值会比在字典和集合中慢很多，因为前者需要进行线性扫描，而后者是基于哈希表的，所以只需要花费常数时间。
+
+#### 内建的 `bisect` 模块
+
+- 对一个排序好的列表进行二分查找或插入；
+- `bisect.bisect`找到元素在列表中的位置，`bisect.insort`将元素插入到相应位置。用法：
+
+```python
+import bisect
+list1 = list(range(10))
+#找到 5 在 list1 中的位置，从 1 开始，因此 position = index + 1
+bisect.bisect(list1, 5)
+#将 3.5 插入 list1 中合适位置
+bisect.insort(list1, 3.5)
+```
+
+**注：`bisect` 模块中的函数并不会去检查列表是否排序好，因为这会花费很多时间。所以，对未排序好的列表使用这些函数也不会报错，但可能会返回不正确的结果。**
+
+### 针对序列类型的切片
+
+序列类型包括 `str`、`array`、`tuple`、`list` 等。
+
+用法：
+
+```python
+list1[start:stop]
+#如果使用 step
+list1(start:stop:step)
+```
+
+**注：切片结果包含 `start` 索引，但不包含 `stop` 索引；`start/stop` 索引可以省略，如果省略，则默认为序列从开始到结束，如 `list1 == list1[:]` 。**
+
+`step` 的应用：
+
+```python
+#取出奇数位置的元素
+list1[::2]
+#反转字符串
+str1[::-1]
+```
+
+### 字典（哈希映射）
+
+```python
+#创建字典
+dict1 = {'key1': 'value1', 2: [3,2]}
+#从序列创建字典
+dict(zip(KeyList, ValueList))
+#获取/设置/插入元素
+dict1['key1']
+dict1['key1'] = 'NewValue'
+#get 提供默认值
+dict1.get('key1', DefaultValue)
+#检查键是否存在
+'key1' in dict1
+#获取键列表
+dict1.keys()
+#获取值列表
+dict1.values()
+#更新值
+dict1.update(dict2)#dict1 的值被 dict2 替换
+```
+
+- 如果键不存在，则会出现 `KeyError Exception` 。
+- 当键不存在时，如果 `get()`不提供默认值则会返回 `None` 。
+- 以相同的顺序返回键列表和值列表，但顺序不是特定的，又称极大可能非排序。
+
+#### 有效字典键类型
+
+- 键必须是不可变的，比如标量类型(`int`、`float`、`string`)或者元组（元组中的所有对象也必须是不可变的）。
+- 这儿涉及的技术术语是 `hashability`。可以用函数 `hash()`来检查一个对象是否是可哈希的，比如 `hash('This is a string')` 会返回一个哈希值，而 `hash([1,2])` 则会报错（不可哈希）。
+
+### 集合
+
+- 一个集合是一些无序且唯一的元素的聚集；
+- 你可以把它看成只有键的字典；
+
+```python
+#创建集合
+set([3, 6, 3])
+#or
+{3, 6, 3}
+#子集测试
+set1.issubset(set2)
+#超集测试
+set1.issuperset(set2)
+#测试两个集合中的元素是否完全相同
+set1 == set2
+```
+
+#### 集合操作
+
+- 并（又称或）：`set1 | set2`
+- 交（又称与）：`set1 & set2`
+- 差：`set1 - set2`
+- 对称差（又称异或）：`set1 ^ set2`
+
+## 函数
+
+Python 的函数参数传递是通过**引用传递**。
+
+- 基本形式
+
+```python
+def func1(posArg1, keywordArg1 = 1, ..)
+```
+
+**注**
+
+- 关键字参数必须跟在位置参数的后面；
+- 默认情况下，Python 不会“延迟求值”，表达式的值会立刻求出来。
+
+### 函数调用机制
+
+- 所有函数均位于模块内部作用域。见“模块”部分。
+- 在调用函数时，参数被打包成一个元组和一个字典，函数接收一个元组 `args` 和一个字典 `kwargs`，然后在函数内部解包。
+
+
+“函数是对象”的常见用法：
+
+```python
+def func1(ops = [str.strip, user_define_func, ..], ..):
+  for function in ops:
+    value = function(value)
+```
+
+### 返回值
+
+- 如果函数末尾没有 `return` 语句，则不会返回任何东西。
+- 如果有多个返回值则通过一个元组来实现。
+
+```python
+return (value1, value2)
+value1, value2 = func1(..)
+```
+
+### 匿名函数（又称 LAMBDA 函数）
+
+- 什么是匿名函数？
+
+匿名函数是一个只包含一条语句的简单函数。
+
+```python
+lambda x : x * 2
+#def func1(x) : return x * 2
+```
+
+- 匿名函数的应用：'curring'，又称利用已存在函数的部分参数来派生新的函数。
+
+```python
+ma60 = lambda x : pd.rolling_mean(x, 60)
+```
+
+### 一些有用的函数（针对数据结构）
+
+- `enumerate()` 返回一个序列`(i, value)`元组，`i` 是当前 `item` 的索引。
+
+```python
+for i, value in enumerate(collection):
+```
+
+应用：创建一个序列中值与其在序列中的位置的字典映射（假设每一个值都是唯一的）。
+
+- `sort()`可以从任意序列中返回一个排序好的序列。
+
+```python
+sorted([2, 1, 3]) => [1, 2, 3]
+```
+
+应用：
+
+```python
+sorted(set('abc bcd')) => [' ',
+'a', 'b', 'c', 'd']
+# 返回一个字符串排序后无重复的字母序列
+```
+
+- `zip()`函数可以把许多列表、元组或其他序列的元素配对起来创建一系列的元组。
+
+```python
+zip(seq1, seq2) => [('seq1_1', 'seq2_1'), (..), ..]
+```
+
+1. `zip()`可以接收任意数量的序列作为参数，但是产生的元素的数目取决于最短的序列。
+
+应用：多个序列同时迭代：
+
+```python 
+for i, (a, b) in enumerate(zip(seq1, seq2)):
+```
+
+2. `unzip`：另一种思考方式是把一些行转化为一些列：
+
+```python
+seq1, seq2 = zip(zipOutput)
+```
+
+- `reversed()` 将一个序列的元素以逆序迭代。
+
+```python 
+list(reversed(range(10))) 
+```
+
+**`reversed()` 会返回一个迭代器，`list()` 使之成为一个列表。**
+
+## 控制流
+
+- 用于 `if-else` 条件中的操作符：
+
+```python
+#检查两个变量是否是相同的对象
+var1 is var2
+#检查两个变量是否是不同的对象
+var1 is not var2
+#检查两个变量的值是否相等
+var1 == var2
+```
+
+**注：Python 中使用 `and`、`or`、`not` 来组合条件，而不是使用 `&&`、`||`、`!` 。**
+
+- `for`循环的常见用法：
+
+```python 
+#可迭代对象（list、tuple）或迭代器
+for element in iterator:
+#如果元素是可以解包的序列
+for a, b, c in iterator:
+```
+
+- `pass`：无操作语句，在不需要进行任何操作的块中使用。
+- 三元表达式，又称简洁的 `if-else`，基本形式：
+
+```python
+value = true-expr if condition else false-expr
+```
+
+- Python 中没有 `switch/case` 语句，请使用 `if/elif`。
+
+## 面向对象编程
+
+- **对象**是 Python 中所有类型的根。
+- 万物（数字、字符串、函数、类、模块等）皆为对象，每个对象均有一个类型（type）。对象变量是一个指向变量在内存中位置的指针。
+- 所有对象均为**引用计数**。
+
+```python
+sys.getrefcount(5) => x
+a = 5, b = a
+#上式会在等号的右边创建一个对象的引用，因此 a 和 b 均指向 5
+sys.getrefcount(5)
+=> x + 2
+del(a); sys.getrefcount(5) => x + 1
+```
+
+- 类的基本形式：
+
+```python 
+class MyObject(object):
+  # 'self' 等价于 Java/C++ 中的 'this'
+  def __init__(self, name):
+    self.name = name
+  def memberFunc1(self, arg1):
+      ..
+  @staticmethod
+  def classFunc2(arg1):
+    ..
+obj1 = MyObject('name1')
+obj1.memberFunc1('a')
+MyObject.classFunc2('b')
+```
+
+- 有用的交互式工具：
+
+```python
+dir(variable1) #列出对象的所有可用方法
+```
+
+## 常见字符串操作
+
+```python
+#通过分隔符连接列表/元组
+', '.join([ 'v1', 'v2', 'v3']) => 'v1, v2, v3'
+
+#格式化字符串
+string1 = 'My name is {0}　{name}'
+newString1 = string1.format('Sean', name =　'Chen')
+
+#分裂字符串
+sep = '-';
+stringList1 =　string1.split(sep)
+
+#获取子串
+start = 1;
+string1[start:8]
+
+#补 '0' 向右对齐字符串
+month = '5';
+month.zfill(2) => '05'
+month = '12';
+month.zfill(2) => '12'
+month.zfill(3) => '012'
+```
+对列表和字典以及元组的深入理解
+## 异常处理
+
+- 基本形式：
+
+```python
+try:
+  ..
+except ValueError as e:
+  print e
+except (TypeError, AnotherError):
+  ..
+except:
+  ..
+finally:
+  .. # 清理，比如 close db;
+```
+
+- 手动引发异常：
+
+```python
+raise AssertionError # 断言失败
+raise SystemExit
+# 请求程序退出
+raise RuntimeError('错误信息 :..')
+```
+
+## 对列表和字典以及元组的深入理解
+
+语法糖（syntactic sugar）会使代码变得更加易读易写。
+
+### 对列表的理解
+
+将一些元素通过一个简短的语句传入一个过滤器进行过滤和转化，然后可以组成一个新的列表。
+
+```python
+#基本形式
+[expr for val in collection if condition]
+#ShortCut
+result = []
+for val in collection:
+  if condition:
+    result.append(expr)
+```
+
+可以省略过滤条件，只留下表达式。
+
+### 对字典的理解
+
+基本形式：
+
+```python
+{key-expr : value-expr for value in collection if condition}
+```
+
+### 对集合的理解
+
+基本形式：和列表一样，只是应该使用 `()` 而不是 `[]` 。
+
+### 嵌套列表
+
+基本形式：
+
+```python
+[expr for val in collection for innerVal in val if condition]
+```
+

languages/python.tex

@@ -0,0 +1,878 @@
+\documentclass[]{article}
+\usepackage{lmodern}
+\usepackage{amssymb,amsmath}
+\usepackage{ifxetex,ifluatex}
+\usepackage{xeCJK}
+\usepackage{fixltx2e} % provides \textsubscript
+\ifnum 0\ifxetex 1\fi\ifluatex 1\fi=0 % if pdftex
+  \usepackage[T1]{fontenc}
+  \usepackage[utf8]{inputenc}
+\else % if luatex or xelatex
+  \ifxetex
+    \usepackage{mathspec}
+  \else
+    \usepackage{fontspec}
+  \fi
+  \defaultfontfeatures{Ligatures=TeX,Scale=MatchLowercase}
+\fi
+% use upquote if available, for straight quotes in verbatim environments
+\IfFileExists{upquote.sty}{\usepackage{upquote}}{}
+% use microtype if available
+\IfFileExists{microtype.sty}{%
+\usepackage[]{microtype}
+\UseMicrotypeSet[protrusion]{basicmath} % disable protrusion for tt fonts
+}{}
+\PassOptionsToPackage{hyphens}{url} % url is loaded by hyperref
+\usepackage[unicode=true]{hyperref}
+\hypersetup{
+            pdfborder={0 0 0},
+            breaklinks=true}
+\urlstyle{same}  % don't use monospace font for urls
+\usepackage{color}
+\usepackage{fancyvrb}
+\newcommand{\VerbBar}{|}
+\newcommand{\VERB}{\Verb[commandchars=\\\{\}]}
+\DefineVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\{\}}
+% Add ',fontsize=\small' for more characters per line
+\newenvironment{Shaded}{}{}
+\newcommand{\KeywordTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{\textbf{#1}}}
+\newcommand{\DataTypeTok}[1]{\textcolor[rgb]{0.56,0.13,0.00}{#1}}
+\newcommand{\DecValTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{#1}}
+\newcommand{\BaseNTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{#1}}
+\newcommand{\FloatTok}[1]{\textcolor[rgb]{0.25,0.63,0.44}{#1}}
+\newcommand{\ConstantTok}[1]{\textcolor[rgb]{0.53,0.00,0.00}{#1}}
+\newcommand{\CharTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{#1}}
+\newcommand{\SpecialCharTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{#1}}
+\newcommand{\StringTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{#1}}
+\newcommand{\VerbatimStringTok}[1]{\textcolor[rgb]{0.25,0.44,0.63}{#1}}
+\newcommand{\SpecialStringTok}[1]{\textcolor[rgb]{0.73,0.40,0.53}{#1}}
+\newcommand{\ImportTok}[1]{#1}
+\newcommand{\CommentTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textit{#1}}}
+\newcommand{\DocumentationTok}[1]{\textcolor[rgb]{0.73,0.13,0.13}{\textit{#1}}}
+\newcommand{\AnnotationTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{#1}}}}
+\newcommand{\CommentVarTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{#1}}}}
+\newcommand{\OtherTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{#1}}
+\newcommand{\FunctionTok}[1]{\textcolor[rgb]{0.02,0.16,0.49}{#1}}
+\newcommand{\VariableTok}[1]{\textcolor[rgb]{0.10,0.09,0.49}{#1}}
+\newcommand{\ControlFlowTok}[1]{\textcolor[rgb]{0.00,0.44,0.13}{\textbf{#1}}}
+\newcommand{\OperatorTok}[1]{\textcolor[rgb]{0.40,0.40,0.40}{#1}}
+\newcommand{\BuiltInTok}[1]{#1}
+\newcommand{\ExtensionTok}[1]{#1}
+\newcommand{\PreprocessorTok}[1]{\textcolor[rgb]{0.74,0.48,0.00}{#1}}
+\newcommand{\AttributeTok}[1]{\textcolor[rgb]{0.49,0.56,0.16}{#1}}
+\newcommand{\RegionMarkerTok}[1]{#1}
+\newcommand{\InformationTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{#1}}}}
+\newcommand{\WarningTok}[1]{\textcolor[rgb]{0.38,0.63,0.69}{\textbf{\textit{#1}}}}
+\newcommand{\AlertTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{#1}}}
+\newcommand{\ErrorTok}[1]{\textcolor[rgb]{1.00,0.00,0.00}{\textbf{#1}}}
+\newcommand{\NormalTok}[1]{#1}
+\IfFileExists{parskip.sty}{%
+\usepackage{parskip}
+}{% else
+\setlength{\parindent}{0pt}
+\setlength{\parskip}{6pt plus 2pt minus 1pt}
+}
+\setlength{\emergencystretch}{3em}  % prevent overfull lines
+\providecommand{\tightlist}{%
+  \setlength{\itemsep}{0pt}\setlength{\parskip}{0pt}}
+\setcounter{secnumdepth}{0}
+% Redefines (sub)paragraphs to behave more like sections
+\ifx\paragraph\undefined\else
+\let\oldparagraph\paragraph
+\renewcommand{\paragraph}[1]{\oldparagraph{#1}\mbox{}}
+\fi
+\ifx\subparagraph\undefined\else
+\let\oldsubparagraph\subparagraph
+\renewcommand{\subparagraph}[1]{\oldsubparagraph{#1}\mbox{}}
+\fi
+
+% set default figure placement to htbp
+\makeatletter
+\def\fps@figure{htbp}
+\makeatother
+
+
+\date{}
+
+\begin{document}
+
+\section{Python 速查表中文版}\label{header-n0}
+
+\begin{itemize}
+\item
+  本手册是 \href{http://datasciencefree.com/python.pdf}{Python cheat
+  sheet} 的中文翻译版。原作者：Arianne Colton and Sean
+  Chen(\href{mailto:data.scientist.info@gmail.com}{\nolinkurl{data.scientist.info@gmail.com}})
+\item
+  编译：\href{https://github.com/ucasFL}{ucasFL}
+\end{itemize}
+
+\protect\hyperlink{header-n32}{惯例}
+
+\protect\hyperlink{header-n43}{获取帮助}
+
+\protect\hyperlink{header-n54}{模块}
+
+\protect\hyperlink{header-n69}{数值类类型}
+
+\protect\hyperlink{header-n128}{数据结构}
+
+\protect\hyperlink{header-n217}{函数}
+
+\protect\hyperlink{header-n307}{控制流}
+
+\protect\hyperlink{header-n332}{面向对象编程}
+
+\protect\hyperlink{header-n354}{常见字符串操作}
+
+\protect\hyperlink{header-n357}{异常处理}
+
+\protect\hyperlink{header-n369}{对列表、字典和元组的深入理解}
+
+\hypertarget{header-n32}{\subsection{惯例}\label{header-n32}}
+
+\begin{itemize}
+\item
+  Python 对大小写敏感；
+\item
+  Python 的索引从 0 开始（所有编程语言均如此）；
+\item
+  Python 使用空白符（制表符或空格）来缩进代码，而不是使用花括号。
+\end{itemize}
+
+\hypertarget{header-n43}{\subsection{获取帮助}\label{header-n43}}
+
+\begin{itemize}
+\item
+  获取主页帮助： \texttt{help()}
+\item
+  获取函数帮助： \texttt{help(str.replace)}
+\item
+  获取模块帮助： \texttt{help(re)}
+\end{itemize}
+
+\hypertarget{header-n54}{\subsection{模块}\label{header-n54}}
+
+模块亦称库，它只是一个简单地以 \texttt{.py} 为后缀的文件。
+
+\begin{itemize}
+\item
+  列出模块内容：\texttt{dir(module1)}
+\item
+  导入模块：\texttt{import\ module}
+\item
+  调用模块中的函数：\texttt{module1.func1()}
+\end{itemize}
+
+\textbf{注：\texttt{import}
+语句会创建一个新的名字空间，并且在该名字空间内执行 \texttt{.py}
+文件中的所有语句。如果你想把模块内容导入到当前名字空间，请使用
+\texttt{from\ module1\ import\ *} 语句。}
+
+\hypertarget{header-n69}{\subsection{数值类类型}\label{header-n69}}
+
+查看变量的数据类型：\texttt{type(variable)}
+
+\subsubsection{六种经常使用的数据类型}\label{header-n72}
+
+\begin{enumerate}
+\def\labelenumi{\arabic{enumi}.}
+\item
+  \textbf{int/long}：过大的 \texttt{int} 类型会被自动转化为
+  \texttt{long} 类型。
+\item
+  \textbf{float}：64 位，Python 中没有 \texttt{double} 类型。
+\item
+  \textbf{bool}：真或假。
+\item
+  \textbf{str}：在 Python 2 中默认以 ASCII 编码，而在 Python 3 中默认以
+  Unicode 编码；
+
+  \begin{itemize}
+  \item
+    字符串可置于单/双/三引号中；
+  \item
+    字符串是字符的序列，因此可以像处理其他序列一样处理字符串；
+  \item
+    特殊字符可通过 \texttt{\textbackslash{}} 或者前缀 \texttt{r} 实现：
+  \end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{str1 }\OperatorTok{=} \VerbatimStringTok{r'this\textbackslash{}f?ff'}
+\end{Highlighting}
+\end{Shaded}
+
+  \begin{itemize}
+  \item
+    字符串可通过多种方式格式化：
+  \end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{template }\OperatorTok{=} \StringTok{'}\SpecialCharTok{%.2f}\StringTok{ }\SpecialCharTok{%s}\StringTok{ haha $}\SpecialCharTok{%d}\StringTok{'}\OperatorTok{;}
+\NormalTok{str1 }\OperatorTok{=}\NormalTok{ template }\OperatorTok{%}\NormalTok{ (}\FloatTok{4.88}\NormalTok{, }\StringTok{'hola'}\NormalTok{, }\DecValTok{2}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+\item
+  \textbf{NoneType(None)}：Python \texttt{null} 值（只有 None
+  对象的一个实例中存在）。
+
+  \begin{itemize}
+  \item
+    \texttt{None} 不是一个保留关键字，而是 \textbf{NoneType}
+    的一个唯一实例。
+  \item
+    \texttt{None} 通常是可选函数参数的默认值：
+  \end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ func1(a, b, c }\OperatorTok{=} \VariableTok{None}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+  \begin{itemize}
+  \item
+    \texttt{None} 的常见用法：
+  \end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{if}\NormalTok{ variable }\KeywordTok{is} \VariableTok{None}\NormalTok{ :}
+\end{Highlighting}
+\end{Shaded}
+\item
+  \textbf{datatime}：Python 内建的 datetime 模块提供了
+  \texttt{datetime}、\texttt{data} 以及 \texttt{time} 类型。
+
+  \begin{itemize}
+  \item
+    \texttt{datetime} 组合了存储于 \texttt{date} 和 \texttt{time}
+    中的信息。
+  \end{itemize}
+\end{enumerate}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{#从字符串中创建 datetime}
+\NormalTok{dt1 }\OperatorTok{=}\NormalTok{ datetime.strptime(}\StringTok{'20091031'}\NormalTok{, }\StringTok{'%Y%m}\SpecialCharTok{%d}\StringTok{'}\NormalTok{)}
+\CommentTok{#获取 date 对象}
+\NormalTok{dt1.date()}
+\CommentTok{#获取 time 对象}
+\NormalTok{dt1.time()}
+\CommentTok{#将 datetime 格式化为字符串}
+\NormalTok{dt1.strftime(}\StringTok{'%m/}\SpecialCharTok{%d}\StringTok{/%Y%H:%M'}\NormalTok{)}
+\CommentTok{#更改字段值}
+\NormalTok{dt2 }\OperatorTok{=}\NormalTok{ dt1.replace(minute }\OperatorTok{=} \DecValTok{0}\NormalTok{, second }\OperatorTok{=} \DecValTok{30}\NormalTok{)}
+\CommentTok{#做差, diff 是一个 datetime.timedelta 对象}
+\NormalTok{diff }\OperatorTok{=}\NormalTok{ dt1 }\OperatorTok{-}\NormalTok{ dt2}
+\end{Highlighting}
+\end{Shaded}
+
+\textbf{注：Python 中的绝大多数对象都是可变的，只有字符串和元组例外。}
+
+\hypertarget{header-n128}{\subsection{数据结构}\label{header-n128}}
+
+\textbf{注：所有的 non-Get 函数调用，比如下面例子中的
+\texttt{list1.sort()} 都是原地操作，即不会创建新的对象，除非特别声明。}
+
+\subsubsection{元组}\label{header-n131}
+
+元组是 Python 中任何类型的对象的一个一维、固定长度、不可变的序列。
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{#创建元组}
+\NormalTok{tup1 }\OperatorTok{=} \DecValTok{4}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{6} 
+\CommentTok{# or}
+\NormalTok{tup1 }\OperatorTok{=}\NormalTok{ (}\DecValTok{6}\NormalTok{, }\DecValTok{7}\NormalTok{, }\DecValTok{8}\NormalTok{)}
+\CommentTok{#创建嵌套元组}
+\NormalTok{tup1 }\OperatorTok{=}\NormalTok{ (}\DecValTok{4}\NormalTok{, }\DecValTok{5}\NormalTok{, }\DecValTok{6}\NormalTok{), (}\DecValTok{7}\NormalTok{, }\DecValTok{8}\NormalTok{)}
+\CommentTok{#将序列或迭代器转化为元组}
+\BuiltInTok{tuple}\NormalTok{([}\DecValTok{1}\NormalTok{, }\DecValTok{0}\NormalTok{, }\DecValTok{2}\NormalTok{])}
+\CommentTok{#连接元组}
+\NormalTok{tup1 }\OperatorTok{+}\NormalTok{ tup2}
+\CommentTok{#解包元组}
+\NormalTok{a, b, c }\OperatorTok{=}\NormalTok{ tup1}
+\end{Highlighting}
+\end{Shaded}
+
+元组应用：
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{#交换两个变量的值}
+\NormalTok{a, b }\OperatorTok{=}\NormalTok{ b, a}
+\end{Highlighting}
+\end{Shaded}
+
+\subsubsection{列表}\label{header-n138}
+
+列表是 Python
+中任何类型的对象的一个一维、非固定长度、可变（比如内容可以被修改）的序列。
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{#创建列表}
+\NormalTok{list1 }\OperatorTok{=}\NormalTok{ [}\DecValTok{1}\NormalTok{, }\StringTok{'a'}\NormalTok{, }\DecValTok{3}\NormalTok{]}
+\CommentTok{#or}
+\NormalTok{list1 }\OperatorTok{=} \BuiltInTok{list}\NormalTok{(tup1)}
+\CommentTok{#连接列表}
+\NormalTok{list1 }\OperatorTok{+}\NormalTok{ list2 }
+\CommentTok{#or}
+\NormalTok{list1.extend(list2)}
+\CommentTok{#追加到列表的末尾}
+\NormalTok{list1.append(}\StringTok{'b'}\NormalTok{)}
+\CommentTok{#插入指定位置}
+\NormalTok{list1.insert(PosIndex, }\StringTok{'a'}\NormalTok{)}
+\CommentTok{#反向插入，即弹出给定位置的值/删除}
+\NormalTok{ValueAtIdx }\OperatorTok{=}\NormalTok{ list1.pop(PosIndex)}
+\CommentTok{#移除列表中的第一个值, a 必须是列表中第一个值}
+\NormalTok{list1.remove(}\StringTok{'a'}\NormalTok{)}
+\CommentTok{#检查成员资格}
+\DecValTok{3} \KeywordTok{in}\NormalTok{ list1 }\OperatorTok{=>} \VariableTok{True} \KeywordTok{or} \VariableTok{False}
+\CommentTok{#对列表进行排序}
+\NormalTok{list1.sort()}
+\CommentTok{#按特定方式排序}
+\NormalTok{list1.sort(key }\OperatorTok{=} \BuiltInTok{len}\NormalTok{) }\CommentTok{# 按长度排序}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{itemize}
+\item
+  使用 +
+  连接列表会有比较大的开支，因为这个过程中会创建一个新的列表，然后复制对象。因此，使用
+  \texttt{extend()} 是更明智的选择；
+\item
+  \texttt{insert} 和 \texttt{append} 相比会有更大的开支（时间/空间）；
+\item
+  在列表中检查是否包含一个值会比在字典和集合中慢很多，因为前者需要进行线性扫描，而后者是基于哈希表的，所以只需要花费常数时间。
+\end{itemize}
+
+\paragraph{\texorpdfstring{内建的 \texttt{bisect}
+模块}{内建的 bisect 模块}}\label{header-n152}
+
+\begin{itemize}
+\item
+  对一个排序好的列表进行二分查找或插入；
+\item
+  \texttt{bisect.bisect}找到元素在列表中的位置，\texttt{bisect.insort}将元素插入到相应位置。用法：
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ImportTok{import}\NormalTok{ bisect}
+\NormalTok{list1 }\OperatorTok{=} \BuiltInTok{list}\NormalTok{(}\BuiltInTok{range}\NormalTok{(}\DecValTok{10}\NormalTok{))}
+\CommentTok{#找到 5 在 list1 中的位置，从 1 开始，因此 position = index + 1}
+\NormalTok{bisect.bisect(list1, }\DecValTok{5}\NormalTok{)}
+\CommentTok{#将 3.5 插入 list1 中合适位置}
+\NormalTok{bisect.insort(list1, }\FloatTok{3.5}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\textbf{注：\texttt{bisect}
+模块中的函数并不会去检查列表是否排序好，因为这会花费很多时间。所以，对未排序好的列表使用这些函数也不会报错，但可能会返回不正确的结果。}
+
+\subsubsection{针对序列类型的切片}\label{header-n163}
+
+序列类型包括 \texttt{str}、\texttt{array}、\texttt{tuple}、\texttt{list}
+等。
+
+用法：
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{list1[start:stop]}
+\CommentTok{#如果使用 step}
+\NormalTok{list1(start:stop:step)}
+\end{Highlighting}
+\end{Shaded}
+
+\textbf{注：切片结果包含 \texttt{start} 索引，但不包含 \texttt{stop}
+索引；\texttt{start/stop}
+索引可以省略，如果省略，则默认为序列从开始到结束，如
+\texttt{list1\ ==\ list1{[}:{]}} 。}
+
+\texttt{step} 的应用：
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{#取出奇数位置的元素}
+\NormalTok{list1[::}\DecValTok{2}\NormalTok{]}
+\CommentTok{#反转字符串}
+\NormalTok{str1[::}\OperatorTok{-}\DecValTok{1}\NormalTok{]}
+\end{Highlighting}
+\end{Shaded}
+
+\subsubsection{字典（哈希映射）}\label{header-n174}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{#创建字典}
+\NormalTok{dict1 }\OperatorTok{=}\NormalTok{ \{}\StringTok{'key1'}\NormalTok{: }\StringTok{'value1'}\NormalTok{, }\DecValTok{2}\NormalTok{: [}\DecValTok{3}\NormalTok{,}\DecValTok{2}\NormalTok{]\}}
+\CommentTok{#从序列创建字典}
+\BuiltInTok{dict}\NormalTok{(}\BuiltInTok{zip}\NormalTok{(KeyList, ValueList))}
+\CommentTok{#获取/设置/插入元素}
+\NormalTok{dict1[}\StringTok{'key1'}\NormalTok{]}
+\NormalTok{dict1[}\StringTok{'key1'}\NormalTok{] }\OperatorTok{=} \StringTok{'NewValue'}
+\CommentTok{#get 提供默认值}
+\NormalTok{dict1.get(}\StringTok{'key1'}\NormalTok{, DefaultValue)}
+\CommentTok{#检查键是否存在}
+\CommentTok{'key1'} \KeywordTok{in}\NormalTok{ dict1}
+\CommentTok{#获取键列表}
+\NormalTok{dict1.keys()}
+\CommentTok{#获取值列表}
+\NormalTok{dict1.values()}
+\CommentTok{#更新值}
+\NormalTok{dict1.update(dict2)}\CommentTok{#dict1 的值被 dict2 替换}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{itemize}
+\item
+  如果键不存在，则会出现 \texttt{KeyError\ Exception} 。
+\item
+  当键不存在时，如果 \texttt{get()}不提供默认值则会返回 \texttt{None} 。
+\item
+  以相同的顺序返回键列表和值列表，但顺序不是特定的，又称极大可能非排序。
+\end{itemize}
+
+\paragraph{有效字典键类型}\label{header-n186}
+
+\begin{itemize}
+\item
+  键必须是不可变的，比如标量类型(\texttt{int}、\texttt{float}、\texttt{string})或者元组（元组中的所有对象也必须是不可变的）。
+\item
+  这儿涉及的技术术语是 \texttt{hashability}。可以用函数
+  \texttt{hash()}来检查一个对象是否是可哈希的，比如
+  \texttt{hash(\textquotesingle{}This\ is\ a\ string\textquotesingle{})}
+  会返回一个哈希值，而 \texttt{hash({[}1,2{]})} 则会报错（不可哈希）。
+\end{itemize}
+
+\subsubsection{集合}\label{header-n194}
+
+\begin{itemize}
+\item
+  一个集合是一些无序且唯一的元素的聚集；
+\item
+  你可以把它看成只有键的字典；
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{#创建集合}
+\BuiltInTok{set}\NormalTok{([}\DecValTok{3}\NormalTok{, }\DecValTok{6}\NormalTok{, }\DecValTok{3}\NormalTok{])}
+\CommentTok{#or}
+\NormalTok{\{}\DecValTok{3}\NormalTok{, }\DecValTok{6}\NormalTok{, }\DecValTok{3}\NormalTok{\}}
+\CommentTok{#子集测试}
+\NormalTok{set1.issubset(set2)}
+\CommentTok{#超集测试}
+\NormalTok{set1.issuperset(set2)}
+\CommentTok{#测试两个集合中的元素是否完全相同}
+\NormalTok{set1 }\OperatorTok{==}\NormalTok{ set2}
+\end{Highlighting}
+\end{Shaded}
+
+\paragraph{集合操作}\label{header-n203}
+
+\begin{itemize}
+\item
+  并（又称或）：\texttt{set1\ \textbar{}\ set2}
+\item
+  交（又称与）：\texttt{set1\ \&\ set2}
+\item
+  差：\texttt{set1\ -\ set2}
+\item
+  对称差（又称异或）：\texttt{set1\ \^{}\ set2}
+\end{itemize}
+
+\hypertarget{header-n217}{\subsection{函数}\label{header-n217}}
+
+Python 的函数参数传递是通过\textbf{引用传递}。
+
+\begin{itemize}
+\item
+  基本形式
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ func1(posArg1, keywordArg1 }\OperatorTok{=} \DecValTok{1}\NormalTok{, ..)}
+\end{Highlighting}
+\end{Shaded}
+
+\textbf{注}
+
+\begin{itemize}
+\item
+  关键字参数必须跟在位置参数的后面；
+\item
+  默认情况下，Python 不会``延迟求值''，表达式的值会立刻求出来。
+\end{itemize}
+
+\subsubsection{函数调用机制}\label{header-n234}
+
+\begin{itemize}
+\item
+  所有函数均位于模块内部作用域。见``模块''部分。
+\item
+  在调用函数时，参数被打包成一个元组和一个字典，函数接收一个元组
+  \texttt{args} 和一个字典 \texttt{kwargs}，然后在函数内部解包。
+\end{itemize}
+
+``函数是对象''的常见用法：
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{def}\NormalTok{ func1(ops }\OperatorTok{=}\NormalTok{ [}\BuiltInTok{str}\NormalTok{.strip, user_define_func, ..], ..):}
+  \ControlFlowTok{for}\NormalTok{ function }\KeywordTok{in}\NormalTok{ ops:}
+\NormalTok{    value }\OperatorTok{=}\NormalTok{ function(value)}
+\end{Highlighting}
+\end{Shaded}
+
+\subsubsection{返回值}\label{header-n245}
+
+\begin{itemize}
+\item
+  如果函数末尾没有 \texttt{return} 语句，则不会返回任何东西。
+\item
+  如果有多个返回值则通过一个元组来实现。
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{return}\NormalTok{ (value1, value2)}
+\NormalTok{value1, value2 }\OperatorTok{=}\NormalTok{ func1(..)}
+\end{Highlighting}
+\end{Shaded}
+
+\subsubsection{匿名函数（又称 LAMBDA 函数）}\label{header-n254}
+
+\begin{itemize}
+\item
+  什么是匿名函数？
+\end{itemize}
+
+匿名函数是一个只包含一条语句的简单函数。
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{lambda}\NormalTok{ x : x }\OperatorTok{*} \DecValTok{2}
+\CommentTok{#def func1(x) : return x * 2}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{itemize}
+\item
+  匿名函数的应用：'curring'，又称利用已存在函数的部分参数来派生新的函数。
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{ma60 }\OperatorTok{=} \KeywordTok{lambda}\NormalTok{ x : pd.rolling_mean(x, }\DecValTok{60}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\subsubsection{一些有用的函数（针对数据结构）}\label{header-n267}
+
+\begin{itemize}
+\item
+  \texttt{enumerate()} 返回一个序列\texttt{(i,\ value)}元组，\texttt{i}
+  是当前 \texttt{item} 的索引。
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{for}\NormalTok{ i, value }\KeywordTok{in} \BuiltInTok{enumerate}\NormalTok{(collection):}
+\end{Highlighting}
+\end{Shaded}
+
+应用：创建一个序列中值与其在序列中的位置的字典映射（假设每一个值都是唯一的）。
+
+\begin{itemize}
+\item
+  \texttt{sort()}可以从任意序列中返回一个排序好的序列。
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\BuiltInTok{sorted}\NormalTok{([}\DecValTok{2}\NormalTok{, }\DecValTok{1}\NormalTok{, }\DecValTok{3}\NormalTok{]) }\OperatorTok{=>}\NormalTok{ [}\DecValTok{1}\NormalTok{, }\DecValTok{2}\NormalTok{, }\DecValTok{3}\NormalTok{]}
+\end{Highlighting}
+\end{Shaded}
+
+应用：
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\BuiltInTok{sorted}\NormalTok{(}\BuiltInTok{set}\NormalTok{(}\StringTok{'abc bcd'}\NormalTok{)) }\OperatorTok{=>}\NormalTok{ [}\StringTok{' '}\NormalTok{,}
+\StringTok{'a'}\NormalTok{, }\StringTok{'b'}\NormalTok{, }\StringTok{'c'}\NormalTok{, }\StringTok{'d'}\NormalTok{]}
+\CommentTok{# 返回一个字符串排序后无重复的字母序列}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{itemize}
+\item
+  \texttt{zip()}函数可以把许多列表、元组或其他序列的元素配对起来创建一系列的元组。
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\BuiltInTok{zip}\NormalTok{(seq1, seq2) }\OperatorTok{=>}\NormalTok{ [(}\StringTok{'seq1_1'}\NormalTok{, }\StringTok{'seq2_1'}\NormalTok{), (..), ..]}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{enumerate}
+\def\labelenumi{\arabic{enumi}.}
+\item
+  \texttt{zip()}可以接收任意数量的序列作为参数，但是产生的元素的数目取决于最短的序列。
+\end{enumerate}
+
+应用：多个序列同时迭代：
+
+\begin{verbatim}
+for i, (a, b) in enumerate(zip(seq1, seq2)):
+\end{verbatim}
+
+\begin{enumerate}
+\def\labelenumi{\arabic{enumi}.}
+\item
+  \texttt{unzip}：另一种思考方式是把一些行转化为一些列：
+\end{enumerate}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{seq1, seq2 }\OperatorTok{=} \BuiltInTok{zip}\NormalTok{(zipOutput)}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{itemize}
+\item
+  \texttt{reversed()} 将一个序列的元素以逆序迭代。
+\end{itemize}
+
+\begin{verbatim}
+list(reversed(range(10))) 
+\end{verbatim}
+
+\textbf{\texttt{reversed()} 会返回一个迭代器，\texttt{list()}
+使之成为一个列表。}
+
+\hypertarget{header-n307}{\subsection{控制流}\label{header-n307}}
+
+\begin{itemize}
+\item
+  用于 \texttt{if-else} 条件中的操作符：
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{#检查两个变量是否是相同的对象}
+\NormalTok{var1 }\KeywordTok{is}\NormalTok{ var2}
+\CommentTok{#检查两个变量是否是不同的对象}
+\NormalTok{var1 }\KeywordTok{is} \KeywordTok{not}\NormalTok{ var2}
+\CommentTok{#检查两个变量的值是否相等}
+\NormalTok{var1 }\OperatorTok{==}\NormalTok{ var2}
+\end{Highlighting}
+\end{Shaded}
+
+\textbf{注：Python 中使用 \texttt{and}、\texttt{or}、\texttt{not}
+来组合条件，而不是使用
+\texttt{\&\&}、\texttt{\textbar{}\textbar{}}、\texttt{!} 。}
+
+\begin{itemize}
+\item
+  \texttt{for}循环的常见用法：
+\end{itemize}
+
+\begin{verbatim}
+#可迭代对象（list、tuple）或迭代器
+for element in iterator:
+#如果元素是可以解包的序列
+for a, b, c in iterator:
+\end{verbatim}
+
+\begin{itemize}
+\item
+  \texttt{pass}：无操作语句，在不需要进行任何操作的块中使用。
+\item
+  三元表达式，又称简洁的 \texttt{if-else}，基本形式：
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{value }\OperatorTok{=}\NormalTok{ true}\OperatorTok{-}\NormalTok{expr }\ControlFlowTok{if}\NormalTok{ condition }\ControlFlowTok{else}\NormalTok{ false}\OperatorTok{-}\NormalTok{expr}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{itemize}
+\item
+  Python 中没有 \texttt{switch/case} 语句，请使用 \texttt{if/elif}。
+\end{itemize}
+
+\hypertarget{header-n332}{\subsection{面向对象编程}\label{header-n332}}
+
+\begin{itemize}
+\item
+  \textbf{对象}是 Python 中所有类型的根。
+\item
+  万物（数字、字符串、函数、类、模块等）皆为对象，每个对象均有一个类型（type）。对象变量是一个指向变量在内存中位置的指针。
+\item
+  所有对象均为\textbf{引用计数}。
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{sys.getrefcount(}\DecValTok{5}\NormalTok{) }\OperatorTok{=>}\NormalTok{ x}
+\NormalTok{a }\OperatorTok{=} \DecValTok{5}\NormalTok{, b }\OperatorTok{=}\NormalTok{ a}
+\CommentTok{#上式会在等号的右边创建一个对象的引用，因此 a 和 b 均指向 5}
+\NormalTok{sys.getrefcount(}\DecValTok{5}\NormalTok{)}
+\OperatorTok{=>}\NormalTok{ x }\OperatorTok{+} \DecValTok{2}
+\KeywordTok{del}\NormalTok{(a)}\OperatorTok{;}\NormalTok{ sys.getrefcount(}\DecValTok{5}\NormalTok{) }\OperatorTok{=>}\NormalTok{ x }\OperatorTok{+} \DecValTok{1}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{itemize}
+\item
+  类的基本形式：
+\end{itemize}
+
+\begin{verbatim}
+class MyObject(object):
+  # 'self' 等价于 Java/C++ 中的 'this'
+  def __init__(self, name):
+    self.name = name
+  def memberFunc1(self, arg1):
+      ..
+  @staticmethod
+  def classFunc2(arg1):
+    ..
+obj1 = MyObject('name1')
+obj1.memberFunc1('a')
+MyObject.classFunc2('b')
+\end{verbatim}
+
+\begin{itemize}
+\item
+  有用的交互式工具：
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\BuiltInTok{dir}\NormalTok{(variable1) }\CommentTok{#列出对象的所有可用方法}
+\end{Highlighting}
+\end{Shaded}
+
+\hypertarget{header-n354}{\subsection{常见字符串操作}\label{header-n354}}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{#通过分隔符连接列表/元组}
+\CommentTok{', '}\NormalTok{.join([ }\StringTok{'v1'}\NormalTok{, }\StringTok{'v2'}\NormalTok{, }\StringTok{'v3'}\NormalTok{]) }\OperatorTok{=>} \StringTok{'v1, v2, v3'}
+
+\CommentTok{#格式化字符串}
+\NormalTok{string1 }\OperatorTok{=} \StringTok{'My name is }\SpecialCharTok{\{0\}}\StringTok{　}\SpecialCharTok{\{name\}}\StringTok{'}
+\NormalTok{newString1 }\OperatorTok{=}\NormalTok{ string1.}\BuiltInTok{format}\NormalTok{(}\StringTok{'Sean'}\NormalTok{, name }\OperatorTok{=}　\StringTok{'Chen'}\NormalTok{)}
+
+\CommentTok{#分裂字符串}
+\NormalTok{sep }\OperatorTok{=} \StringTok{'-'}\OperatorTok{;}
+\NormalTok{stringList1 }\OperatorTok{=}\NormalTok{　string1.split(sep)}
+
+\CommentTok{#获取子串}
+\NormalTok{start }\OperatorTok{=} \DecValTok{1}\OperatorTok{;}
+\NormalTok{string1[start:}\DecValTok{8}\NormalTok{]}
+
+\CommentTok{#补 '0' 向右对齐字符串}
+\NormalTok{month }\OperatorTok{=} \StringTok{'5'}\OperatorTok{;}
+\NormalTok{month.zfill(}\DecValTok{2}\NormalTok{) }\OperatorTok{=>} \StringTok{'05'}
+\NormalTok{month }\OperatorTok{=} \StringTok{'12'}\OperatorTok{;}
+\NormalTok{month.zfill(}\DecValTok{2}\NormalTok{) }\OperatorTok{=>} \StringTok{'12'}
+\NormalTok{month.zfill(}\DecValTok{3}\NormalTok{) }\OperatorTok{=>} \StringTok{'012'}
+\end{Highlighting}
+\end{Shaded}
+
+对列表和字典以及元组的深入理解
+
+\hypertarget{header-n357}{\subsection{异常处理}\label{header-n357}}
+
+\begin{itemize}
+\item
+  基本形式：
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{try}\NormalTok{:}
+\NormalTok{  ..}
+\ControlFlowTok{except} \PreprocessorTok{ValueError} \ImportTok{as}\NormalTok{ e:}
+  \BuiltInTok{print}\NormalTok{ e}
+\ControlFlowTok{except}\NormalTok{ (}\PreprocessorTok{TypeError}\NormalTok{, AnotherError):}
+\NormalTok{  ..}
+\ControlFlowTok{except}\NormalTok{:}
+\NormalTok{  ..}
+\ControlFlowTok{finally}\NormalTok{:}
+\NormalTok{  .. }\CommentTok{# 清理，比如 close db;}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{itemize}
+\item
+  手动引发异常：
+\end{itemize}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\ControlFlowTok{raise} \PreprocessorTok{AssertionError} \CommentTok{# 断言失败}
+\ControlFlowTok{raise} \PreprocessorTok{SystemExit}
+\CommentTok{# 请求程序退出}
+\ControlFlowTok{raise} \PreprocessorTok{RuntimeError}\NormalTok{(}\StringTok{'错误信息 :..'}\NormalTok{)}
+\end{Highlighting}
+\end{Shaded}
+
+\hypertarget{header-n369}{\subsection{对列表和字典以及元组的深入理解}\label{header-n369}}
+
+语法糖（syntactic sugar）会使代码变得更加易读易写。
+
+\subsubsection{对列表的理解}\label{header-n372}
+
+将一些元素通过一个简短的语句传入一个过滤器进行过滤和转化，然后可以组成一个新的列表。
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{#基本形式}
+\NormalTok{[expr }\ControlFlowTok{for}\NormalTok{ val }\KeywordTok{in}\NormalTok{ collection }\ControlFlowTok{if}\NormalTok{ condition]}
+\CommentTok{#ShortCut}
+\NormalTok{result }\OperatorTok{=}\NormalTok{ []}
+\ControlFlowTok{for}\NormalTok{ val }\KeywordTok{in}\NormalTok{ collection:}
+  \ControlFlowTok{if}\NormalTok{ condition:}
+\NormalTok{    result.append(expr)}
+\end{Highlighting}
+\end{Shaded}
+
+可以省略过滤条件，只留下表达式。
+
+\subsubsection{对字典的理解}\label{header-n378}
+
+基本形式：
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{\{key}\OperatorTok{-}\NormalTok{expr : value}\OperatorTok{-}\NormalTok{expr }\ControlFlowTok{for}\NormalTok{ value }\KeywordTok{in}\NormalTok{ collection }\ControlFlowTok{if}\NormalTok{ condition\}}
+\end{Highlighting}
+\end{Shaded}
+
+\subsubsection{对集合的理解}\label{header-n382}
+
+基本形式：和列表一样，只是应该使用 \texttt{()} 而不是 \texttt{{[}{]}} 。
+
+\subsubsection{嵌套列表}\label{header-n385}
+
+基本形式：
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\NormalTok{[expr }\ControlFlowTok{for}\NormalTok{ val }\KeywordTok{in}\NormalTok{ collection }\ControlFlowTok{for}\NormalTok{ innerVal }\KeywordTok{in}\NormalTok{ val }\ControlFlowTok{if}\NormalTok{ condition]}
+\end{Highlighting}
+\end{Shaded}
+
+\end{document}