目录
序列
序列是一种数据存储方式,用来存储一系列的数据。在内存中,序列就是一块用来存放多个值的连续的内存空间。
由于 Python3 中一切皆对象,在内存中实际是按照如下方式存储的:
a = [10,20,30,40]
从图示中,我们可以看出序列中存储的是整数对象的地址,而不是整数对象的值。python
中常用的序列结构有:
字符串、列表、元组、字典、集合
列表 list
列表:用于存储任意数目、任意类型的数据集合。
列表是内置可变序列,是包含多个元素的有序连续的内存空间。列表定义的标准语法格式:
a = [10,20,30,40]
其中,10,20,30,40 这些称为:列表 a 的元素。
列表对象的常用方法汇总如下:
方法 | 要点 | 描述 |
list.append(x) | 增加元素 | 将元素 x 增加到列表 list 尾部 |
list.extend(aList) | 增加元素 | 将列表 alist 所有元素加到列表 list 尾部 |
list.insert(index,x) | 增加元素 | 在列表 list 指定位置 index 处插入元素 x |
list.remove(x) | 删除元素 | 在列表 list 中删除首次出现的指定元素 x |
list.pop([index]) | 删除元素 | 删除并返回列表 list 指定位置 index 处的元素,默认是最后一个元素 |
list.clear() | 删除所有元素 | 删除列表所有元素,并不是删除列表对象 |
list.index(x) | 访问元素 | 返回第一个 x 的索引位置,若不存在 x 元素抛出异常 |
list.count(x) | 计数 | 返回指定元素 x 在列表 list 中出现的次数 |
len(list) | 列表长度 | 返回列表中包含元素的个数 |
list.reverse() | 翻转列表 | 所有元素原地翻转 |
list.sort() | 排序 | 所有元素原地排序 |
list.copy() | 浅拷贝 | 返回列表对象的浅拷贝 |
列表的创建
常见的有3种基本形式
方法1:用[]创建
>>> a = []
#创建一个空的列表对象
方法2:list()创建
使用 list()可以将任何可迭代的数据转化成列表。
>>> a=list('hello') #将字符串‘hello'转换成列表中的一个个元素
>>> a
['h', 'e', 'l', 'l', 'o']
方法3:range()创建整数列表
range()可以帮助我们非常方便的创建整数列表,这在开发中及其有用。语法格式为:
range([start,] end [,step])
start 参数:可选,表示起始数字。默认是 0
end 参数:必选,表示结尾数字。
step 参数:可选,表示步长,默认为 1
python3 中 range()返回的是一个 range 对象,而不是列表。我们需要通过 list()方法将其转换成列表对象。
>>> list(range(15,3,-1))
[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]
列表的常见操作
增加元素
append()方法
extend()方法
+运算符操作
乘法扩展
insert()插入元素
属于原地操作,在列表尾部添加新元素,,推荐使用
属于原列表操作,但是会涉及到指定位置后面的元素移位
会生成新列表对象,对于操作大量的元素不建议使用
删除元素
del 删除
pop()方法
remove()方法
属于原列表操作,但是会涉及到指定位置后面的元素移位
元素访问
1.通过索引直接访问元素
2.index()获得指定元素在列表中首次出现的索引
元素计数
count()获得指定元素在列表中出现的次数
len()返回列表长度
成员资格判断 关键字in
返回True 表示存在
返回False 表示不存在
切片slice操作 与字符串操作一致
列表排序
修改原列表的排序
- list.sort() #默认升序排列
- list.sort(reverse=True) #降序排列
- import random random.shuffle(list) #打乱顺序
建新列表的排序
b = sorted(a) #默认升序
c = sorted(a,reverse=True) #降序
注: b和c都是新生成的列表对象和对象a的地址不一样
逆序排列
reverse()方法 在原列表上逆序排列,不产生新的列表对象
内置函数 reversed() 不对原列表做任何修改,只是返回一个逆序排列的迭代器对象。
其他函数汇总
max 返回列表中最大的元素值
min 返回列表中最小的元素值
sum 返回列表中所有元素的和
( 只能对数值型列表的所有元素进行求和操作,对非数值型列表运算则会报错。
与字符串的操作方法一样)
元组 tuple
列表属于可变序列,可以任意修改列表中的元素。元组属于不可变序列,不能修改元组中的元素。
因此,元组没有增加元素、修改元素、删除元素相关的方法。我们只需要学习元组的创建和删除,元组中元素的访问和计数即可。元组支持如下操作:
1. 索引访问
2. 切片操作
3. 连接操作
4. 成员关系操作
5. 比较运算操作
6. 计数:元组长度 len()、最大值 max()、最小值 min()、求和 sum()等。
元组的创建
1. 通过()创建元组。小括号可以省略。
a = (10,20,30) 或者 a = 10,20,30
如果元组只有一个元素,则必须后面加逗号。这是因为解释器会把(1)解释为整数 1, 而(1,)才解释为元组。
2. 通过 tuple()创建元组
b = tuple() #创建一个空元组对象
总结:
tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。
元组的元素访问和计数
元组的元素访问和列表一样,只不过返回的仍然是元组对象。元组的元素是不能修改的
列表关于排序的方法 list.sort()是修改原列表对象,元组没有该方法。如果要对元组排序,只能使用内置函数 sorted(tupleObj),且生成的是新列表对象。
>>> a=(20,10,30,9)
>>> b=sorted(a)
>>> b
[9, 10, 20, 30] #生成的是列表
>>> id(a)
1896461167168
>>> id(b)
1896461757376
zip
zip(列表 1,列表 2,...)将多个列表对应位置的元素组合成为元组,并返回这个 zip 对象。
元组总结
- 元组的核心特点是:不可变序列。
- 元组的访问和处理速度比列表快。
- 与整数和字符串一样,元组可以作为字典的键,列表则永远不能作为字典的键使用。
字典
字典是“键值对”的无序可变序列,字典中的每个元素都是一个“键值对”,包含:“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值对象”。“键”是任意的不可变数据,比如:整数、浮点数、字符串、元组。但是:列表、字典、集合这些可变对象,不能作为“键”。并且“键”不可重复。
“值”可以是任意的数据,并且可重复。
字典的定义方式:
a = {'name':'gaoqi','age':18,'job':'programmer'}
字典的创建
1. 我们可以通过{}、dict()来创建字典对象。
a={'name':'gaoqi','age':18,'job':'programmer'}
b=dict(name='gaoqi',age=18,job='programmer')
c=dict([('name','gaoqi'),('age',18),('job','programmer')]) #将列表转换成字典
2. 通过 zip()创建字典对象
k = ['name','age','job']
v = ['gaoqi',18,'techer']
d = dict(zip(k,v))
3. 通过 fromkeys 创建值为空的字典
>>> a = dict.fromkeys(['name','age','job'])
>>> a
{'name': None, 'age': None, 'job': None}
字典元素的常用操作
序列解包
序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。
序列解包用于字典时,默认是对“键”进行操作; 如果需要对键值对操作,则需要使用dict.items();
如果需要对“值”进行操作,则需要使用 dict.values();如下所示
>>> s = {'name':'gaoqi','age':18,'job':'teacher'}
>>> name,age,job=s #默认对键进行操作
>>> name
'name'
>>> name,age,job=s.items() #对键值对进行操作
>>> name
('name', 'gaoqi')
>>> name,age,job=s.values() #对值进行操作
>>> name
'gaoqi'
实战1:表格数据使用字典和列表存储,并实现访问
r1={'name':'高小一','age':18,'salary':30000,'city':'北京'}
r2={'name':'高小二','age':19,'salary':20000,'city':'上海'}
r3={'name':'高小五','age':20,'salary':10000,'city':'深圳'}
tb=[r1,r2,r3]
#获取第二行的人薪资
print(tb[1].get('salary'))
#打印表中所有人的薪资
for i in range(len(tb)):
print(tb[i].get('salary'))
#打印表格中所有的数据
#方法1:
for i in range(len(tb)):
print(tb[i].items())
#方法2:
for i in range(len(tb)):
print(tb[i].get('name'),tb[i].get('age'),tb[i].get('salary'),tb[i].get('city'))
#方法3:
for i in range(len(tb)):
name,age,salary,city=tb[i].values() #通过序列解包的方法获取字典中所有的值
print(name,age,salary,city)
字典核心底层原理
字典对象的核心是散列表。散列表是一个稀疏数组(总是有空白元素的数组),数组的每个单元叫做 bucket。每个 bucket 有两部分:一个是键对象的引用,一个是值对象的引用。由于,所有 bucket 结构和大小一致,我们可以通过偏移量来读取指定 bucket。
将一个键值对放进字典的底层过程
假设字典 a 对象创建完后,数组长度为 8:
>>> a = {}
>>>a["name"]="gaoqi"
我们要把”name”=”gaoqi”这个键值对放到字典对象 a 中,首先第一步需要计算键”name”的散列值。Python 中可以通过 hash()来计算。
>>> bin(hash("name"))
'-0b1010111101001110110101100100101'
由于数组长度为 8,我们可以拿计算出的散列值的最右边 3 位数字作为偏移量,即“101”,十进制是数字 5。我们查看偏移量 5,对应的 bucket 是否为空。如果为空,则将键值对放进去。如果不为空,则依次取右边 3 位作为偏移量,即“100”,十进制是数字4。再查看偏移量为 4 的 bucket 是否为空。直到找到为空的 bucket 将键值对放进去。
扩容
python 会根据散列表的拥挤程度扩容。“扩容”指的是:创造更大的数组,将原有内容
拷贝到新数组中。
接近 2/3 时,数组就会扩容。
集合
集合是无序可变,元素不能重复。实际上,集合底层是字典实现,集合的所有元素都是字典中的“键对象”,因此是不能重复的且唯一的。
集合的常用操作