数据类型

打印类型

print(type(18))

输出： <class 'int'>

整数 int

import sys

# 整数 没有小数点的数字，可以是正数或负数，也可以是0
age = 18
temp = -5
score = 0

# 当数很大时，我们可以使用下划线来分隔数字，使代码更易读
big_num = 1_000_000
price = 300_000

# Python 中整数的范围是无限的(取决于计算机的内存大小)，这意味着我们可以使用任意大的整数
huge_num = 9**9999

# 会报错，因为print会将整数转换为字符串，默认限制是4300位
# print(huge_num)

# 解决办法
sys.set_int_max_str_digits(0)
# 现在可以打印出 huge_num 了
print(huge_num)

浮点数 float

# 浮点数 有小数点的数字，可以是正数或负数
height = 1.75
weight = 65.5
temp = -25.5

# 当数很大或很小时，我们可以使用科学计数法来表示
big_num = 1.23e6
small_num = 1.23e-6
# e 和 E 都可以用来表示科学计数法
light_speed = 3E8

# 浮点数的精度是有限的，这意味着我们不能精确表示所有的浮点数
0.1 + 0.2 == 0.3  # False

# 解决办法
# 1. 直接比较两个浮点数的差是否小于一个很小的数
abs(0.1 + 0.2 - 0.3) < 1e-10  # True

# 2. 使用 decimal 模块
from decimal import Decimal
Decimal('0.1') + Decimal('0.2') == Decimal('0.3')  # True

字符串 str

# 字符串4种定义方法 用引号包起来的任意字符序列
# 单引号
name = '张三'
# 双引号
gender = "男"
# 三引号(可以包含换行符)
hobby = '''篮球'''
# 三引号(可以包含换行符)
hat = """黑色"""

# 字符串的重复
repeat = "abc" * 3
print(repeat)

# 字符串的截取
substring = "hello world"[6:11]
print(substring)

# 字符串的长度
print(len("hello world"))  # 11

格式化输出

# 1. 字符串拼接
print("你好，" + name + "！")

# 2. 使用 % 运算符
> %s 字符串占位符(万能)
> %d 整数占位符(十进制)
> %f 浮点数占位符
> %i 整数占位符
print("我是%s，我今年%d岁。" % (name, age))
# %±m.n[s/d/f/n]  控制占位宽度和精度
> ± 正数是向右对齐，负数是向左对齐
> m 字符串的最小宽度，位数不够回自动使用空格补全(位数小于字符串长度则不起作用)
> n 精度控制，最多输出n个字符(位数大于等于n则不起作用)

print("我是%s，我今年%03d岁。" % (name, age))  # 我是张三，我今年018岁。

# 3. 使用 format() 方法
print("我是{}，我今年{}岁。".format(name, age))

# 4. 使用 f-string 格式化输出(推荐)
print(f"我是{name}，我今年{age}岁。")

# 5. 格式化输出的其他方法
print(f"我是{name}，我今年{age:.2f}岁。")

转义字符

# 转义字符 用于在字符串中表示一些特殊的字符
# \' 单引号
# \" 双引号
# \n 换行符
# \\ 反斜杠 输出反斜杠
# \b 退格符 输出退格
# \r 使光标回到本行开头
# \t 水平制表符（让光标移动到下一个制表位置）

print("hello'world")  # hello'world
print("hello\"world")  # hello"world
print("hello\nworld")  
# hello
# world

print("hello\\world")  # hello\world

print("world❥\b")  # world

# expandtabs() 方法将字符串中的制表符替换为空格，即替换为4个空格
print(123412341234)
print("ab\tcd",expandtabs(4))
print("abc\td",expandtabs(4))
print("abcd\ta",expandtabs(4))
#123412341234
#ab  cd
#abc d
#abcd    a

布尔值 bool

布尔类型是int的子类型，底层的本质是整数 0 和 1

# 布尔值 只有 True 和 False 两个值
is_student = True
is_teacher = False

# 布尔值可以用于条件判断
if is_student:
    print("你是个学生")
else:
    print("你不是个学生")

列表 list （序列）

列表是有序的可变序列，每个元素都有一个唯一的索引

定义

# 定义一个包含元素的列表
my_list = [1, 2, 3, "hello", True]
# 索引 列表的索引从0开始，负数索引从-1开始
print(my_list[0])  # 1
print(my_list[-1])  # True

