二、Python之高级数据结构

序言

有一个著名的等式“程序=算法+数据结构”，在任何一门编程语言中数据结构的重要性可见一斑。Python高级数据结构主要有：

• 列表
• 元组
• 字符串
• 字典
• 集合
  本篇将从创建、访问、应用等方面分别对以上各个类型的数据结构进行详细阐述。

列表 list

1. 创建

# 两个中括号括起来，内部各个元素用','分隔开
number=[1,2,3,4,5,6]
name=['zhangsan','lisi','wangwu']
mixture=[520,'Fish',[1,2,3,4,5,6]]
empty=[] #创建空列表
empty=list() #创建空列表

2. 追加元素

>>number=[1,2,3,4,5,6]

>>number.append(7) #一次追加一个元素在列表尾部
>>number
1,2,3,4,5,6,7

>>number.extend([7,8,9]) #将另一个列表接在number尾部
>>number
1,2,3,4,5,6,7,8,9

>>number.insert(5,5.5) #number.insert(Index,Value),使Value插在新列表的Index处
>>number
1,2,3,4,5,5.5,6

3. 访问元素
   Python的列表与C中数组非常相似，可以通过偏移访问符'[*]'进行访问

>>number=[1,2,3,4,5,6]
>>number[1] #获取
2
>>number[-1] #获取，最后一个元素索引值为-1，倒数第二位-2，以此类推
6

>>number[1]='Fish' #修改
>>number
[1,'Fish',3,4,5,6]

>>_2D_array=[1,2,3,[5,6,7]]
>>_2D_array[3,2] #双层索引
7

4. 列表切片 slice
   所谓列表切片就是将列表元素成段的取出，从原列表中返回一个新的列表。虽然可以通过循环将列表多个元素一一取出，但是过于繁琐，不符合Python的身份（这就是开源的力量吧）。(Python的切片有点类似MATLAB)

>>num=[0,1,2,3,4,5,6]
>>slip1=num[1:4]
[1,2,3] # 注意列表切片不含最后一个元素
>>slip2=num[4:]
[4,5,6]
>>slip3=num[:4]
[0,1,2,3]
>>slip3=num[:]
[0,1,2,3,4,5,6]
>>slip4=num[4:-1]
[4,5,6]
>>slip4=num[::-1] # 切片其实有第三分参数—————步长
[6,5,4,3,2,1,0]

5. 从列表中删除元素
   Python中删除元素有三种方法可以实现，remove(),pop(),del

>>mixture=[1,2,3,'zhangsan',['daju','wangcai']]
>>mixture.remove('zhangsan') 
#使用remove()删除元素不需要知道该元素在列表中的具体位置,如果列表中不存在该元素，程序就会报错。
[1,2,3,['daju','wangcai']]

>>mixture.pop(4)
>>mixture
[1,2,3,'zhangsan']

del mixture #删除整个列表变量

6. 列表常用的操作符与方法（方法与BIF的区别后续讲解）

# 比较运算符 > >= < <= ==
>>list1=[123,245,'wangcai','daju']
>>list2=['a','wangwang','miaomiao']
>>list1<list2
False  #列表比较时从第一个元素依次向后比较，有一个决胜负了就结束了

# 连接符 '+'，重复符'*'
>>list1+list2
[123,245,'wangcai','daju','a','wangwang','miaomiao']
>>list1*3 
[123,245,'wangcai','daju',123,245,'wangcai','daju',123,245,'wangcai','daju']

# in 和 not in 用以判断列表是否存在某个元素
>>123 in list1
True

# in 配合 not in 不重复地将旧列表中元素“复制”到新列表中
>> for each in old_list
      if each not in new_list
          new_list.append(each)

# count() 统计元素的方法
>>list1=[123,245,'daju','wangcai','daju']
>>list1.count('daju')
2

# index() 返回元素首发地址方法
>>list1=[123,245,'daju','wangcai','daju']
>>list1.index('daju')
2
>>list1.index('daju',star_position,end_position) # index()还可以限定搜索范围

# reverse() 返回列表翻转方法
>>list1=[123,245,'daju','wangcai','daju']
>>list1.reverse()
['daju','wangcai','daju',245,123]

# sort() 列表元素排列方法
>>list1=[1,3,5,2,4,6,8,7,0,9]
>>list1.sort()
[0,1,2,3,4,5,6,7,8,9] # sort(func,key,reverse=False),默认从小到大排列

元组 tuple

如果说列表是打了激素的数组，那么元组就是带了枷锁的数组。元组只可读而不能写，也就是说只能读取元组中的元素，而不能添加、删除、修改其中的元素。

1. 创建元组

>>tuple1=(1,2,3,4,5) #创建列表用[],创建元组用()
>>tuple1
(1,2,3,4,5)

2. 访问元组，用'[*]'

>>tuple1=(1,2,3,4,5) 
>>tuple1[4] #单个访问
5
>>tuple1[:3] #切片
1,2,3

3.更新和删除元组

# 元组的元素不可以修改但我们可以用同名元组去更新它

4. 一点提醒:逗号是元组的标志

>>3*(3)
9
>>3*(3,)
(9,9,9)

字符串————特殊的元组

字符同样不能修改只能更新！

