python组合数据类型总结_Python学习笔记(4):常用的组合数据类型

序列类型

列表: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的唯一性,也会报错