# 列表的重复
repeat = [1, 2, 3] * 3
print(repeat)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

# 列表的截取
sub_list = my_list[1:4]
print(sub_list)  # [2, 3, "hello"]

# 列表的长度
print(len(my_list))  # 5

# 空列表
empty_list1 = []
empty_list2 = list()

# 嵌套列表
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(nested_list)  # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

增删改查

# 增 [1, 2, 3, "hello", True]
my_list.append(4)
print(my_list)  # [1, 2, 3, "hello", True, 4]

my_list.insert(2, "world")
print(my_list)  # [1, 2, "world", 3, "hello", True, 4]

my_list.extend([5, 6, 7])
print(my_list)  # [1, 2, "world", 3, "hello", True, 4, 5, 6, 7]

# 删 [1, 2, 3, "hello", True, 4]
my_list.remove(3)
print(my_list)  # [1, 2, "hello", True, 4]

my_list.pop()
print(my_list)  # [1, 2, "hello", True]

del my_list[2]
print(my_list)  # [1, 2, True, 4]

my_list.clear()
print(my_list)  # []

# 查 [1, 2, True, 4]
print(2 in my_list)  # True
print("hello" not in my_list)  # False
print(my_list.index(True))  # 2
print(my_list[2])  # True
print(my_list[1:3])  # [2, True]
# 查5出现的次数
print(my_list.count(5))  # 0

# 改 [1, 2, "hello", True, 4]
my_list[0] = 100
print(my_list)  # [100, 2, "hello", True, 4]

my_list[1:3] = [5, 6]
print(my_list)  # [100, 5, 6, True, 4]

my_list.reverse()
print(my_list)  # [4, True, 6, 5, 100]

my_list.sort()
print(my_list)  # [4, 5, 6, True, 100]

my_list.sort(reverse=True)
print(my_list)  # [100, 6, 5, True, 4]

遍历

my_list [100, 6, 5, True, 4]
# while 循环遍历列表
index = 0
while index < len(my_list):
    print(my_list[index])  # 100 6 5 True 4
    index += 1
# for 循环遍历列表
for item in my_list:
    print(item)  # 100 6 5 True 4

for index in range(len(my_list)):
    print(my_list[index])  # 100 6 5 True 4

for index, item in enumerate(my_list):
    print(index, item)  # 0 100 1 6 2 5 3 True 4

元组 tuple （序列）

元组是不可变的序列，一旦创建就不能修改

定义

# 定义一个包含元素的元组
my_tuple = (1, 2, 3, "hello", True, [4, 5])
# 元祖中的列表是可变的，所以可以修改
my_tuple[5].append(6)
print(my_tuple)  # (1, 2, 3, "hello", True, [4, 5, 6])

序列的通用操作

提示

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 切片 [start:stop:step] 
# start: 切片的起始索引，默认值为0
# stop: 切片的结束索引，默认值为序列的长度
# step: 切片的步长，默认值为1
# 列表、元组、集合、字典都支持切片操作
print(my_list[1:5])  # [2, 3, 4, 5]
print(my_list[1:5:2])  # [2, 4]
print(my_list[1:5:-2])  # [3, 1]
print(my_list[5:1:-2])  # [6, 4]
#当起始索引大于结束索引时，步长必须为负数，否则会返回空列表
print(my_list[5:1:2])  # []
print(my_list[::-1])  # [9, 8, 7, 6, 5, 4, 3, 2, 1]


# 相加
print(my_list + [10, 11, 12])  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

# 相乘
print(my_list * 2)  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9]

集合 set/frozenset

set 可变集合 无序的不重复元素的集合

frozenset 不可变集合 无序的不重复元素的集合

集合中不能嵌套可变集合，但可以嵌套不可变集合（只有不可变的东西才能被添加到集合中）

定义

# 可变集合
my_set = {1, 2, 3, "hello", True}
print(my_set)  # {1, 2, 3, "hello", True}

# 不可变集合
my_frozenset = frozenset({1, 2, 3, "hello", True})
print(my_frozenset)  # frozenset({1, 2, 3, "hello", True})

# 空集合
empty_error = {} # 空集合不能使用 {} 定义, 会被解释为空字典
empty_set1 = set()
empty_set2 = frozenset()

增删改查