# 字符串的创建既可以'*'，也可以"*"
string="He could remember every things in great detail!"

# 字符串索引
>>name='Daju'
>>name[2]
'j'

# 字符串的切片
>>string[-7:]
'detail!'

# 字符串方法
string.count(sub,start=0,end=-1) # 返回sub在字符串里出现的次数
string.find(sub,start=0,end=-1)  # 返回sub在string出现的第一个索引值，若没有则返回-1
string.strip() # 删除字符串前后的所有空白字符
string.replace(old,new,max_count=-1) # 把old用new替换掉，-1次（不限次）
string.slit(sep=None,max_count=-1) # 用sep（默认为空白字符）将原字符串分割，返回分割后的列表
# format()方法接收位置参数和关键字参数，两者均传递到一个名为replacement的字段，而replacement字段在字符串内是用{}表示的。
'{0} love {1}.{2}'.format('I','Fishc','com') # 位置参数
'{a} love {b}.{c}'.format(a='I',b='Fishc',c='com') # 关键字参数
'{0}:{1:.2f}'.format('圆周率',3.1415926) # ':'后是格式控制域

# 格式化操作符 %
>>'%c%c%c%c' %(70,105,115,104,67)
'FishC'
# 常用格式化辅助操作符
m.n # m是最小总宽度，n是小数点后的位数
-   # 结果左对齐
+   # 在显示正数前面显示 + 号
#   # 在八进制前显示'0o',十六进制前显示'0x'

列表、元组与字符串小结————序列

列表、元组和字符串统称为：序列，都可以通过索引得到每一个元素，都可以切片，有很多共用操作符和方法。除此以外，序列还有很多BIF。

>>a=list() #list()的参数可以是空或者是序列，tuple()相同
>>a
[]

str() #将一个序列转换为字符串
len() #返回一个序列的长度
max() #返回一个序列的最大值，min()
sum() #序列求和
sorted() #排序，list.sort()返回的是原列表，sorted(list)返回的是一个新列表

字典 dict

所谓字典就,是映射类型数据，map类型数据。

1. 创建字典

# {}创建字典，:连接键和值， ,分割项
dict1={"老子":"道可道，非常道","孔子":"君子务本，本立而道生","孙子":"知己知彼，百战不殆"}
dict2={} #创建一个空字典
dict3=dict(F=70,i=105,s=115,h=104,C=67) #用具有映射关系的数据创建字典，注意此法中键的位置不能加表示字符串的引号！！！
dict4=dict(  [ (F,70),(i,105),(s,115),(h,104),(C,67) ]    )

2. 访问字典

#把键放在方括号里，即可访问键所对应的值
>>dict1={"老子":"道可道，非常道","孔子":"君子务本，本立而道生","孙子":"知己知彼，百战不殆"}
>>dict1["孔子"]
"君子务本，本立而道生"
>>dict1["孟子"] #不存在的键索引后会报错
KeyError: "孟子"

>>dict1["孟子"]="鱼我所欲也" #若键已存在则修改键的值，若键不存在则添加该项

3. 字典的内置方法

.fromkeys() #用以创建并返回一个新字典
>>dict_obj.fromkeys( (1,2,3) )
{1:None,2:None,3:None}

>>dict_obj.fromkeys( (1,2,3),"Number" )
{1:'Number',2:'Number',3:'Number'}

>>dict_obj.fromkeys( (1,2,3),("one","two","three") )
{1:("one","two","three"),2:("one","two","three"),3:("one","two","three")}

dict_obj.keys() #返回字典中所有键
dict_obj.values() #返回字典中所有值
dict_obj.items() #返回字典中所有键值对（项）
dict_obj.get(key[,default]) #另外一种访问字典的方式，当键不存在时返回defualt

#如果需要确认一个键是否存在，可以用成员资格操作符 in 或 not in
>> 31 in direct1 #注意这里查找的是键而不是值，序列查找的是元素值而不是索引
True
>> 32 in direct1
False

dict_obj.clear() #清空字典
dict2=dict1.copy() #字典拷贝，注意区别于dict2=dict1,用 = 进行拷贝只是在原字典基础上重新贴了个标签

dict_obj.pop(key) #弹出值后，删除项
dict_obj.popitem(key) #弹出首项后，删除项

集合

1. 创建集合

set0={}
set1={0,1,2,3,4,5} # 大括号创建
set2=set([0,1,2,3,4,5]) # 工厂函数创建

2. 访问集合

# 注意集合不支持通过索引进行访问，只能用遍历进行访问
set1={1,2,3,4,5,4,2}
for each in set1:
  print(each)

3. 集合方法

>>set1={1,2,3,4,5,4,2}
>>set1.add(6) # 向集合中添加元素
>>set1.remove(5) # 移除集合中的元素

4. 元组集合

# 定义不可修改集合
>>set2=frozenset({1,2,3,4,5})
>>set2.add(6)
Error

5. 集合特质——元素互斥性

# 去除列表[1,2,3,4,5,6,6,4,2]中的重复元素

# 法一
list1=[1,2,3,4,5,6,6,4,2]
list2=[]
for each in list1:
  if each not in list2:
    list2.append(each) 
# 法二
list1=[1,2,3,4,5,6,6,4,2]
list1=list(set(list1))