4. 变量和集合

print 是内置的打印函数

print("I'm Python. Nice to meet you!")

默认情况下，print 函数会在输出结果后加入一个空行作为结尾，可以使用附加参数改变输出结尾。

# => Hello, World!
print("Hello, World", end="!")

可以很简单的从终端获得输入数据

# 返回字符串数值
input_string_var = input("Enter some data: ")

在给变量赋值前不用提前声明，习惯上变量命名是纯小写，用下划线分隔单词。

some_var = 5
# => 5
some_var

访问未赋值的变量会抛出异常，参考流程控制一段来学习异常处理。

# 抛出 NameError
some_unknown_var

“if” 可以用作表达式，它的作用等同于 C 语言的三元运算符 “?:”

# => "nay!"
"yay!" if 0 > 1 else "nay!"

列表

用列表 (list) 储存序列

li = []

创建列表时也可以同时赋给元素

other_li = [4, 5, 6]

用 append 在列表最后追加元素

# li现在是[1]
li.append(1)
# li现在是[1, 2]
li.append(2)
# li现在是[1, 2, 4]
li.append(4)
# li现在是[1, 2, 4, 3]
li.append(3)

用 pop 从列表尾部删除

# => 3 且li现在是[1, 2, 4]
li.pop()

把 3 再放回去

# li变回[1, 2, 4, 3]
li.append(3)

列表存取和数组一样

# => 1
li[0]

取出最后一个元素

# => 3
li[-1]

越界存取会造成 IndexError

# 抛出 IndexError
li[4]

列表有切割语法

# => [2, 4]
li[1:3]

取尾

# => [4, 3]
li[2:]

取头

# => [1, 2, 4]
li[:3]

隔一个取一个

# => [1, 4]
li[::2]

倒排列表

# => [3, 4, 2, 1]
li[::-1]

可以用三个参数的任何组合来构建切割，li[始:终:步伐] 简单的实现了单层数组的深度复制。

# => li2 = [1, 2, 4, 3] ，但 (li2 is li) 会返回 False
li2 = li[:]

用 del 删除任何一个元素

# li 现在为 [1, 2, 3]
del li[2]

删除第一个匹配的元素

# li 现在为 [1, 3]
li.remove(2)
# 抛出错误 ValueError: 2 is not in the list
li.remove(2)

在指定索引处插入一个新的元素

# li is now [1, 2, 3] again
li.insert(1, 2)

获得列表第一个匹配的值的索引

# => 1
li.index(2)
# 抛出一个 ValueError: 4 is not in the list
li.index(4)

列表可以相加，注意：li 和 other_li 的值都不变。

# => [1, 2, 3, 4, 5, 6]
li + other_li

用 “extend()” 拼接列表

# li 现在是[1, 2, 3, 4, 5, 6]
li.extend(other_li)

用 “in” 测试列表是否包含某个值

# => True
1 in li

用 “len()” 取列表长度

# => 6
len(li)

元组

元组类似列表，但是不允许修改。

tup = (1, 2, 3)
# => 1
tup[0]
# 抛出 TypeError
tup[0] = 3

如果元素数量为 1 的元组必须在元素之后加一个逗号，其他元素数量的元组，包括空元组，都不需要。

# => <class 'int'>
type((1))
# => <class 'tuple'>
type((1,))
# => <class 'tuple'>
type(())

列表允许的操作元组大多都可以

# => 3
len(tup)
# => (1, 2, 3, 4, 5, 6)
tup + (4, 5, 6)
# => (1, 2)
tup[:2]
# => True
2 in tup

可以把元组和列表解包，赋值给变量

# 现在 a 是 1，b 是 2，c 是 3
a, b, c = (1, 2, 3)

也可以做扩展解包

# 现在 a 是 1, b 是 [2, 3]， c 是 4
a, *b, c = (1, 2, 3, 4)

元组周围的括号是可以省略的

# 元组 4, 5, 6 通过解包被赋值给变量 d, e, f
d, e, f = 4, 5, 6

交换两个变量的值

# 现在 d 是 5，e 是 4
e, d = d, e