# 可变集合
my_set = {1, 2, 3, "hello", True}
# 增
my_set.add(4)
print(my_set)  # {1, 2, 3, "hello", True, 4}

my_set.update([5, 6, 7])
print(my_set)  # {1, 2, 3, "hello", True, 4, 5, 6, 7}

# 删
my_set.remove(3) # 删除元素3, 如果元素不存在会报错
print(my_set)  # {1, 2, "hello", True, 4, 5, 6, 7}

my_set.discard(5) # 删除元素5, 如果元素不存在不会报错
print(my_set)  # {1, 2, "hello", True, 4, 6, 7}

my_set.pop() # 随机删除一个元素，返回删除的元素
print(my_set)  # {1, 2, "hello", True, 4, 6, 7}

my_set.clear()
print(my_set)  # set()

# 改 (删+增)

# 查
print(2 in my_set)  # True
print("hello" not in my_set)  # False

常用方法/数学运算

# difference() 方法返回两个集合的差集
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1.difference(set2))  # {1, 2, 3}

# difference_update() 方法将两个集合的差集更新到第一个集合，无返回值
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
set1.difference_update(set2)
print(set1)  # {1, 2, 3}

# union() 方法返回两个集合的并集
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1.union(set2))  # {1, 2, 3, 4, 5, 6, 7, 8}

# issubset() 方法判断一个集合是否是另一个集合的子集
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1.issubset(set2))  # False

# issuperset() 方法判断一个集合是否是另一个集合的超集
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1.issuperset(set2))  # False

# isdisjoint() 方法判断两个集合是否没有交集
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1.isdisjoint(set2))  # False

# | 并集
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7, 8}

# & 交集
print(set1 & set2)  # {4, 5}

# - 差集
print(set1 - set2)  # {1, 2, 3}

# ^ 对称差集（两个集合中不重复的元素）
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}

遍历

# 遍历集合 集合不能使用while循环遍历
for item in my_set:
    print(item)  # 1 2 3 4 5 6 7

字典 dict

字典是无序的可变序列，每个元素都有一个唯一的键，键必须是不可变的，值可以是任意类型

定义

# 定义一个包含元素的字典
my_dict = {"name": "张三", "age": 18, "is_student": True}
print(my_dict)  # {"name": "张三", "age": 18, "is_student": True}

# 空字典
empty_dict1 = {}
empty_dict2 = dict()

# 嵌套字典
nested_dict = {"name": "张三", "age": 18, "is_student": True, "address": {"city": "北京", "district": "东城区"}}
print(nested_dict)  # {"name": "张三", "age": 18, "is_student": True, "address": {"city": "北京", "district": "东城区"}}

增删改查

# 定义一个包含元素的字典
my_dict = {"name": "张三", "age": 18, "is_student": True}

# 增/改
my_dict["gender"] = "男"
print(my_dict)  # {"name": "张三", "age": 18, "is_student": True, "gender": "男"}

my_dict.update({"age": 20, "is_student": False})
print(my_dict)  # {"name": "张三", "age": 20, "is_student": False, "gender": "男"}

# 删
del my_dict["gender"]
print(my_dict)  # {"name": "张三", "age": 20, "is_student": False}

# pop 方法删除指定键的元素，当指定元素不存在是，可以不报错，并且可以指定返回的默认值
my_dict.pop("age")
print(my_dict)  # {"name": "张三", "is_student": False}
result = my_dict.pop("age", "年龄不存在")
print(result)  # 年龄不存在

my_dict.clear()
print(my_dict)  # {}

# 查
print(my_dict["name"])  # 张三
print(my_dict.get("age"))  # None (如果键不存在，返回None)
print(my_dict.get("age", 18))  # 18 (如果键不存在，返回默认值18)

常用方法

# keys() 方法返回字典所有的键 返回dict_keys类型
print(my_dict.keys())  # dict_keys(["name", "is_student"])

# values() 方法返回字典所有的值 返回dict_values类型
print(my_dict.values())  # dict_values(["张三", False])

# items() 方法返回字典所有的键值对 返回dict_items类型
print(my_dict.items())  # dict_items([("name", "张三"), ("is_student", False)])

遍历

# 遍历字典 不能使用while循环遍历
my_dict = {"name": "张三", "age": 18, "is_student": True}

for key, value in my_dict.items():
    print(key, value)  # name 张三 age 18 is_student False