【基础】基础数据类型详解：字符串、数字、列表、元组、集合、字典

# 2.1 字符串的定义和创建

字符串是Python中表示文本数据的基本数据类型。它由一个有序的字符序列组成，并用单引号（'）或双引号（"）括起来。

### 2.1.1 字符串的单引号和双引号

单引号和双引号都可以用来创建字符串，它们之间没有区别。但是，在使用单引号时，如果字符串中需要包含单引号，则需要使用转义字符\来转义单引号。类似地，在使用双引号时，如果字符串中需要包含双引号，则需要使用转义字符\"来转义双引号。

# 2. 字符串类型详解

### 2.1 字符串的定义和创建

#### 2.1.1 字符串的单引号和双引号

在 Python 中，字符串可以使用单引号 (') 或双引号 (") 括起来。两种引号之间没有区别，使用哪种引号取决于个人喜好。

# 使用单引号创建字符串
my_string_1 = 'Hello, world!'

# 使用双引号创建字符串
my_string_2 = "Hello, world!"

#### 2.1.2 字符串的转义字符

转义字符用于表示特殊字符，如换行符、制表符和引号。以下是一些常用的转义字符：

| 转义字符 | 描述 |
|---|---|
| `\n` | 换行符 |
| `\t` | 制表符 |
| `\\` | 反斜杠 |
| `\'` | 单引号 |
| `\"` | 双引号 |

例如，要创建一个包含换行符的字符串，可以使用以下代码：

my_string = "Hello,\nworld!"

### 2.2 字符串的操作

#### 2.2.1 字符串的拼接和分割

字符串可以拼接和分割以创建新的字符串。

**拼接**

使用 `+` 运算符可以拼接两个或多个字符串：

my_string_1 = "Hello"
my_string_2 = "world!"
my_new_string = my_string_1 + " " + my_string_2

**分割**

使用 `split()` 方法可以将字符串分割为一个列表：

my_string = "Hello, world!"
my_list = my_string.split(", ")

#### 2.2.2 字符串的查找和替换

**查找**

使用 `find()` 方法可以在字符串中查找子字符串：

my_string = "Hello, world!"
index = my_string.find("world")

**替换**

使用 `replace()` 方法可以在字符串中替换子字符串：

my_string = "Hello, world!"
my_new_string = my_string.replace("world", "Python")

#### 2.2.3 字符串的格式化

使用 `format()` 方法可以将变量格式化为字符串：

name = "John"
age = 30
my_string = "My name is {} and I am {} years old.".format(name, age)

# 3.1 整数类型

#### 3.1.1 整数的表示和范围

在 Python 中，整数类型用于表示没有小数部分的数字。整数可以表示为十进制、十六进制或八进制。

十进制整数使用标准的数字 0 到 9 来表示。例如：

num = 12345

十六进制整数以 "0x" 前缀表示，并使用数字 0 到 9 以及字母 A 到 F 来表示。例如：

num = 0x1234

八进制整数以 "0o" 前缀表示，并使用数字 0 到 7 来表示。例如：

num = 0o1234

Python 中的整数类型具有无限的范围，这意味着它们可以表示任意大小的整数。

#### 3.1.2 整数的运算和转换

整数类型支持各种算术运算，包括加法、减法、乘法、除法和取模。例如：

num1 = 10
num2 = 5

print(num1 + num2)  # 输出：15
print(num1 - num2)  # 输出：5
print(num1 * num2)  # 输出：50
print(num1 / num2)  # 输出：2.0
print(num1 % num2)  # 输出：0

整数类型也可以转换为其他数据类型，例如浮点数或字符串。例如：

num = 123

# 转换为浮点数
num_float = float(num)

# 转换为字符串
num_str = str(num)

### 3.2 浮点数类型

#### 3.2.1 浮点数的表示和范围

浮点数类型用于表示带有小数部分的数字。浮点数使用科学计数法表示，即一个数字乘以 10 的幂。例如：

num = 1.2345

等价于：

num = 1.2345 * 10^0

浮点数类型具有有限的范围，由计算机中可用的内存量决定。在 Python 中，浮点数的范围约为 -1.8 * 10^-308 到 1.8 * 10^308。

#### 3.2.2 浮点数的运算和精度

浮点数类型支持各种算术运算，包括加法、减法、乘法和除法。但是，由于浮点数的有限精度，浮点数运算可能会产生舍入误差。例如：

num1 = 0.1
num2 = 0.2

print(num1 + num2)  # 输出：0.30000000000000004

由于舍入误差，结果并不是精确的 0.3。

浮点数类型也可以转换为其他数据类型，例如整数或字符串。例如：

num = 1.2345

# 转换为整数
num_int = int(num)

# 转换为字符串
num_str = str(num)

# 4. 列表类型详解

### 4.1 列表的定义和创建

#### 4.1.1 列表的元素类型和顺序

列表是一种有序的可变序列，可以存储不同类型的数据元素。与字符串类似，列表中的元素也按顺序排列，并且可以使用索引访问。列表中的元素类型可以是任何数据类型，包括其他列表。

#### 4.1.2 列表的创建和初始化

有两种主要方法可以创建列表：

- **使用方括号 ([])：** 这是创建列表最常用的方法。例如：

my_list = [1, 2.5, 'Hello', [4, 5, 6]]

- **使用 list() 函数：** list() 函数可以将其他可迭代对象（如元组、字符串）转换为列表。例如：

my_list = list((1, 2.5, 'Hello', [4, 5, 6]))

### 4.2 列表的操作

#### 4.2.1 列表的添加和删除元素

- **append() 方法：** 将元素添加到列表末尾。例如：

my_list.append(7)

- **insert() 方法：** 在指定索引处插入元素。例如：

my_list.insert(1, 'World')

- **remove() 方法：** 删除第一个匹配的元素。例如：

my_list.remove(2.5)

- **pop() 方法：** 删除并返回列表中指定索引处的元素。例如：

removed_element = my_list.pop(2)

#### 4.2.2 列表的查找和排序

- **index() 方法：** 返回第一个匹配元素的索引。例如：

index = my_list.index('Hello')

- **count() 方法：** 返回列表中元素出现的次数。例如：

count = my_list.count(4)

- **sort() 方法：** 对列表进行原地排序。例如：

my_list.sort()

- **sorted() 函数：** 返回列表的已排序副本。例如：

sorted_list = sorted(my_list)

#### 4.2.3 列表的遍历和迭代

- **for 循环：** 遍历列表中的每个元素。例如：

for element in my_list:
    print(element)

- **enumerate() 函数：** 返回一个枚举对象，其中包含元素及其索引。例如：

for index, element in enumerate(my_list):
    print(f'{index}: {element}')

- **list comprehension：** 使用简洁的语法创建新列表。例如：

new_list = [element * 2 for element in my_list]

# 5. 元组类型详解

### 5.1 元组的定义和创建

#### 5.1.1 元组的元素类型和顺序

元组是一种不可变有序序列，其中包含不同类型的数据元素。元组中的元素可以是任何数据类型，包括其他元组、列表或字典。元组中的元素按其出现顺序排列，并且不能被修改或删除。

#### 5.1.2 元组的创建和初始化

元组可以通过使用圆括号 `()` 来创建。圆括号中的元素用逗号分隔。例如：

my_tuple = (1, "Hello", 3.14)

上面的代码创建了一个包含三个元素的元组：一个整数、一个字符串和一个浮点数。

### 5.2 元组的操作

#### 5.2.1 元组的元素访问和索引

与列表类似，元组中的元素可以通过索引来访问。索引从 0 开始，并且表示元素在元组中的位置。例如：

print(my_tuple[0])  # 输出：1
print(my_tuple[1])  # 输出：Hello
print(my_tuple[2])  # 输出：3.14

#### 5.2.2 元组的连接和拆包

元组可以通过 `+` 运算符连接，从而创建一个新的元组。例如：

new_tuple = my_tuple + (4, "World")
print(new_tuple)  # 输出：(1, "Hello", 3.14, 4, "World")

元组也可以使用 `*` 运算符进行拆包，将元组中的元素分配给多个变量。例如：

a, b, c = my_tuple
print(a)  # 输出：1
print(b)  # 输出：Hello
print(c)  # 输出：3.14

### 5.2.3 元组的比较和哈希

元组是可比较的，这意味着它们可以相互比较。比较基于元组中元素的顺序比较。例如：

tuple1 = (1, "Hello")
tuple2 = (1, "World")
print(tuple1 == tuple2)  # 输出：False
print(tuple1 < tuple2)  # 输出：True

元组也是可哈希的，这意味着它们可以作为字典的键。哈希值基于元组中元素的哈希值。例如：

my_dict = {my_tuple: "Value"}
print(my_dict[my_tuple])  # 输出：Value

# 6.1 集合的定义和创建

### 6.1.1 集合的元素类型和唯一性

集合是 Python 中一种无序、不可重复的数据类型。它可以包含任何类型的元素，包括其他数据结构（如列表或元组）。集合中的元素是唯一的，这意味着每个元素只能出现一次。

### 6.1.2 集合的创建和初始化

集合可以通过以下方式创建：

- 使用 `set()` 函数：

my_set = set()

- 使用大括号 `{}`：

my_set = {1, 2, 3, 4, 5}

- 从其他可迭代对象（如列表或元组）创建：

my_set = set([1, 2, 3, 4, 5])

创建集合时，重复的元素会被自动忽略。例如，以下代码创建了一个包含元素 1、2、3 的集合：

my_set = set([1, 2, 3, 1, 2, 3])
print(my_set)  # 输出：{1, 2, 3}