字典

字典用来存储 key 到 value 的映射关系

empty_dict = {}

初始化字典

filled_dict = {"one": 1, "two": 2, "three": 3}

字典的 key 必须为不可变类型，这是为了确保 key 被转换为唯一的哈希值以用于快速查询。不可变类型包括整数、浮点、字符串、元组。

# => 抛出 TypeError: unhashable type: 'list'
invalid_dict = {[1,2,3]: "123"}
# 然而 value 可以是任何类型
valid_dict = {(1,2,3):[1,2,3]}

用 [] 取值

# => 1
filled_dict["one"]

用 keys 获得所有的键，因为 keys 返回一个可迭代对象，所以需要把它包在 “list()” 里才能转换为列表。 注意：对于版本 < 3.7 的 python, 字典的 key 的排序是无序的，你的运行结果可能与下面的例子不符，但是在 3.7 版本，字典中的项会按照他们被插入到字典的顺序进行排序。

# => ["three", "two", "one"] Python 版本 <3.7
list(filled_dict.keys())
# => ["one", "two", "three"] Python 版本 3.7+
list(filled_dict.keys())

用 “values()” 获得所有的值，跟 keys 一样也是可迭代对象，要使用 “list()” 才能转换为列表。 注意：排序顺序和 keys 的情况相同。

# => [3, 2, 1] Python 版本 < 3.7
list(filled_dict.values())
# => [1, 2, 3] Python 版本 3.7+
list(filled_dict.values())

用 in 测试一个字典是否包含一个键

# => True
"one" in filled_dict
# => False
1 in filled_dict

访问不存在的键会导致 KeyError

# KeyError
filled_dict["four"]

用 “get()” 来避免 KeyError

# => 1
filled_dict.get("one")
# => None
filled_dict.get("four")

当键不存在的时候 “get()” 方法可以返回默认值

# => 1
filled_dict.get("one", 4)
# => 4
filled_dict.get("four", 4)

“setdefault()” 方法只有当键不存在的时候插入新值

# filled_dict["five"] 设为5
filled_dict.setdefault("five", 5)
# filled_dict["five"] 还是5
filled_dict.setdefault("five", 6)

字典赋值

# => {"one": 1, "two": 2, "three": 3, "four": 4}
filled_dict.update({"four":4})
# 另一种赋值方法
filled_dict["four"] = 4

用 del 删除项

# 从 filled_dict 中把 one 删除
del filled_dict["one"]

集合

用 set 表达集合

empty_set = set()

初始化一个集合，语法跟字典相似。

# some_set 现在是 {1, 2, 3, 4}
some_set = {1, 1, 2, 2, 3, 4}

类似字典的 keys，set 的元素也必须是不可变类型。

# => Raises a TypeError: unhashable type: 'list'
invalid_set = {[1], 1}
valid_set = {(1,), 1}

可以把集合赋值于变量

filled_set = some_set

为集合添加元素

# filled_set 现在是 {1, 2, 3, 4, 5}
filled_set.add(5)

set 没有重复的元素

# filled_set 依然是 {1, 2, 3, 4, 5}
filled_set.add(5)

用 “&” 取交集

other_set = {3, 4, 5, 6}
# => {3, 4, 5}
filled_set & other_set

用 “|” 取并集

# => {1, 2, 3, 4, 5, 6}
filled_set | other_set

用 “-” 取补集

# => {1, 4}
{1, 2, 3, 4} - {2, 3, 5}

用 “^” 取异或集（对称差）

# => {1, 4, 5}
{1, 2, 3, 4} ^ {2, 3, 5}

判断左边的集合是否是右边集合的超集

# => False
{1, 2} >= {1, 2, 3}

判断左边的集合是否是右边集合的子集

# => True
{1, 2} <= {1, 2, 3}

in 测试集合是否包含某元素

# => True
2 in filled_set
# => False
10 in filled_set

单层集合的深度复制

# filled_set 是 {1, 2, 3, 4, 5}
filled_set = some_set.copy()
# => False
filled_set is some_set