序列类型

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