目录

序列介绍

列表

 列表的创建

range()创建整数列表 

 推导式生成列表

列表对象常用方法汇总

列表元素的访问和计数

通过索引直接访问元素

成员资格判断

 切片操作

 列表遍历

 列表相关的其他内置函数汇总

多维列表 

二维列表

​编辑

元组tuple

元组的创建

1.通过()创建元组,小括号可以省略

​编辑

2.通过tuple()创建元组

元组的元素访问和计数

ZIP

   生成器推导式创建元组

 字典

字典的创建

 2.通过zip()创建字典对象 

 字典元素的访问

字典元素添加、修改删除

序列解包

表格数据使用字典和列表存储并实现访问 

字典核心底层原理非常重要

集合

集合的创建和删除

集合相关操作

总结列表、元组、字典、集合区别

---

序列介绍

        字符串、列表、元组、集合都是序列序列是什么呢序列是一种数据存储方式用来存储一系列的数据。在内存中序列就是一块用来存放多个值的连续的内存空间。比如说一个整数序列[10,20,30,40],可以这样表示

      如下图理解我们将 10、20、30、40每一个对象的地址分别存储到列表的内存最后将整个列表的地址赋给变量a。也就是我们先通过变量a找到列表的地址再通过索引找到列表元素的地址再通过列表元素的地址找到对象。

         在序列中存储的是对象的地址而不是对象的值上一篇博客我们着重对字符串进行介绍接下来我们将对列表、元组、集合进行介绍。 

列表

        列表可以用来存储任意数目、任意类型的数据集合列表是内置可变序列是包含多个元素的有序连续的内存空间。列表定义的标准语法格式如下

a = [10,20,30,40]

其中10,20,30,40这些称为列表a的元素。而列表中的元素不要求类型相同可以类型不同比如

a = [10,20,‘yyq’,True]

里边既可以有数字、也可以有字符串、还可以有布尔型。

 列表的创建

基本语法[]创建

list = [1,2,'3',True,2,3];
print(list)

 list()创建

        使用list()可以将任何迭代的数据转化成列表。

a = list()
print(a)
b = list(range(10))
print(b)
# 将字符串转化为列表
c = list('I Love you yyq')
print(c)

range()创建整数列表 

range()可以帮助我们非常方便的创建整数列表这在开发中非常重要语法格式如下

range([start,end,step])

start参数可选表示起始数字默认是0

end参数可选表示结尾数字

step参数可选表示步长默认是1.

在Python3中range返回的是一个range对象而不是列表我们需要通过list()方法将其转化成列表对象。

# range 产生的是整数
a = list(range(2,10,3))
print(a)
b = list(range(-8,20,2))
print(b)

 如果倒序怎么办我们将步长换成负数即可。

 推导式生成列表

        使用列表推导式可以非常方便的创建列表在开发中经常使用。他一般和控制语句结合使用。

a = [x*3 for x in range(8)]
print(a)
b = [x*3 for x in range(8) if x%2==0]
print(b)

列表对象常用方法汇总

列表对象常用方法汇总

序号	方法	要点	描述
1	list.append(x)	增加元素	将元素x增加到列表的尾部
2	list.extend(alist)	增加元素	将列表alist的所有元素增加到列表尾部
3	list.insert(index,x)	增加元素	在列表list,指定位置index插入元素x
4	list.remove(x)	删除元素	在列表list删除首次出现的指定元素x
5	list.pop([index])	删除元素	删除并返回列表list指定位置index处的元素默认是最后一个元素索引是从0开始的
6	list.clear()	删除所有元素	删除列表所有元素并不是列表对象,此时对象的地址还存在
7	list.index(x)	访问元素	返回第一个x索引位置若不存在x元素抛出异常
8	list.count(x)	计数	返回指定元素x在列表list出现的次数
9	len(list)	列表长度	返回列表中包含元素的个数
10	list.reverse()	翻转列表	所有元素原地翻转
11	list.sort	排序	所有元素原地排序
12	list.copy	浅拷贝	所有列表对象的浅拷贝

示例说明:

1.将元素插入列表尾部

        当列表增加和删除元素时列表会自动进行内存管理大大减少程序员的负担。但这个特点涉及列表元素的大量移动效率低下除非必要否则我们只在列表尾部进行添加元素或者删除元素这会大大提高列表的操作效率。而+运算符操作并不是真正尾部添加元素而是创建新的列表对象将原列表元素和新列表元素依次复制到新的列表中对于操作大量元素不建议使用。

