序列类型
列表:list
列表的特点:
- 用方括号[]括起来
- 内容的元素用逗号”,”间隔开
- 各元素可以是各种数据类型:字符型,整数型,浮点型,列表,字典,均可
- 列表内元素的下标是0
列表的运用
列表元素的索引:取列表中的元素
a=[1,2,'adggd',3,['x','y','z'],4,5] #此为初始化列表
print(a)
[1,2,'adggd',3,['x','y','z'],4,5]
print(a[2])
adggd
print(a[4][1]) #要取列表中第几个元素,就在列表名后用方括号里面输入第几(注意:下标是0开始)
y
列表元素的编辑
- 列表元素的添加:在最后添加一个元素,用: 列表名.append(新元素)---对比:字符串无append这个添加功能
a=[1,2,3,4,5,6]
a.append("ok")
print(a)
[1,2,3,4,5,6,"ok"]
- 列表元素的插入:在列表元素中间或最前面插入一个新元素,用: 列表名.insert(插入位置,新插入的元素)
a=[1,2,3,4,5,6]
a.insert(4,100) #在列表的第四个元素位置插入整数100
print(a)
[1,2,3,4,100,5,6]
a.insert(0,999) #再在列表的第0个元素位置(即最前面 )插入整数999
print(a)
[999,1,2,3,4,100,5,6]
- 列表元素的修改:用赋值的方式,将第几个元素修改
a=[1,2,3,4,5,6]
a[2]=688 #将第3个元素即整数'3'修改为整数'688'
print(a)
[1,2,688,4,5,6]
- 列表元素的删除:列表名.pop(元素位置)
删除最后一位元素:列表名.pop(),里面为空
a=[1,2,3,4,5,6]
a.pop() #将最后那个元素删除
print(a)
[]1,2,3,4,5]
删除第N位元素:列表名.pop(N)
a=[1,2,3,4,5,6]
a.pop(3) #将第4元素删除
print(a)
=[1,2,3,5,6]
列表地址的传引用,相当于"传址"
首先,对比一下变量之间传值的区别:把变量a的值传给变量b,变量b的值变了,变量a的值不会改变,这叫"传值"
a=123
b=a
b=456
print(b)
456
print(a)
123
其次,看一下列表之间传引用的区别:把列表a的传引用地址传给变量b,变量b的值变了,变量a的也会发生改变,这叫"传引用"
a=[1,2,3,4,5,6]
b=a
b[2]=99
print(b)
[1,2,99,4,5,6]
print(a)
[1,2,99,4,5,6]
最后,看一下列表之间想达到传值的效果:把列表a的值传给列表b,列表b的值变了,列表a的值不会改变,采取方法,传的列表后面加上[:],相当于用[:]就是把a列表的值复制了,并传给列表b
a=[1,2,3,4,5,6]
b=a[:]
b[2]=99
print(b)
[1,2,99,4,5,6]
print(a)
[1,2,3,4,5,6]
列表的切片处理:
方括号里用冒号[:],前面跟不同的整数
切片的特点:前闭后开,即前面包括,后面不包括
列表的切片
- 切取第N个(包括第N个)元素到最后一个元素,方法:[N:]**
a=[1,2,3,4,5,6,7]
b=a[2:]
print(a)
[1,2,3,4,5,6,7]
print(b)
[3,4,5,6,7]
- 切取最前面的元素到第N个前面(不包括第N个)那个元素,方法:[:N]**
a=[1,2,3,4,5,6,7]
b=a[:2]
print(a)
[1,2,3,4,5,6,7]
print(b)
[1,2]
- 切取第N个(包括第N个)到第M个(不包括第M个)之间的元素,方法:[N:M]**
a=[1,2,3,4,5,6,7]
b=a[2:5]
print(a)
[1,2,3,4,5,6,7]
print(b)
[3,4,5]
- 切取倒数第N个元素,方法:[-N]**
a=[1,2,3,4,5,6,7]
b=a[-1]
print(b)
7
c=a[-2]
print(c)
6
- 切取第N个(包括N)到倒数第M个(不包括M)元素,方法:[N,-M]**
a=[1,2,3,4,5,6,7]
b=a[2:-2]
print(b)
[3,4,5]
- 步进式跳着切取元素,在切片后面用冒号
:,紧跟步进数值,方法:[M:N:K],K为步长**
a=[1,2,3,4,5,6,7]
print(a[2:6:2]) #从第三个元素3(含)切片到第七个元素7(不含),步长为2,即隔一个元素切取
[3,5]
b=a[:] #结果还是为:[1,2,3,4,5,6,7],相当于复制,未切片,见前面"**列表传址引用**"
[1,2,3,4,5,6,7]
b=a[::] #结果还是为:[1,2,3,4,5,6,7],相当于复制,未切片
[1,2,3,4,5,6,7]
b=a[::1] #步长为1,结果还是为:[1,2,3,4,5,6,7],相当于复制,未切片
[1,2,3,4,5,6,7]
c=a[::2] #结果为:[1,3,5,7],全部切片,步长值为2,即隔一个元素切片
[1,3,5,7]
d=a[::3] #结果为:[1,4,7]
[1,4,7]
- 元素倒序排列,方法:[::-N]**
a=[1,2,3,4,5,6,7]
b=a[::-1] #结果为:
[7, 6, 5, 4, 3, 2, 1]
c=a[::-2] #结果为:
[7, 5, 3, 1]
d=a[::-3] #结果为:
[7, 4, 1]
字符串:string
字符串的特点:
列表的特点及与列表相比的区别:
- 用单引号''或双引号""引起来---而列表是用方括号[]括起来
- 内容的元素不用需用逗号间隔开---而列表必须用逗号","间隔开
- 各元素是字符型---而列表的元素可以是各种数据类型:字符型,整数型,浮点型,列表,字典均可
- 字符串内元素的下标是0---列表也一样
- 切片特点:前闭后开(即前面包括后面不包括)
- 字符串不能直接添加(追加)\插入\修改\删除字符,其他切片功能与列表相似
字符串的运用
字符串与列表相同之处:切片完全一样
a='abcdefg'
b=a[2] #结果为: c
c=a[2:] #结果为: cdefg
d=a[:2] #结果为: ab
e=a[2:5] #结果为: cde
f=a[2:-3] #结果为: cd
g=a[::1] #结果为: abcdefg,相当于复制,未切片
h=a[::-1] #结果为:gfedcba,全部倒序排列
i=a[::-2] #结果为:geca,倒序跳着间隔一个,即间隔(含)两个切取
字符串与列表不一样的地方:无如下编辑功能
j=a.append() #字符串跟列表不一样,无append这个添加元素功能
k=a.insert(1,'x') #字符串跟列表不一样,无insert这个插入元素功能
l=a.pop(0) #字符串跟列表不一样,无pop这个删除元素功能
a[1]='x' #字符串跟列表不一样,无修改元素的功能
元组:touple
元组用()表示,里面的元素用,隔开
元组的特点：
- 元组元素的索引、切片方法跟列表一样如:
a=(1,2,3,4,5) #初始化元组
b=a[2]
print(b) #结果为：
3
a=(1,2,3,4,5) #初始化元组
b=a[2:4]
print(b) #结果为：
(3,4)
- 元组内元素不能直接用append,insert,赋值等方式修改
元组内元素若要修改，需要先转成列表（list），修改后再从列表转为元组(tuple)
a=(1,2,3,4,5,6)
b=list(a) #元组转换为了列表b：[1, 2, 3, 4, 5, 6]
print(b)
[1, 2, 3, 4, 5, 6]
b[2]=99 #用赋值的方式，将列表b第二个元素3修改为99
c=tuple(b) #又将列表b转换在元组c:(1, 2, 99, 4, 5, 6)
print(c)
(1, 2, 99, 4, 5, 6)
元组内的元素若是列表,则可以对里面的列表元素内的列表元素进行修改:
a=(1,2,3,4,[“X”,”y”,”z”],6)
a[4][1]=”此处修改了”
print(a)
(1,2,3,4,[“X”,” 此处修改了”,”z”],6)
#说明,这里并不是元组的元素被修改了,而是对应元素的列表引用里面的元素被修改了
- 元组的初始化:
A=() #初始化一个空元组
B=(“hello”,) #初始化只有一个元素的元组
'''注意一定加逗号`,`若不加逗号`,`,圆括号里面的数据是什么类型,那么初始化的B就是什么类型,而不是元组;
比如B=(“hello”)就是字符型,B=(4)就是整数int型''',而不是元组
映射类型
字典:dict
字典的特点:
- 字典
dict,全称dictionary，在其他语言中也称为map，使用键:值（key:value）存储，具有极快的查找速度。 - 书写方式用花括号括起来，都是成对出现，前者为key(键值)，后者为value(值)
- 字典内的各组key和value无序
a={'a':'xyz','b':123,'c':23.15}
print(a) #打印出来实际为如下等多种顺序
{'c': 23.15, 'a': 'xyz', 'b': 123}
字典value读取的方式：
- 方式一：
key方式:
若读取没有的key,则程序将报错
a={'a':'xyz','b':123,'c':23.15}
print(a['a']) #结果为：
xyz
print(a['e']) #读取没有的key:'e'时，程序会报错：
KeyError: 'e'
- 方式二：
get方式:
若读取没有的key，则程序不会报错，而是打印结果：None,或自定义提示信息
a={'a':'xyz','b':123,'c':23.15}
print(a.get('b')) #结果为：
123
print(a.get('e')) #打印结果：
None
print(a.get('e','没有找到!')) #打印结果：
没有找到!
字典的items()方法:
a={'a':'xyz','b':123,'c':23.15}
k=a.items()
print(k) #结果为:
dict_items([('b', 123), ('a', 'xyz'), ('c', 23.15)]) #注意:此处顺序会变,因为字典的无序性,下面结果也会变
print(list(k)) #结果为元素是元组的列表或别的顺序列表:
[('c', 23.15), ('b', 123), ('a', 'xyz')]
print(list(k)[1]) #结果为上面列表的第一个元素的元组或别的顺序元组
('a', 'xyz')
print(list(k)[1][1]) #结果为上面元组的第一个元素 或别的
xyz
in判断键值key是否在字典中:
in方式,可判断相应的键值key是否在此字典之中,若在则返回True,若不在则返回False
a={'a':'xyz','b':123,'c':23.15}
'b' in a
True
'd' in a
False
字典元素的增减
- 字典元素的添加:是以新赋值的方式实现
a={'x':'how','y':'are'}
a['z']='you ?' #给新KEY赋值的方式添加字典元素
print(a)
{'z':'you ?','x':'how','y':'are'} #字典是无序的,随时打印出来的位置会变
- 字典元素的删除
用pop()方法删除相应的key,其value也一块删除
a={'x':123,'y':456,'z':'wow'}
a.pop('z')
print(a) #结果为:
{'x': 123, 'y': 456}
由元组构成的列表,可以转成字典
a=[('b', 123), ('a', 'xyz'), ('c', 23.15)]
b=dict(a)
print(b) #结果为: ,顺序会变
{'a': 'xyz', 'b': 123, 'c': 23.15}
print(b['b']) #结果为:123 ,取出key'b'对应的value
123
字典和列表比较，各自的特点：
字典的特点:
- 查找和插入的速度极快，不会随着key的增加而变慢；
- 需要占用大量的内存，内存浪费多。
列表list的特点:
- 查找和插入的时间随着元素的增加而增加；
- 占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法。
集合类型
集合:set
集合的特点:
- 用花括号,元素间用逗号隔开
- 转换成集合用:set
- 集合
set和字典dict类似，也是一组key的集合，不同的是集合不存储value。由于key不能重复，所以，在集合set中，没有重复的key。 - 因为由于
key不能重复,集合元素的唯一性,所以集合元素不能是可变对象如列表,即列表不能作为集合元素,否则会报错.试试看:
a={1,2[3,4]}
#TypeError:unhashable Typle:'list' #错误的类型:列表
- 集合的无序性:集合里面的元素是无序性的,不能直接索引,如:a={1,2,3,4,5},无法通过a[2]的方式索引到里面的元素”3”
- 集合的单一性:集合里的元素均是唯一的,不会重复,用此功能,可以将列表转换为集合去重,再转换为列表使用的功能
a=[1,2,2,2,3,4,5,6] #先初始化一个列表a
b=set(a) #将列表a转换为集合b,同时去重
print(b) #打印结果为:
{1, 2, 3, 4, 5, 6}
a=list(b) #将集合b转换为列表a:[1, 2, 3, 4, 5, 6],已将重复的"2"去掉
print(a)
[1, 2, 3, 4, 5, 6]
集合的三种操作
- 集合的交集,即求同:
a=[1,2,2,2,3,4,5,6,7] #初始化列表a
b=[1,2,3,4,5,6,7,8,9] #初始化列表b
c=set(a)&set(b) #列表a及列表b转换成集合,求交集
print(c) #结果为:
{1, 2, 3, 4, 5, 6, 7}
- 集合的并集,即合并,把所有相同及不同的元素合并在一起,接上示例:
d=set(a)|set(b)
print(d) #结果为:
{1, 2, 3, 4, 5, 6, 7, 8, 9}
- 集合的求异:
e=set(b)-set(a)
print(e) #结果为:{8, 9},即把b列表在a列表中没有的元素找出来
集合的编辑
- 通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：
s = set([1, 1, 2, 2, 3, 3])
s
{1, 2, 3} #有重复元素的列表,转换为集合后去重
s.add(4) #添加一个元素`4`
s
{1, 2, 3, 4}
s.add(4) #重复添加'4'，但不会有效果
s
{1, 2, 3, 4}
- 通过remove(key)方法可以删除集合的指定元素：接上示例:
s.remove(4) #把元素'4'删除
s
{1, 2, 3}
组合数据类型之间的转换
列表与字符串的转换
列表转为字符串：
- 处理方法： 拼接符.join(列表名)
- 注意：元素为数值等类型如[1,2,3]这类列表，不能直接拼接
- 示例：
a=['x','y','z']
b=''.join(a) #结果是：
'xyz'
c='*'.join(a) #结果是：
'x*y*z'
print(b)
print(c)
字符串转为列表
- 条件：字符串内，字符之间要有明显的分隔符
- 处理方法：字符串名.split('分隔符')
- 示例：
a='Q_W_E_R_T'
b=a.split('_')
print(b) #结果为：
['Q', 'W', 'E', 'R', 'T']
由成对元素组成的元组所构成的列表,可以转成字典
a=[('b', 123), ('a', 'xyz'), ('c', 23.15)]
b=dict(a)
print(b) #结果为: ,顺序会变
{'a': 'xyz', 'b': 123, 'c': 23.15}
print(b['a']) #结果为:123 ,取出`key':`b'对应的value
xyz
列表list、元组tuple、集合set之间相互转换
a=[1,2,3]
b=(4,5,6)
c={7,8,9}
元组、集合转换成列表list
list(b)
[4,5,6]
list(c)
[7,8,9]
列表、集合转换成元组tuple
tuple(a)
(1,2,3)
tuple(c)
(8,9,7) #因为`c`为集合,是无序组合,位置随时会变,转换时位置不固定
列表、元组转换成集合set
set(a)
{1,2,3}
set(b)
(4,5,6)
神奇的加号"+",即并集
- 列表+列表=列表
a=[1,2,3]
b=[4,5,6]
c=a+b
print(c) #结果为:
[1, 2, 3, 4, 5, 6]
- 字符串+字符串=字符串
a='abc'
b='xyz'
c=a+b
print(c) #结果为:
abcxyz
- 元组+元组=元组
a=('a','b','c')
b=(1,2,3)
c=a+b
print(c) #结果为:('a', 'b', 'c', 1, 2, 3)
- 注意:
--集合是不能加(+)的,因为两个集合里若有同一元素,根据集合的唯一性,会报错
--字典也不能加(+),因为为两个字典若有相同关键字(key),根据字典key的唯一性,也会报错