Python数据类型：深入理解6种基本数据类型，数据处理无忧

# 1. Python数据类型概述

Python是一种动态类型语言，这意味着变量的数据类型在运行时确定。Python提供了一系列内置数据类型，包括整数、浮点数、布尔值、字符串、列表、元组和字典。这些数据类型具有不同的特性和操作，为构建复杂数据结构和执行各种操作提供了基础。

# 2. Python基本数据类型详解

Python提供了多种基本数据类型，每种类型都有其独特的特性和用途。本章将详细介绍Python的基本数据类型，包括整数、浮点数、布尔值、字符串、列表和元组。

### 2.1 整数（int）

整数是表示整数的Python数据类型。它可以表示正整数、负整数和零。

#### 2.1.1 整数的表示形式

整数可以使用十进制、十六进制或八进制表示。十进制表示使用数字0-9，十六进制表示使用数字0-9和字母A-F，八进制表示使用数字0-7。

# 十进制整数
decimal_int = 10

# 十六进制整数
hex_int = 0xA

# 八进制整数
oct_int = 0o12

#### 2.1.2 整数的运算

整数支持加、减、乘、除、取余和幂运算。

| 运算符 | 描述 |
|---|---|
| + | 加法 |
| - | 减法 |
| * | 乘法 |
| / | 除法，返回浮点数 |
| % | 取余 |
| ** | 幂运算 |

# 加法
result = 10 + 5
print(result)  # 输出：15

# 减法
result = 10 - 5
print(result)  # 输出：5

# 乘法
result = 10 * 5
print(result)  # 输出：50

# 除法
result = 10 / 5
print(result)  # 输出：2.0

# 取余
result = 10 % 5
print(result)  # 输出：0

# 幂运算
result = 10 ** 2
print(result)  # 输出：100

### 2.2 浮点数（float）

浮点数是表示实数的Python数据类型。它可以表示小数、科学计数法和无穷大。

#### 2.2.1 浮点数的表示形式

浮点数可以使用十进制或科学计数法表示。十进制表示使用小数点，科学计数法使用指数表示法。

# 十进制浮点数
decimal_float = 3.14

# 科学计数法浮点数
scientific_float = 3.14e-10

#### 2.2.2 浮点数的运算

浮点数支持加、减、乘、除、取余和幂运算。

| 运算符 | 描述 |
|---|---|
| + | 加法 |
| - | 减法 |
| * | 乘法 |
| / | 除法，返回浮点数 |
| % | 取余，返回浮点数 |
| ** | 幂运算 |

# 加法
result = 3.14 + 1.618
print(result)  # 输出：4.758

# 减法
result = 3.14 - 1.618
print(result)  # 输出：1.522

# 乘法
result = 3.14 * 1.618
print(result)  # 输出：5.09072

# 除法
result = 3.14 / 1.618
print(result)  # 输出：1.9427971319629273

# 取余
result = 3.14 % 1.618
print(result)  # 输出：1.522

# 幂运算
result = 3.14 ** 2
print(result)  # 输出：9.8596

### 2.3 布尔值（bool）

布尔值是表示真或假的Python数据类型。它只有两个值：True和False。

#### 2.3.1 布尔值的表示形式

布尔值可以使用True和False表示。

# True
boolean_true = True

# False
boolean_false = False

#### 2.3.2 布尔值的运算

布尔值支持逻辑与（and）、逻辑或（or）和逻辑非（not）运算。

| 运算符 | 描述 |
|---|---|
| and | 逻辑与，两个布尔值都为True时返回True |
| or | 逻辑或，两个布尔值有一个为True时返回True |
| not | 逻辑非，将True变为False，将False变为True |

# 逻辑与
result = True and True
print(result)  # 输出：True

# 逻辑或
result = True or False
print(result)  # 输出：True

# 逻辑非
result = not True
print(result)  # 输出：False

### 2.4 字符串（str）

字符串是表示文本的Python数据类型。它可以包含字母、数字、符号和空格。

#### 2.4.1 字符串的表示形式