k = [1,2,'3',True];
# 将'yyq'增加到列表的尾部
k.append('yyq')
c = k+['yyq']
print(k,c)
print(id(k),id(c))

 2.将列表alist的所有元素插入列表list之后在原地拼接不涉及新的对象的创建。

list = [1,2,'3',True];
alist = ['I','','','Love','','You','','yyq']
# 将列表alist 的所有元素插入到list 列表之后
list.extend(alist)
print(list)

3.将列表list指定位置插入元素

        使用insert()方法可以将指定的元素插入到列表对象的任意位置。这样会让插入位置后面所有的元素进行移动会影响处理速度。涉及大量元素时尽量避免使用类似发生这种移动函数的还有remove()、pop()、del(),他们在删除非尾部元素时也会发生操作位置后面元素的移动也涉及到数组的移动与拷贝。

list = [1,2,'3',True];
# 将列表list指定位置插入元素
list.insert(2,False)
print(list)

4.在列表list删除首次出现的指定元素x

list = [1,2,'3',True,2];
# 在列表list删除首次出现的指定元素x
list.remove(2)
print(list)

 5.删除并返回列表list指定位置index处的元素或者del list[2],默认是最后一个元素索引是从0开始的.看似是元素的删除实际里边涉及到数组的移动和拷贝。将字符’3’删除以后将索引3位置移动到索引2位置将索引4位置移动到索引3的位置。别的列表中间操作同理。

list = [1,2,'3',True,2];
# 删除并返回列表list指定位置index处的元素
list.pop(2)
print(list)

6.删除列表所有元素并不是列表对象,此时对象的地址还存在

list = [1,2,'3',True,2];
list.clear()
print(list)
print(id(list))

 

7.返回第一个x索引位置若不存在x元素抛出异常

list = [1,2,'3',True,2];
a = list.index(2)
print(a)

 

 8.返回指定元素x在列表list出现的次数

list = [1,2,'3',True,2];
a = list.count(2)
print(a)

9. 返回列表中包含元素的个数

list = [1,2,'3',True,2];
a = len(list)
print(a)

 

 10.所有元素原地翻转,也就是前后顺序颠倒

list = [1,2,'3',True,2];
list.reverse()
print(list)

 11.所有元素原地排序,必须都是数字不需要创建新列表排序列表中不能是字符串。

list = [1,2,5,6,100,0.1,6,2];
list.sort()
print(list)

注意如果是降序排序则为a.sort(reverse=True)我们也可以通过内置函数sorted进行排序这个方法是返回新的列表不对原列表做修改。

12. 所有列表对象的浅拷贝

list = [1,2,'3',True,2,3];
list.copy()
print(list)

13.列表的乘法扩展

        使用乘法扩展列表生成一个新列表时对原列表进行多次操作。

a = ['I',520]
b = a*3;
print(b)

        根据上述示例可知Python的列表大小可变根据实际需要可以调整列表的大小字符串和列表都是序列类型一个字符串是一个序列一个列表是任何元素的序列我上一篇博客https://blog.csdn.net/zywcxz/article/details/128317597详细介绍了字符串的应用详解在列表中的应用几乎一模一样有需要的小伙伴看一下。

列表元素的访问和计数

通过索引直接访问元素

        我们可以通过索引直接访问元素索引的区间是[0len(list)-1]这个范围超出这个范围将会抛出异常。

a = list(x for x in range(10) if x % 3 == 0)
b = len(a)
m = input('请输入整数类型')
if int(m) > (b-1):
    print('输出超出索引维度')
else:
    c = a[int(m)]
    print(a, b, c)

 

 

成员资格判断

        判断列表中是否存在指定元素我们可以用count()方法返回0则表示不存在返回大于0表示存在。但是一般我们会使用更加简洁的in关键字来判断。直接返回True和False。

a = list(x for x in range(10) if x % 3 == 0 ) 
20 in a

 切片操作

        切片是Python 序列及其重要的操作适用于列表元祖字符串等等,按照索引查找。切片格式如下

[起始偏移量start:终止偏移量步长step]

b = list(n for n in range(100) if n%30 ==0)
# 提取所有字符
c = b[::]
#从开始到结尾
d = b[2::]
#从开始到end-1
e = b[0:3:]
#从开始到结尾步长为2
f = b[0:3:2]
print(b)
print(c)
print(d)
print(e)
print(f)

        切片操作时起始偏移和终止偏移量不在[0字符串长度-1]这个范围也不会报错。其实偏移量小于0则会当做0终止偏移量大于len(list)-1则会被当成len(list)-1eg:

a = list(range(0,100,10))
print(a)
a[1:100]

 列表遍历

格式如下

for obj in list(Obj)

        print(obj)

eg:

g = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
for x in g:
    print(x)

 列表相关的其他内置函数汇总

1.max 和 min

用于返回列表中的最大值和最小值

a = list(x for x in range(100) if x % 10 == 0)
b = min(a)
c = max(a)
print(a,b,c)

 2.sum

对数值型列表的所有元素求和对非数值型列表会报错

a = list(x for x in range(100) if x % 10 == 0)
b = sum(a)
print(b)

多维列表 

二维列表

        一维列表可以帮助我们存储一维线性的数据二维列表可以帮助我们存储二维表格的数据。

姓名	语文成绩	数学成绩	英语成绩
张三	90	60	90
王五	80	90	80
李四	85	100	60

内存结构图如下我们通过找到二维列表对象的索引找到里边的列表对象再通过里边的列表对象索引找到最里边的元素对其进行操作。

a=[
    ['张三',90,60,90],
    ['王五',80,90,80],
    ['李四',85,100,60],
]
for m in range(3):  # 行操作
    for n in range(4):  # 列操作
        print(a[m][n],end='\t')
    print()# 打印完换行

元组tuple

        列表属于可变序列可以任意修改列表中的元素元组属于不可变序列不能改变元组中的元素。因此元组没有增加元素、删除元素的相关方法。因此只需要学习元组的创建和删除元组元素的访问计数即可。元组支持如下操作1、索引访问  2、切片操作 3、连接操作 4、成员关系操作  5、比较运算操作 6、计数元组长度len、最大值max()、最小值min()、求和sum()等。

元组的创建

1.通过()创建元组,小括号可以省略

        如果元组只有一个元素则必须后面加逗号这是因为解释器会把1解释为整数而11则解释我将会解释为元组。

c = (10,20,30)
d = 10,10,30
print(type(c),type(d))

2.通过tuple()创建元组

tuple(可迭代的对象)

eg:

b = tuple() # 创建一个空元组对象
c = tuple("abc")
d = tuple(range(3))
e = tuple([2,3,4])
f = tuple(['1',2,3]) # 将列表转化为元组
print(b,c,d,e,f)

 总结tuple() 可以接收列表、字符串、其他序列类型迭代器等生成元组。

list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。

元组的元素访问和计数

1.元组的元素不能修改

2.元组的元素访问和列表一样只不过返回的仍然是元组

3.列表关于排序的方法list.sorted()是修改原列表对象元组没有该方法如果要对元组排序只能使用内置函数sqrted(tupleObj),并生成新的列表对象。sorted生成的都是列表不管你传的是列表还是元组。

ZIP

        zip(列表1列表2...)将多个列表对应位置的元素组合为元组并返回这个zip对象。

a = [10,20,30]
b = [40,50,60]
c = [70,80,90]
d = zip(a,b,c)
print(list(d))

   生成器推导式创建元组

        从形式上看生成器推导式与列表推导式类似只是生成器推导式使用小括号列表推导式生成列表对象生成器推导式生成的不是列表也不是元组而是一个生成器对象。我们可以通过生成器对象转化成列表或者元组。也可以使用生成器对象的_next_()方法进行遍历或者直接作为迭代器对象来使用。不管什么方式使用元素访问结束后如果需要重新访问其中的元素必须重新创建该生成器对象只能用一次。

s = (x*2 for x in range(5))
print(tuple(s))
print(tuple(s))

 用s.__next__()指针来移动操作根据序列去取值指针以此后移

s = (x*2 for x in range(5))
print(s.__next__())
print(s.__next__())
print(s.__next__())
print(s.__next__())
print(s.__next__())

 字典

        字典是"键值对"的无序可变序列键值对是成对存储的。通过对来操作值。来字典中每一个元素都是一个“键值对”包含"键对象”和值对象。可以通过“键对象”实现快速获取、删除、更新对象的“值对象”。

        列表中我们通过“下标数字”找到对象。字典中通过“键对象”找到对应的值对象。“键”是任意的不可变数据比如整数、浮点数、字符串、元组。但是列表、字典、集合这些可变对象不能作为“键”。并且键不可重复。“值”可以是任意的数据并且“键不可重复”。

