本文内容基本上翻译自http://cheat.sh/python/:learn)

非原创, 非原创, 非原创!!!

感谢原文社区作者

# Python 有 print 语句
print "I'm Python. Nice to meet you!"  # => I'm Python. Nice to meet you!

# Python3 的时候你应该这么写
print("I'm Python. Nice to meet you!")  # => I'm Python. Nice to meet you!

# 从控制台获取输入的简便方法
input_string_var = raw_input(
    "Enter some data: ")  # 返回字符串
input_var = input("Enter some data: ")  # 把输入作为python代码执行
# 警告: 使用input() 方法时千万请小心谨慎
# 注意: python 3里input()方法被废弃了，并且raw_input()被重命名成了input()

# 给变量赋值之前是不需要声明的
some_var = 5  # 一般约定使用下划线去给变量名分词 lower_case_with_underscores
some_var  # => 5

# 访问没有定义的变量会抛出异常
# 在控制流部分可以查看更多关于异常处理的信息
some_other_var  # Raises a name error

# if可以作为表达式使用
# 跟 C语言中 '?:' 三元操作符等价
"yahoo!" if 3 > 2 else 2  # => "yahoo!"


li = []
# 你可以定义一个预填充(或者叫非空的列表可能比较好)列表
other_li = [4, 5, 6]

# 使用append方法向列表的尾部添加元素
li.append(1)  # li is now [1]
li.append(2)  # li is now [1, 2]
li.append(4)  # li is now [1, 2, 4]
li.append(3)  # li is now [1, 2, 4, 3]
# 使用pop将元素从列表尾部移除
li.pop()  # => 3 and li is now [1, 2, 4]
# 重新加回去
li.append(3)  # li is now [1, 2, 4, 3] again.

# 访问列表元素跟访问数组元素的语法是相同的
li[0]  # => 1
# 使用 = 可以给已经初始化过的索引赋新值
li[0] = 42
li[0]  # => 42
li[0] = 1  # 注意: 设置回原先的值
# 访问最后1个元素
li[-1]  # => 3

# 访问越界的话会抛出 IndexError
li[4]  # Raises an IndexError

# 使用切片(slice)语法可以访问列表中的部分元素.
# (It's a closed/open range for you mathy types.)
li[1:3]  # => [2, 4]
# 忽略开头
li[:3]  # => [1, 2, 4]
# 忽略结尾
li[2:]  # => [4, 3]
# 每隔2个元素选择1个
li[::2]  # =>[1, 4]
# 反转列表的拷贝
li[::-1]  # => [3, 4, 2, 1]
# Use any combination of these to make advanced slices
# 使用上述的各种组合来创建更加复杂的切片
# li[start:end:step]

# 使用 "del" 来删除任意元素
del li[2]  # li is now [1, 2, 3]

# 列表可以相加
li + other_li  # => [1, 2, 3, 4, 5, 6]
# 注意: li 和 for other_li 的值没有变化的

# 使用"extend()"来连接列表
# 注意: li的值变化了的
li.extend(other_li)  # Now li is [1, 2, 3, 4, 5, 6]

# 移除第一个满足条件的值
li.remove(2)  # li is now [1, 3, 4, 5, 6]
li.remove(2)  # 抛出ValueError, 2已经不在列表里了

# 在特定的索引(index)处插入元素
li.insert(1, 2)  # li is now [1, 2, 3, 4, 5, 6] again

# 返回第1个满足条件的值的索引
li.index(2)  # => 1
li.index(7)  # 抛出ValueError，因为7不在列表里

# 用 "in" 来检查元素是否在列表中存在
1 in li  # => True

# 用 "len()" 来返回列表的长度
len(li)  # => 6

# 元组(Tuples) 跟列表很想，区别是元组是不可变的
tup = (1, 2, 3)
tup[0]  # => 1
tup[0] = 3  # 抛出TypeError异常

# 你可以在元组上做下面一些的列表操作
len(tup)  # => 3
tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
tup[:2]  # => (1, 2)
2 in tup  # => True

# You can unpack tuples (or lists) into variables
# 你可以把元组(或列表) unpack成变量
a, b, c = (1, 2, 3)  # a is now 1, b is now 2 and c is now 3
d, e, f = 4, 5, 6  # 你都可以省略括号
# 如果你不加括号的话，默认情况下会创建元组
g = 4, 5, 6  # => (4, 5, 6)
# 看一下，交换变量的值那是相当容易的
e, d = d, e  # d is now 5 and e is now 4

# 字典是用来存储属性名(key)和属性值(value)的
empty_dict = {}
# 这是预填充的字典
filled_dict = {"one": 1, "two": 2, "three": 3}

# 用[]来查找属性的值(value)
filled_dict["one"]  # => 1

# 用"keys()"来返回所有key的列表
filled_dict.keys()  # => ["three", "two", "one"]
# 注意 - 字典key的顺序是不保证的
# 你自己的结果可能会跟上面不同

# "values()"返回所有值(value)的列表
filled_dict.values()  # => [3, 2, 1]
# 注意 - 排序问题跟上面的类似

# "items()" 返回所有的键值对(key-value)的元组组成的列表
filled_dicts.items()  # => [("one", 1), ("two", 2), ("three", 3)]

# 用"in"来判断某个属性名/某个键是否存在
"one" in filled_dict  # => True
1 in filled_dict  # => False

# 访问不存在的属性名/键的时候会抛出 KeyError
filled_dict["four"]  # KeyError

# 用"get()"方法可以避免 KeyError
filled_dict.get("one")  # => 1
filled_dict.get("four")  # => None
# get支持当属性名/键不存在的时候返回1个设定的默认值
filled_dict.get("one", 4)  # => 1
filled_dict.get("four", 4)  # => 4
# 注意: filled_dict.get("four") 仍然是 => None
# (get 并不会设置字典的值)

# 为某个属性名/键赋值跟列表赋值的方式差不多
filled_dict["four"] = 4  # now, filled_dict["four"] => 4

# "setdefault()" 方法在给定的属性名/键不存在的时候会插入具体的值
filled_dict.setdefault("five", 5)  # filled_dict["five"] 被设置成 5
filled_dict.setdefault("five", 6)  # filled_dict["five"] 仍然是 5

# 集合是存储... 好吧，集合 (跟列表差不多，只是不能有重复的项)
empty_set = set()
# 初始化的时候赋一些值
some_set = set([1, 2, 2, 3, 4])  # some_set 现在等于set([1, 2, 3, 4])

# 顺序是不被保证的, 即使有时候看起来像排过序一样
another_set = set([4, 3, 2, 2, 1])  # another_set 现在是 set([1, 2, 3, 4])

# 从Python 2.7开始, {} 可以被用来声明集合
filled_set = {1, 2, 2, 3, 4}  # => {1, 2, 3, 4}

# 往集合里添加更多项
filled_set.add(5)  # filled_set is now {1, 2, 3, 4, 5}

# 用 & 来取交集
other_set = {3, 4, 5, 6}
filled_set & other_set  # => {3, 4, 5}

# 用 | 取并集
filled_set | other_set  # => {1, 2, 3, 4, 5, 6}

# 用 - 来取差集
{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}

# 用 ^ 取对称差集
{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}

# 判断左边的集合是不是右边的超集
{1, 2} >= {1, 2, 3}  # => False

# 判断左边的集合是不是右边的子集
{1, 2} <= {1, 2, 3}  # => True

# 用in来判断元素在集合中是否存在
2 in filled_set  # => True
10 in filled_set  # => False