2，序列的相关操作 （1）切片操作len()函数可计算字符串的字符个数
注意正向和反向的索引序号
切片的各个参数：start,end,step
注意各参数的含义和默认值
s="helloworld" s1=s[0:5:1] #指定起始和结束位置以及步长 print(s1) #输出为hello（2）序列的相关操作_操作符_函数
（二）列表 1，列表的创建与删除序列相加：要求序列类型相同（序列的类型有列表、元组、集合、字典和字符串），元素的 类型可以是字符型或整型。理解序列类型和序列中的元素类型
列表是可变长序列，因为其可以增加、删除元素
#列表的创建
#直接使用[]创建
lst=["hello","world",99.8,] #变量名为lst不是list,因为list是内置函数
#使用内置函数list()创建
lst2=list("hello") #结果为["h","e","l","l","0"]
lst3=list(range(1,10,2)) #从1开始，到10结束(不包括10)且步长是2，输出结果为[1,3,5,7,9]
#列表中的操作
print(lst2+lst3) #结果为["h","e","l","l","0",1,3,5,7,9]
print(lst2*3) #结果为["h","e","l","l","0","h","e","l","l","0","h","e","l","l","0"]
print(len(lst2))
print(max(lst3)) #序列的操作同样适用
print(min(lst3))
#列表的删除
del lst #删除列表，则列表不存在
del lst2
del lst3
2，列表元素的遍历
#使用for循环遍历列表元素
lst=["hello","world","python","php"]
for item in lst:
print(item)
#使用for循环，range()函数，len()函数，根据索引进行遍历元素
for i in range(len(lst)):
print(i,"-->",lst[i])
#使用for循环，enumerate()函数进行遍历
for index,item in enumerate(lst): #默认index序号从0开始
print(index,item)
for index,item in enumerate(lst，1): #修改index序号从1开始
print(index,item)
3，列表元素的新增_修改_删除操作
lst=["hello","python","php"]
print("原列表："，lst,id(lst)) #id()函数表示该地址，输出为原列表：["hello","python","php"]
#使用insert(index,x)在指定位置插入元素
lst.insert(1,100) #在位置1处插入元素100(默认位置从0开始)
#删除元素
lst.remove("hello")
#使用pop(index),根据索引移出元素，先将元素取出，再将元素删除
lst.pop(1) #该语句直接在窗口输出100
#清空列表所有元素
lst.clear()
#将列表中元素的位置反转
lst.reverse()
#列表的拷贝，并产生新的列表
new_lst=lst.copy() #两个列表的内存地址不一样
#列表元素的修改
lst[1]="mysql"
4,列表的排序
sort方法：reverse=True,则降序排序；False是升序排序，默认是升序排序对
sorted函数：是内置函数
注意sort()是方法，而sorted()是内置函数
对中文的排序效果不是很好，但可以对英文排序，按照首字母的unicode码值进行排(ASCII码是unicode码的一部分)
#用sort()方法进行排序 lst=[5,15,46,3,59,62] lst.sort() #默认是升序排序 lst.sort(reverse=True) #降序排序 #对英文排序 lst2=["banana","apple","python","orange"] lst2.sort() #默认升序排序，先排大写再排小写(按照首字母的unicode码排序) lst2.sort(reverse=True) #降序排序，先排小写在排大写 #忽略大小写进行排序 lst2.sort(key=str.lower) #默认升序排序且部分大小写，用到参数key
#用sorted()内置函数进行排序 lst=[5,15,23,86,3,87] asc_lst=sorted(lst) #默认是升序排序 print(lst) print(asc_lst) #输出会发现lst未改变，asc_lst排序改变 #sorted()函数的参数和sort()方法相同，可采用一样的形式5，列表生成式
expression是表达式的意思，即前面的可以是任何表达式
#列表生成式 #生成整数列表 lst=[i for i in range(1,11)] lst1=[i*i for i in range(1,11)] #前面是表达式 #产生10个随机数列表 import random #要产生随机数要导入random模块 lst3=[random.randint for _ in range(10)] #因为前面没有用到循环变量，所以用下划线代替则该循环表示循环的次数 #从列表中选择符合条件的元素组成新的列表 lst4=[i for i in range(10) if i%==0] #产生0~9之间的偶数列表6，二维列表
#创建二维列表
lst=[["城市","环比","同比"],
["北京",102,103],
["上海",104,504],
["深圳",103,205]
]
#遍历二位列表
for row in lst
for item in row
print(item,end="t")
print()
#列表生成式创建四行五列的列表
lst2=[[j for j in range(5)]for i in range(4)]
print(lst2) #输出是[[0,1,2,3,4],[0,1,2,3,4],[0,1,2,3,4],[0,1,2,3,4]]
#也可效仿一维列表生成式添加条件筛选
（三）元组
1,元组的创建与删除
元组是不可变序列
元组中的数据类型可以是字符串、整型、也可以是列表,元组
#直接使用()创建元组
t=("hello","python",[0,1,2],10)
print(t) #输出是("hello","python",[0,1,2],10)，输出中带有()
#使用内置函数tuple()创建元组
t=tuple("hello")
print(t) #输出为("h","e","l","l","o")
t=tuple([1,2,3])
print(t) #输出是(1,2,3)
t=tuple(range(1,5))
print(t) #输出是(1,2,3,4)
#元组的相关操作和序列的操作一样
#若元组中只有一个元素，括号中应带“,”
z=(10)
print(type(z)) #输出
m=(10,)
print(type(m)) #输出
#删除元组
del m
print(m) #报错:nameerror:m is not defined
2，元组的访问与遍历
t=("python","php","hello")
print(t[0]) #输出为python,根据索引访问
t1=t[0:3:1]
print(t1) #输出是("python","php","hello"),切片操作
#元组的遍历
#1，直接使用for循环遍历
t=("python","php","hello")
for item in t:
print(item)
#2,for循环+range()+len()组合遍历
t=("python","php","hello")
for i in range(0,len(t)):
print(t[i])
#3,enumerate()函数遍历
for index,item in enumerate(t):
print(index,item) #使用enumerate()函数时index默认从0开始
3,元组生成式
t=(i for i in range(1,4)) print(t) #结果是>生成器对象 #1，生成器对象可转换成元组类型输出 t=tuple(t) print(t) #输出(1,2,3) #2,生成器对象可以直接只用for循环遍历，不用转成元组类型 for item in t: print(item) #3，生成器对象方法__next__()方法遍历 print(t.__next__()) #拿到第一个元素 print(t.__next__()) #拿到第二个元素 print(t.__next__()) #拿到第三个元素 t=tuple(t) print(t) #输出会发现元素为空 #生成器遍历之后，再想重新遍历必须重新创建一个生成器对象，因为遍历之后原生成器对象不存在
4，元组和列表的区别注意：生成器遍历之后，再想重新遍历必须重新创建一个生成器对象，因为遍历之后原生成器对象不存在
（四）字典 1，字典创建与删除1，列表时可变序列，可进行添加删除操作；元组是不可变序列。
2，列表是可变序列故不能作为字典的键；元组是不可变序列可作为字典的键
3，当只需要访问元素而不修改元素时，用元组
字典没有索引，只能通过键来访问
字典中的键必须是不可变序列，值可以是任意类型
字典是可变序列，可以添加和删除元素
字典的删除：del 字典名
#1，直接使用{}创建
d={10:"car",20:"dog",30:"pet"}
#2,映射函数zip()函数结合dict()使用
lst1=[10,20,30,40]
lst2=["cat","dog","car","zoo"]
ziph=zip(lst1,lst2) #映射函数的结果是zip对象
#zip()函数将两个列表中对应位置的元素作为元组结合，并产生zip对象
#print(ziph) #输出是
#print(list(ziph)) #zip对象需转化成列表或元组才能输出
d=dict(ziph)
print(d) #输出是{10:"cat",20:"dog",30:"car",40:"zoo"}
#3,使用dict()并用参数创建字典
d=dict(cat=10,dog=20,car=30) #括号若写成10=cat则报错因为变量不能是数字
print(d) #输出是{"cat":10,"dog":20,"car":30}
t=(10,20,30)
m={t:10} #键必须是不可变序列
print(m) #输出是{(10,20,30):10}
n=[10,20,30]
m={n:10}
print(m) #报错typeError:unhashable type:"list"
#删除字典
del m #删除后就不存在
del n
2，字典的访问和遍历
字典元素遍历：方法items()指的是键值对
d={"hello":10,"world":20,"php":30}
#访问字典元素
#1，使用[key]
print(d["hello"])
#2,使用d.get(key)
print(d.get("hello"))
#[key]和d.get(key)的区别，若键不存在时会出现区别
#print(d["java"]) 直接报错：KeyError键错误
print(d.get("java")) #不会报错，输出None，d.get("java")默认值None
print(d.get("java","不存在")) #输出默认值不存在
#字典的遍历
for item in d.items():
print(item) #输出是元组形式，即("hello",10)形式，因为items是键值对形式
for key,value in d.items():
print(key,value) #输出对应的值
3，字典的相关操作
d={1001:"李梅",1002:"王华",1003:"张锋"}
#向字典中添加数据
d[1004]="张丽" #直接使用d[key]=value赋值运算，添加数据
#获取字典中所有的key
key=d.keys() #d.keys()结果是dict_keys,python中的一种内部数据类型，专用于表示字典的key
#若希望更好的显示数据，可用list()或tuple()转为列表或元组
print(list(key))
print(tuple(key))
#获取字典中所有的value
value=d.values() #d.values()结果是dict_values
print(list(value))
print(tuple(value))
#使用pop()方法
print(d.pop(1008,"不存在")) #若键不存在，输出默认值“不存在”
#清除字典
d.clear()
print(bool(d)) #输出False
4,字典生成式
#使用指定范围的数做键key
import random
d={item:random.randint(1,100) for item in range(4)}
print(d) #输出{0:39,1:25,2:45,3:56}
#使用映射函数zip()作为生成表达式
lst1=[1001,1002,1003]
lst2=["刘伟","张强","李华"]
d={key:value for key,value in zip(lst1,lst2)}
print(d)
(五)集合
1，集合的创建与删除
集合中的元素不能重复，若重复则自动降重，可实现字符串的降重
本博客只叙述可变集合set
#第一种创建集合方法
s={10,20,30,40]
print(s) #输出为{40,10,20,30},因为集合是无序的
s={[10,20],[30,40]}
print(s) #报错TypeError,因为列表是可变的
s={} #创建的是空字典
s=set() #创建的是空集合
#第二种创建集合，set(可迭代对象)，可迭代对象就是能用for循环遍历的类型
s1=set("hello")
s2=set([10,20,30])
s3=set(range(1,10))
print(s1) #输出{"h","l","o","e"},集合中的元素不能重复，可实现字符串的去重
print(s2)
print(s3)
del s1 #删除s3
2，集合的操作符
a={10,20,30,60}
b={20,30,40,80}
print(a&b) #输出是{20,30},仍为集合
print(a|b) #输出仍是集合
print(a-b)
print(a^b) #补集，即去掉a和b中重复的元素后剩下的所有元素
3,集合的相关操作，遍历和生成式
s={10,20,30}
#添加元素
s.add(100) #结果是{100,10,20,30}
#删除元素
s.remove(20)
#清除集合中所有元素
s.clear()
#遍历集合元素
for i in s:
print(i)
#使用ennumerate()函数遍历
for index,value in ennumerate(s,1): #index是序号，不是索引
print(index,value)
#集合生成式
s={i for i in range(1,10)}
m={i for i in range(1,10) if i%2==0}
(六)组合数据类型的总结
