Python数据结构精讲-优快云博客

文章目录

序列
字典
集合

序列

访问模式
- 元素从0开始通过下标偏移量访问
- 一次可访问一个或多个元素
下标
- 索引可以从0到n -1
- 索引也可以逆序从-1到-n

标准类型运算符

值比较 <>+!

>>> 'apple'<'banana'
True
>>> [1,2,5]!=[3,4,6]
True

对象身份比较 is is not

 aTuple=('BA','xxx','12.45')
>>> bTuple=aTuple
>>> aTuple=bTuple
>>> aTuple is not bTuple
False

布尔运算 not and or
```
>>> (12<16)and('apple'<'banana')
True
```

序列类型运算符

获取

>>> nums=[1,2,3,4,5,6,7]
>>> print(nums[1],nums[-2],'\n',nums[1:4],'\n',nums[:6],'\n',nums[::-1])
2 6 
 [2, 3, 4] 
 [1, 2, 3, 4, 5, 6] 
 [7, 6, 5, 4, 3, 2, 1]  #nums[::-1]原序列逆序
    
>>> astr='hello, world'
>>> bstr=astr[:7]+'python'
>>> bstr
'hello,python'

重复
```
>>> 'apple'*3
'appleappleapple'
```
连接
```
>>> 'pine'+'apple'
'pineapple'
```
判断
```
>>> 'ab' in ('aaa','ab','dasd')
True
```

内建函数

序列类型转换 list() str() tuple()

>>> list('hello,world')     #将字符串转换成列表
['h', 'e', 'l', 'l', 'o', ',', 'w', 'o', 'r', 'l', 'd']
>>> tuple('hello,world')    #将字符串转换成元组
('h', 'e', 'l', 'l', 'o', ',', 'w', 'o', 'r', 'l', 'd')
>>> str(nums)              #将元组或者列表转成字符串
'[1, 2, 3, 4, 5, 6, 7]'

序列类型可用 len() max() min() zip() sorted() reversed() sum()

