Python笔记——容器类型

容器类型

字符串 str

定义：由一系列字符组成的不可变序列容器，存储的是字符的编码值。

编码

1. 字节byte：计算机最小存储单位，等于8 位bit.
2. 字符：单个的数字，文字与符号。
3. 字符集(码表)：存储字符与二进制序列的对应关系。
4. 编码：将字符转换为对应的二进制序列的过程。
5. 解码：将二进制序列转换为对应的字符的过程。
6. 编码方式：

• ASCII编码：包含英文、数字等字符，每个字符1个字节。
• GBK编码：兼容ASCII编码，包含21003个中文；英文1个字节，汉字2个字节。
• Unicode字符集：国际统一编码，旧字符集每个字符2字节，新字符集4字节。
• UTF-8编码：Unicode的存储与传输方式，英文1字节，中文3字节。

7. 相关函数
   1. ord(字符串):返回该字符串的Unicode码。
   2. chr(整数):返回该整数对应的字符串。

 # 1.在终端中获取一个字符串，打印出每个文字的编码值
str01 = input("请输入一个字符串：")
for item in str01:
    print(ord(item))

# 2.在终端中，循环录入编码值，打印每个文字
# 要求：如果录入空字符串则程序退出
while True:
    num = input("请输入编码值：")
    if num == "":
        break
    num = int(num)
    print(chr(num))

字面值

单引和双引号的区别

1. 单引号内的双引号不算结束符
2. 双引号内的单引号不算结束符

三引号作用

1. 换行会自动转换为换行符\n
2. 三引号内可以包含单引号和双引号
3. 作为文档字符串

#    双引号
name01 = "小白"
#    单引号
name02 = '小白'
#    三引号(可见即所得)
name03 = '''小白'''
name04 = """小白"""

message = '我叫"小白".'
message = "我叫'小白'."
message = """我叫'小"白"啊'."""#三引号内可以包含单引号和双引号

转义字符

1. 改变字符的原始含义。
   \’ \” \””” \n \ \t \0 空字符
2. 原始字符串：取消转义。
   a = r”C:\newfile\test.py”

#	转义字符：改变字符的原始含义。
# \"  \'   \\
message = "我叫\"齐天大圣\"."
url = "C:\\arogram Files\\bntel\cedia SDK"
# 原始字符串：没有转义字符
url = r"C:\arogram Files\bntel\cedia SDK"
print(url)

# \t 水平制表格
print("我爱\t编程.")
# \n 换行
print("我爱\n编程.")

字符串格式化

1. 定义：
   生成一定格式的字符串。
2. 语法：
   字符串%(变量)
   “我的名字是%s,年龄是%d” % (name, age)
3. 类型码：
   %s 字符串 %d整数 %f 浮点数

# 字符串格式化
name = "zza"
age = 20
score = 66.66
print("我的名字是%s,年龄是%d,成绩是%.3f" % (name, age, score))
#%.f 小数点后数字为保留多少位小数 如：1.2345    %.2f -->1.23

day = 5
hour = 4
minute = 30
# print(day + "天" + hour + "小时" + minute + "分钟")
print("%d天%d小时%d分钟"%(day,hour,minute))

通用操作

数学运算符

1. +：用于拼接两个容器
2. +=：用原容器与右侧容器拼接,并重新绑定变量
3. *：重复生成容器元素
4. *=：用原容器生成重复元素, 并重新绑定变量
5. < <= > >= == !=：依次比较两个容器中元素,一但不同则返回比较结果。

# 算数运算符
# -- +容器元素拼接
name01 = "小"
name01 += "白"
print(name)# 小白
# -- *容器元素重复多次
name02 = "小白"
name02 *= 2
print(name02)# 小白小白

# 依次比较两个容器中元素,一但不同则返回比较结果。
print("小白" > "大白")

成员运算符

1. 语法：
   数据 in 序列
   数据 not in 序列
2. 作用：
   如果在指定的序列中找到值，返回bool类型。

# 成员运算 in   not in
print("我爱" in "我爱你")  # true
print("爱我" in "我爱你")  # flase

索引index

1. 作用：定位单个容器元素
2. 语法：容器[整数]
3. 说明：
   正向索引从0开始，第二个索引为1，最后一个为len(s)-1。
   反向索引从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)。

message = "我是小白啊."
# 索引:定位单个元素
print(message[1])#是
print(message[-2])#啊
# 索引越界
# print(message[7])# 报错 IndexError
# print(message[-8])# 报错 IndexError

