Python 3.6
运算符
- + - * / 四则运算 % 求余 **乘方
- // 用于整除
字符串
- 字符串用单引号或双引号括起来。
- 三引号（单引号或双引号均可）表示多行字符串，行末加反斜杠表示换行不算在字符串之内。
- 字符串加上前缀 r 表示原生字符串。
- + 用于连接字符串。
- * 用于重复字符串。
- 相邻的字符串字面量会自动连接。
- 字符串存在片段（slice）语法（使用下标获取子串），但字符串本身不可变。
- 片段语法中下标 0 指向第一个元素，下标 -1 指向最后一个元素。
>>> 'a' * 3
'aaa'
>>> 'b' 'a'
'ba'
>>> 'b' + "a"
'ba'
>>> print(r'C:some
ame')
C:some
ame
>>> print("""
a
b
c
""")
a
b
c
>>> "abcde"[1:]
'bcde'
>>> "abcde"[:4]
'abcd'
>>> "abcde"[:]
'abcde'
>>> "abcde"[-3:]
'cde'
列表（Lists）
- 列表：一种成员的类型相同但个数不限的数据结构。
- 列表采用中括号加逗号的特殊语法。
- + 连接两个列表。
- 列表存在片段（slice）语法（使用下标获取子列表），列表片段可变（可以通过赋值被替换）。
- 片段语法中下标 0 指向第一个元素，下标 -1 指向最后一个元素。
>>> [1,2,3][1:]
[2, 3]
>>> [1,2,3][-2:]
[2, 3]
>>> a = [1,2,3,4]
>>> a[2:] = [4,5,6]
>>> a
[1, 2, 4, 5, 6]
>>> a[2:] = []
>>> a
[1, 2]
- append 方法添加元素。
- extend 方法连接另一个列表。
- insert 方法插入元素。
- remove 方法移除指定元素。
- pop 方法弹出最后面的元素。
- clear 方法清空列表。
- index 方法查找指定元素的下标。
- count 方法返回列表的长度。
- reverse 方法翻转列表。
- copy 方法复制列表。
>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'kiwi', 'orange', 'pear']
- 列表解析（List Comprehensions）
>>> [x**2 for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
元组（Tuples）
- 元组：一种成员数量和次序固定但种类不尽相同的数据结构。
- 元组采用小括号加逗号的特殊语法。（最外层元组的小括号可省略）
- 元组是不可变的。
- 元组存在下标语法。
- 存在没有任何成员的元组 () 以及只有一个成员的元组 a, （元素后跟一个逗号表示元组）
>>> t = 123,"123"
>>> t[0]
123
>>> t[1]
'123'
>>> u = t, 456
>>> u
((123, '123'), 456)
>>> v = 1,
>>> v
(1,)
解构语法
>>> a,b = [1,2]
>>> a,b
(1, 2)
>>> a,b = (1,2)
>>> a,b
(1, 2)
>>> a,b = b,a
>>> a,b
(2, 1)
集合（Sets）
- 集合：一种不存在重复元素的哈希表数据结构。
- 集合采用大括号加逗号的特殊语法。
- 常用操作包括求差集，并集，交集，对称差集。
- 存在集合的解析表达式。（set comprehensions）
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> basket
{'pear', 'orange', 'banana', 'apple'}
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'c', 'a', 'r', 'd', 'b'}
>>> b
{'l', 'c', 'a', 'm', 'z'}
>>> a - b # 差集
{'b', 'd', 'r'}
>>> a | b # 并集
{'m', 'l', 'c', 'a', 'r', 'd', 'b', 'z'}
>>> a & b # 交集
{'c', 'a'}
>>> a ^ b # 对称差集
{'d', 'b', 'l', 'm', 'z', 'r'}
>>> {x for x in 'abracadabra' if x not in 'abc'}
{'d', 'r'}
字典（Dictionaries）
- 字典：一种存放键值对的哈希表数据结构。
- 字典采用大括号加冒号和逗号的特殊语法。
- 存在字典的解析表达式。（dictionary comprehensions）
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel
{'jack': 4098, 'sape': 4139}
>>> tel['jack']
4098
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
range 函数
>>> list(range(5,10))
[5, 6, 7, 8, 9]
>>> list(range(0,10,3))
[0, 3, 6, 9]
>>> list(range(-10,-100,-30))
[-10, -40, -70]
语句
- while 语句
- for 语句（实质上是 foreach）
- if ... elif ... else 语句
- 代码块采用冒号加缩进来表示
- pass 语句（空语句）
- break continue 语句
- 循环 + else语句（表示循环正常结束，没有被 break）
>>> for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, 'equals', x, '*', n//x)
break
else:
print(n, 'is a prime number')
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3
函数
- 定义函数使用 def。
- 形参的特殊形式有：带缺省值的形参 arg=value，元组形参 *args，字典形参 **args。
- 实参的特殊形式有：带关键字的实参 kwarg=value，列表/元组实参 *args，字典实参 **args。
- 函数可以嵌套。
- 函数名本身是一个对象。
>>> def f(a, b=2): # 带缺省值的形参
print(a,b)
>>> f(3)
3 2
>>> f(a=4) # 带关键字的实参
4 2
>>> d = {"a":3,"b":5}
>>> f(**d) # 字典实参，调用时展开
3 5
>>> def f(k, *args, **kws): # 元组形参，字典形参
print(k)
for arg in args:
print(arg)
for kw in kws:
print(kw, ":", kws[kw])
>>> f("a", 1,2,3, c=4,d="abc") # 调用时 1,2,3 打包成元组，c=4,d="abc" 打包成字典
a
1
2
3
c : 4
d : abc
>>> args = [3,6]
>>> list(range(*args)) # 列表实参，调用时展开
[3, 4, 5]
>>> args = (3,6)
>>> list(range(*args)) # 元组实参，调用时展开
[3, 4, 5]
lambda 表达式
>>> def make_incrementor(n):
return lambda x: x + n
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43
>>> pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]