字典的定义方式

a = {'name':'gaoqi','age':18,'job':'programmer'}

其中有三个键值对'name'、'age'、'job'是键'gaoqi''18''programmer'是对.

其中我们传入 'name'这个键就可以找到'gaoqi'这个对。利用a.get(‘name’),我感觉和C语言结构体类似。

字典的创建

1.1我们可以通过{}2dict()来创建字典对象

1通过{}

a = {'name':'gaoqi','age':18,'job':'programmer'}
a.get('name')

 2dict()来创建字典对象

①注意键不加字符号且用的‘=’而不是冒号注意区别

b = dict(姓名='小花',年龄=18,工作='村花')
print(b)

 ②把键值和对放在一块并且用[]表示注意是而不是

b = dict([('姓名','小花'),('年龄',18),('工作','村花')])
print(b)

 2.通过zip()创建字典对象 

k = ['姓名','年龄','工作']
v = ['小花',18,'村花']
m = dict(zip(k,v))
print(m)

3.通过fromkeys创建值为空的字典只有键没有值

a = dict.fromkeys(['姓名','年龄','工作'])
print(a)

 字典元素的访问

1.通过键获得“值”若键不存在则抛出异常。

k = ['姓名','年龄','工作']
v = ['小花',18,'村花']
m = dict(zip(k,v))
print(m)
m['姓名']

 2.通过get()方法获得值推荐使用。有点是指定键不存在返回None;也可以设定指定键不存在默认返回的对象。推荐使用get()获取值对象。

k = ['姓名','年龄','工作']
v = ['小花',18,'村花']
m = dict(zip(k,v))
print(m)
m.get('年龄')

 3.列出所有的键值对进行遍历是一个列表里边包含元组

4.列出所有的键a.keys()列出所有的值a.value() 

5.键值对的个数用len()函数查看

6.检测一个“键”是否在字典中用 in

字典元素添加、修改删除

1.给字典新增“键值对”。如果“键已经存在”则覆盖就得键值对如果“键不存在”则新增“键值对”。

k = ['姓名','年龄','工作']
v = ['小花',18,'村花']
m = dict(zip(k,v))
print(m)
m['地址']='女儿国'
print(m)

2.使用update()将新字典中所有键值对全部添加到旧字典对象如果key有重复直接覆盖。

3.字典元素中的删除可以使用del方法或者clear()删除所有的建值对pop删除指定的键值对并返回对应的‘值对象’。

k = ['姓名','年龄','工作']
v = ['小花',18,'村花']
m = dict(zip(k,v))
o = ['姓名','属相','生日']
p = ['小花','兔','5.21']
r = dict(zip(o,p))
print(m)
del(m['姓名'])
b = r.pop('属相')
print(m)
print(b)

 4.popitem随机删除和返回该键值对。字典是“无序可变序列”因此没有第一个元素最后一个元素的概念popitem弹出随机项因为字典并没有“最后元素”或者其他顺序的概念。若想一个接一个地移除这个方法是非常有效的因为不用首先获取键的列表。

k = ['姓名','年龄','工作']
v = ['小花',18,'村花']
m = dict(zip(k,v))
o = ['姓名','属相','生日']
p = ['小花','兔','5.21']
r = dict(zip(o,p))
print(m)
m.popitem()
m.popitem()
m.popitem()

序列解包

序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。

x,y,z = (20,30,10)
(x,y,z) = (20,30,10)
[a,b,c] = [10,20,30]

序列解包用于字典时默认是对“键”进行操作如果需要对键值对操作则需要使用items()如果需要对“值”进行操作则需要使用values();方便对多个变量赋值。时

k = ['姓名','年龄','工作']
v = ['小花',18,'村花']
m = dict(zip(k,v))
o = ['姓名','属相','生日']
p = ['小花','兔','5.21']
r = dict(zip(o,p))
print(m)
a,b,c = m  #默认对键进行操作
print(a,b,c)
a,b,c = m.items()  #对键值对进行操作
print(a,b,c)
a,b,c = m.values()  #对值进行操作
print(a,b,c)

表格数据使用字典和列表存储并实现访问 

在我们今后的学习中 格

姓名	语文成绩	数学成绩	英语成绩
张三	90	60	90
王五	80	90	80
李四	85	100	60