切片slice

1. 作用：
   定位多个容器元素。
2. 语法：
   容器[(开始索引):(结束索引)(:(步长))]
3. 说明：
   小括号()括起的部分代表可省略
   结束索引不包含该位置元素
   步长是切片每次获取完当前元素后移动的偏移量

# 切片:定位多个元素
# range(  ,  ,  )
message="我是小白啊"
# [开始索引:结束索引:间隔]    不包含结束索引
print(message[0:4:1])  # 我是小白
# [:结束索引]
print(message[:4])  # 我是小白
# [:]
print(message[:])  # 我是小白啊
# message[::-1]
print(message[::-1])  #啊白小是我
# [开始索引::]
print(message[3::])  # 白啊
# [::间隔]
print(message[::2])  # 我小啊
# 切片不会越界
print(message[:100])  # 我是小白啊
print(message[3:3])  # 获取空
print(message[1:-2])  # 是小
print(message[1:5:-1])  # 获取空

列表 list

定义：由一系列变量组成的可变序列容器。

基础操作

1. 创建列表：
   列表名 = []
   列表名 = list(可迭代对象)
2. 添加元素：
   列表名.append(元素)
   列表.insert(索引，元素)
3. 定位元素：
   列表名[索引] = 元素
   变量 = 列表名[索引]
   变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表
   列表名[切片] = 容器 # 右侧必须是可迭代对象，左侧切片没有创建新列表。遍历列表：
   正向：
   for 变量名 in 列表名:
   变量名就是元素
   反向：
   for 索引名 in range(len(列表名)-1,-1,-1):
   列表名[索引名]就是元素
4. 删除元素：
   列表名.remove(元素)
   del 列表名[索引或切片]

"""
    列表list   的基础操作
"""
# 1. 创建
# -- 直接存储数据
list01 = []
list01 = ["小", "白"]
# -- 将其他可迭代对象存入列表
list01 = list("我是小白啊")

# 2. 增加
list02 = list("我是啊")
# 追加(在末尾)
list02.append("小")  # 在列表末尾加上小
print(list02)  # ['我', '是', '啊', '小']
# 插入(在指定位置)
list02.insert(1, "白")  # 在别表索引是1的位置上加上白
print(list02)  # ['我', '白', '是', '啊', '小']

# 3. 删除
# 根据元素
list03 = list("我是小白啊")
if "小白" in list03:
    list03.remove("小白")  # 备注：如果没有if判断直接删除元素则报错
# 根据位置
# del list01[1]
del list03[1:3]
print(list03)  # ['我', '白', '啊']

# 4. 修改
list04 = list("我是小白啊")
# 索引
list04[0] = "你"  # 索引
print(list04)  # ['你', '是', '小', '白', '啊']
# 切片
# 原理：遍历右侧可迭代对象,将每个元素赋值给左边切片定位的元素
list04[2:3] = [1, 2, 3, 4, 5]
print(list04)  # ['你', '是', 1, 2, 3, 4, 5, '白', '啊']


# 5. 查询
# 索引
list05 = list("我是小白啊")
print(list05[-1])  # 啊
# 切片
# 原理：切片后返回新列表（拷贝）
print(list05[:])  # ['我', '是', '小', '白', '啊']
# 循环
for item in list05:
    print(item)  # 一行一个显示列表中的元素

# 需求倒序获取所有元素（不建议切片）
# for item in list02[::-1]:
#     print(item)

for index in range(len(list05) - 1, -1, -1):
    print(list05[index])  # # 一行一个倒序显示列表中的元素

深拷贝和浅拷贝

浅拷贝：复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
深拷贝：复制整个的变量。

"""
    深拷贝
    优点：
        对其中之一的修改，
        绝对不影响另外一个.
    缺点：
        比较占用内存
"""
# 准备深拷贝的工具
import copy

list01 = [
    [1,2,3],
    [4,5,6]
]
# list02 =list01[:]
# 深拷贝列表
list02 = copy.deepcopy(list01)
list01[0] = "一"
list01[1][0] = "二"
print(list02)#[[1, 2, 3], [4, 5, 6]]

身份运算符

1. 语法:
   x is y
   x is not y
2. 作用：
   is 用于判断两个对象是否是同一个对象,是时返回True,否则返回False。
   is not 的作用与is相反

"""
    身份运算符
"""
list01 = [100]
list02 = [100]

# 两个变量指向的对象是否同一个
print(list01 is list02)# False

list03 = list01
print(list03 is list01)# True

