了解python中的序列（列表，元组，字典，集合）这一篇足矣

了解什么为序列。序列就是在一块内存空间连续存放多个值，并且有一定的顺序。

1. 列表
2. 元组
3. 字典
4. 集合

谨记可变序列，在原有序列上进行增删改等操作，不会返回新的对象，有序序列可以用索引查找元素
列表，从业务逻辑上来讲存放相同的数据类型，但可以不同。
列表可变，有序序列（可变，有序，就应该知道有什么操作了）

set_1={1,2,3,4}
e=set_1[1]
f=set_1[1:3]
print(e)
print(f)    #TypeError: \'set\' object does not support indexing

dict_1={1:2,3:4,5:6,7:8}
g=dict_1[1]
i=dict_1[1:3]
print(g)
print(i)    #unhashable type: \'slice\'

列表增加元素

good=[1,2,3,4]
goood=[\'b\',\'c\']
a=good.append(5)
print(a)        #None
print(good)     #[1, 2, 3, 4, 5]
#列表是可变序列，在原列表上进行增加，而不是返回一个新对象
good.extend(\'67\')#参数为可迭代对象
print(good)     #[1, 2, 3, 4, \'6\',\'7\']
good.insert(3,0)
print(good)     #[1, 2, 3, 0, 4, 5,\'6\',\'7\'] 
goods=good+goood   #返回一个新的对象
print(goods)    #[1, 2, 3, 0, 4, 5, \'6\', \'7\', \'b\', \'c\']

列表删除操作

good=[\'a\',\'b\',\'c\']
good.remove(\'e\')    #报错：ValueError: list.remove(x): x not in list
good.remove(\'a\')    #good->[\'b\',\'c\']，根据指定的值删除元素
goods=[1,2,3]
goods.clear()       #goods->[]
goodss=[1,2,3,4,55]
goodss.pop(2)       #goodss->[1, 2, 4, 55],根据下标删除元素

列表查操作

list_1=[\'a\',[1,2],(1,2)]#可以存放字符串，序列
a=list_1[1]         #[1, 2]
b=list_1[1:2]       #[[1, 2]],以列表形式返回
print(a)
print(b)
c=list_1.index(\'a\')  #根据指定值返回索引
print(c)             #0

列表改操作sort()与sorted()不同的在于，前者会改变原列表，后者则不会(生成一个新列表对象）

list_1=[1,2,3,4,5]
list_1[1]=1
print(list_1)             #[1, 1, 3, 4, 5]
list_1.sort(reverse=False)#[1, 1, 3, 4, 5],升序操作，False第一个字母要大写，在python中严重区分大小写
list_1.sort(reverse=True)#[5, 4, 3, 1, 1]，降序操作
list_1.reverse()         #[5, 4, 3, 1, 1],是翻转，不是排序
print(list_1)

列表生成式，列表元素总是有规律的

a=[i*i for i in range(1,10)]
print(a)          #[1, 4, 9, 16, 25, 36, 49, 64, 81]
list_1=[(x,y) for x in range(5) if x%2==0 for y in range(5) if y%2==1]
print(list_1)     #满足if语句的条件

列表含字典元素怎样排序

p=[{\'name\':\'zhangsan\',\'age\':18,\'score\':98},{\'name\':\'lisi\',\'age\':19,\'score\':100},{\'name\':\'wanger\',\'age\':28,\'score\':98}]
p.sort(key=lambda x:x[\'age\'])      #key=选定一个值来比较，x表示元素
print(p)

元组是不可变，有序序列，所以没有增，删，改，查操作，但，，，

a=(1,2,3,4)
c=(5,6,7)
e=a+c
b=a*3
print(b)     #(1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4)
print(a)     #(1, 2, 3, 4)
print(e)     #(1, 2, 3, 4, 5, 6, 7)
tuple_1=(1,2,3,4)
c=tuple_1[1]
d=tuple_1[1:3]
print(c)     #2
print(d)     #(2, 3)

字典可变，无序序列（无序不可根据下标获取值）
字典获取值

dict_1={\'name\':\'zhangsan\',\'age\':28,\'score\':98}
a=dict_1[\'name\']      #key值不存在，则报错KeyError
b=dict_1.get(\'nianji\',\'wangwu\')#若key值nianji不存在，则输出wangwu
c=dict_1.get(\'name\',\'wangwu\')  #若key值name存在，则输出字典中key对应value
print(a)             #zhangsan
print(b)             #wangwu
print(c)             #zhangsan

字典用key来增加或修改元素

dict_1={\'name\':\'zhangsan\',\'age\':28,\'score\':98}
dict_1[\'name\']=\'lisi\'  #key存在则改变
print(dict_1)          #{\'name\': \'lisi\', \'age\': 28, \'score\': 98}
dict_1[\'nianji\']=6     #key不存在则添加
print(dict_1)          #{\'name\': \'lisi\', \'age\': 28, \'score\': 98, \'nianji\': 6}
dict_1.setdefault(\'name\',\'haode\')#key(name)存在，则没有任何反应
print(dict_1)          #{\'name\': \'lisi\', \'age\': 28, \'score\': 98, \'nianji\': 6}
dict_1.setdefault(\'jj\',\'haode\')#key(jj)不存在，则将键值对添加入字典当中
print(dict_1)          #{\'name\': \'lisi\', \'age\': 28, \'score\': 98, \'nianji\': 6,\'jj\':\'haode\'}
dict_2={\'帅吗\':\'好帅呀\'}
dict_1.update(dict_2)  #将dict_2连接到dict_1的尾部
print(dict_1)          #{\'name\': \'lisi\', \'age\': 28, \'score\': 98, \'nianji\': 6, \'jj\': \'haode\', \'帅吗\': \'好帅呀\'}

获取字典的视图

dict_1={\'name\':\'zhangsan\',\'age\':28,\'score\':98}
a=dict_1.keys()
print(a)         #dict_keys([\'name\', \'age\', \'score\'])
b=dict_1.values()
print(b)         #dict_values([\'zhangsan\', 28, 98])
c=dict_1.items()
print(c)         #dict_items([(\'name\', \'zhangsan\'), (\'age\', 28), (\'score\', 98)])

删除字典的键值对

dict_1={\'name\':\'zhangsan\',\'age\':28,\'score\':98}
dict_1.pop(\'name\')   #删除指定key的键值对
dict_1.popitem()     #删除最后一个键值对
print(dict_1)        #{\'age\': 28}

字典生成式

items={\'name\',\'age\',\'score\'}#为序列
prices=[1,2,3]              #为序列
b={item:price for item,price in zip(prices,items)}
print(b)                    #{\'age\': 1, \'name\': 2, \'score\': 3}
list_1=[\'name\',\'age\',\'gender\']
list_2=[\'maomao\',2,\'male\']
dict_1={list_1[i]:list_2[i] for i in range(len(list_1))}
print(dict_1)               #{\'name\': \'maomao\', \'age\': 2, \'gender\': \'male\'}

集合可变，无序的
集合删除操作

set_1={1,2,3,4,5}
set_1.remove(1)  #若指定元素不存在，会报错
set_1.discard(6) #若指定元素不存在，则返回原集合{1,2,3,4,5}，不会报错
print(set_1)     #{2, 3, 4, 5}
set_1.pop()      #删除第一个元素
print(set_1)     #{3, 4, 5}

集合添加操作

set_1={1,2,3,4,5}
set_1.add(\'4\')
print(set_1)#{1, 2, 3, 4, 5, \'4\'}
set_1.update([6,\'6\'])  #为序列[6,\'6\']or{6,\'6\'}
print(set_1)           #{1, 2, 3, 4, 5, 6, \'6\', \'4\'}

集合之间的数学问题

set_1={1,2,3,4,5}
set_2={1,2,3}
print(set_1.issubset(set_2))    #判断set_1是set_2的子集
print(set_1.issuperset(set_2))  #判断set_1是set_2的超集
print(set_1.isdisjoint(set_2))  #判断set与set之间是否有交集，有交集返回false

set_1={1,2,3,4,5}
set_2={1,2,3,6}
a=set_1.intersection(set_2)        #返回交集
b=set_1.union(set_2)               #返回并集
c=set_1.difference(set_2)          #返回差集
d=set_1.symmetric_difference(set_2)#返回对称差集
print(a)         #{1, 2, 3}
print(b)         #{1, 2, 3, 4, 5, 6}
print(c)         #{4, 5}
print(d)         #{4, 5, 6}

容器对象的公共方法
“+”用于字符串，列表，元组的合并操作

str_ = \'字符串“+”操作\'
print(str_.center(20, \'-\'))
str_1 = \'abc\'
str_2 = \'def\'
str_3 = str_1+str_2
print(str_3)
list_ = \"列表’+‘操作\"
print(list_.center(20, \"*\"))
list_1 = [1, 2, 3]
list_2 = [4, 5, 6]
list_3 = list_1+list_2
print(list_3)
tuple_=\'元组“+”操作\'
print(tuple_.center(20, \'&\'))
tuple_1 = (\'A\', \'B\', \'C\')
tuple_2 = (\'D\', \'E\', \'F\')
tuple_3 = tuple_1+tuple_2
print(tuple_3)

\"*\"操作符对字符串，列表，元组进行复制操作

print(\'=\'*10)
print([1, 2, 3]*10)
print((1, 2, 3)*10)

\"in,not in\"判断字符串，列表，元组，字典中的元素是否存在(以字符串为例）

str_1=\'abcd\'
print(\'a\' in str_1)
print(\'a\' not in str_1)

len()确定容器对象的元素个数(以字符串为例）

str_1=\'abcd\'
print(len(str_1))#4

max,min返回容器对象最大值，最小值(以字符串为例）

str_1=\'abcd\'
print(max(str_1))#d
print(min(str_1))

容器类型转换tuple(),set(),list(),以tuple()为例

list_1=[1,2,3,4]
s1=\'abcd\'
print(tuple(list_1))    #(1, 2, 3, 4)
print(tuple(s1))        #(\'a\', \'b\', \'c\', \'d\')