Python 百战 入门 4 序列

列表_特点_内存分析

列表简介
1 列表：用于存储任意数目、任意类型的数据集合。
2 列表是内置可变序列，是包含多个元素的有序连续的内存空间。
列表的标准语法格式：
a = [10,20,30,40]
其中，10,20,30,40这些称为：列表a的元素。
3 列表中的元素可以各不相同，可以是任意类型。比如：
a = [10,20,'abc',True] #可以直接输出

List表示列表名，比如上面的a

创建列表的4种方式_推导式创建列表

1.基本语法 [] 创建
a = [10,20,'gaoqi','sxt']
b = [] #创建一个空的列表对象

2.list()创建
a = list() #创建一个空的列表对象
b = list(range(10)) #结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
c = list("gaoqi,sxt") #结果：['g', 'a', 'o', 'q', 'i', ',', 's', 'x', 't']

3.range创建整数列表
range([start,] end [,step])
比如 a = list(range(2,10,2))，end必填

4.推导式生成列表
a = [x2 for x in range(5)]
b = [x2 for x in range(100) if x%9==0]
print(a,b)
[0, 2, 4, 6, 8] [0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

列表_元素的5种添加方式_效率问题

1.append()方法（尾部操作效率最高）
a = [20,40]
a.append(80)
print(a) #结果：[20, 40, 80]

2.+运算符操作
a = [20,40]
print(id(a))
a = a+[80]
print(id(a)) #两次地址不一样，创建了新的对象，效果和上面一样

3.extend()方法
a = [20,40]
print(id(a))
b = [50,60]
a.extend(b) #原对象修改，地址不变
print(id(a))
a = a+b #产生新对象
print(id(a))

4.insert()插入元素
a = [10,20,30]
a.insert(2,100)
print(a) #结果：[10, 20, 100, 30]

5.乘法扩展
= ['sxt',100]
b = a*3
print(a) #结果：['sxt', 100]
print(b) #结果：['sxt', 100, 'sxt', 100,
'sxt', 100]

列表删除的三种方式_删除的本质是元素拷贝

1.del 删除
a = [100,200,888,300,400]
del a[2]
print(a) #结果：[100,200,300,400]

2.pop()方法
a = [10,20,30,40,50]
b1 = a.pop() #结果：b1=50，默认最后一个
print(a,b1) #结果：[10, 20, 30, 40] 50
b2 = a.pop(1)
print(a,b2) #结果：[10, 30, 40],20

3.remove()方法
a = [10,20,30,40,50,20,30,20,30]
a.remove(20) #[10, 30, 40, 50, 20, 30, 20, 30]，删第一个20
a.remove(100) #报错：
ValueError:list.remove(x): x not in list

列表_元素的访问_出现次数统计_成员资格判断

a = [10,20,30,40,50,20,30,20,30]
print(a[2]) #结果：30
print(a[10]) #报错：IndexError: list index out
of range

index()获得指定元素在列表中首次出现的索引

index(value,[start],[end])

a = [10,20,30,40,50,20,30,20,30]
a.index(20) #结果：1
a.index(20,3) #结果：5 从索引位置3开始往
后搜索的第一个20
a.index(30,5,7) #结果：6 从索引位置5到7这个
区间，第一次出现30元素的位置

count()获得指定元素在列表中出现的次数

a = [10,20,30,40,50,20,30,20,30]
a.count(20)
3

len()返回列表长度

a = [10,20,30]
len(a)
3

成员资格判断

a = [10,20,30,40,50,20,30,20,30]
20 in a
True
100 not in a
True
30 not in a
False

切片slice操作

看字符串的切片操作

列表_遍历_排序_max_min_sum

列表遍历

a = [10,20,30,40]
for obj in a: #obj是临时变量名称，随意起
print(obj)

复制列表所有的元素到新列表对象

list1 = [30,40,50]
list2 = list1 #这不是拷贝，知识list2指向了list1的地址

list1 = [30,40,50]
list2 = [] + list1 #生成了新列表对象

建新列表的排序

a = [20,10,30,40]
id(a)
46016008
b = sorted(a) #默认升序
b
[10, 20, 30, 40]
id(b)
45907848
c = sorted(a,reverse=True) #降序reversed()返回迭代器
c
[40, 30, 20, 10]

reversed()返回迭代器

内置函数reversed()也支持进行逆序排列，与列表对象reverse()方
法不同的是，内置函数reversed()不对原列表做任何修改，只是返
回一个逆序排列的迭代器对象。
a = [20,10,30,40]
c = reversed(a)
print(c) #<list_reverseiterator object at 0x00000186EAAAE950>
print(list(c)) #[40, 30, 10, 20]

max和min，sum

a = [3,10,20,15,9]
max(a)
20
min(a)
3
sum(a)
57

列表_二维列表_表格数据存储和读取

a = [
["高小一",18,30000,"北京"],
["高小二",19,20000,"上海"],
["高小五",20,10000,"深圳"],
]

print(a[1][0],a[1][1],a[1][2])
高小二 19 20000
for m in range(3):
for n in range(4):
print(a[m][n],end="\t")
print() #打印完一行，换行

元组_特点_创建的两种方式_tuple()要点

元组属于不可变序列，不能修改元组中的元素。
因此，元组没有增加元素、修改元素、删除元素相关的方法。

元组的创建

1.()创建

a = (1) #这不是元组，只有一个数据必须加‘，’
type(a)
<class 'int'>
a = (1,) #或者 a = 1,
type(a)
<class 'tuple'>

