2020-10-09 DAY 4 序列

目录

 

序列

列表 list

列表的创建

列表的常见操作

元组 tuple

元组的创建

元组的元素访问和计数

字典

字典的创建

字典元素的常用操作

​

序列解包

字典核心底层原理

集合

---

序列

序列是一种数据存储方式,用来存储一系列的数据。在内存中,序列就是一块用来存放多个值的连续的内存空间。

由于 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 对象。

元组总结

1. 元组的核心特点是:不可变序列。
2. 元组的访问和处理速度比列表快。
3. 与整数和字符串一样,元组可以作为字典的键,列表则永远不能作为字典的键使用。
    

字典

字典是“键值对”的无序可变序列,字典中的每个元素都是一个“键值对”,包含:“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值对象”。“键”是任意的不可变数据,比如:整数、浮点数、字符串、元组。但是:列表、字典、集合这些可变对象,不能作为“键”。并且“键”不可重复。
“值”可以是任意的数据,并且可重复。
字典的定义方式:
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 时,数组就会扩容。

集合

集合是无序可变,元素不能重复。实际上,集合底层是字典实现,集合的所有元素都是字典中的“键对象”,因此是不能重复的且唯一的。
集合的常用操作