Ⅰ、序列
序列是一种数据存储方式，用来存储一系列的数据。在内存中，序列就是一块用来存放多个值的连续的内存空间。比如一个整数序列[10,20,30,40]。
由于Python3中一切皆对象，在内存中实际是按照如下方式存储的： a =[10,20,30,40]
从图示中，我们可以看出序列中存储的是整数对象的地址，而不是整数对象的值。python 中常用的序列结构有： 字符串、列表、元组、字典、集合。
一.列表
列表：用于存储任意数目、任意类型的数据集合。列表中的元素可以各不相同，可以是任意类型。比如： a =[10,20,'abc',True]。
列表对象的常用方法汇总如下，方便大家学习和查阅：
字符串和列表都是序列类型，一个字符串是一个字符序列，一个列表是任何元素的序列。
1.列表的创建
a = [10,20,'gaoqi','sxt']
a = [] #创建一个空的列表对象2.list()创建
使用list()可以将任何可迭代的数据转化成列表。
a =list() #创建一个空的列表对象
a =list(range(10)) #列表a长度为10，初始默认为0
print(a)
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]a =list("gaoqi,sxt")
print(a)
#['g', 'a', 'o', 'q', 'i', ',', 's', 'x', 't']3.range()创建整数列表
range()可以帮助我们非常方便的创建整数列表，这在开发中及其有用。语法格式为： range([start,] end [,step])
start 参数：可选，表示起始数字。默认是0
end 参数：必选，表示结尾数字。
step 参数：可选，表示步长，默认为1
python3 中range()返回的是一个range对象，而不是列表。我们需要通过list()方法将其 转换成列表对象。
b = list(range(3,-10,-1))
print(b)
#[3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7, -8, -9]4.推导式生成列表
使用列表推导式可以非常方便的创建列表，在开发中经常使用。
a = [x*2 for x in range(5)] #循环创建多个元素
print(a) #x乘以2在0~4中
#[0, 2, 4, 6, 8]a = [x*2 for x in range(100) if x%9 == 0] #通过if过滤元素
print(a)
#[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]5.列表元素的增加
当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这个特点涉及列表元素的大量移动，效率较低。除非必要，我们一般只在列表的尾部添加元素或删除元素，这会大大提高列表的操作效率。
①append()方法
原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用。
a =[20,40]
a.append(80)
print(a)
#[20, 40, 80]②+运算符操作
并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次 复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用。
a = [20, 40]
print(id(a))
a = a + [80]
print(id(a))
#2384721882816
#2384722199616
#两个id并不一样通过如上测试，我们发现变量a的地址发生了变化。也就是创建了新的列表对象。
③extend()方法
将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象
a = [20, 40]
print(id(a))
a.extend([80])
print(id(a))
#1923240570560
#1923240570560我们发现变量a的地址没有发生变化。
④insert()插入元素
使用insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。。类似发生这种移动的函数还有：remove()、pop()、del()。
a =[10,20,30]
a.insert(2,100)
print(a)
#[10, 20, 100, 30]⑤乘法扩展
使用乘法扩展列表，生成一个新列表，新列表元素时原列表元素的多次重复。
a = ['sxt',100]
b = a*3
print(a)
print(b)
#['sxt', 100]
#['sxt', 100, 'sxt', 100, 'sxt', 100]6.列表元素的删除
①del 删除
删除列表指定位置的元素。
a = [100,200,300,400]
del a[0]
print(a)
#[200, 300, 400]②pop()方法
pop()删除并返回指定位置元素，如果未指定位置则默认操作列表最后一个元素。
a =[10,20,30,40,50]
a.pop()
print(a)③remove()方法
删除首次出现的指定元素，若不存在该元素抛出异常。
a =[10,20,30,40,50,20,30,20,30]
a.remove(20)
print(a)
#[10, 30, 40, 50, 20, 30, 20, 30]7.列表元素访问和计数
①通过索引直接访问元素
我们可以通过索引直接访问元素。索引的区间在[0, 列表长度-1]这个范围。超过这个范围则会抛出异常。
a =[10,20,30,40,50,20,30,20,30]
print(a[6])
#30②index()获得指定元素在列表中首次出现的索引
index()可以获取指定元素首次出现的索引位置。语法是：index(value,[start,[end]])。其中， start 和 end 指定了搜索的范围。
a =[10,20,30,40,50,20,30,20,30]
print(a.index(20))
print(a.index(20,3))
print(a.index(20,6))
#1
#5
#7③count()获得指定元素在列表中出现的次数
count()可以返回指定元素在列表中出现的次数。
a =[10,20,30,40,50,20,30,20,30]
print(a.count(20))
#3④len()返回列表长度
a =[10,20,30,40,50,20,30,20,30]
print(len(a))
#9⑤成员资格判断
判断列表中是否存在指定的元素，我们可以使用count()方法，返回0则表示不存在，返回大于0则表示存在。但是，一般我们会使用更加简洁的in关键字来判断，直接返回True 或False。
a =[10,20,30,40,50,20,30,20,30]
print(20 in a)
print(90 in a)
print(30 not in a)
#True
#False
#False8.切片操作
我们在前面学习字符串时，学习过字符串的切片操作，对于列表的切片操作和字符串类似。 切片是Python序列及其重要的操作，适用于列表、元组、字符串等等。
切片的格式如下： 切片slice 操作可以让我们快速提取子列表或修改。标准格式为：
[起始偏移量start:终止偏移量end[:步长step]]
注：当步长省略时顺便可以省略第二个冒号。
a =[10,20,30,40,50,20,30,20,30]
b = a[:]
c = a[1:]
d = a[:2]
e = a[1:2]
print(b)
print(c)
print(d)
print(e)
#[10, 20, 30, 40, 50, 20, 30, 20, 30]
#[20, 30, 40, 50, 20, 30, 20, 30]
#[10, 20]
#[20]9.列表的遍历
a =[10,20,30,40,50,20,30,20,30]
for i in a:
print(i)
# 10
# 20
# 30
# 40
# 50
# 20
# 30
# 20
# 3010.复制列表所有的元素到新列表对象
如下代码实现列表元素的复制了吗？
list1 = [30,40,50]
list2 = list1
只是将list2 也指向了列表对象，也就是说list2和list2持有地址值是相同的，列表对象本身的元素并没有复制。
我们可以通过如下简单方式，实现列表元素内容的复制：
list1 = [30,40,50]
list2 = [] + list111.列表排序
①修改原列表，不建新列表的排序
a = [20,36,50,40,33,100,-63]
print(id(a))
a.sort() #默认是升序排序
print(a)
print(id(a))
a.sort(reverse = True)
print(a)
#2619882942144
#[-63, 20, 33, 36, 40, 50, 100]
#2619882942144
#[100, 50, 40, 36, 33, 20, -63]import random
a = [20,36,50,40,33,100,-63]
random.shuffle(a)
print(a)
#[40, -63, 36, 20, 33, 100, 50]②建新列表的排序
我们也可以通过内置函数sorted()进行排序，这个方法返回新列表，不对原列表做修改。
a = [20,36,50,40,33,100,-63]
print(id(a))
a = sorted(a)
print(a)
print(id(a))
b = sorted(a,reverse = True)
print(b)
print(id(b))
# 2399323172544
# [-63, 20, 33, 36, 40, 50, 100]
# 2399323189184
# [100, 50, 40, 36, 33, 20, -63]
# 2399327749184③reversed()返回迭代器
内置函数reversed()也支持进行逆序排列，与列表对象reverse()方法不同的是，内置函数 reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。
a =[20,10,30,40]
c =reversed(a)
print(c)
print(list(c))
print(list(c))
#<list_reverseiterator object at 0x0000026149816BB0>
#[40, 30, 10, 20]
#[]我们打印输出c发现提示是：list_reverseiterator。也就是一个迭代对象。同时，我们使用 list(c)进行输出，发现只能使用一次。第一次输出了元素，第二次为空。那是因为迭代对象在第一次时已经遍历结束了，第二次不能再使用。
12.列表相关的其他内置函数汇总
①max和min
用于返回列表中最大和最小值。
a =[20,10,30,40]
print(max(a))
#40②sum
对数值型列表的所有元素进行求和操作，对非数值型列表运算则会报错。
a =[20,10,30,40]
print(sum(a))
#10013.多维列表
①二维列表
一维列表可以帮助我们存储一维、线性的数据。 二维列表可以帮助我们存储二维、表格的数据。例如下表的数据：
a = [
['高小一',18,30000,'北京']
['高小二',19,20000,'上海']
['高小三',20,10000,'深圳']
]
print(a[1][0],a[1][1],a[1][2])
#高小二 19 20000内存结构图：
嵌套循环打印二维列表所有的数据:
a = [
['高小一',18,30000,'北京'],
['高小二',19,20000,'上海'],
['高小三',20,10000,'深圳'],
]
for i in range(3):
for j in range(4):
print(a[i][j],end = '\t') #end = '\t',\t 的意思是 ：水平制表符。相当于一个tab键。
print() # 换行
#高小一 18 30000 北京
#高小二 19 20000 上海
#高小三 20 10000 深圳二.元组
列表属于可变序列，可以任意修改列表中的元素。元组属于不可变序列，不能修改元组中的 元素。因此，元组没有增加元素、修改元素、删除元素相关的方法。因此，我们只需要学习元组的创建和删除，元组中元素的访问和计数即可。
1.元组的创建
①通过()创建元组，小括号可以省略
如果元组只有一个元素，则必须后面加逗号。这是因为解释器会把(1)解释为整数1，(1,) 解释为元组。
a =(10,20,30)
b = 10,20,30
c = (10)
d = 20,
e = (30,)
print(type(c))
print(type(d))
print(type(e))
#<class 'int'>
#<class 'tuple'>
#<class 'tuple'>
②通过tuple()创建元组
b =tuple()
#创建一个空元组对象
b =tuple("abc")
b =tuple(range(3))
b =tuple([2,3,4])总结
tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。 list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。
③元组的元素访问和计数
列表关于排序的方法list.sorted()是修改原列表对象，元组没有该方法。如果要对元组排序，只能使用内置函数sorted(tupleObj)，并生成新的列表对象。
④.zip
zip(列表 1，列表2，...)将多个列表对应位置的元素组合成为元组，并返回这个zip对象。
a = (20,10,30)
b = (30,50,-90)
c = (60,40,20)
d = zip(a,b,c)
print(d)
print(list(d))
#<zip object at 0x0000023E8AF60840>
#[(20, 30, 60), (10, 50, 40), (30, -90, 20)]⑤生成器推导式创建元组
从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。
我们可以通过生成器对象，转化成列表或者元组。也可以使用生成器对象的__next__() 方法进行遍历，或者直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。
s =(x*2 for x in range(5))
print(s)
print(tuple(s))
print(list(s)) # #只能访问一次元素。第二次就为空了。需要再生成一次
s =(x*2 for x in range(5))
print(s)
print(list(s))
s =(x*2 for x in range(5))
print(s)
print(s.__next__()) #使用生成器对象的__next__() 方法进行遍历
print(s.__next__())
print(s.__next__())
print(s.__next__())
print(s.__next__())
#<generator object <genexpr> at 0x000001339D6224A0>
# (0, 2, 4, 6, 8)
# []
# <generator object <genexpr> at 0x000001339D622430>
# [0, 2, 4, 6, 8]
# <generator object <genexpr> at 0x000001339D6224A0>
# 0
# 2
# 4
# 6
# 82.元组总结
①元组的核心特点是：不可变序列。
②元组的访问和处理速度比列表快。
③与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用。
三.字典
字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值对”，包含：“键 对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。
列表中我们通过“下标数字”找到对应的对象。字典中通过“键对象”找到对应的“值 对象”。“键”是任意的不可变数据，比如：整数、浮点数、字符串、元组。但是：列表、 字典、集合这些可变对象，不能作为“键”。并且“键”不可重复。
“值”可以是任意的数据，并且可重复。
一个典型的字典的定义方式：
a ={'name':'gaoqi','age':18,'job':'programmer'}
1.字典的创建
①我们可以通过{}、dict()来创建字典对象
a ={'name':'gaoqi','age':18,'job':'programmer'}
b=dict(name='gaoqi',age=18,job='programmer')
a =dict([("name","gaoqi"),("age",18)])
c ={} #空的字典对象
d=dict() #空的字典对象②通过zip()创建字典对象
k=['name','age','job']
v=['gaoqi',18,'techer']
d=dict(zip(k,v))
print(d)
#{'name': 'gaoqi', 'age': 18, 'job': 'techer'}③通过fromkeys 创建值为空的字典
a =dict.fromkeys(['name','age','job'])
print(a)
#{'name': None, 'age': None, 'job': None}2.字典元素的访问
为了测试各种访问方法，我们这里设定一个字典对象：
a ={'name':'gaoqi','age':18,'job':'programmer'}① 通过 [键] 获得“值”
若键不存在，则抛出异常。
a ={'name':'gaoqi','age':18,'job':'programmer'}
print(a['name'])
print(a['job'])
print(a['long'])
"""gaoqi
programmer
Traceback (most recent call last):
File "e:/table/code/python/1py.py", line 4, in <module>
print(a['long'])
KeyError: 'long' """
②通过get()方法获得“值”，推荐使用。
优点是：指定键不存在，返回None；也可以设定指定键不存在时默认返回的对象。推荐使用get()获取“值对象”。
a ={'name':'gaoqi','age':18,'job':'programmer'}
print(a.get('name'))
print(a.get('sex'))
print(a.get('sex','一个男人'))
#gaoqi
#None
#一个男人③列出所有的键值对
a ={'name':'gaoqi','age':18,'job':'programmer'}
print(a.items())
#dict_items([('name', 'gaoqi'), ('age', 18), ('job', 'programmer')])④列出所有的键，列出所有的值
a ={'name':'gaoqi','age':18,'job':'programmer'}
print(a.keys())
print(a.values())
#dict_keys(['name', 'age', 'job'])
#dict_values(['gaoqi', 18, 'programmer'])⑤len() 键值对的个数
a ={'name':'gaoqi','age':18,'job':'programmer'}
print(len(a))
#3⑥检测一个“键”是否在字典中
a ={'name':'gaoqi','age':18,'job':'programmer'}
print("name" in a)
#True3.字典元素添加、修改、删除
①给字典新增“键值对”
如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在， 则新增“键值对”
a ={'name':'gaoqi','age':18,'job':'programmer'}
a['address']='西三旗 1 号院'
a['age']=16
print(a)
#{'name': 'gaoqi', 'age': 16, 'job': 'programmer', 'address': '西三旗 1 号院'}②update()更新
使用update()将新字典中所有键值对全部添加到旧字典对象上。如果key有重复，则直接覆盖。
a ={'name':'gaoqi','age':18,'job':'programmer'}
b ={'name':'gaoxixi','money':1000,'sex':'男'}
a.update(b)
print(a)
#{'name': 'gaoxixi', 'age': 18, 'job': 'programmer', 'money': 1000, 'sex': '男'}③字典中元素的删除
可以使用del()方法；或者clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象”。
a ={'name':'gaoqi','age':18,'job':'programmer'}
del(a['name'])
print(a)
b = a.pop('age')
print(b)
#{'age': 18, 'job': 'programmer'}
#18④popitem() ：随机删除和返回该键值对
字典是“无序可变序列”，因此没有第一个元 素、最后一个元素的概念；popitem弹出随机的项，因为字典并没有"最后的元素"或者其 他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效。
a ={'name':'gaoqi','age':18,'job':'programmer'}
print(a.popitem())
print(a)
print(a.popitem())
print(a)
print(a.popitem())
print(a)
# ('job', 'programmer')
# {'name': 'gaoqi', 'age': 18}
# ('age', 18)
# {'name': 'gaoqi'}
# ('name', 'gaoqi')
# {}4.序列解包
序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。
x,y,z=(20,30,10)
print(x)
print(y)
print(z)
#20
#30
#10序列解包用于字典时，默认是对“键”进行操作； 如果需要对键值对操作，则需要使用 items()；如果需要对“值”进行操作，则需要使用values()；
s1 ={'name':'gaoqi','age':18,'job':'teacher'}
name,age,job=s1
print(name) #默认对键进行操作
s2 = {'name':'gaoqi','age':18,'job':'teacher'}
name,age,job=s2.items()
print(name)
s3 = {'name':'gaoqi','age':18,'job':'teacher'}
name,age,job = s3.values()
print(name)
#name
#('name', 'gaoqi')
#gaoqi5.表格数据使用字典和列表存储，并实现访问
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"))
#20000
#30000
#20000
#100006.字典核心底层原理(重要)
字典对象的核心是散列表。散列表是一个稀疏数组（总是有空白元素的数组），数组的每个单元叫做bucket。每个bucket有两部分：一个是键对象的引用，一个是值对象的引用。
由于，所有bucket结构和大小一致，我们可以通过偏移量来读取指定bucket。
✿将一个键值对放进字典的底层过程
（略）
四、集合
集合是无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典 中的“键对象”，因此是不能重复的且唯一的。
1.集合创建和删除
①使用{}创建集合对象，并使用add()方法添加元素
a = {6,3,5}
a.add(7)
print(a)
#{3, 5, 6, 7}②使用set()，将列表、元组等可迭代对象转成集合
如果原来数据存在重复数据，则只保留一个。
a = [2,6,2,5,8,3,2]
b = set(a)
print(b)
#{2, 3, 5, 6, 8}③remove()删除指定元素；clear()清空整个集合
a = {2,6,5,8,3}
a.remove(3)
print(a)
#{2, 5, 6, 8}2.集合相关操作
像数学中概念一样，Python对集合也提供了并集、交集、差集等运算。
a = {3,'drink','love',67,555}
b = {3,'pen',555}
print(a|b) #并集 a.union(b)
print(a&b) #交集 a.intersection(b)
print(a-b) #差集 a.difference(b)
print(b-a) #差集 b.difference(a)
#{'pen', 67, 3, 'love', 555, 'drink'}
#{3, 555}
#{'love', 67, 'drink'}
#{'pen'}五、章节实操作业
1.使用range生成序列：30,40,50,60,70,80
a = [ x*10 for x in range(3,9)]
print(a)
#或
b = [ x for x in range(30,90,10)]
print(b)2.推导式生成列表： a=[x*2 for x in range(100) if x%9==0]，手写出结果。
结果：[18,36,54,72,90] ×
[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]原数列为2~200间隔为2，别忘了100之后的数字。
3.创建一个字典对象，包含如下信息：
支出金额：300.15，支出日期：2018.10.18，支出人：高小七
a = {'name':'高小七','pay':'300.15','date':'2018.10.18'}
扫一扫
8953
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
