三、容器类型
（一）容器通用操作
1.运算
类型 | |
拼接 | x+y 连接两个容器 累加x +=y |
复制 | x * n , x *= n 将容器x复制n遍 |
比较 | 对容器里的内容先转为对应的编码，再依次比较 |
成员运算符 | in, not in 判断一个成员是否在容器内 |
2.索引
#语法：<变量>[ ]
lists = [1,2,3]
lists[0]
"""
字符串的序号
-3 -2 -1 反向
刘 亦 菲
0 1 2 正向
"""注： ( <>[ ] = 可以修改容器内内容，字符串是不可变的数据类型，因此不可修改)
3.切片
"""语法：<变量>[login:end] 返回一段内容，范围[login,end)"""
lists = [1,2,2]
lists = [0:1] # 1
"""高级切片 <变量>[m:n:step] 根据步长切片，步长的正负需与mn保持一致。可以省略m或n，表示至开头或结尾。[ : : -1]=>逆序"""4.函数、方法
名称 | |
len() | 返回序列 的长度 |
max() | 返回序列的最大值元素 |
min() | 返回序列的最小值元素 |
sum() | 对数值求和 |
（二）字符串 str
1.定义
由一列字符组成的不可变序列容器，存储的是字符的编码值
2.表示
‘ ’，“ ”，""" """ 三引号可以所见即所得 str()
3.字符串格式化
对 ‘\’ 后面的字符进行转义
转义字符 | |
\ ' | 显示一个普通的单引号 |
\ " | 显示一个的双引号 |
\n | 表示一个换行 |
\t | 表示一个tab键 |
\ (r"") | 表示一个普通的反斜线\ |
注
取消转义
url = " c: \ \nlr\aode"
url = r" c:\nlr\aode"
4.字符串格式化
- 使用%占位符
占位符 | |
%s | 表示字符串的占位符 |
%% | 输出百分数 50% |
%d | 表示整数的占位符 |
%f | 表示浮点数的占位符 |
%.nd | 显示n位数字，不足空格补齐 |
%.0nd | 不足0补齐 |
%.-nd | 表示在后面补齐 |
%.nf | 保留n位小数 |
%x | 表示以十六进制输出 |
print("名字:%s,性别:%s"%("张飞","男")) print("名字:%(name)s,性别:%(sex)s"%{"name":"张飞","sex":"男"}) #以字典的形式
- format格式#"{:<填充>|<对齐>|<宽度>|<,>|<精度>|<类型>}".format() "{}:计算机{}的CPU功率{}".format("2018","1","2") "我是{name}，我今年{age}".format(age=18,name="") "我是{name}，我今年{age}".format({“age”:18,"name":""})
： | 引号符号 |
<填充> | 用于填充的字符(宽度不足) |
<对齐> | “<” 左对齐 "^" 居中 ">" 右对 |
<宽度> | 设定输出字符串的宽度 |
<,> | 数字的千分位分隔符 |
<精度> | 浮点数精度 |
<类型> | 整数 b二进制, d(10) o(8) x X(16) 浮点数 e E f % |
- f格式(3.6版以后)
#语法：f"{}" age=18 name="" f"我是{name}，我今年{age}" #2.具有eval功能,将字符串当成表达式运行 f'{print("")}' result = f'{3+5}'
5.编码
\1. 字节byte：计算机最小存储单位，等于8 位bit.
\2. 字符：单个的数字，文字与符号。
\3. 字符集(码表)：存储字符与二进制序列的对应关系。
\4. 编码：将字符转换为对应的二进制序列的过程。
\5. 解码：将二进制序列转换为对应的字符的过程。
\6. 编码方式：
--ASCII编码：包含英文、数字等字符，每个字符1个字节。
--GBK编码：兼容ASCII编码，包含21003个中文；英文1个字节，汉字2个字节。
--Unicode字符集：国际统一编码，旧字符集每个字符2字节，新字符集4字节。
-- UTF-8编码：Unicode的存储与传输方式，英文1字节，中文3字节。
6.函数
类型 | 函数/方法("".) | |
其他 | ord(字符串） | 返回该字符串的unicode码 |
chr(unicode码) | 返回相应的字符串 | |
判断 | .isspace() | 如果字符串中只包含空白，则返回 True，否则返回 False. |
.lower() | 判断字符串是否是小写 | |
.upper() | 判断字符串是否是大写 | |
.istitle() | 判断字符串每个单词首字母是否大写 | |
.isalnum() | 判断字符串是否由字母或数字组成 | |
.isspace() | 字符串由字母组成结果为True | |
.startswith(substr, beg=0,end=len(string)) | 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 | |
.endswith(suffix, beg=0, end=len(string)) | 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. | |
.isdigit() | 判断字符串是否由数字组成 | |
查找 | .find(str, beg=0 end=len(string)) | 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1 |
.rfind(str, beg=0,end=len(string)) | 从右边开始查找. | |
.count(str, beg= 0,end=len(string)) | 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 | |
修改 | .replace(old, new [, max]) | 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。 |
.lstrip() | 截掉字符串左边的空格或指定字符。 | |
.rstrip() | 删除字符串字符串末尾的空格. | |
.strip([chars]) | 在字符串上执行 lstrip()和 rstrip() | |
.lower() | 转换字符串中所有大写字符为小写. | |
upper() | 转换字符串中的小写字母为大写 | |
swapcase() | 将字符串中大写转换为小写，小写转换为大写 |
（三）列表 list
1.定义
由一系列变量组成的可变序列容器
列表内存图
2.表示
[<对象>,] 或 list([<其他容器>])
3.操作
- 获取元素
#索引 lists = [1,2,3] lists[0] #切片 通过切片获取元素，会创建新列表，仅仅拷贝第一层 ----浅拷贝 list[0:1]
- 修改
#语法: list.[index/切片] = lists = ["刘亦菲","貂蝉"] lists[1] = "杨幂" lists[1] =["杨幂","刘诗诗"] #L.sort(reverse=False) | 将列表中的元素进行排序，默认顺序按值的小到大的顺序排列 #L.reverse() | 列表的反转，用来改变原列表的先后顺序 进行排序，容器内的元素必须是同种类型
- 增加
方法 | |
.append(object) | 在列表末尾添加 |
.insert(index,object) | 在index位置添加 |
- 合并列表
#语法：list_a.extend(list_b) 把b追加到a里
- 删除
方法 | |
.pop([index]) / del a[index] | 默认(没有index)，删除末尾元素 |
.remove(objext) | 删除列表里的内容，若不存在，则报错。 |
.clean() | 清楚列表 |
注：
删除实质：在内存中，后一个替换前一个
---------------------------------
可以从后往前删
for i in range (-(len(a),-1,-1):
4.遍历列表
#语法：for item in list:
lists = ["1","2",1]
for item in lists:
print(item)
#倒叙
#1）for i in list02[::-1]:
#list02[::-1] 通过切片拿元素，会重新创建新列表。浪费内存,不建议
#（2）0 1 2 3 => 3 2 1 0 或 -1 -2 -3 -4
for i in range( len(lists)-1, -1 , -1) :
print( lisrs[i])
for i in range (-1,-len(lists)-1,-1):
print( lisrs[i])5.拷贝
- 浅拷贝
通过切片，[ 4,[ a,b]]只拷贝一层,内面容器的内容不拷贝
a.copy()- 深拷贝
将所有内容拷贝，使用copy模块， a=copy.deepcopy(b)- 注：
- 不过是浅拷贝还是深拷贝，都无法拷贝不可变的容器
6.列表推导式
- 定义
使用简易方法，将可迭代对象转换成列表 - 语法
#变量 = [ 表达式 for 变量 in 可迭代对象] #变量 = [ 表达式 for 变量 in 可迭代对象 for 变量 in 可迭代对象] 双for结构 #变量 = [ 表达式 for 变量 in 可迭代对象 if 条件]
7.列表扩容
1.列表在创建时都会预留空间
2.当预留空间不足时，都会在创建新列表（更大的空间）
3.将原有数据拷贝到新列表中
4.替换引用
（四）元组 tuple
1.定义
由一系列变量组成的不可变序列容器，一旦创建，里面的变量不可操作（按需分配）
2.操作
- 创建
#空元组
a= ()
a = tuple()
#默认值
a = (1,2)
#元组只有一个元组
a = (1,)- 获取元素
同列表，索引、切片
（五）字典
1.定义
由一系列键值对组成的可变映射容器
映射：一对一的对应关系
键必须唯一且不可变（字符串/数字/元组），值没有限制
2.操作
- 创建
#空字典
dict0 = {}
dict0 = dict()
#默认值
dict01 ={"1":1}
dict01 ={x=1,y=1}
dict01 = dict(<容器>) #dict( [("a","1"),["age",12]] )
keys = ["name","age"]
value = None
dict01 ={}.formkeys(keys,values<默认值>)- 查找
dict01 = {" name":"杨幂","sex":"女"}
#1.dict[key]
dict01["name"] #杨幂
#2.dict.get(key,value)
print(dict01.get("name","刘亦菲")) #若字典中不存在，则返回"刘亦菲"- 修改/添加
#dict[key] = 若字典中存在，则修改，否则是增加
dict01["name"] = "张飞" #dict01 = {" name":"张飞","sex":"女"}- 删除 #语法：del dict01[ ]
- 遍历
"""
for key,value in dict01.items(): 得到key,value
for i in dict01.items(): 以元组形式得到键值
for i in dict01: 得到key
for i in dict01.values(): 得到value
"""3.列表与字典的嵌套
- 字典内嵌列表 { <>: [ ] }
- 字典内嵌字典 { <>: {} }
- 列表内嵌字典 [ { : } ]
- 列表内嵌列表
#1. exercise05字典内嵌列表:
{
"张无忌":[28,100,"男"],
}
#2. exercise06字典内嵌字典:
{
"张无忌":{"age":28,"score":100,"sex":"男"},
}
#3. exercise07列表内嵌字典:
[
{"name":"张无忌","age":28,"score":100,"sex":"男"},
]
#4. 列表内嵌列表
[
["张无忌",28,100男],
]
"""
选择策略：根据具体需求，结合优缺点，综合考虑(两害相权取其轻).
字典：
优点：根据键获取值，读取速度快；
代码可读性相对列表更高(根据键获取与根据索引获取).
缺点：内存占用大；
获取值只能根据键,不灵活.
列表：
优点：根据索引/切片，获取元素更灵活.
相比字典占内存更小。
缺点：通过索引获取，如果信息较多，可读性不高.
"""
4.推导式
#语法：{ item:item ** 2 for item in range(1,11) if item >5}
5.函数
- 查找
函数/方法 | |
.get(key, default=None) | 返回指定键的值，如果值不在字典中返回default值 |
.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
.popitem() | 随机返回并删除字典中的一对键和值(一般删除末尾对)。 |
.items() | 以列表返回可遍历的(键, 值) 元组数组 |
.keys() | 返回一个迭代器，可以使用 list() 来转换为列表 |
values() | 返回一个迭代器，可以使用 list() 来转换为列表 |
- 修改
方法 | |
update(dict2) | 字典记录累加 |
clear() | 删除字典内所有元素 |
6.键值互换
#语法
dic = { value:key for key ,value in dict01.items()}
#value重复时
li = [(value,key) for key,value in dict01.items()]（六）集合 set
1.定义
由一系列不重复的不可变类型变量组成的可变映射容器，相当于有键无值的字典
2.操作
- 创建
#空值
set0 = set()
set1 =set(可迭代对象)
#默认值
set2 = {1,2,3}- 添加 .add( <元素>)
- 删除 .discard( <元素>)
- 遍历 for item in set0:
3.函数
update() 给集合添加元素
clear() 移除集合中的所有元素
copy() 拷贝一个集合
pop() 随机移除元素
4.运算
交集 &
并集 |
补集 (两边不同) ^
补集 (一边不同) -
子集 <
超集 >
5.固定集合
不可变集合 -frozenset()
运算同集合
（七）容器转换
列表 =>字符串 | result=" 连接符".join(<list>) 注：列表内的元素须是字符串 |
字符串 => 列表 | result="a-b-c".split(<分隔符>) |
列表 => 元组 | tuple( [ ] ) |
元组 => 列表 | list( <tuple>) |
集合=>字符串 | 先转为列表，再转 |
