Python中，萬物皆對象。不過這并不是這里要探討的話題，想說的是一定要注意關鍵字，因為所有東西都是對象，所以一個簡簡單單的賦值操作就可以把系統內置的函數給變成一個普通變量，來看下邊例子：
id(type) # 506070640L
type = 1 # type成了指向1的變量
id(type) # 35556792L
id = 2 # id成了指向2的變量
from __future__ import print_function
print = 3 # print成了指向3的變量

注意print是個很特殊的存在，在Python3中是按照函數用，在Python2中卻是個命令式的語句，最早print的用法其實是下邊這樣：
print "Hello world!"

這么用主要是受到ABC語法的影響，但這個用法并不Pythonic，后來加入了print函數，為了兼容允許兩種用法并存。所以單純給print賦值是不靈的，在Python2中使用Python3中的一些特性都是用from __future__ import來實現。

模塊導入

因為提到了對象名覆蓋和import，所以簡單講一下。import是利用Python中各種強大庫的基礎，比如要計算cos(π)的值，可以有下面4種方式：
# 直接導入Python的內置基礎數學庫
import math
print(math.cos(math.pi))

# 從math中導入cos函數和pi變量
from math import cos, pi
print(cos(pi))

# 如果是個模塊，在導入的時候可以起個別名，避免名字沖突或是方便懶得打字的人使用
import math as m
print(m.cos(m.pi))

# 從math中導入所有東西
from math import *
print(cos(pi))

一般來說最后一種方式不是很推薦，因為不知道import導入的名字里是否和現有對象名已經有沖突，很可能會不知不覺覆蓋了現有的對象。

容器

列表

Python中的容器是異常好用且異常有用的結構。這節主要介紹列表（list），元組（tuple），字典（dict）和集合（set）。這些結構和其他語言中的類似結構并無本質不同，來看例子了解下使用：

a = [1, 2, 3, 4]
b = [1]
c = [1]
d = b
e = [1, "Hello world!", c, False]
print(id(b), id(c)) # (194100040L, 194100552L)
print(id(b), id(d)) # (194100040L, 194100040L)
print(b == c) # True
f = list("abcd")
print(f) # ['a', 'b', 'c', 'd']
g = [0]*3 + [1]*4 + [2]*2 # [0, 0, 0, 1, 1, 1, 1, 2, 2]

因為變量其實是個引用，所以對列表而言也沒什么不同，所以列表對類型沒什么限制。也正因為如此，和變量不同的是，即使用相同的語句賦值，列表的地址也是不同的，在這個例子中體現在id(b)和id(c)不相等，而內容相等。列表也可以用list()初始化，輸入參數需要是一個可以遍歷的結構，其中每一個元素會作為列表的一項。“*”操作符對于列表而言是復制，最后一個語句用這種辦法生成了分段的列表。

列表的基本操作有訪問，增加，刪除，和拼接：
a.pop() # 把最后一個值4從列表中移除并作為pop的返回值
a.append(5) # 末尾插入值，[1, 2, 3, 5]
a.index(2) # 找到第一個2所在的位置，也就是1
a[2] # 取下標，也就是位置在2的值，也就是第三個值3
a += [4, 3, 2] # 拼接，[1, 2, 3, 5, 4, 3, 2]
a.insert(1, 0) # 在下標為1處插入元素0，[1, 0, 2, 3, 5, 4, 3, 2]
a.remove(2) # 移除第一個2，[1, 0, 3, 5, 4, 3, 2]
a.reverse() # 倒序，a變為[2, 3, 4, 5, 3, 0, 1]
a[3] = 9 # 指定下標處賦值，[2, 3, 4, 9, 3, 0, 1]
b = a[2:5] # 取下標2開始到5之前的子序列，[4, 9, 3]
c = a[2:-2] # 下標也可以倒著數，方便算不過來的人，[4, 9, 3]
d = a[2:] # 取下標2開始到結尾的子序列，[4, 9, 3, 0, 1]
e = a[:5] # 取開始到下標5之前的子序列，[2, 3, 4, 9, 3]
f = a[:] # 取從開頭到最后的整個子序列，相當于值拷貝，[2, 3, 4, 9, 3, 0, 1]
a[2:-2] = [1, 2, 3] # 賦值也可以按照一段來，[2, 3, 1, 2, 3, 0, 1]
g = a[::-1] # 也是倒序，通過slicing實現并賦值，效率略低于reverse()
a.sort()
print(a) # 列表內排序，a變為[0, 1, 1, 2, 2, 3, 3]

因為列表是有順序的，所以和順序相關的操作是列表中最常見的，首先我們來打亂一個列表的順序，然后再對這個列表排序：
import random
a = range(10) # 生成一個列表，從0開始+1遞增到9
print(a) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
random.shuffle(a) # shuffle函數可以對可遍歷且可變結構打亂順序
print(a) # [4, 3, 8, 9, 0, 6, 2, 7, 5, 1]
b = sorted(a)
print(b) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
c = sorted(a, reverse=True)
print(c) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

元組

元組和列表有很多相似的地方，最大的區別在于不可變，還有如果初始化只包含一個元素的tuple和列表不一樣，因為語法必須明確，所以必須在元素后加上逗號。另外直接用逗號分隔多個元素賦值默認是個tuple，這在函數多返回值的時候很好用：
a = (1, 2)
b = tuple(['3', 4]) # 也可以從列表初始化
c = (5,)
print(c) # (5,)
d = (6)
print(d) # 6
e = 3, 4, 5
print(e) # (3, 4, 5)

集合