了解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')