# 原理：判断变量存储的地址是否相同
print(id(list01))# 140235347048584
print(id(list02))# 140235357765192
print(id(list03))# 140235347048584

列表VS字符串

1. 列表和字符串都是序列,元素之间有先后顺序关系。
2. 字符串是不可变的序列,列表是可变的序列。
3. 字符串中每个元素只能存储字符,而列表可以存储任意类型。
4. 列表和字符串都是可迭代对象。
5. 函数：
   将多个字符串拼接为一个。
   result = “连接符”.join(列表)
   将一个字符串拆分为多个。
   列表 = “a-b-c-d”.split(“分隔符”)

"""
    list --> str
    在终端中循环录入字符串，如果录入为空，则停止
    打印所有录入的内容(一个字符串)
"""
list_str = []
while True:
    str_input = input("请输入字符串：")
    if str_input == "":
        break
    list_str.append(str_input)
str_result = "".join(list_str)
print(str_result)

"""
    str --> list
    将英文语句进行反转
    How are you
"""
str_ = "How are you"
list_str = str_.split(" ")
str_result = " ".join(list_str[::-1])
print(str_result)# you are How

列表推导式

1. 定义：
   使用简易方法，将可迭代对象转换为列表。
2. 语法：
   变量 = [表达式 for 变量 in 可迭代对象]
   变量 = [表达式 for 变量 in 可迭代对象 if 条件]
3. 说明:
   如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。

"""
    使用列表推倒式生成1--50之间能被3或5整除的数字
    使用列表推倒式生成5--60之间数字的平方
    将1970年到2050年之间的闰年存入列表
"""
# 1.使用列表推倒式生成1--50之间能被3或5整除的数字
list_01 = [item for item in range(1, 51) if item % 3 == 0 or item % 5 == 0]
print(list_01)

# 2.使用列表推倒式生成5--60之间数字的平方
list_02 = [item ** 2 for item in range(5, 61)]
print(list_02)

# 3.将1970年到2050年之间的闰年存入列表
list_03 = [i for i in range(1970, 2051) if i % 4 == 0 and i % 100 != 0 or i % 400 == 0]
print(list_03)

列表推导式嵌套

1. 语法：
   变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2]
2. 传统写法：

result = []
for r in  ["a", "b", "c"]:
    for c in ["A", "B", "C"]:
        result.append(r + c)

3. 推导式写法：

result = [r + c for r in list01 for c in list02]

元组 tuple

1. 由一系列变量组成的不可变序列容器。
2. 不可变是指一但创建，不可以再添加/删除/修改元素。

基础操作

1. 创建空元组：
   元组名 = ()
   元组名 = tuple()
2. 创建非空元组：
   元组名 = (20,)
   元组名 = (1, 2, 3)
   元组名 = 100,200,300
   元组名 = tuple(可迭代对象)
3. 获取元素：
   变量 = 元组名[索引]
   变量 = 元组名[切片] # 赋值给变量的是切片所创建的新列表
4. 遍历元组：
   正向：
   for 变量名 in 元组名:
   变量名就是元素
   反向：
   for 索引名 in range(len(元组名)-1,-1,-1):
   元组名[索引名]就是元素

# 1. 创建
tuple01 = ()
tuple01 = (4, 545, 5665, 7, 78)
list01 = [54, 5, 56, 67]
# 列表（预留空间） -->  元组（按需分配）
tuple02 = tuple(list01)
#  元组（按需分配） --> 列表（预留空间）
list02 = list(tuple01)
# 特殊
# -- 如果元组只有一个数据,必须在后面添加逗号
tuple03 = (4,)
# -- 小括号可以省略
tuple04 = 4, 5, 6
# -- 可以直接将容器赋值给多个变量
a, b, c = (8, 9, 10)
print(type(tuple04))# <class 'tuple'>
# 2. 查询
# -- 索引
print(tuple01[-1])  # 获取最后一个
print(tuple01[2])  # 获取第三个
# -- 切片
# 原理：创建新容器
print(tuple01[-3:])  # 最后三个
# -- 循环
for item in tuple01:
    print(item)

for i in range(len(tuple01) - 1, -1, -1):
    print(tuple01[i])

作用

1. 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。
2. 元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。
3. 应用：
   变量交换的本质就是创建元组：x, y = （y, x ）
   格式化字符串的本质就是创建元祖：“姓名:%s, 年龄:%d” % (“小白”, 15)

字典 dict

