前言
本章节讲述python的基础数据类型，python的基础数据类型主要包括以下
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
Number（数字）
number（数字）类型用于表示数值数据。Python 提供了多种内置的数字类型，主要包括：
1. 整数 (int)
int 类型用于表示整数，可以是正数、负数或零。Python 3 的 int 类型没有大小限制（仅受限于可用内存），因此可以处理非常大的整数。
特点：
无大小限制
可以用十进制、二进制、八进制或十六进制表示
示例：
# 十进制
x = 42
y = -17
z = 0
# 二进制 (以 0b 或 0B 开头)
binary_num = 0b1010 # 等于十进制的 10
# 八进制 (以 0o 或 0O 开头)
octal_num = 0o17 # 等于十进制的 15
# 十六进制 (以 0x 或 0X 开头)
hex_num = 0xFF # 等于十进制的 255
# 大整数
big_num = 123456789012345678901234567890
print(type(big_num)) # <class 'int'>
2. 浮点数 (float)
float 类型用于表示带有小数点的数字（实数）。它们遵循 IEEE 754 双精度浮点数标准，通常有大约 17 位有效数字。
特点：
有精度限制
可能存在浮点数精度问题
可以用科学计数法表示
示例：
# 普通浮点数
pi = 3.14159
temperature = -12.5
price = 9.99
# 科学计数法
scientific = 1.5e-3 # 等于 0.0015
large_float = 2.5e8 # 等于 250000000.0
# 浮点数精度问题示例
print(0.1 + 0.2) # 输出: 0.30000000000000004
print(0.1 + 0.2 == 0.3) # 输出: False
# 使用 decimal 模块解决精度问题
from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2') == Decimal('0.3')) # True
3. 复数 (complex)
complex 类型用于表示复数，形式为 a + bj，其中 a 是实部，b 是虚部，j 表示虚数单位（√-1）。
特点：
实部和虚部都是浮点数
可以通过 .real 和 .imag 属性访问实部和虚部
示例：
# 复数
z1 = 3 + 4j
z2 = -2.5 + 1.7j
z3 = 5j # 只有虚部
z4 = 3.0 + 0j # 只有实部
# 访问实部和虚部
print(z1.real) # 3.0
print(z1.imag) # 4.0
# 复数运算
z_sum = z1 + z2
print(z_sum) # (0.5+5.7j)
# 获取模长
import cmath
print(abs(z1)) # 5.0
print(cmath.phase(z1)) # 获取相位
4. 布尔值 (bool)
虽然 bool 类型通常被视为逻辑类型，但在 Python 中它是 int 的子类。True 和 False 分别等价于整数 1 和 0。
示例：
# 布尔值
is_active = True
is_done = False
# 布尔值是 int 的子类
print(isinstance(True, int)) # True
print(True + 1) # 2
print(False * 10) # 0
# 在条件语句中的使用
if True:
print("这总是会执行")
if 1:
print("非零数值被视为 True")
5. 数字类型的转换
Python 提供了内置函数在不同数字类型之间进行转换。
转换函数：
# int() - 转换为整数
print(int(3.7)) # 3 (向零取整)
print(int("42")) # 42
print(int(True)) # 1
# float() - 转换为浮点数
print(float(42)) # 42.0
print(float("3.14")) # 3.14
print(float(True)) # 1.0
# complex() - 转换为复数
print(complex(3, 4)) # (3+4j)
print(complex("2+3j")) # (2+3j)
6. 数字类型的检查和操作
# 检查类型
x = 42
y = 3.14
z = 2 + 3j
print(type(x)) # <class 'int'>
print(type(y)) # <class 'float'>
print(type(z)) # <class 'complex'>
# isinstance() 检查
print(isinstance(x, int)) # True
print(isinstance(y, float)) # True
print(isinstance(z, complex)) # True
# 常用数学运算
a, b = 10, 3
print(a + b) # 13
print(a - b) # 7
print(a * b) # 30
print(a / b) # 3.333... (结果总是 float)
print(a // b) # 3 (整除)
print(a % b) # 1 (取余)
print(a ** b) # 1000 (幂运算)
7. 内置数学函数
Python 提供了许多内置的数学函数：
# 基本数学函数
print(abs(-5)) # 5
print(round(3.14159, 2)) # 3.14
print(pow(2, 3)) # 8
print(max(1, 5, 3)) # 5
print(min(1, 5, 3)) # 1
# 需要导入 math 模块
import math
print(math.pi) # 3.141592653589793
print(math.e) # 2.718281828459045
print(math.sqrt(16)) # 4.0
print(math.floor(3.7)) # 3
print(math.ceil(3.2)) # 4
print(math.log(10)) # 自然对数
print(math.log10(100)) # 以10为底的对数
String（字符串）
字符串（String） 在python中是一种用于表示文本数据的基本数据类型。字符串是由一系列字符组成的不可变序列。
1. 字符串的创建
Python 中有多种方式创建字符串：
# 使用单引号
s1 = 'Hello World'
# 使用双引号
s2 = "Hello World"
# 使用三重引号（可以跨行）
s3 = """这是一个
多行字符串"""
s4 = '''也可以
这样写'''
# 空字符串
empty_str = ""
注意：单引号和双引号功能相同，选择一种风格并保持一致。三重引号常用于文档字符串（docstring）或多行文本。
2. 字符串的特性
不可变性（Immutable）：字符串一旦创建就不能被修改。任何“修改”操作实际上都会创建一个新的字符串对象。
有序性（Ordered）：字符串中的字符有固定的顺序，可以通过索引访问。
可迭代（Iterable）：可以使用 for 循环遍历字符串中的每个字符。
3. 字符串索引与切片
索引（Indexing）
text = "Python"
print(text[0]) # P (第一个字符)
print(text[-1]) # n (最后一个字符)
print(text[5]) # n
切片（Slicing）
语法：string[start:end:step]
text = "Hello World"
# 基本切片
print(text[0:5]) # Hello (索引0到4)
print(text[6:]) # World (从索引6到末尾)
print(text[:5]) # Hello (从开头到索引4)
# 步长
print(text[::2]) # HloWrd (每隔一个字符)
print(text[::-1]) # dlroW olleH (反转字符串)
# 负索引切片
print(text[-5:]) # World
4. 字符串的常用操作
拼接（Concatenation）
# 使用 + 操作符
greeting = "Hello" + " " + "World"
# 使用 join() 方法（推荐，效率更高）
words = ["Hello", "Beautiful", "World"]
sentence = " ".join(words) # "Hello Beautiful World"
重复
repeat = "Ha" * 3 # "HaHaHa"
长度
length = len("Python") # 6
5. 常用字符串方法
Python 提供了丰富的内置方法来操作字符串：
text = " Hello World "
# 大小写转换
print(text.upper()) # " HELLO WORLD "
print(text.lower()) # " hello world "
print(text.capitalize()) # " hello world " -> " hello world " (首字母大写)
print(text.title()) # " Hello World "
# 去除空白
print(text.strip()) # "Hello World"
print(text.lstrip()) # "Hello World " (左)
print(text.rstrip()) # " Hello World" (右)
# 查找与替换
print(text.find("World")) # 8 (找到的索引，未找到返回-1)
print(text.replace("World", "Python")) # " Hello Python "
# 判断方法
print("Hello".isalpha()) # True (是否全是字母)
print("123".isdigit()) # True (是否全是数字)
print("hello".startswith("he")) # True
print("world".endswith("ld")) # True
# 分割与合并
sentence = "apple,banana,orange"
fruits = sentence.split(",") # ['apple', 'banana', 'orange']
joined = "-".join(["a", "b", "c"]) # "a-b-c"
6. 字符串格式化
1. f-string（推荐，Python 3.6+）
name = "Alice"
age = 25
message = f"我的名字是 {name}，今年 {age} 岁。"
print(message) # 我的名字是 Alice，今年 25 岁。
2. .format() 方法
message = "我的名字是 {}，今年 {} 岁。".format(name, age)
message = "我的名字是 {n}，今年 {a} 岁。".format(n=name, a=age)
3. % 格式化（较老的方式）
message = "我的名字是 %s，今年 %d 岁。" % (name, age)
7. 转义字符
使用反斜杠 \ 来表示特殊字符：
转义字符 含义
\\ 反斜杠
\' 单引号
\" 双引号
\n 换行
\t 制表符
\r 回车
print("Hello\nWorld") # 换行
print("He said: \"Hello\"") # He said: "Hello"
print("C:\\Users\\Name") # 路径
原始字符串（Raw String）：在字符串前加 r，忽略转义字符。
path = r"C:\Users\Name\Documents" # 不需要双写反斜杠
8. 字符串的不可变性示例
text = "Hello"
# text[0] = "h" # ❌ 错误！字符串不可变
# 正确的做法是创建新字符串
new_text = "h" + text[1:] # "hello"
9. 实用技巧
遍历字符串
for char in "Python":
print(char)
检查子字符串
if "hello" in "hello world":
print("找到了！")
统计字符
text = "hello"
print(text.count("l")) # 2
Tuple（元组）
在 Python 中，元组（Tuple） 是一种有序、不可变的序列数据类型。它与列表（List）非常相似，但最大的区别在于一旦创建，元组的内容不能被修改。
1. 元组的创建
元组可以通过以下几种方式创建：
# 使用圆括号 ()
t1 = (1, 2, 3, 4, 5)
t2 = ("apple", "banana", "cherry")
t3 = (1, "hello", 3.14, True)
# 单个元素的元组需要加逗号
single = (42,) # 注意逗号，否则会被当作普通括号
print(type(single)) # <class 'tuple'>
# 省略括号（但不推荐，可读性差）
t4 = 1, 2, 3
print(type(t4)) # <class 'tuple'>
# 空元组
empty_tuple = ()
# 使用 tuple() 构造函数
t5 = tuple([1, 2, 3]) # 从列表创建
t6 = tuple("hello") # 从字符串创建 -> ('h', 'e', 'l', 'l', 'o')
2. 元组的特性
特性 说明
有序（Ordered） 元素有固定的顺序，可以通过索引访问
不可变（Immutable） 一旦创建，不能添加、删除或修改元素
可重复（Allow Duplicates） 可以包含重复的元素
可哈希（Hashable） 如果元组中的所有元素都是不可变的，那么元组本身是可哈希的，可以用作字典的键或集合的元素
3. 元组的访问
索引（Indexing）
t = (10, 20, 30, 40, 50)
print(t[0]) # 10
print(t[-1]) # 50 (最后一个)
切片（Slicing）
print(t[1:4]) # (20, 30, 40)
print(t[::2]) # (10, 30, 50)
print(t[::-1]) # (50, 40, 30, 20, 10) 反转
4. 元组的操作
拼接（Concatenation）
t1 = (1, 2)
t2 = (3, 4)
t3 = t1 + t2 # (1, 2, 3, 4)
重复
t = (1, 2) * 3 # (1, 2, 1, 2, 1, 2)
成员检查
if 2 in t:
print("2 在元组中")
长度
length = len(t) # 获取元组长度
5. 元组的常用方法
由于元组不可变，它的方法很少：
t = (1, 2, 3, 2, 4, 2)
# count() - 统计某个元素出现的次数
print(t.count(2)) # 3
# index() - 查找元素第一次出现的索引
print(t.index(3)) # 2
# print(t.index(99)) # ValueError: tuple.index(x): x not in tuple
6. 元组的解包（Unpacking）
元组解包是 Python 中非常强大和常用的功能。
# 基本解包
coordinates = (3, 4)
x, y = coordinates
print(x, y) # 3 4
# 函数返回多个值
def get_name_age():
return "Alice", 25
name, age = get_name_age()
# 忽略某些值
data = (1, 2, 3, 4, 5)
a, b, *rest = data # a=1, b=2, rest=[3,4,5]
print(rest) # [3, 4, 5]
# 只取首尾
first, *middle, last = (1, 2, 3, 4, 5)
print(first, middle, last) # 1 [2, 3, 4] 5
7. 元组的应用场景
作为字典的键
# ✅ 元组可以作为字典的键
locations = {
(0, 0): "原点",
(3, 4): "点A",
(-1, 2): "点B"
}
函数返回多个值
def min_max(numbers):
return min(numbers), max(numbers)
minimum, maximum = min_max([1, 2, 3, 4, 5])
数据保护
# 防止意外修改
days_of_week = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday")
# days_of_week[0] = "Mon" # ❌ 会报错，保护数据
格式化字符串
print("坐标: %d, %d" % (3, 4))
8. 注意事项
不可变性是浅层的：如果元组包含可变对象（如列表），那么该对象的内容仍然可以被修改。
t = (1, [2, 3], 4)
t[1].append(5) # ✅ 允许，因为修改的是列表
print(t) # (1, [2, 3, 5], 4)
# t[1] = [2, 3, 4] # ❌ 不允许，因为要替换元组元素
总结
