Python基础知识总结笔记（三）容器及使用

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

Python中的序列
列表List
列表推导式 list comprehension
元组Tuple
集合Set
字典Dictionary
Python内存管理
可变与不可变对象
1. Python中的序列
￭ 序列的概念:
1. 有序存储（元素与元素之间的相互位置是确定的），
2. 并能通过下标偏移进行访问。（可以通过索引访问）

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

#初始化 
#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：判断我指定的元素是否在序列里
■连接与重复(共类型之间)——*和+ ：用于同类型之间：+表示连接；*表示复制
■ 访问(索引与切片)——为序列访问的共性
￭ 其它操作
■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 ￭ 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

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)