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元素存在检查
in2 in filled_set # => True 10 in filled_set # => False
网友评论