2.通过tuple()创建元组
a = tuple() #创建一个空元组对象
b = tuple("abc")
c = tuple(range(3))
d = tuple([2,3,4])
元组的元素访问、index()、count()、切片等操作，和列表一样。

zip

zip(列表1，列表2，...)将多个列表对应位置的元素组合成为元组，并返回这个zip对象。
a = [10,20,30]
b = [40,50,60]
c = [70,80,90,100]
d = zip(a,b,c)
print(d) #zip object
e = list(d) #列表：[(10, 40, 70), (20, 50,
80), (30, 60, 90)]
print(e)

元组_生成器推导式创建元组_总结

列表推导式： [0, 2, 4, 6, 8]

a = [x*2 for x in range(5)]

print(a)

s = (x*2 for x in range(5))
print(s) #<generator object at
0x0000021C80BE2880>
b = tuple(s)
print(b) #(0, 2, 4, 6, 8)
c = tuple(s)
print(c) #()，只能用一次
s2 = (x for x in range(3))
print(s2.next()) #0
print(s2.next()) #1
print(s2.next()) #2
print(s2.next()) #报错

1. 如下代码，如下说法正确的是：
   A s是一个元组
   B s是一个列表
   C s是一个生成器对象，只能被迭代一次
   D s是一个生成器对象，可以被反复迭代多次
   答案
   1=>C

字典_特点_4种创建方式_普通_dict_zip_fromkeys

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

字典的创建

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() #空的字典对象

2.用zip
k = ['name','age','job']
v = ['gaoqi',18,'teacher']
d = dict(zip(k,v))
print(d) #{'name': 'gaoqi', 'age': 18,
'job': 'techer'}

3.fromkeys（创建值为空的字典）
f = dict.fromkeys(['name','age','job'])
print(f) #结果：{'name': None, 'age': None, 'job': None}

字典元素的访问

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

{'name':'gaoqi','age':18,'job':'programmer
'}
b = a['name']
print(b)

2.通过get()方法获得“值”。❤推荐使用。
优点是：指定键不存在，返回None；也可以设定指定键不存在时默认返回的对象。
a =
{'name':'gaoqi','age':18,'job':'programmer
'}
b = a.get('name')
c = a.get('gender','不存在')
print(b)
print(c)

3.列出所有的键值对
a ={'name':'gaoqi','age':18,'job':'programmer'}
b = a.items()
print(b) #dict_items([('name', 'gaoqi'),('age', 18), ('job', 'programmer')])

4.列出所有的键，列出所有的值
a ={'name':'gaoqi','age':18,'job':'programmer'}
k = a.keys()
v = a.values()
print(k) #dict_keys(['name', 'age','job'])
print(v) #dict_values(['gaoqi', 18,'programmer'])

5.len() 键值对的个数
a ={'name':'gaoqi','age':18,'job':'programmer'}
num = len(a)
print(num) #3

6.检测一个“键”是否在字典中
a ={'name':'gaoqi','age':18,'job':'programmer'}
print("name" in a) #True

字典元素添加、修改、删除

1.添加与修改
a ={'name':'gaoqi','age':18,'job':'programmer'}
a['address']='西三旗1号院' #添加
a['age']=16 #修改
print(a)

2.使用 update() 将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复，则直接覆盖
a ={'name':'gaoqi','age':18,'job':'programmer'}
b ={'name':'gaoxixi','money':1000,'gender':'男的'}
a.update(b)
print(a)#{'name': 'gaoxixi', 'age': 18, 'job':'programmer', 'money': 1000, 'gender': '男的'}

3.字典中元素的删除，可以使用 del() 方法；或者 clear() 删除所有键值对； pop() 删除指定键值对，并返回对应的“值对象”
a ={'name':'gaoqi','age':18,'job':'programmer'}
del(a['name'])
print(a) #{'age': 18, 'job':'programmer'}
age = a.pop('age')
print(age) #18

4.随机删除popitem
a ={'name':'gaoqi','age':18,'job':'programmer'}
r1 = a.popitem()
r2 = a.popitem()
r3 = a.popitem()
print(a) #{}

序列解包

x,y,z=(20,30,10)
(a,b,c)=(9,8,10)
[m,n,p]=[10,20,30]

s = {'name':'gaoqi','age':18,'job':'teacher'}
name,age,job=s #默认对键进行操作
print(name) #name
name,age,job=s.items() #对键值对进行操作
print(name) #('name', 'gaoqi')
name,age,job=s.values() #对值进行操作
print(name) #gaoqi

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

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)): # i -->0,1,2
print(tb[i].get("salary"))
打印表的所有数据
for i in range(len(tb)):
print(tb[i].get("name"),tb[i].get("age"),tb
[i].get("salary"),tb[i].get("city"))

字典核心底层原理(重要)

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

集合.

集合创建和删除

1.使用{}创建集合对象，并使用add()方法添加元素
a = {3,5,7}
a.add(9) #{9, 3, 5, 7}

2.使用set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保留一个
a = ['a','b','c','b']
b = set(a) #{'b', 'a', 'c'}

3.remove()删除指定元素；clear()清空整个集合
集合相关操作
像数学中概念一样，Python对集合也提供了并集、交集、差集等运算。我们给出示例：

a = {1,3,'sxt'}
b = {'he','it','sxt'}
a|b #并集
{1, 3, 'sxt', 'he', 'it'}
a&b #交集
{'sxt'}
a-b #差集
{1, 3}
a.union(b) #并集
{1, 3, 'sxt', 'he', 'it'}
a.intersection(b) #交集
{'sxt'}
a.difference(b) #差集