八大数据类型
概念
Python中有许多数据类型，但常用的八大数据类型包括：
-
整数（int）: 表示整数值，例如：
x = 10 -
浮点数（float）: 表示带有小数点的数值，例如：
y = 3.14 -
字符串（str）: 表示文本数据，例如：
text = "Hello, World!" -
列表（list）: 有序可变序列，可以包含不同类型的元素，例如：
my_list = [1, 2, "three"] -
元组（tuple）: 有序不可变序列，用于保存有关联的元素，例如：
my_tuple = (1, 2, "three") -
集合（set）: 无序可变集合，用于存储唯一元素，例如：
my_set = {1, 2, 3} -
字典（dict）: 无序的键-值对集合，用于存储相关数据，例如：
my_dict = {'name': 'John', 'age': 25} -
布尔值（bool）: 表示真（True）或假（False），用于逻辑判断，例如：
is_true = True
整数和浮点数
# 整型
number = 18
print(number) # 18
print(type(number)) # <class 'int'>
print(id(number)) # 140705976863704
# 浮点型
number_float = 18.6
print(number_float) # 18.6
print(type(number_float)) # <class 'float'>
print(id(number_float)) # 1864376363952
# 四则运算
x = 18
y = 5
print(x + y) # 23
print(x - y) # 13
print(x * y) # 90
print(x / y) # 3.6 tips: 只要运算了除法，结果必然是浮点数
int相关用法
int("0o52", 8) # 42
int("0b101010", 2) # 42
int("0x2a", 16) # 42
数字转进制
# 16进制
hex(42) # '0x2a'
# 2进制
bin(42) # '0b101010'
# 8进制
oct(42) # '0o52'
字符串
定义一个字符串
name = "小满"
age = 3
sentence = """
山腰的风景很美
然而
我还是
想去山顶看看
"""
字符串的嵌套
外面是单引号, 里面的字符串使用双引号
外面是双引号, 里面的字符串使用单引号
content = '编程里有一个DRY原则: "Don\'t repeat your self."'
print(content) # 编程里有一个DRY原则: "Don't repeat your self."
content = "编程里有一个DRY原则: 'Do not repeat your self.'"
print(content) # 编程里有一个DRY原则: 'Do not repeat your self.'
原始字符串
使用原始字符串, 就是在字符串最前面加上一个r, 一般情况下正则用的会比较多
# 未使用原始字符串
path = "c:\teacher\homework"
print(path) # c: eacher\homework
# 使用了原始字符串
path = r"c:\teacher\homework"
print(path) # c:\teacher\homework
字符串相加
first_name = "jack"
last_name = "chen"
full_name = first_name + " " + last_name
print(full_name) # jack chen
字符串相乘
word = "ha"
sentence = "He said " + word * 5
print(sentence) # He said hahahahaha
字符串索引
索引从0开始，在字符串中取值可以使用
str[index]的方法去取值，-1为最后一个值。
sentence = "下雨了别跑，反正前面也是雨。"
print(sentence[0]) # 下
print(sentence[-2]) # 雨
查看索引
# 方法1 index
# 找到了返回对应位置，找不到就报错
sentence = "下雨了别跑，反正前面也是雨。"
print(sentence.index("别跑")) # 3
sentence = "下雨了别跑，反正前面也是雨。"
print(sentence.index("别跑啦")) # 报错 ValueError: substring not found
# 方法2 find
# 找到了返回对应位置，找不到返回-1
sentence = "下雨了别跑，反正前面也是雨。"
print(sentence.find("前面")) # 8
sentence = "下雨了别跑，反正前面也是雨。"
print(sentence.find("后面")) # -1
切片
sentence = "下雨了别跑，反正前面也是雨。"
print(sentence[:3]) # 下雨了
print(sentence[-6:-1]) # 前面也是雨
print(sentence[:]) # 下雨了别跑，反正前面也是雨
统计次数
sentence = "下雨了别跑，反正前面也是雨。"
print(sentence.count("雨")) # 2
print(sentence.count("跑")) # 1
print(sentence.count("走")) # 0
字符串转义
| 转义字符 | 说明 |
|---|---|
| \n | 换行符，将光标位置移到下一行开头。 |
| \r | 回车符，将光标位置移到本行开头。 |
| \t | 水平制表符，也即 Tab 键，一般相当于四个空格。 |
| \a | 蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。 |
| \b | 退格（Backspace），将光标位置移到前一列。 |
| \ | 反斜线 |
| ' | 单引号 |
| " | 双引号 |
| \ | 在字符串行尾的续行符，即一行未完，转到下一行继续写。 |
字符串格式化输出
f-string格式化
f-string 是在 Python 3.6 版本引入的一种字符串格式化方法，它允许在字符串中嵌入表达式，并在运行时对它们进行求值。使用 f-string 可以更简洁和直观地进行字符串格式化。
f-string 的语法很简单，只需在字符串前加上字母 'f' 或 'F'，然后在字符串中使用花括号 {} 括起表达式。在花括号中，你可以放置变量、表达式或调用函数。
food = "冰淇淋"
number = 2
sentence = f"“我不会因为一个{food}和你走！” “{number}个” “好那我去收拾行李。”"
print(sentence) # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”
进制格式化，结果不含前缀
num = 42
# 二进制
binary = f"Binary: {num:b}"
print(binary) # 输出: Binary: 101010
# 八进制
octal = f"Octal: {num:o}"
print(octal) # 输出: Octal: 52
# 十六进制
hex_lower = f"Hex (lowercase): {num:x}"
print(hex_lower) # 输出: Hex (lowercase): 2a
hex_upper = f"Hex (uppercase): {num:X}"
print(hex_upper) # 输出: Hex (uppercase): 2A
.format格式化
基本语法
food = "冰淇淋"
number = 2
sentence = "“我不会因为一个{}和你走！” “{}个” “好那我去收拾行李。”".format(food, number)
print(sentence) # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”
位置参数
food = "冰淇淋"
number = 2
sentence = "“我不会因为一个{1}和你走！” “{0}个” “好那我去收拾行李。”".format(number, food)
print(sentence) # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”
关键字参数
sentence = "“我不会因为一个{food}和你走！” “{number}个” “好那我去收拾行李。”".format(food="冰淇淋", number=2)
print(sentence) # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”
混合使用位置参数和关键字参数
sentence = "“我不会因为一个{}和你走！” “{number}个” “好那我去收拾行李。”".format("冰淇淋", number=2)
print(sentence) # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”
解包字典
data = {
"food": "冰淇淋",
"number": 2
}
sentence = "“我不会因为一个{food}和你走！” “{number}个” “好那我去收拾行李。”".format(**data)
print(sentence) # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”
其他方法补充
# 保留几位小数
# {:.nf} n表示几位小数
from math import pi
print("The value of pi is approximately: {:.2f}".format(pi))
# The value of pi is approximately: 3.14
# 填充与对齐
number = 42
# {:填充字符 对其方式 共几位} tips:中间无空格
# 尖角号朝左边就是左对齐
# 尖角号朝右边就是右对齐
# ^ 表示居中对齐 tips:英文模式下 shift + 6
# 左对齐 占位10位 右边填充指定字符
print("{:*<10}".format(number)) # 42********
# 右对齐 占位10位 左边填充指定字符
print("{:*>10}".format(number)) # ********42
# 居中对齐 占位10位 左右两侧填充指定字符
print("{:*^10}".format(number)) # ****42****
# 千位分隔符
# 语法 {:,}
phone_number = 13800138000
print("谁能告诉我这是什么电话号码: {:,}".format(phone_number))
# 谁能告诉我这是什么电话号码: 13,800,138,000
# 扩展知识
# 在python中，int类型和float类型，如果数字过长，可以使用 _ 下划线去连接
phone_number = 1380_0138_000
print(phone_number) # 13800138000
print("谁能告诉我这是什么电话号码: {:,}".format(phone_number))
# 谁能告诉我这是什么电话号码: 13,800,138,000
指定宽度和精度
# {:n.3f}
# n表示一共多少位字符
# tips: n的左侧可以填充对其方式以及填充字符 {:0>10.3f}
# 如何不写默认是右对齐填充空白
# 3表示小数部分的精度
# f表示是一个浮点数
# 字符共10位 右对齐 不足的位置填充*号 小数点保留3位
print("{:*>10.3f}".format(number))
# 字符共10位 右对齐 不足的位置填充空白 小数点保留3位
print("{:10.3f}".format(number))
# 字符共10位 右对齐 不足的位置填充数字0 小数点保留3位
print("{:0>10.3f}".format(number))
# 结果如下
**1234.568
1234.568
001234.568
进制格式化
decimal_number = 42
# 将整数格式化为二进制，无前缀 "0b"
binary_string = "Binary representation: {:b}".format(decimal_number)
print(binary_string) # Hex representation with prefix: 101010
# 将整数格式化为八进制，无前缀 "0o"
octal_string = "Octal representation: {:o}".format(decimal_number)
print(octal_string) # Hex representation with prefix: 52
# 将整数格式化为十六进制，无前缀 "0x"
hex_string = "Hex representation: {:x}".format(decimal_number)
print(hex_string) # Hex representation with prefix: 2a
# 将整数格式化为十六进制，带有前缀 "0x"
hex_string_with_prefix = "Hex representation with prefix: {:#x}".format(decimal_number)
print(hex_string_with_prefix) # Hex representation with prefix: 0x2a
解包字典
如果你想在 format() 方法中不传递任何参数，并使用两个星号 ** 解包字典以获取字典的值，可以使用以下方法：
person = {"name": "Alice", "age": 25}
message = "My name is {} and I am {} years old.".format(*person.values())
print(message)
输出结果将是：
My name is Alice and I am 25 years old.
在这个示例中，我们使用 person.values() 来获取字典 person 中的所有值，并将其作为参数传递给 format() 方法。在 format() 方法中，我们使用花括号 {} 来表示占位符，而不传递任何参数。
通过这种方式，我们可以在 format() 方法中不传递任何参数，并使用两个星号 ** 解包字典以获取字典的值，并将其正确打印出来。
format_map格式化
str.format_map(mapping) 是 Python 字符串的方法之一，它用于使用映射对象（通常是字典）中的键值对来替换字符串中的占位符。这个方法类似于 str.format()，但是它接受一个字典作为参数，用字典中的键值对来填充字符串中的占位符。
以下是一个简单的示例：
# 使用 format_map 替换字符串中的占位符
person = {'name': 'Alice', 'age': 30}
sentence = "My name is {name} and I am {age} years old."
formatted_sentence = sentence.format_map(person)
print(formatted_sentence)
在这个例子中，{name} 和 {age} 是占位符，format_map(person) 使用字典中的键值对来替换这些占位符。输出结果将是：
My name is Alice and I am 30 years old.
需要注意的是，format_map() 方法在替换占位符时，如果字典中缺少对应的键，不会引发 KeyError，而是保留占位符不变。这与 format() 方法不同，format() 方法在遇到未知的键时会引发 KeyError。
# 使用 format_map 时不会引发 KeyError
person = {'name': 'Alice'}
sentence = "My name is {name} and I am {age} years old."
formatted_sentence = sentence.format_map(person)
print(formatted_sentence)
输出结果：
My name is Alice and I am {age} years old.
这使得 format_map() 方法在处理部分缺失的数据时更为灵活。
%格式化
food = "冰淇淋"
sentence = "“我不会因为一个%s和你走！” “2个” “好那我去收拾行李。”" % food
print(sentence) # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”
number = 2
sentence = "“我不会因为一个冰淇淋和你走！” “%d个” “好那我去收拾行李。”" % number
print(sentence) # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”
number = "2" # 注意，这里是字符串
sentence = "“我不会因为一个冰淇淋和你走！” “%d个” “好那我去收拾行李。”" % number
print(sentence) # 报错 TypeError: %d format: a real number is required, not str
# 当参数大于1个的时候，百分号右边需要用一共括号括起来
food = "冰淇淋"
number = 2
sentence = "“我不会因为一个%s和你走！” “%d个” “好那我去收拾行李。”" % (food, number)
print(sentence) # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”
# %.nf 浮点数，n表示保留几位小数
from math import pi
print("The value of pi is approximately: %.2f" % pi)
# The value of pi is approximately: 3.14
进制格式化
decimal_number = 42
# 将整数格式化为二进制，带有前缀 "0b"
binary_string = "Binary representation: %s" % bin(decimal_number)
print(binary_string) # Binary representation: 0b101010
# 将整数格式化为八进制，无前缀 "0o"
octal_string = "Octal representation: %o" % decimal_number
print(octal_string) # Octal representation: 52
# 将整数格式化为十六进制，无前缀 "0x"
hex_string = "Hex representation: %x" % decimal_number
print(hex_string) # Hex representation: 2a
总结
更推荐使用f-string格式化或者.format格式化
字符串常用方法
dir(str)
text = "hello worLD"
print(f"text的值为 '{text}'")
print("text.title() 输出", text.title())
print("text.lower() 输出", text.lower())
print("text.upper() 输出 ", text.upper())
print("text.swapcase() 输出", text.swapcase())
print("text.center(20, '*') 输出", text.center(20, "*"))
print("text.ljust(20, '=') 输出", text.ljust(20, "="))
print("text.rjust(20, '=') 输出", text.rjust(20, "="))
print("text.zfill(20) 输出", text.zfill(20))
print("text.strip('LD') 输出", text.strip("LD"))
print("text.rstrip('LD') 输出", text.rstrip("LD"))
print("text.lstrip('h') 输出", text.lstrip('h'))
print("text.split() 输出", text.split())
print("text.casefold() 输出", text.casefold())
print("text.find('1') 输出", text.find('1'), "解析: 如果使用find查找, 找不到就是-1")
print("text.find('L') 输出", text.find('L'))
print("text.find('L', 1) 输出", text.find('L', 1), "解析: 第二个参数表示从哪里开始找")
print("text.count('L') 输出", text.count('L'), "解析: 如果找不到不会报错, 会返回0")
print("text.startswith('hello') 输出", text.startswith('hello'))
print("text.endswith('hello') 输出", text.endswith('hello'))
print("'11'.isdigit() 输出", '11'.isdigit())
print("'11'.isalnum() 输出", '11'.isalnum())
print("'11'.isaplha() 输出", '11'.isalpha())
print("'11'.isnumeric() 输出", '11'.isnumeric())
print("'hello'.islower() 输出", 'hello'.islower())
print("'hello'.isupper() 输出", 'hello'.isupper())
print("'hello'.istitle() 输出", 'hello'.istitle())
print("text.replace('worLD', '小满') 输出", text.replace('worLD', '小满'))
# str.isspace() 是 Python 字符串对象的一个方法，用于检查字符串是否全由空白字符组成。空白字符包括空格、制表符、换行符等。
print("'hello world'.isspace() 输出", "hello world".isspace())
# str.isprintable() 是 Python 字符串对象的方法，用于检查字符串是否可打印。
# 可打印字符是指除了空白字符之外的字符，这些字符在屏幕上会有可见的表示，例如字母、数字、标点符号等。
print(r'"\n\t".isprinttable() 输出', "\n\t".isprintable())
print("'-'.join(['love', 'you']) 输出", '-'.join(['love', 'you']))
# python3.9新增的两个方法
# removeprefix 移除开始的指定字符，如不存在返回整个字符
# removesuffix 移除结尾的指定字符，如不存在返回整个字符
print("text.removeprefix('hello') 输出", text.removeprefix("hello"))
print("text.removesuffix('worLD') 输出", text.removesuffix("worLD"))
结果如下
text的值为 'hello worLD'
text.title() 输出 Hello World
text.lower() 输出 hello world
text.upper() 输出 HELLO WORLD
text.swapcase() 输出 HELLO WORld
text.center(20, '*') 输出 ****hello worLD*****
text.ljust(20, '=') 输出 hello worLD=========
text.rjust(20, '=') 输出 =========hello worLD
text.zfill(20) 输出 000000000hello worLD
text.strip('LD') 输出 hello wor
text.rstrip('LD') 输出 hello wor
text.lstrip('h') 输出 ello worLD
text.split() 输出 ['hello', 'worLD']
text.casefold() 输出 hello world
text.find('1') 输出 -1 解析: 如果使用find查找, 找不到就是-1
text.find('L') 输出 9
text.find('L', 1) 输出 9 解析: 第二个参数表示从哪里开始找
text.count('L') 输出 1 解析: 如果找不到不会报错, 会返回0
text.startswith('hello') 输出 True
text.endswith('hello') 输出 False
'11'.isdigit() 输出 True
'11'.isalnum() 输出 True
'11'.isaplha() 输出 False
'11'.isnumeric() 输出 True
'hello'.islower() 输出 True
'hello'.isupper() 输出 False
'hello'.istitle() 输出 False
text.replace('worLD', '小满') 输出 hello 小满
'hello world'.isspace() 输出 False
"\n\t".isprinttable() 输出 False
'-'.join(['love', 'you']) 输出 love-you
text.removeprefix('hello') 输出 worLD
text.removesuffix('worLD') 输出 hello
name = "amigo123"
print(name.isalnum()) # 字符串中既可以包含数字也可以包含字母，True
print(name.isalpha()) # 字符串中只包含字母，False
print(name.isidentifier()) # 字符串是否是合法标识符，True
print(name.islower()) # 字符串是否是纯小写，True
print(name.isupper()) # 字符串是否是纯大写，False
print(name.isspace()) # 字符串是否全是空格，False
print(name.istitle()) # 字符串中的单词首字母是否都是大写，False
casefold方法
str.casefold() 是 Python 字符串对象的方法，用于执行字符串的大小写折叠（case folding）。大小写折叠是一种更加广泛的字符匹配方式，通常用于比较字符串而忽略大小写，并且比 str.lower() 更具有 Unicode 兼容性。
在 Python 中，str.casefold() 将字符串中的所有字符转换为小写，并且还考虑了一些特殊字符的 Unicode 等价物。这使得字符串比较更加严格，适用于不同语言和区域的情况。
以下是一个示例：
string1 = "Hello"
string2 = "heLLo"
# 使用 casefold 进行比较
if string1.casefold() == string2.casefold():
print("Strings are case-insensitive equal.")
else:
print("Strings are not case-insensitive equal.")
在这个例子中，string1.casefold() 和 string2.casefold() 都将字符串转换为小写，并进行大小写折叠比较。输出结果将是 "Strings are case-insensitive equal."。
使用 str.casefold() 在进行字符串比较时是一种推荐的方式，尤其是当你需要考虑多语言、特殊字符和 Unicode 等价性的情况。
maketrans方法
str.maketrans(x[, y[, z]]) 是 Python 字符串对象的一个类方法，用于创建一个转换表（translation table）对象，这个对象可以在字符串的 translate() 方法中使用，用来执行字符的映射或删除操作。
参数说明：
x：单个字符的字符串，表示需要映射的字符集。y：与x具有相同长度的字符串，表示将x中的字符映射到的字符集。z：字符串，表示要删除的字符集。
如果只提供了 x 参数，它必须是一个长度为 256 的字符串，其中每个字符的 Unicode 码点与其在表中的位置相对应。如果提供了 x 和 y 两个参数，它们必须是等长的字符串，表示字符的一对一映射。如果提供了 z 参数，它是一个字符串，其中包含要删除的字符。
以下是一些示例：
# 创建一个简单的映射表，将 'abc' 映射到 '123'
translation_table = str.maketrans('abc', '123')
# 使用映射表进行字符串的映射
original_string = "abcxyz"
mapped_string = original_string.translate(translation_table)
print(mapped_string)
输出结果：
123xyz
在这个例子中，maketrans('abc', '123') 创建了一个映射表，该表将字符 'a' 映射到 '1'，'b' 映射到 '2'，'c' 映射到 '3'。然后，translate() 方法使用这个映射表将字符串中的字符进行映射。
这个方法常用于一些字符替换或字符删除的操作。
partition方法
str.partition(sep) 是 Python 字符串对象的一个方法，用于根据指定的分隔符 sep 将字符串分割成三部分：分隔符之前的部分、分隔符本身、分隔符之后的部分。如果字符串中不包含分隔符，那么将返回原始字符串和两个空字符串。
以下是一个简单的示例：
text = "python:is:fun"
# 使用 partition() 方法根据 ":" 分割字符串
result = text.partition(":")
print(result)
输出结果：
('python', ':', 'is:fun')
在这个例子中，partition(":") 方法根据冒号 : 将字符串分成三部分。结果是一个包含三个元素的元组，其中第一个元素是分隔符之前的部分，第二个元素是分隔符本身，第三个元素是分隔符之后的部分。
这个方法通常在需要从字符串中提取特定部分时很有用，特别是在处理具有固定格式的字符串时。
结果是元组
列表
列表里面可以放任何数据类型，如果要取值，比字符串更加方便
但凡能被for循环遍历的类型都可以当作参数传给list()转成列表
for循环内部不建议修改数据，如果要修改放循环外修改，否则会导致代码逻辑很混乱。
data_list = [42, 3.14, "浮生六记", {"南康白起": "我等你到35岁"}, True, False, set(), ["我爱你", "与你无关"]]
print(type(data_list))
print(data_list)
# 结果如下
<class 'list'>
[42, 3.14, '浮生六记', {'南康白起': '我等你到35岁'}, True, False, set(), ['我爱你', '与你无关']]
索引取值
data_list = [42, 3.14, "浮生六记", {"南康白起": "我等你到35岁"}, True, False, set(), ["我爱你", "与你无关"]]
print(data_list[2]) # 浮生六记
嵌套取值
data_list = [42, 3.14, "浮生六记", {"南康白起": "我等你到35岁"}, True, False, set(), ["我爱你", "与你无关"]]
print(data_list[-1][-2]) # 我爱你
print(data_list[3]['南康白起']) # 我等你到35岁
data_list = [42, 3.14, "浮生六记", {"南康白起": "我等你到35岁"},{'book': ["活着", "杀死一只知更鸟", ("余华", "哈珀·李")]}]
print(data_list[4]['book'][1]) # 杀死一只知更鸟
print(data_list[4]['book'][2][-1]) # 哈珀·李
列表相加或相乘
# 列表相加
name_list = ["小满", "王昭君"]
hero_list = ["大乔", "小乔", "海月"]
real_list = name_list + hero_list
print(real_list) # ['小满', '王昭君', '大乔', '小乔', '海月']
# 列表相乘
hero_list = ["大乔", "小乔", "海月"]
real_list = hero_list * 3
print(real_list)
# ['大乔', '小乔', '海月', '大乔', '小乔', '海月', '大乔', '小乔', '海月']
加入列表
append
name_list = ["小满"]
name_list.append({"南康": "快快长大"})
name_list.append(["余华", "活着"])
name_list.append((True, "Yes"))
name_list.append("我是一个士兵，我爱上了将军的女儿。")
print(name_list)
# ['小满', {'南康': '快快长大'}, ['余华', '活着'], (True, 'Yes'), '我是一个士兵，我爱上了将军的女儿。']
extend
可迭代元素都可以通过extend添加
name_list = ["小满", "王昭君"]
hero_list = ["大乔", "小乔", "海月"]
name_list.extend(name_list)
print(name_list) # ['小满', '王昭君', '小满', '王昭君']
print(hero_list) # ['大乔', '小乔', '海月']
name_list = ["小满", "王昭君"]
hero_dict = {
"大乔": 4,
"小乔": 3
}
# 添加的是字典的键
name_list.extend(hero_dict)
print(name_list) # ['小满', '王昭君', '大乔', '小乔']
name_list = ["小满", "王昭君"]
sentence = "你是年少的欢喜"
name_list.extend(sentence)
print(name_list) # ['小满', '王昭君', '你', '是', '年', '少', '的', '欢', '喜']
name_list = ["小满", "王昭君"]
name_tuple = ["小乔", "大乔"]
name_list.extend(name_tuple)
print(name_list) # ['小满', '王昭君', '小乔', '大乔']
name_list = ["小满", "王昭君"]
name_set = {"小乔", "大乔"}
name_list.extend(name_set)
print(name_list) # ['小满', '王昭君', '小乔', '大乔']
insert
name_list = ["小满", "王昭君"]
name_list.insert(1, "海月")
print(name_list) # ['小满', '海月', '王昭君']
使用+号
name_list = ["小满", "王昭君"]
hero_list = ["王昭君", "海月"]
result = name_list + hero_list
print(result) # ['小满', '王昭君', '王昭君', '海月']
删除元素
pop方法
name_list = ["小满", "王昭君", "海月"]
print(name_list) # ['小满', '王昭君', '海月']
# pop()括号里面可以传一个索引
# 当不传任何索引时候，默认删除列表的最后一个元素，返回值就是被删除的元素
deleted_hero = name_list.pop()
print(f"{deleted_hero} 被删除了。") # 海月 被删除了。
print(name_list) # ['小满', '王昭君']
# 传入索引, 删除指定索引位置的元素
deleted_hero = name_list.pop(1)
print(f"{deleted_hero} 被删除了") # 王昭君 被删除了
print(name_list) # ['小满']
del方法
按索引去删除
# 语法 del list[index]
name_list = ["小满", "王昭君", "海月"]
del name_list[1]
print(name_list) # ['小满', '海月']
按切片去删除
# 0 1 2 3 4
name_list = ["小满", "王昭君", "海月", "大乔", "小乔"]
del name_list[1:4] # ['小满', '小乔']
print(name_list)
# 0 1 2 3 4
name_list = ["小满", "王昭君", "海月", "大乔", "小乔"]
del name_list[::2]
print(name_list) # ['王昭君', '大乔']
# 0 1 2 3 4
name_list = ["小满", "王昭君", "海月", "大乔", "小乔"]
del name_list[1::2]
print(name_list) # ['小满', '海月', '小乔']
remove方法
name_list = ['小满', '大乔', '海月', '小乔']
# list.remove()无返回值
result = name_list.remove('大乔')
print(result) # None
name_list = ['小满', '大乔', '海月', '小乔']
name_list.remove('大乔')
print(name_list) # ['小满', '海月', '小乔']
name_list = ['小满', '大乔', '海月', '小乔']
# 当删除的元素不存在会报错
name_list.remove('王昭君')
print(name_list) # ValueError: list.remove(x): x not in list
报错解决方案，可以先判断是否在列表里面
name_list = ['小满', '大乔', '海月', '小乔']
name = "王昭君"
if name in name_list:
name_list.remove(name)
print(name_list) # ['小满', '大乔', '海月', '小乔']
name_list = ['小满', '大乔', '海月', '小乔']
name = "海月"
if name in name_list:
name_list.remove(name)
print(name_list) # ['小满', '大乔', '小乔']
列表排序
sort
列表里面的元素必须是同种类型才可以
可以传入两个参数，一个是key 另外一个是bool值
默认是升序排序
number_list = [58, 59, 60, 69, 31, 93, 74, 47, 91, 95]
# list.sort() 无返回值
result = number_list.sort()
print(result) # None
number_list = [58, 59, 60, 69, 31, 93, 74, 47, 91, 95]
# 默认从小到大
number_list.sort()
print(number_list) # [31, 47, 58, 59, 60, 69, 74, 91, 93, 95]
number_list = [58, 59, 60, 69, 31, 93, 74, 47, 91, 95]
# list.sort()可以接受一个参数
# 默认从小到大
# 为True结果从大到小
number_list.sort(reverse=True)
print(number_list) # [95, 93, 91, 74, 69, 60, 59, 58, 47, 31]
sorted
sorted(iterable, key=None, reverse=False)函数用于对可迭代对象进行排序。
它接受三个参数：
iterable：要排序的可迭代对象。
key：可选参数，用于指定排序的依据。默认为None，表示按照元素的自然顺序进行排序。
reverse：可选参数，用于指定是否以逆序进行排序。默认为False，表示升序排序。
用一个新的变量值去接受，不影响原列表（id不一样）
number_list = [58, 59, 60, 69, 31, 93, 74, 47, 91, 95]
new_number_list = sorted(number_list)
print(number_list) # [58, 59, 60, 69, 31, 93, 74, 47, 91, 95]
print(new_number_list) # [31, 47, 58, 59, 60, 69, 74, 91, 93, 95]
number_list = [58, 59, 60, 69, 31, 93, 74, 47, 91, 95]
new_number_list = sorted(number_list, reverse=True)
print(number_list) # [58, 59, 60, 69, 31, 93, 74, 47, 91, 95]
print(new_number_list) # [95, 93, 91, 74, 69, 60, 59, 58, 47, 31]
当结合lambda函数使用时，可以自定义排序的规则或反转的方式。lambda函数是一种匿名函数，可以在需要一个简单函数的地方使用。
下面是一个使用sorted()函数结合lambda函数的示例，按照元素的绝对值进行排序：
number_list = [58, 59, -7, 60, -18, 69, 31, -36, 52, 35]
new_number_list = sorted(number_list, key=lambda x: abs(x))
print(number_list) # [58, 59, 60, 69, 31, 93, 74, 47, 91, 95]
print(new_number_list) # [-7, -18, 31, 35, -36, 52, 58, 59, 60, 69]
在这个示例中，lambda x: abs(x)定义了一个匿名函数，它以参数x为输入，返回x的绝对值。sorted()函数根据这个绝对值的规则对numbers列表进行排序。
reverse
name_list = ['小满', '大乔', '海月']
# list.reverse()无返回值
result = name_list.reverse()
print(result) # None
name_list = ['小满', '大乔', '海月']
name_list.reverse()
print(name_list) # ['海月', '大乔', '小满']
reversed
reversed(sequence)函数用于反转序列中的元素。
它接受一个参数：
sequence：要反转的序列，可以是列表、元组或字符串。
number_list = [58, 59, 60, 69, 31, 93, 74, 47, 91, 95]
new_number_list = list(reversed(number_list))
print(number_list) # [58, 59, 60, 69, 31, 93, 74, 47, 91, 95]
print(new_number_list) # [95, 93, 91, 74, 69, 60, 59, 58, 47, 31]
count统计次数
name_list = ['小满', '大乔', '海月', '小乔', "小满"]
count= name_list.count("小满")
print(count) # 2
复制列表
copy方法
内存地址不一样
name_list = ['小满', '大乔', '海月', '小乔']
hero_list = name_list.copy()
print(name_list) # ['小满', '大乔', '海月', '小乔']
print(hero_list) # ['小满', '大乔', '海月', '小乔']
print(id(name_list)) # 2281024354880
print(id(hero_list)) # 2281024342272
name_list.remove('海月')
# list.copy()方法创建的列表id和之前的不一样
# 所以当其中一个列表操作增删改查的时候，不会影响另外一个列表
print(name_list) # ['小满', '大乔', '小乔']
print(hero_list) # ['小满', '大乔', '海月', '小乔']
直接用=号赋值
内存地址一样
name_list = ['小满', '大乔', '海月', '小乔']
hero_list = name_list
print(name_list) # ['小满', '大乔', '海月', '小乔']
print(hero_list) # ['小满', '大乔', '海月', '小乔']
print(id(name_list)) # 1144123914816
print(id(hero_list)) # 1144123914816
name_list.remove("海月")
# [:]赋值的方法创建的列表id和之前的一样
# 所以当其中一个列表操作增删改查的时候，会影响另外一个列表
print(name_list) # ['小满', '大乔', '小乔']
print(hero_list) # ['小满', '大乔', '小乔']
v1 = [1,2,3,4,5]
v2 = [v1,v1,v1]
v2[1][0] = 111
v2[2][0] = 222
print(id(v1)) # 2133014532800
for inner_list in v2:
print(id(inner_list)) # 2133014532800 重复3次
print(v1) # [222, 2, 3, 4, 5]
print(v2) # [[222, 2, 3, 4, 5], [222, 2, 3, 4, 5], [222, 2, 3, 4, 5]]
使用[:]赋值
内存地址不一样
name_list = ['小满', '大乔', '海月', '小乔']
hero_list = name_list[:]
print(name_list) # ['小满', '大乔', '海月', '小乔']
print(hero_list) # ['小满', '大乔', '海月', '小乔']
print(id(name_list)) # 2217441000000
print(id(hero_list)) # 2217440987392
name_list.remove("海月")
# [:]赋值的方法创建的列表id和之前的不一样
# 所以当其中一个列表操作增删改查的时候，不会影响另外一个列表
print(name_list) # ['小满', '大乔', '小乔']
print(hero_list) # ['小满', '大乔', '海月', '小乔']
清空列表
clear方法
# list.clear()方法无返回值
name_list = ['小满', '大乔', '海月', '小乔']
result = name_list.clear()
print(result) # None
name_list = ['小满', '大乔', '海月', '小乔']
name_list.clear()
print(name_list) # []
删除整个列表
name_list = ['小满', '大乔', '海月', '小乔']
print(name_list) # ['小满', '大乔', '海月', '小乔']
del name_list
print(name_list) # 报错 NameError: name 'name_list' is not defined.
列表补充
队列 FIFO 先进先出
- 相当于上扶梯，先上的先出来
>>> l = []
>>> l.append(1)
>>> l.append(2)
>>> l.append(3)
>>> print(l)
[1, 2, 3]
>>> l.pop(0)
1
>>> l.pop(0)
2
>>> l.pop(0)
3
>>> l
[]
堆栈LIFO 后进先出
- 相当于往衣柜放衣服，后放进去的先取出来
>>> l = []
>>> l.append(1)
>>> l.append(2)
>>> l.append(3)
>>> print(l)
[1, 2, 3]
>>> l.pop()
3
>>> l.pop()
2
>>> l.pop()
1
>>> l
[]
字典
定义一个字典
# 方式1 直接使用一个空字典
data_dict = {}
# 方式2 使用定义字典的关键字
data_dict = dict()
字典的取值
# 方式1 通过dict[key]的方式去取值
data_dict = {
"name": "小满",
"age": 3
}
info = data_dict['name']
print(info) # 小满
# 如果key 不在字典中 使用dict[key]的方法会报错
data_dict = {
"name": "小满",
"age": 3
}
info = data_dict['sex']
print(info) # KeyError: 'sex'
# 方式2 通过dict.get(key)的方式去取值
data_dict = {
"name": "小满",
"age": 3
}
info = data_dict.get("name")
print(info) # 小满
# 通过dict.get(key)的方式，如果key不在指定中，并不会报错
data_dict = {
"name": "小满",
"age": 3
}
# 情况1、未给get设置第二个参数
info = data_dict.get("sex")
print(info) # None
# 情况2、给get设置了第二个参数
info = data_dict.get("sex", "女")
print(info) # 女
嵌套取值
data_dict = {
"战士": ["小满", {"姓名": "小满", "年龄": 3, "台词": ["别羡慕，我可是凭本事摸鱼的!", "武道没有定势啊，人生…亦是如此!"]}],
"法师": {"王昭君": {"姓名": "王昭君", "年龄": 4, "台词": ("凛冬已至", "故乡的梅花，开了吗？")}},
}
name = data_dict.get("战士")[0]
word = data_dict.get("战士")[1]["台词"][-2]
print(name) # 小满
print(word) # 别羡慕，我可是凭本事摸鱼的!
name = data_dict.get("法师")["王昭君"]["姓名"]
age = data_dict.get("法师")["王昭君"]["年龄"]
word = data_dict.get("法师")["王昭君"]["台词"][0]
print(name) # 王昭君
print(age) # 4
print(word) # 凛冬已至
字典的常用方法
clear方法
data_dict = {
"name": "小满",
"age": 3
}
print(data_dict) # {'name': '小满', 'age': 3}
data_dict.clear()
print(data_dict) # {}
copy方法
data_dict = {
"name": "小满",
"age": 3
}
hero_dict = data_dict.copy()
print(hero_dict) # {'name': '小满', 'age': 3}
print(data_dict) # {'name': '小满', 'age': 3}
pop方法
data_dict = {
"name": "小满",
"age": 3
}
# pop中传入要删除的键，返回键对应的值
# 一定要传参，不然会报错
hero = hero_dict = data_dict.pop("name")
print(hero) # 小满
print(data_dict) # {'age': 3}
data_dict = {
"name": "小满",
"age": 3
}
# 如果key不在dict中，然后pop第二个参数不指定默认值
# 结果会报错
sex = hero_dict = data_dict.pop("sex")
print(sex) # KeyError: 'sex'
data_dict = {
"name": "小满",
"age": 3
}
# 如果key不在dict中，然后pop第二个参数指定了默认值
# 会返回指定的值，原字典不会删除数据
sex = hero_dict = data_dict.pop("sex", "女")
print(sex) # 女
print(data_dict) # {'name': '小满', 'age': 3}
setdefault
data_dict = {
"name": "小满",
"age": 3
}
# setdefault 设置字典的默认值，如果存在，则不修改，如果不存在则新增
# 返回修改后字典对应的value，若已经存在原字典中，则直接返回原字典的value
# setdefault可以设置第二个参数，如果不设置，新增的键值对中的值为None
value = data_dict.setdefault("sex")
print(value) # None
print(data_dict) # {'name': '小满', 'age': 3, 'sex': None}
data_dict = {
"name": "小满",
"age": 3
}
# 指定了第二个值
value = data_dict.setdefault("sex", "女")
print(value) # 女
print(data_dict) # {'name': '小满', 'age': 3, 'sex': '女'}
data_dict = {
"name": "小满",
"age": 3
}
value = data_dict.setdefault("name", "王昭君")
print(value) # 小满
print(data_dict) # {'name': '小满', 'age': 3}
items
data_dict = {
"name": "小满",
"age": 3
}
items = data_dict.items()
print(items) # dict_items([('name', '小满'), ('age', 3)])
print(type(items)) # <class 'dict_items'>
print(list(items)) # [('name', '小满'), ('age', 3)]
for key, value in items:
print(key, value)
# name 小满
# age 3
values
data_dict = {
"name": "小满",
"age": 3
}
values = data_dict.values()
print(values) # dict_values(['小满', 3])
print(type(values)) # <class 'dict_values'>
print(list(values)) # ['小满', 3]
keys
data_dict = {
"name": "小满",
"age": 3
}
keys = data_dict.keys()
print(keys) # dict_keys(['name', 'age'])
print(type(keys)) # <class 'dict_keys'>
print(list(keys)) # ['name', 'age']
转成列表
hero_dict = {
"小满": 3,
"大乔": 4
}
hero_list = list(hero_dict)
print(hero_list) # ['小满', '大乔']
popitem
# 从字典中移除一个键值对，并以一个元组的形式返回被移除的键值对。
# 3.7以后的版本，是移除字典的最后一个键值对，3.7之前的是随机移除
data_dict = {
"name": "小满",
"age": 3
}
items = data_dict.popitem()
print(items) # ('age', 3)
print(type(items)) # <class 'tuple'>
print(data_dict) # {'name': '小满'}
# 如果字典为空时调用 popitem() 方法，会抛出 KeyError 异常。
data_dict = {}
items = data_dict.popitem()
# 结果报错：KeyError: 'popitem(): dictionary is empty'
fromkeys
dict.fromkeys(iterable, value=None) 是 Python 字典（dict）的一个方法，用于创建一个新的字典，其中包含指定可迭代对象中的元素作为键，并将所有键的值设置为指定的值。
下面是 dict.fromkeys() 方法的语法：
new_dict = dict.fromkeys(iterable, value)
其中，iterable 是一个可迭代对象，用于提供字典中的键，value 是可选参数，表示要设置的值，默认为 None。
使用示例：
hero_list = ["小满", "王昭君", "小乔"]
age = 3
hero_dict = dict.fromkeys(hero_list, age)
print(hero_dict) # {'小满': 3, '王昭君': 3, '小乔': 3}
hero_dict = dict.fromkeys(hero_list)
print(hero_dict) # {'小满': None, '王昭君': None, '小乔': None}
fromkeys() 方法通常用于快速创建具有相同默认值的字典，特别是在初始化字典时非常有用。
update
# 将一个字典的键值对更新到另一个字典中，或者向字典中添加新的键值对。
data_dict = {
"name": "小满",
"age": 3
}
data = {"sex": "女"}
data_dict.update(data)
print(data_dict) # {'name': '小满', 'age': 3, 'sex': '女'}
hero_dict = {"小满": 3, "大乔": 4}
hero_dict.update(小乔=5)
print(hero_dict) # {'小满': 3, '大乔': 4, '小乔': 5}
字典排序 sorted
变量 = sorted(
iterable, key = 匿名函数)
hero_dict = {"小满": 3, "大乔": 4, "小乔": 5, "阿珂": 20, "王昭君": 2}
print(hero_dict) # {'小满': 3, '大乔': 4, '小乔': 5, '阿珂': 20, '王昭君': 2}
result = dict(sorted(hero_dict.items(), key=lambda x: x[1]))
print(result) # {'王昭君': 2, '小满': 3, '大乔': 4, '小乔': 5, '阿珂': 20}
hero_dict = {"小满": 3, "大乔": 4, "小乔": 5, "阿珂": 20, "王昭君": 2}
print(hero_dict) # {'小满': 3, '大乔': 4, '小乔': 5, '阿珂': 20, '王昭君': 2}
result = dict(sorted(hero_dict.items(), key=lambda x: x[1], reverse=True))
print(result) # {'阿珂': 20, '小乔': 5, '大乔': 4, '小满': 3, '王昭君': 2}
删除字典
data_dict = {
"name": "小满",
"age": 3
}
print(data_dict) # {'name': '小满', 'age': 3}
del data_dict
print(data_dict) # NameError: name 'data_dict' is not defined
布尔类型
布尔类型只有两个值
True或者False在条件语句、循环以及其他控制结构中，布尔类型经常用于判断条件的真假
x = 10
y = 3
print(x < y) # False
print(x > y) # True
symbol = True
if x > y and symbol:
print(True) # True
else:
print(False)
布尔值为假的情况
# False关键字
my_bool = False
# None关键字
my_bool = None
# 整数、浮点数中数值为零的情况会被视为假。
my_bool = 0
my_float = 0.0
# 空序列和集合：空字符串 (''), 空列表 ([]), 空元组 (()), 空集合 (set()), 空字典 ({}) 都被视为假。
empty_str = ''
empty_list = []
empty_tuple = ()
empty_set = set()
empty_dict = {}
布尔值为真的情况
除了为假的情况之外，其余的情况都为真
元组
定义一个元组
# 定义一个空元组
data = tuple()
print(data) # ()
print(type(data)) # <class 'tuple'>
data = ()
print(data) # ()
print(type(data)) # <class 'tuple'>
data = ("小满", 3)
print(data) # ('小满', 3)
print(type(data)) # <class 'tuple'>
# 可以 但是不建议
data = "小满", 3
print(data) # ('小满', 3)
print(type(data)) # <class 'tuple'>
元组的相加
number = (1, 2, 3, 4)
symbol = ("a", "b", "c", "d")
new_tuple = number + symbol
print(new_tuple) # (1, 2, 3, 4, 'a', 'b', 'c', 'd')
元组的相乘
base_tuple = ("小满", "最棒啦")
new_tuple = base_tuple * 3
print(new_tuple) # ('小满', '最棒啦', '小满', '最棒啦', '小满', '最棒啦')
元组的常用方法
元组无法增删改查，一般用来存放的数据基本上不会去做修改
count
data = ("小满", 3, "女", "小满")
print(data.count("小满")) # 2
index
data = ("小满", 3, "女", "小满")
print(data.index("小满")) # 0
元组的修改
元组是不支持增删改查的，不过可以先转成列表，修改好值之后，然后转成元组
my_tuple = ("小满", 3)
data = list(my_tuple)
data[0] = "王昭君"
new_tuple = tuple(data)
print(my_tuple) # ('小满', 3)
print(new_tuple) # ('王昭君', 3)
集合
集合（Set）是 Python 中的一个数据类型，用于存储唯一且无序的元素。集合中的元素是不可变的，并且没有重复的值。
集合使用花括号 {} 表示，元素之间用逗号 , 分隔。
定义一个集合
my_set = set()
print(my_set) # set()
print(type(my_set)) # <class 'set'>
集合中的元素是唯一的，如果在创建集合时有重复的元素，只会保留一个副本。
my_set = {1, 2, 2, 3, 3, 4, 5}
print(my_set) # 输出: {1, 2, 3, 4, 5}
集合的常用方法
union 或 |
并集 或者 合计 全部取出
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
union_set = set1.union(set2)
simple_union_set = set1 | set2
print(union_set) # {1, 2, 3, 4, 5, 6, 7, 8}
print(simple_union_set) # {1, 2, 3, 4, 5, 6, 7, 8}
intersection 或 &
交集 共有的部分
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
intersection_set = set1.intersection(set2)
simple_intersection_set = set1 & set2
print(intersection_set) # {4, 5}
print(simple_intersection_set) # {4, 5}
difference 或 -
一个集合减去另外一个集合的共有部分，保留剩下的
a - b 表示a减去a和b共同的部分，保留a独有的东西。
b - a 表示b减去a和b共同的部分，保留b独有的东西。
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
# 共有部分是{4, 5} set1去除共有部分
difference_set = set1.difference(set2)
simple_difference_set = set1 - set2
print(difference_set) # {1, 2, 3}
print(simple_difference_set) # {1, 2, 3}
symmetric_difference_set 或 ^
两个集合的独有元素（即去掉共有的元素）
相当于先并集然后减去交集
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
symmetric_difference_set = set1.symmetric_difference(set2)
simple_symmetric_difference_set = set1 ^ set2
print(symmetric_difference_set) # {1, 2, 3, 6, 7, 8}
print(simple_symmetric_difference_set) # {1, 2, 3, 6, 7, 8}
issubset 或 <=
判断集合是否是另一个集合的子集。
set1 = {1, 2, 3, 4, 5}
set2 = {2, 3}
result = set2.issubset(set1)
simple_result = set1 <= set2
print(result) # True
print(simple_result) # False
issuperset 或 >=
判断集合是否是另一个集合的超集。
set1 = {1, 2, 3, 4, 5}
set2 = {2, 3}
result = set1.issuperset(set2)
simple_result = set1 >= set2
print(result) # True
print(simple_result) # True
isdisjoint
判断集合是否与另一个集合没有交集。
如果两个集合没有交集（共同部分）则返回True 否则返回False
set1 = {1, 2, 3, 4, 5}
set2 = {2, 3}
result = set1.isdisjoint(set2)
print(result) # False
set1 = {1, 2, 3, 4, 5}
set2 = {7, 9}
result = set1.isdisjoint(set2)
print(result) # True
copy
创建并返回集合的一个副本
set1 = {1, 2, 3, 4, 5}
set2 = set1.copy()
print(set2) # set1 = {1, 2, 3, 4, 5}
add
向集合中添加一个元素
set1 = {1, 2, 3, 4, 5}
set1.add(8)
print(set1) # {1, 2, 3, 4, 5, 8}
update
将可迭代的元素添加到集合中
set1 = {1, 2, 3, 4, 5}
set1.update("小满最棒啦")
print(set1) # {'满', 1, 2, 3, 4, 5, '小', '棒', '啦', '最'}
set1 = {1, 2, 3, 4, 5}
set1.update(["a", "b"])
print(set1) # {1, 2, 3, 4, 5, 'a', 'b'}
set1 = {1, 2, 3, 4, 5}
set1.update({"小满": "最棒啦"})
print(set1) # {1, 2, 3, 4, 5, '小满'}
set1 = {1, 2, 3, 4, 5}
data = ("Eva", "Amigo")
set1.update(data)
print(set1) # {1, 2, 3, 4, 5, 'Amigo', 'Eva'}
remove
从集合中移除指定的元素，如果元素不存在会引发 KeyError。
set1 = {1, 2, 3, 4, 5}
set1.remove(3)
print(set1) # {1, 2, 4, 5}
set1 = {1, 2, 3, 4, 5}
set1.remove(8)
print(set1) # KeyError: 8
discard
从集合中移除指定的元素，如果元素不存在不会引发错误。
set1 = {1, 2, 3, 4, 5}
set1.discard(8)
print(set1) # {1, 2, 3, 4, 5}
pop
随机移除并返回集合中的一个元素。
set1 = {1, 2, 3, 4, 5}
number = set1.pop()
print(number) # 1
print(set1) # {2, 3, 4, 5}
clear
清空集合里面的元素
set1 = {1, 2, 3, 4, 5}
set1.clear()
print(set1) # set()
删除集合
set1 = {1, 2, 3, 4, 5}
print(set1)
del set1
print(set1) # NameError: name 'set1' is not defined.
八大数据类型总结
存储空间占用
# 从低到高
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
按存值个数
| 标量／原子类型 | 容器类型 |
|---|---|
| 数字，字符串 | 列表，元组，字典，集合 |
可变不可变
| 可变 | 不可变 |
|---|---|
| 列表、字典、集合 | 数字，字符串，元组 |
有序无序
| 直接访问 | 顺序访问（序列类型） | key值访问（映射类型） |
|---|---|---|
| 数字 | 字符串，列表，元组 | 字典 |
集合的看整体而不研究单个元素