字符串可以使用单引号（'）、双引号（"）或三引号（'''或"""）表示。

# 单引号字符串
single_quoted_string = 'Hello World'

# 双引号字符串
double_quoted_string = "Hello World"

# 三引号字符串
triple_quoted_string = '''Hello
World'''

#### 2.4.2 字符串的运算

字符串支持加（+）、乘（*）和比较（==、!=、<、>、<=、>=）运算。

| 运算符 | 描述 |
|---|---|
| + | 字符串连接 |
| * | 字符串重复 |
| == | 字符串相等比较 |
| != | 字符串不相等比较 |
| < | 字符串小于比较 |
| > | 字符串大于比较 |
| <= | 字符串小于等于比较 |
| >= | 字符串大于等于比较 |

# 字符串连接
result = 'Hello' + ' ' + 'World'
print(result)  # 输出：Hello World

# 字符串重复
result = 'Hello' * 3
print(result)  # 输出：HelloHelloHello

# 字符串比较
result = 'Hello' == 'Hello'
print(result)  # 输出：True

# 字符串不相等比较
result = 'Hello' != 'World'
print(result)  # 输出：True

### 2.5 列表（list）

列表是表示有序集合的Python数据类型。它可以包含任何类型的元素，包括其他列表。

#### 2.5.1 列表的表示形式

列表可以使用方括号（[]）表示。

# 列表
my_list = [1, 2, 3, 'Hello', [1, 2, 3]]

#### 2.5.2 列表的运算

列表支持索引、切片、添加、删除和比较运算。

| 运算符 | 描述 |
|---|---|
| [] | 索引，获取列表中的元素 |
| [:] | 切片，获取列表中的子序列 |
| append() | 添加元素到列表末尾 |
| remove() | 删除列表中的元素 |
| == | 列表相等比较 |
| != | 列表不相等比较 |

# 索引
element = my_list[0]
print(element)  # 输出：1

# 切片
sublist = my_list[1:3]
print(sublist)  # 输出：[2, 3]

# 添加元素
my_list.append(4)
print(my_list)  # 输出：[1, 2, 3, 'Hello', [1, 2, 3], 4]

# 删除元素
my_list.remove(3)
print(my_list)  # 输出：[1, 2, 'Hello', [1, 2, 3], 4]

# 列表比较
result = my_list == [1, 2, 'Hello', [1, 2, 3], 4]
print(result)  # 输出：True

# 列表不相等比较
result = my_list != [1, 2, 'Hello', [1, 2, 3], 5]
print(result)  # 输出：True

### 2.6 元组（tuple）

元组是表示有序集合的Python数据类型。它与列表类似，但不可变，即无法添加、删除或修改元素。

#### 2.6.1 元组的表示形式

元组可以使用圆括号（()）表示。

# 元组
my_tuple = (1, 2, 3, 'Hello', (1, 2, 3))

#### 2.6.2 元组的运算

元组支持索引、切片和比较运算。

| 运算符 | 描述 |
|---|---|
| [] | 索引，获取元

# 3. Python数据类型转换

### 3.1 类型转换函数

Python提供了多种内置函数来进行数据类型转换，这些函数可以将一种数据类型转换为另一种数据类型。常用的类型转换函数包括：

- `int()`：将其他数据类型转换为整数。
- `float()`：将其他数据类型转换为浮点数。
- `str()`：将其他数据类型转换为字符串。

### 3.2 类型转换实例

#### 3.2.1 整数转浮点数

# 将整数 10 转换为浮点数
num = 10
float_num = float(num)
print(float_num)  # 输出：10.0

#### 3.2.2 浮点数转整数

# 将浮点数 10.5 转换为整数
num = 10.5
int_num = int(num)
print(int_num)  # 输出：10

#### 3.2.3 字符串转数字

# 将字符串 "10" 转换为整数
num = "10"
int_num = int(num)
print(int_num)  # 输出：10

# 将字符串 "10.5" 转换为浮点数
num = "10.5"
float_num = float(num)
print(float_num)  # 输出：10.5

**注意：**

- 在进行类型转换时，如果源数据类型无法转换为目标数据类型，则会引发 `ValueError` 异常。
- `int()` 函数在将浮点数转换为整数时，会舍弃小数部分。
- `float()` 函数在将整数转换为浮点数时，会将整数转换为浮点数，并保留小数部分为 0。

# 4. Python数据类型应用

### 4.1 数据结构

数据结构是组织和存储数据的形式。Python提供了一系列内置的数据结构，包括列表、元组和字典。这些数据结构可以用来存储和处理各种类型的数据。

#### 4.1.1 列表的应用

列表是一种有序的、可变的集合。它可以存储任何类型的元素，包括其他列表。列表可以使用方括号创建，元素之间用逗号分隔。

my_list = [1, 2.5, 'Hello', [10, 20]]

列表可以用于存储各种类型的相关数据。例如，可以创建一个包含学生成绩的列表，其中每个元素都是一个包含学生姓名、成绩和课程名称的元组。

student_records = [
    ('John', 90, 'Math'),
    ('Jane', 85, 'Science'),
    ('Peter', 95, 'English')
]

#### 4.1.2 元组的应用

元组是一种有序的、不可变的集合。它可以存储任何类型的元素，但一旦创建就不能被修改。元组可以使用圆括号创建，元素之间用逗号分隔。

my_tuple = (1, 2.5, 'Hello', (10, 20))

元组通常用于存储相关数据的不可变集合。例如，可以创建一个包含学生姓名和学号的元组。

student_info = ('John', 12345)

#### 4.1.3 字典的应用

字典是一种无序的、可变的集合，它将键映射到值。键和值都可以是任何类型的对象。字典可以使用大括号创建，键和值之间用冒号分隔，键和值对之间用逗号分隔。

my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}

字典可以用于存储各种类型的相关数据。例如，可以创建一个包含学生姓名和成绩的字典。

student_grades = {
    'John': 90,
    'Jane': 85,
    'Peter': 95
}

### 4.2 数据处理

Python提供了一系列内置函数和方法，用于处理数据。这些函数和方法可以用于对数据进行排序、过滤和统计。

#### 4.2.1 数据排序

`sort()`方法可以对列表或元组中的元素进行排序。该方法会就地修改原始列表或元组。

my_list = [1, 5, 2, 4, 3]
my_list.sort()
print(my_list)  # 输出：[1, 2, 3, 4, 5]

`sorted()`函数可以返回一个排序后的列表或元组，而不修改原始列表或元组。

my_list = [1, 5, 2, 4, 3]
sorted_list = sorted(my_list)
print(sorted_list)  # 输出：[1, 2, 3, 4, 5]
print(my_list)  # 输出：[1, 5, 2, 4, 3]

#### 4.2.2 数据过滤

`filter()`函数可以过滤一个列表或元组，返回一个包含满足给定条件的元素的新列表或元组。

my_list = [1, 2, 3, 4, 5]
even_numbers = list(filter(lambda x: x % 2 == 0, my_list))
print(even_numbers)  # 输出：[2, 4]

#### 4.2.3 数据统计

`sum()`函数可以计算列表或元组中所有元素的总和。

my_list = [1, 2, 3, 4, 5]
total = sum(my_list)
print(total)  # 输出：15

`max()`和`min()`函数可以分别返回列表或元组中最大的元素和最小的元素。

my_list = [1, 2, 3, 4, 5]
max_value = max(my_list)
min_value = min(my_list)
print(max_value)  # 输出：5
print(min_value)  # 输出：1

# 5.1 数据结构的嵌套

在 Python 中，数据结构可以嵌套，即一个数据结构可以包含另一个数据结构。这使得我们可以创建复杂的数据结构来存储和组织数据。

### 5.1.1 列表的嵌套

列表可以嵌套，即一个列表可以包含另一个列表。例如：

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

这个列表包含三个子列表，每个子列表包含三个元素。我们可以使用索引来访问子列表和元素。例如：

print(my_list[0][1])  # 输出：2

### 5.1.2 元组的嵌套

元组也可以嵌套，即一个元组可以包含另一个元组。例如：

my_tuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))

这个元组包含三个子元组，每个子元组包含三个元素。我们可以使用索引来访问子元组和元素。例如：

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

### 5.1.3 字典的嵌套

字典也可以嵌套，即一个字典可以包含另一个字典。例如：

my_dict = {
    "key1": {"subkey1": 1, "subkey2": 2},
    "key2": {"subkey3": 3, "subkey4": 4},
    "key3": {"subkey5": 5, "subkey6": 6},
}

这个字典包含三个子字典，每个子字典包含两个键值对。我们可以使用键来访问子字典和键值对。例如：

print(my_dict["key1"]["subkey2"])  # 输出：2