（三）Python总结笔记：容器及使用

ゝ一世哀愁。 2023-07-06 11:39 20阅读 0赞

## Python总结笔记（三）容器及使用 ##

接上一节Python基础知识总结笔记（二）
    Python标准数据类型
    ■ 不可变类型:
    □ 数值 Number
    □ 字符串 String
    ■ 容器类型(可变类型):
    □列表 List
    □元组 Tuple
    □集合 Set
    □字典 Dictionary	
    其中字符串、列表、元组：序列（有序序列）
    集合：无序序列

1.  Python中的序列
2.  列表List
3.  列表推导式 list comprehension
4.  元组Tuple
5.  集合Set
6.  字典Dictionary
7.  Python内存管理
8.  可变与不可变对象

### 1. Python中的序列 ###

￭ 序列的概念:  
**1. 有序存储（元素与元素之间的相互位置是确定的），  
2. 并能通过下标偏移进行访问。（可以通过索引访问）**

￭序列对象（都符合序列的概念）: str字符串，list列表，tuple元组  
■序列对象初始化：  
□str字符串——"“初始化  
□list列表——\[\]初始化，里面可以字符串”"、新的列表\[\]、字典\{\}  
□tuple元组——()初始化

￭ 标准操作:  
■ 成员操作——in /not in：判断我指定的元素是否在序列里  
■连接与重复(共类型之间)——\*和+ ：用于同类型之间：+表示连接；\*表示复制  
■ 访问(索引与切片)——为序列访问的共性  
￭ 其它操作  
■BIF:  
￭ len() 求内部有多少个元素  
￭ reversed() 注意：reversed(t1)执行不了，返回一个对象 需要类型转换返回list格式  
￭ 序列拼接zip() 注意：两个列表长度需要一致才可拼接。Eg：l1=\[‘julyedu’,‘AI教育’\] ；l2=\[’.com’,‘平台’\]，则1+l2 得到\[‘julyedu’,‘AI教育’,’.com’,‘平台’\] ，并不是一一对应的关系；而zip(l1,l2)返回zip对象，list(zip(l1,l2))得到一一对应的关系，则得到：\[(‘julyedu’, ‘.com’), (‘AI教育’, ‘平台’)\]。将zip后的分开也可以，a,b=list(zip(\*a))可分别得到(‘julyedu’, ‘AI教育’)以及(’.com’, ‘平台’)。  
￭ sorted() 注意：sorted(）返回排序的结果，并不会改变原列表；而l.sort(）返回排序的结果，改变原列表l  
￭ 枚举enumerate() 为枚举器：做行号的对应。  
￭ max()，min()，sum()求最小值、求最大值、求和  
￭ all() （有空返回Flase）判断对象中的所有元素不为0、’’、False或者x为空对象，则返回True，否则返回False  
￭ any() （全为空返回Flase。）any判断对象是否为空对象，如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true  
■序列类型转换type()  
￭ list() ， str() ， tuple()  
强制类型转换： Eg：a=5.6; int(a)  
判断对象类型：type(b)==str

#初始化 
    #str字符串""初始化；list[]初始化--里面可以字符串""、新的列表[]、字典{}；tuple()初始化
    s1='julyedu.com '
    l1=['julyedu','AI教育'] 
    l2=['.com','平台']
    l3=[5,12,6,3,8,9]
    l4=['tensorflow','sklearn','']
    l5=['','','','']
    t1=('julyedu',['国内领先的人工智能平台','AI'])#有两个元素t1[0] 以及t1[1](为list类型)
    print(t1[0]) #第一个元素：julyedu
    print(t1[1])  #第二个元素：['国内领先的人工智能平台', 'AI']
    print(t1[1][0])    #第二个元素中的第一个元素：国内领先的人工智能平台
    print(t1[1][1])    #第二个元素中的第二个元素：AI
    print(t1[0][:5]) #可以访问第一个元素中的索引值从0-4的5个字符
    
    
    #标准操作 
    #成员操作--in /not in：判断我指定的元素是否在序列里
    print('julyedu' in t1)
    print('com' not in s1)
    
    #连接与重复(共类型之间)--*和+ ：用于同类型之间：+表示连接；*表示复制
    s1*10
    s1+s1
    l1*5
    
    #索引访问-- 序列访问的共性
    s1[0]
    l1[0]
    t1[1]
    
    #切片访问--[开始：结束：步长]
    s1[0:-1:3]
    t1[0:-1]
    
    #其它操作
    len(t1)  #求内部有多少个元素
    len(s1)
    list(reversed(t1))  #reversed(t1)执行不了，返回一个对象 需要类型转换返回list格式
    sorted(s1)    #sorted(）返回排序的结果，并不会改变原列表s1
    l3.sort()       #sort(）返回排序的结果，改变原列表s1
    l3 
    sorted(l1)
    sorted(l3)
    max(l3);min(l3);sum(l3)#求最小值 #求最大值 #求和
    max(l1)
    l3 [-3:0:-1]
    l3[0:-1]
    l3[::-1]
    l3[-2:]
    
    #枚举--enumerate()为枚举器：做行号的对应
    for _,item in enumerate(l1):
        print(_,item)#加行号从0开始 ： 0 julyedu 1 AI教育
        #print(_+1,item)#加行号从1开始 ： 1 julyedu 2 AI教育
    
    #序列拼接--zip()函数
    #l1=['julyedu','AI教育'] 
    #l2=['.com','平台']
    #希望拼接l1、l2（两个列表长度需要一致）： 
    #l1+l2 得到['julyedu','AI教育','.com','平台'] ，并不是一一对应的关系
    list(zip(l1,t1))  #zip(l1,l2)返回zip对象，list(zip(l1,l2))得到一一对应的关系，则得到：[('julyedu', '.com'), ('AI教育', '平台')]
    list(zip(l1,l2))
    
    a=list(zip(l1,l2))
    list(zip(*a))#分开，得到[('julyedu', 'AI教育'), ('.com', '平台')]
    
    a,b=list(zip(*a))#可分别得到('julyedu', 'AI教育')以及('.com', '平台')
    print(a) 
    print(b) 
    
    
    
    #any判断对象是否为空对象，如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true
    any(l4)#l4中有空元素，但也有不为空的元素
    any(l5)#l5中的元素全部为空，0或者false,any返回的就是false
    
    #all判断对象中的所有元素不为0、''、False或者x为空对象，则返回True，否则返回False
    all(l4)#l4中有一个空元素，则返回False
    all(l3)#l5中的元素全部为空，0或者false,any返回的就是false
    
    
    #类型转换-- 看对象的类型：type() 
    #强制类型转换： Eg：a=5.6; int(a)
    #判断对象类型：type(b)==str
    type(list(t1))
    type(str(l1))
    type(tuple(s1))

### 2. 列表List ###

■初始化  
1.用 \[\]进行初始化，可以保存不同类型的数据  
2. 通过对别的数据类型转换而获得。range(从几开始：从几结束：步长)，按照左闭右开原则。与序列访问类似  
■列表属性  
内置电池：len()，获取列表长度  
■列表操作  
□ 成员操作： in 或not in  
□ +与\*  
□ 访问：索引与切片  
□ 列表内部操作：  
￭ =赋值：l1\[3\]=‘Caffe’ 表示第四个元素赋值为8  
￭ append()添加到未尾： 如果元素是列表，也是按照列表添加进来（作为一个元素添加进来）  
￭ extend()扩展： 如果是扩展元素是列表，是只添加列表内的元素  
￭ insert()：插入元素，按索引插入  
￭ find()：获得指定元素的索引位置，没找到的话，不会报错  
￭ index()：获得指定元素的索引位置，如果存在相同元素，返回的是从左到右第一个的索引位置  
￭ rindex()：获得指定元素的索引位置，如果存在相同元素，返回的是从右到左第一个的索引位置  
￭ count()：统计元素出现的次数  
￭ pop()：返回并弹出队尾的元素（先返回给你，再删除指定位置的元素）  
￭ pop(3)：返回并弹出指定索引位置的元素（先返回给你，再删除指定位置的元素）  
￭ del m\[-1\] ：删除列表元素，按索引位置删除  
￭ remove(’)：指定元素进行删除，如果存在相同元素，则删除从左至右第一个元素  
□ 比较，反转、排序  
￭ l2<l3：列表比较，逐元素进行对比  
￭ reversed()：将列表反转， 返回对象  
￭ sorted()：排序  
□ 其它操作

#初始化 
    #1. []进行初始化，可以保存不同类型的数据 
    #2. 通过对别的数据类型转换而获得。range(从几开始：从几结束：步长)，按照左闭右开原则。与序列访问类似
    l1=['julyedu.com','AI','tensorflow','','sklearn','AI']
    l2=list(range(1,6))     #[1, 2, 3, 4, 5]
    l3=list(range(1,18,2))    #[1, 3, 5, 7, 9, 11, 13, 15, 17]
    
    print(l2)  #[1, 2, 3, 4, 5]
    print(l3)  #[1, 3, 5, 7, 9, 11, 13, 15, 17]
    
    #列表属性--内置电池：len()
    len(l1)#列表长度
    
    #成员操作
    'AI' in l1
    'tensor' not in l1
    
    #列表访问,索引与切片
    l1[2]
    l1[0:-1:2]
    
    #列表内部操作
    l1[3]='Caffe'#赋值：第四个元素赋值为8
    l1.append(l2)#添加到未尾： 如果元素是列表，也是按照列表添加进来（作为一个元素添加进来）
    l1.extend(['Torch'])#扩展，如果是扩展元素是列表，是只添加列表内的元素
    l1.insert(0,'sklearn')#插入元素，按索引插入
    l1.index('sklearn')#获得指定元素的索引位置，如果存在相同元素，返回的是从右到左第一个的索引位置
    help(l1.index())
    l1.count('AI')#统计元素出现的次数
    l1.pop()#返回并弹出队尾的元素
    l1.pop(3)#返回并弹出指定索引位置的元素（先返回给你，再删除指定位置的元素）
    
    del l1[-1] #删除列表元素，按索引位置删除
    l1.remove('AI')#指定元素进行删除，如果存在相同元素，则删除从左至右第一个元素
    l1
    
    #列表操作
    reversed(l1)#将列表反转， 返回对象
    sorted(l1)#排序
    
    l2<l3#列表比较，逐元素进行对比

### 3. 列表推导式 list comprehension ###

■定义:  
□ 列表推导式也叫列表解析式(list comprehension)， 是利用现有列表创建新列表。  
□ 这种可以非常简洁的方式来快速生成满足特定需求 的列表，代码可读性强  
□ Python的内部实现对列表推导式做了大量优化，可 以保证很快的运行速度。  
■语法:  
□ \[表达式for变量in列表\]  
□ \[表达式for变量in列表if条件\]

l1=list(range(300))
    
    [x for x in l1 if x>=288]
    
    #从一个列表中
    [i for i in range(9) if i%2==0]
    
    #从两个列表中进行推导
    [(i,j) for i in range(5) for j in range(5)]

### 4. 元组Tuple ###

▪ 元组tuple是只读有序序列。  
▪ 可以认为tuple是只读列表，它有许多操作和list很接近，不再列举。除了对其进行修改。  
▪ 注意：（不可变类型）不可更改。字符串、字符不可以修改，但是列表、字典都可以修改。

#tuple：可以认为是一个只读列表
    
    #tuple成员操作
    t1=(5,6,7)
    #dir(t1)#查看相应操作
    
    #t1+4#这里为什么会报错 。4为数值型对象，不同类型的对象不可计算
    t1+(4,) #这里为什么会成功。4为tuple类型，在结尾追加4
    #通常我们在命令行输入4,5,6返回的是一个tuple
    #而只输入4时，返回的是一个数值型
    # t1还是原来的， 并不可以被改变
    #解包unpack：有几个元素就用几个来解包
    a,b,c=t1
    
    
    #tuple不可修改的是什么？——
    t1=(1,2,3,[4,5,6])
    t1[0]=0#报错
    #'tuple' object does not support item assignment
    #这里的tuple object指的是tuple中的元素，元素不可修改。
    #数值型元素不可更改。
    #列表、字典都可以修改，但是字符串、字符不可以修改。
    t1[-1].append(7) 不报错
    
    #列表可以
    print('t1 id:',id(t1))
    print('t1[-1] id：',id(t1[-1]))
    
    t1[-1].append(7)
    print(t1)
    print('t1[-1] id：',id(t1[-1]))
    
    #对元素中字典元素进行修改
    t1=(1,'a',{ 'name':'AI'})
    t1[-1]['name']='Julyedu.com'
    t1

### 5. 集合Set ###

■集合set: 一组key的无序排列集合，因此无法用索引及切片访问 。  
■主要作用: 用于去重及集合间操作  
■集合初始化：\{\}和字典类似，但只有key，没有value。但集合不是序列。 不可以用索引、切片。  
即：s1=\[‘julyedu’,‘julyedu.com’,‘julyedu’,‘AI’\]；s1\[0\] 或者s1\[0:\] 都不可以 。  
■ 集合内部操作:  
□in 或者 not in判断是否在内部  
□s1.add(‘f’)：添加key\#增加元素  
□remove(‘AI’)：删除元素  
■集合间操作:  
□ 交集：a&b  
□ 并集 ：a|b  
□ 差集：a-b  
□ 合并：类似于并集，但是改变原来的集合  
■集合与元组:

l1=['julyedu','julyedu.com','julyedu','AI']
    
    #初始化--{}和字典类似，但只有key，没有value。集合不是序列
    #set(l1) 为{'AI', 'julyedu', 'julyedu.com'}
    a=set(l1)
    
    # s1[0] #集合不是序列， 不可以用索引 'set' object does not support indexing
    # s1[0:] #不可以用切片
    #成员操作
    'AI' in a
    'Caffe' not in b
    
    
    #集合内部操作
    a.add('f')#添加key#增加元素，s1.add（）
    a.remove('AI')#删除元素remove（）
    
    
    #集合间操作--返回结果，不改变原来的
    a=set('abcde')
    b=set('cdefg')
    
    # &交集
    a&b
    # 结果：{'c', 'd', 'e'}
    
    # |并集
    a|b
    # 结果：{'a', 'b', 'c', 'd', 'e', 'f', 'g'}
    
    # -差集
    a-b
    # 结果：{'a', 'b'}
    
    
    #合并--类似于并集，改变原来的
    a.update(b)#集合合并

在敲代码过程中可用： help(d1) 以及 dir(**builtins**) 查询相应的用法

### 6. 字典Dictionary ###

▪ 字典:  
■ 字典这种数据结构，是把一个元素映射到另一个元素上, 可以简单理解为k:v对应。  
其中key值的选取：能被hash的值都可以做为key，即：key值为不可变类型(字符串、数字)。  
■ 常见操作:  
□ 初始化：\{K:V, K:V\}  
□ 成员判断 ：通过key判断成员  
□ 新增成员：d1\[‘address’\]=‘beijing’  
□ 访问：  
按key访问valued：1\[‘name’\]或者d1.get(‘name’,-1)  
访问所有key：d1.keys()  
访问所有value：d1.values()  
访问所有元素：d1.items()  
□ 删除成员  
d1.pop(‘address’)：返回指定key的值。并弹出元素  
d1.popitem()：返回整个元素。并弹出  
□ 字典推导式  
▪ Key值的选取:  
■ Key值必须是可被哈希的，也就是说key只能是数字，字符串或者元组

#字典的： K:V对应
    
    #初始化--{K:V, K:V}
    d1={ 'name':'jack','age':24}
    d2=dict({ 'salary':9999,'level':5})
    
    #成员判断(针对 key)。通过key判断成员
    'name' in d1
    'address' in d1
    
    #新增成员
    d1['address']='beijing'
    
    #访问：按key访问value： --对比d1[0]或者d1[0:]
    d1['name']
    d1.get('name',-1)
    #访问所有key--返回所有key值
    d1.keys()
    #访问所有value
    d1.values()
    #访问所有元素
    d1.items()
    #可以迭代访问所有元素--遍历
    # for key,value in d1.items():
    # print(key,value)
    
    #删除成员
    d1.pop('address')#返回指定key的值。并弹出元素
    d1.popitem()#返回整个元素。并弹出
    
    
    # help(d1) 查询用法
    # dir(__builtins__)
    
    #清空
    d1.clear()
    
    
    #Key值的选取，能被hash的值都可以做为key，即不可变类型(字符串、数字)可以做为key值。
    hash('a')

### 7. Python内存管理 ###

□ 引用的概念：==变量与对象之间关系叫引用 ==  
□ 在Python中，每个对象都有存有指向该对象的引用总数，即引用计数(reference count)。我们可以使用sys包中的getrefcount()，来查看某个对象的引用计数。需要注意的是，当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。因此，getrefcount()所得到的结果，会比期望的多1。

#引用的概念--变量和对象关系：引用
    
    a='julyedu'#python在内存中创建了一个字符串，然后创建了a这个变量去指向这个字符串
    b=a#创建了一个变量b，并把它引向变量a指向的字符串julyedu
    
    a='AI'#这时在内存中创建了一个字符串AI，并把变量a的指向重新指向AI这个字符串
    print(b)#b的指向并没有变，还是julyedu
    # print('a id==b id',id(a)==id(b))
    
    c=a#再创建一个变量c，指向a所指向的字符串AI
    del a#删除的是b这个引用，而非AI这个字符串,所以c这个变量指向的还是AI这个字符串
    print(c)
    
    del c#这时AI字符串的最后一个引用c也被删除了,我们就无法再去访问AI这个字符串了
    
    
    
    #在Python中，每个对象都有存有指向该对象的引用总数，即引用计数(reference count)。
    #我们可以使用sys包中的getrefcount()，来查看某个对象的引用计数。
    #需要注意的是，当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。
    #因此，getrefcount()所得到的结果，会比期望的多1。
    
    from sys import getrefcount#统计对象被几个地方引用
    a = [1, 2, 3]
    print(getrefcount(a))
    
    b = a
    print(getrefcount(b))

### 8. 可变与不可变对象 ###

▪ 核心思想:引用与对象分离  
□ 引用可以随时指向一个新的对象  
□ 一个对象可以被多个引用指向

▪ 不可变数据对象□ 数值 Number□ 字符串 String  
□ 不能改变对象本身，只能改变引用的指向

▪ 可变数据对象□列表 List□元组 Tuple□集合 Set□字典 Dictionary  
□ 通过引用其元素，改变对象自身

#知识点：引用与对象分离--对象和对象名的关系
    
    a=b=c=5#创建了三个变量，均指向一个int类型的对象5，一个对象可以被多个引用指向
    del c#删除c这个变量对5的引用
    a=[1,2,3]#把a这个变量的指向，重新指向了一个列表对象，引用可以随时指向一个新的对象
    print(b)#b依旧指向5，5没有被改变
    
    # ■ 不可变类型:□ 数值 Number□ 字符串 String
    # ■ 容器类型(可变类型):□列表 List□元组 Tuple□集合 Set□字典 Dictionary
    
    #什么是不可变对象？#不能改变对象本身，只能改变引用的指向
    a=b=c='beijing'
    a='shanghai'
    #打印a,b,c,d指向对象的id，看看是否是一个家伙
    print('id(a):',id(a),'id(b):',id(b),'id(c):',id(c))
    #看似是把a变量指向的字符串从beijing，改为shanghai,但其它并没有改变beijing，只是a的指向被改变了
    print(a,b,c)
    
    #什么是可变对象？#通过引用其元素，改变对象自身
    a=b=c=[1,2,3]
    print(a,b,c)
    a.append(4)#通过a能真正改变列表[1,2,3],
    print(a,b,c)