2.变量和集合

Python 有一个打印函数

print("亲爱的用户你好，我是你爸爸，微软如是说")  
# => 亲爱的用户你好，我是你爸爸，微软如是说

默认的打印会自动打印一个回车帮你换行

但是你也可以使用 end 实现不换行

print("小姐姐小姐姐，我有一个东西想要给你！", end="我你要么？") 
# => 小姐姐小姐姐，我有一个东西想要给你！我你要么？

一个从控制台简单的获取数据的方法

input_string_var = input("输入一些东西: ") # 输入数据然后回车

变量是不需要声明的

some_var = 5

some_var  # => 5

if可以被用作三目运算符

temp = 'A' if (3 > 2) else 'B'
print(temp)
# 如果条件成立输出‘A’ 否则 输出 ‘B’

列表

时刻记住列表下标从0开始

li = []

也可以声明一个有内容的列表

other_li = [4, 5, 6]

列表内容追加 所谓追加就是在列表的最后一行添加

li.append(1)    # 列表现在变成 [1]
li.append(2)    # 列表现在变成 [1, 2]
li.append(4)    # 列表现在变成 [1, 2, 4]
li.append(3)    # 列表现在变成 [1, 2, 4, 3]

删除最后一个元素

li.pop() # 列表现在变成 [1, 2, 4]

把刚才删除的值放回去

li.append(3) # 列表现在又变成 [1, 2, 4, 3]

获取列表元素 如同访问数组一般

li[0] # => 1

获取列表最后一个元素

li[-1] # => 3

这样的访问将会引起越界

li[4] # Raises an IndexError

---

时刻记住列表下标从0开始 拿出耐心来 学到这里已经有些无聊了是么？

切片操作 就像你切香肠一样 只是包前不包后

第1个到第3个，并且不取第三个 li[1] li[2]

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

li[2]到最后一个

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

li[0]到li[3]

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

每隔两个取一个

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

反向的copy

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

使用这些你可以随心所欲的操作列表

li[开始index:结束index:步数]

深度的复制

li2 = li[:]  
# => li2 = [1, 2, 4, 3] 但是 (li2 is li) 将会返回 False 他们不是一个对象
# => (li2 == li) 将会返回 True

删除任何一个你想删除的

del li[2] # [1, 2, 4, 3] 变成 [1, 2, 3]

从第一个开始寻找，删除第一个找到的项

li.remove(2)  # 加入list为][1,2,3,2] 现在变成了 [1,3,2]

li.remove(2)  # [1,3,2] 变成 [1,3]

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

li.insert(1, 2)  # 在li[1]处插入2

获取索引

li.index(2)  # => ‘2’这个元素所在的位置
li.index(4)  # Raises a ValueError 4不在集合中所有会引发异常

你可以连接两个list

li1=[1,2,3]
li2=[4,5,6]
li1 + li2  # => [1, 2, 3, 4, 5, 6]

也可以使"extend()"

li1.extend(li2)  # 效果是一样的

检查元素是否在list中

1 in li  # => True

获得list长度

len(li)  # => 6

Tuples元组

看起来像list但是它不可改变

tup = (1, 2, 3)
tup[0]      # => 1
tup[0] = 3  # Raises a TypeError

长度为1的元组必须在最后一个元素后面有一个逗号

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

你可以把许多的list操作迁移到元组的操作上

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

你可以使用元组/list给变量批量的赋值

a, b, c = (1, 2, 3)  # a=1 b=2 c=3

你也可以打包赋值

a, *b, c = (1, 2, 3, 4)  # a=1 b=[2, 3] c=4

离开了括号，元组会自主默认创建

d, e, f = 4, 5, 6

交换两个变量的值，很简单

e=5
d=4
e, d = d, e  # d=5 e= 4

字典类型

存储键值对

empty_dict = {}

预定义字典值

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

字典的键必须是不可变类型，因为这样才能使得键可以被转化为哈希值以便快速查找

不可变类型包括 ints, floats, strings, tuples.

invalid_dict = {[1,2,3]: "123"}  # => Raises a TypeError: list是可变的类型
valid_dict = {(1,2,3):[1,2,3]}   # 元组就是可以的

用[]查看值

filled_dict["one"]  # => 1

使用Keys()可以获取 键的集合，将它放在list中就可以迭代取处。但是它们的顺序是混乱的

list(filled_dict.keys())  # => ["three", "two", "one"]

使用Values()可以获取 键的集合，将它放在list中就可以迭代取处。但是它们的顺序是混乱的

list(filled_dict.values())  # => [3, 2, 1]

检查一个key是否在字典中，使用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支持默认值，当所取的值不存在的时候会返回默认值

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

setdefault()当这个键值对不存在的时候将它插入字典

filled_dict.setdefault("five", 5)  # 将 filled_dict["five"] 设置为 5
filled_dict.setdefault("five", 6)  # filled_dict["five"] 依旧是 5

添加一个键值对到字典

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

使用del删除字典里的一个键值对

del filled_dict["one"]

这是我也不懂，也懒得查资料～嘿嘿！

{'a': 1, **{'b': 2}}  # => {'a': 1, 'b': 2}
{'a': 1, **{'a': 2}}  # => {'a': 2}

集合

这是一个空的集合

empty_set = set()

初始化一个带值的集合，它看起来有点像字典

some_set = {1, 1, 2, 2, 3, 4}  # some_set is now {1, 2, 3, 4}

类似于字典的特性，集合的元素也要求必须不可变

invalid_set = {[1], 1}  # => Raises a TypeError: 列表可变引发错误
valid_set = {(1,), 1}

给集合添加元素

filled_set = {1, 2, 3, 4}
filled_set.add(5)  # filled_set 现在是 {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