a1 = {'姓名': '张三', '语文成绩': 90, '数学成绩': '60', '英语成绩': '90'}
a2 = {'姓名': '王五', '语文成绩': 80, '数学成绩': '90', '英语成绩': '80'}
a3 = {'姓名': '李四', '语文成绩': 85, '数学成绩': '100', '英语成绩': '60'}
tb = [a1, a2, a3]
# 获得语文成绩
for i in range(len(tb)):
    print(tb[i].get('语文成绩'))

字典核心底层原理非常重要

        字典对象的核心是散列表。散列表是一个稀疏数据总是有空白元素的数组数组的每个单元叫做bucket.每个bucket有两部分一个是键对象的引用一个是值对象的引用。由于所有bucket结构和大小一致我们通过偏移量来读取指定bucket.

 理解key既可以数值也可以字符串怎么把一个key值对应成一个索引值分两个步骤

①将一个键值对放进字典的底层过程

a = {}
a["name"] = "yyq"
print(a)

 假设字典a对象创建完后数组长度为8我们如何把它变成0-7的数字索引最后将他放进去呢我们要把“name”=“yyq”这个键值对放进字典对象a中首先第一步需要计算键“name”的散列值。Python中通过hash()来计算。

a = {}
a["name"] = "yyq"
print(bin(hash("name")))
print(a)

 由于数组长度为8我们可以拿计算出的散列值的最右边3位数字作为偏移量即“101”,十进制是数字5。我们查看偏移量5对应的bucket是否为空。如果为空则将键值对放不进去。如果不为空则依次取右边3位作为偏移量即 "100"十进制是数字。如果都满了数组将扩容。

再查看偏移量为4的bucket是否为空。直到找到为空的bucket将键值对放进去流程图如下

 ②根据键查找“键值对”的底层过程

        和存储的底层流程算法一致也是依次取散列值的不同位置的数字假设数组长度为8我们可以拿计算出的散列值的最右边3位数字作为偏移量即“101”,十进制是数字5。我们查看偏移量5对应的bucket是否为空。如果为空则返回None。如果不为空则将这个bucket的键对象计算对应的散列值和我们的散列值进行比较如果相等。则将对应的”值对象”返回。如果不相等则依次取其他几位数字重新计算偏移量。重新取完后仍然没有找到则返回None,流程图如下

字典用法总结

1.键必须可散列

1数字、字符串、元组都是可散列。

2自定义对象需要支持下面三点

①支持hash()函数

②支持通过_eq_()方法检测相等性

③若a == b为真则has(a)==has(b)也为真

2.字典在内存中开销巨大典型中的空间换时间。

3.键查询速度很快。

4.往字典里面添加新建可能导致扩容导致散列表中键的次序变化。因此不要在遍历字典的同时进行字典的修改。

集合

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

集合的创建和删除

1.使用{}创建集合对象并使用add()方法添加元素

a = {1,2,3}
a.add(4)
print(a)

2.使用set(),将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据则只保留一个。

b = ['a','x','c']
set(b)
print(b)

3.remove()删除指定元素clear()清空整个集合。

c = ['a','x','c']
c.remove('a')
c.clear()
print(c)

集合相关操作

像数学中概念一样Python对集合也提供了并集、交集、差集等运算示例如下

a = {1,3,'sxt'}
b = {'he','it','sxt'}
c = a|b  # 并集
d = a-b  # 差集
e = a&b # 交集
f = a.union(b)  # 并集
g = a.difference(b)  # 差集
h = a.intersection(b) # 交集
print(c,d,e,end = '\t')
print(f,g,h,end = '\t')

总结列表、元组、字典、集合区别

1.列表与元组、字典、集合的区别

①列表与元组区别列表内的值是可以修改的元组不能修改列表是可变类型而元组是不可变类型

​ ②列表与字典区别列表存储值而字典存储键值对列表是有序序列而字典是无序序列

​ ③列表与集合区别 列表是有序序列集合是无序序列列表内可以存储重复数据集合内不能存储重复数据

2.元组与字典、集合的区别

①元组与字典区别元组是不可变类型字典式可变类型元组是有序序列字典是无序序列元组值不可以更改字典的值是可以更改的

​ ②元组与集合区别元组是不可变类型集合是可变类型元组是有序序列集合是无序序列元组存储的值可以重复集合存储的值不能重复

3.字典与集合区别

字典与集合区别字典存储的值可重复集合存储的值是不可重复