1. 由一系列键值对组成的可变散列容器。
2. 散列：对键进行哈希运算，确定在内存中的存储位置，每条数据存储无先后顺序。
3. 键必须惟一且不可变(字符串/数字/元组)，值没有限制。

基础操作

1. 创建字典：
   字典名 = {键1：值1，键2：值2}
   字典名 = dict (可迭代对象)
2. 添加/修改元素：
   语法:
   字典名[键] = 数据
   说明:
   键不存在，创建记录。
   键存在，修改值。
3. 获取元素：
   变量 = 字典名[键] # 没有键则错误
4. 遍历字典：
   for 键名 in 字典名:
   字典名[键名]
   for 键名,值名 in 字典名.items():
   语句
5. 删除元素：
   del 字典名[键]

# 1. 创建
dict01 = {}
dict01 = {101: "悟空", 102: "八戒", 103: "唐僧"}

# 列表(格式) --> 字典
# 格式：[(k,v),(k,v)]
dict02 = dict(["悟空", (102, "猪八戒"), [103, "唐僧"]])
# 字典 --> 列表(只保留key)
list01 = list(dict01)

# 2. 添加
# --通过键-值
dict01[104] = "沙僧"

# 3. 修改（如果key存在,则为修改,不存在则为添加）
dict01[101] = "孙悟空"

# 4. 删除
# 如果key不存在则报错
if 108 in dict01:
    del dict01[108]

# 5. 查询
# key/循环
print(dict01[101])

# -- 获取所有key
for key in dict01:
    print(key)

# --获取所有value
for value in dict01.values():
    print(value)

# --获取所有key - value
# for item in dict01.items():
#     print(item)# (k,v)

for key,value in dict01.items():
    print(key)
    print(value)

字典 VS 列表

1. 都是可变容器。
2. 获取元素方式不同,列表用索引,字典用键。
3. 字典的插入,删除,修改的速度快于列表。
4. 列表的存储是有序的,字典的存储是无序的。

集合 set

1. 由一系列不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器。
2. 相当于只有键没有值的字典(键则是集合的数据)。

基础操作

1. 创建空集合：
   集合名 = set()
   集合名 = set(可迭代对象)
2. 创建具有默认值集合：
   集合名 = {1, 2, 3}
   集合名 = set(可迭代对象)
3. 添加元素：
   集合名.add(元素)
4. 删除元素：
   集合名.discard(元素)

运算

1. 交集&：返回共同元素。
   s1 = {1, 2, 3}
   s2 = {2, 3, 4}
   s3 = s1 & s2 # {2, 3}

2. 并集：返回不重复元素
   s1 = {1, 2, 3}
   s2 = {2, 3, 4}
   s3 = s1 | s2 # {1, 2, 3, 4}

3. 补集-：返回只属于其中之一的元素
   s1 = {1, 2, 3}
   s2 = {2, 3, 4}
   s1 - s2 # {1} 属于s1但不属于s2

   补集^：返回不同的的元素
   s1 = {1, 2, 3}
   s2 = {2, 3, 4}
   s3 = s1 ^ s2 # {1, 4} 等同于(s1-s2 | s2-s1)

4. 子集<：判断一个集合的所有元素是否完全在另一个集合中

5. 超集>：判断一个集合是否具有另一个集合的所有元素
   s1 = {1, 2, 3}
   s2 = {2, 3}
   s2 < s1 # True
   s1 > s2 # True

6. 相同或不同== !=：判断集合中的所有元素是否和另一个集合相同。
   s1 = {1, 2, 3}
   s2 = {3, 2, 1}
   s1 == s2 # True
   s1 != s2 # False
   子集或相同,超集或相同 <= >=

# 1. 创建
# set01 ={}  # 创建字典,不是集合
set01 = {"悟空", "八戒", "唐僧"}
list01 = ["悟空", "八戒", "唐僧", "八戒"]
set02 = set(list01)
print(set02)

# 2. 添加
set01.add("沙僧")

# 3. 删除
set01.remove("悟空")

# 4. 修改(先删除后添加)

print(set01)

# 5. 数学运算
# 交集
#  &
s01 = {1, 2, 3}
s02 = {2, 3, 4}
print(s01 & s02)  # {2, 3}
# 并集
#  |
print(s01 | s02)  # {1, 2, 3, 4}
# 补集
# ^
print(s01 ^ s02)  # {1, 4}
print(s01 - s02)  # {1 }
print(s02 - s01)  # {4 }
# 子集超集
s03 = {2, 3}
print(s03 < s01)