>>> str='hello,world!'
>>> len(str)
12
>>> sorted(str)  #会新生成一个副本 原序列不变 当使用str.sort()则原序列排序被改变
['!', ',', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
>>> max(str)
'w'
>>> min(str)
'!'

字符串

对于要换行的字符串应该使用三引号
r可用于包含文件路径中方便
```
>>> s1=r'd:\c\e'
>>> s1
'd:\\c\\e'
```

格式化输出占位符形式

>>> age,height=21,1.758
>>> print('age:{0:<5d},height:{1:5.2f}'.format(age,height))
age:21   ,height: 1.76

使用dir(str)查看更多字符串包含的方法

列表 `list`

可变可扩展和字符串的不同所以它是最常用之一

可以包含不同类型的对象因为保存的是元素对象的指针也因此内存开销大

>>> alist=list('hello')
>>> alist
['h', 'e', 'l', 'l', 'o']
>>> alist[0]='H'
>>> alist
['H', 'e', 'l', 'l', 'o']
>>> blist=[1,2,'a',3.3]
>>> blist
[1, 2, 'a', 3.3]

>>> scores=[1,3,2,4,6,5,8,7,10,9]
>>> ascore=9
>>> scores.sort()
>>> scores.pop()
10
>>> scores.pop(0)
1
>>> scores.append(ascore)
>>> avescores=sum(scores)/len(scores)
>>> print(avescores)
5.888888888888889

>>> week=['mon','tues','wed','thu','fri']
>>> weekend=['sat','sun']
>>> week.extend(weekend)
>>> for i,j in enumerate(week):   #enumerate 可以把序号和元素同时读出
...     print(i+1,j)
... 
1 mon
2 tues
3 wed
4 thu
5 fri
6 sat
7 sun

列表解析

动态创建列表简单灵活有用

[exp for exp1 in seq1
     for exp2 in seq2...
	 if condition]

>>> listN=[x**2 for x in range(10) if x**2<80]
>>> listN
[0, 1, 4, 9, 16, 25, 36, 49, 64]
>>> listXY=[(x+1,y+1) for x in range(2) for y in range(2)]
>>> listXY
[(1, 1), (1, 2), (2, 1), (2, 2)]

生成器表达式

>>> n=sum(x for x in range(10))
>>> n
45

元组 `Tuple`

元素是不可变的不同于列表
序列的一般操作都有用圆括号
函数
1. 因为元组元素不可变所以要改变元素的方法元组不支持比如元组支持sorted(tuple)方法但是不支持tuple.sort()方法

作用场景

在映射类型中当作键使用

函数的特殊类型参数可变长位置参数

>>> def foo(arg1,*arg2):
...     print(arg1)
...     print(arg2)
... 
>>> foo('hello','wonderful','python')
hello
('wonderful', 'python')

作为函数的特殊返回值

>>> def foo():
...     return 1,2,3
... 
>>> foo()
(1, 2, 3)

字典

特性：
- 是python中唯一内建的映射类型即key-value类型
- 字典内部元素无序只和key 有关

创建字典

直接创建

ainfo={'A':90,'B':80,'C':70,'D':60}
>>> ainfo
{'A': 90, 'B': 80, 'C': 70, 'D': 60}

使用dict函数只要元素内部存在一一对应关系就可以转化

>>> info=[('A',90),('B',80),('C',70),('D',60)]  #元组
>>> binfo=dict(info)
>>> binfo
{'A': 90, 'B': 80, 'C': 70, 'D': 60}

>>> cinfo=dict([['a',90],['B',80],['C',70],['D',60]])  #列表 里面使用元组也可以
>>> dinfo=dict(A=90,B=80,C=70,D=60)

>>> cinfo
{'a': 90, 'B': 80, 'C': 70, 'D': 60}
>>> dinfo
{'A': 90, 'B': 80, 'C': 70, 'D': 60}

使用{}.fromkeys(序列，默认值) 创建字典时把默认值都统一

>>> edict={}.fromkeys(('A','B','C','D'),3000)
>>> edict
{'A': 3000, 'B': 3000, 'C': 3000, 'D': 3000}
>>> print(sorted(edict))
['A', 'B', 'C', 'D']

使用dict(zip(序列1，序列2)) 把两个序列对应元素组合成字典

>>> degrees=['A','B','C','D']
>>> scores=[90,80,70,60]
>>> dict(zip(degrees,scores))
{'A': 90, 'B': 80, 'C': 70, 'D': 60}

字典的基本操作

包括键值查找更新添加成员判断删除字典成员

>>> ainfo
{'A': 90, 'B': 80, 'C': 70, 'D': 60}
>>> ainfo['B'] #键值查找
80
>>> ainfo['C']=100   #更新元素
>>> ainfo
{'A': 90, 'B': 80, 'C': 100, 'D': 60}
>>> ainfo['x']=99         #添加元素
>>> ainfo
{'A': 90, 'B': 80, 'C': 100, 'D': 60, 'x': 99}
>>> 'x' in ainfo            #成员判断
True
>>> del ainfo['x']         #删除元素
>>> ainfo
{'A': 90, 'B': 80, 'C': 100, 'D': 60}

字典的内建函数
- hash（var）判断对象是否可哈希通过help了解更多

字典方法

获取键值对操作 keys() values() items()

>>> ainfo.keys()
dict_keys(['A', 'B', 'C', 'D'])
>>> ainfo.values()
dict_values([90, 80, 100, 60])
>>> ainfo.items()
dict_items([('A', 90), ('B', 80), ('C', 100), ('D', 60)])
>>> for k,v in ainfo.items():
...     print(k,v)
... 
A 90
B 80
C 100
D 60

更新字典 update(dictionary)

>>> binfo
{'A': 90, 'B': 80, 'C': 70, 'D': 60}
>>> binfo['A']=100
>>> binfo['x']=99
>>> binfo
{'A': 100, 'B': 80, 'C': 70, 'D': 60, 'x': 99}
>>> ainfo.update(binfo)
>>> ainfo
{'A': 100, 'B': 80, 'C': 70, 'D': 60, 'x': 99}

查找元素方法 get(key)

>>> ainfo.get('z')
>>> print(ainfo.get('z'))               #推荐使用这种方法
None
>>> print(ainfo['z'])            #这种方法有可能导致程序终止
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'z'

删除字典的方法确保释放了内存clear()

>>> qinfo=binfo
>>> qinfo
{'A': 100, 'B': 80, 'C': 70, 'D': 60, 'x': 99}
>>> binfo.clear()
>>> qinfo
{}

集合

每一个元素都是唯一即无序不重复的元素的组合

>>> names=['aa','bbb','aa','bbb',1,2,1,2]
>>> namesSet=set(names)
>>> namesSet
{1, 'aa', 2, 'bbb'}

类型
- 可变集合 set
- 不可变集合 frozenset

集合比较

元素与集合的属于关系 in not in == !=

集合之间的包含关系 < > <= >=

>>> set1=set('sunrise')
>>> set2=set('sunset')
>>> 'u' in set1
True
>>> set1=set2
>>> set1=set('sunrise')
>>> set1==set2
False
>>> set('sun')<set2
True

集合关系运算并交叉补& | - ^ 运算符可符合增强

>>> set1
{'i', 'r', 'e', 'u', 'n', 's'}
>>> set2
{'s', 'e', 'u', 'n', 't'}
>>> set1&set2
{'e', 'u', 'n', 's'}
>>> set1 | set2
{'i', 't', 'r', 'e', 'u', 'n', 's'}
>>> set1 - set2
{'i', 'r'}
>>> set1 ^ set2
{'r', 't', 'i'}
>>> set1-=set('sun')
>>> set1
{'i', 'r', 'e'}

集合内建函数

面向所有集合有判断是否是子集拷贝集合聚合等

面向可变集合可以对元素操作对集合操作

>>> set1=set('sunrise')
>>> set1.add('!')
>>> set1
{'i', 'r', 'e', 'u', '!', 'n', 's'}
>>> set1.remove('!')
>>> set1
{'i', 'r', 'e', 'u', 'n', 's'}
>>> set1.update('Yeah')
>>> set1
{'i', 'h', 'r', 'e', 'Y', 'u', 'a', 'n', 's'}
>>> set1.clear()
set()