【基础】Python中的数据类型及常用操作

# 1. Python中的数据类型**

Python中的数据类型是用来描述和存储数据的基本单位，它决定了数据的类型、大小和操作方式。Python中内置了多种数据类型，包括基本数据类型（数值型、字符串型、布尔型）和复合数据类型（列表、元组、字典）。每种数据类型都有其独特的特性和操作方式，了解这些数据类型对于有效地使用Python至关重要。

# 2. Python中的数据类型操作

### 2.1 基本数据类型操作

#### 2.1.1 数值型数据操作

数值型数据包括整数、浮点数和复数。整数可以进行加、减、乘、除、取余等算术运算，浮点数可以进行加、减、乘、除、取余、幂运算，复数可以进行加、减、乘、除、取共轭、取模等运算。

# 整数加法
a = 10
b = 20
c = a + b
print(c)  # 输出：30

# 浮点数除法
a = 10.5
b = 2.5
c = a / b
print(c)  # 输出：4.2

# 复数乘法
a = 3 + 4j
b = 5 + 6j
c = a * b
print(c)  # 输出：(-11+34j)

#### 2.1.2 字符串型数据操作

字符串型数据可以进行连接、切片、查找、替换、格式化等操作。

# 字符串连接
a = "Hello"
b = "World"
c = a + b
print(c)  # 输出：HelloWorld

# 字符串切片
a = "Hello World"
b = a[0:5]
print(b)  # 输出：Hello

# 字符串查找
a = "Hello World"
b = a.find("World")
print(b)  # 输出：6

# 字符串替换
a = "Hello World"
b = a.replace("World", "Python")
print(b)  # 输出：Hello Python

# 字符串格式化
a = "Hello {name}"
b = a.format(name="Python")
print(b)  # 输出：Hello Python

#### 2.1.3 布尔型数据操作

布尔型数据只有 True 和 False 两个值，可以进行逻辑运算，如与、或、非等。

# 布尔型与运算
a = True
b = False
c = a and b
print(c)  # 输出：False

# 布尔型或运算
a = True
b = False
c = a or b
print(c)  # 输出：True

# 布尔型非运算
a = True
b = not a
print(b)  # 输出：False

### 2.2 复合数据类型操作

#### 2.2.1 列表操作

列表是一种有序的可变序列，可以存储不同类型的数据元素。列表可以进行添加、删除、插入、查找、排序等操作。

# 列表添加元素
a = [1, 2, 3]
a.append(4)
print(a)  # 输出：[1, 2, 3, 4]

# 列表删除元素
a = [1, 2, 3, 4]
a.remove(2)
print(a)  # 输出：[1, 3, 4]

# 列表插入元素
a = [1, 2, 3]
a.insert(1, 4)
print(a)  # 输出：[1, 4, 2, 3]

# 列表查找元素
a = [1, 2, 3, 4]
b = a.index(3)
print(b)  # 输出：2

# 列表排序
a = [4, 2, 1, 3]
a.sort()
print(a)  # 输出：[1, 2, 3, 4]

#### 2.2.2 元组操作

元组是一种有序的不可变序列，可以存储不同类型的数据元素。元组可以进行切片、查找、连接等操作。

# 元组切片
a = (1, 2, 3, 4)
b = a[0:2]
print(b)  # 输出：(1, 2)

# 元组查找元素
a = (1, 2, 3, 4)
b = a.index(3)
print(b)  # 输出：2

# 元组连接
a = (1, 2, 3)
b = (4, 5, 6)
c = a + b
print(c)  # 输出：(1, 2, 3, 4, 5, 6)

#### 2.2.3 字典操作

字典是一种无序的键值对集合，键和值可以是任意类型的数据。字典可以进行添加、删除、查找、修改等操作。

# 字典添加元素
a = {"name": "Python", "age": 10}
a["gender"] = "male"
print(a)  # 输出：{'name': 'Python', 'age': 10, 'gender': 'male'}

# 字典删除元素
a = {"name": "Python", "age": 10}
del a["age"]
print(a)  # 输出：{'name': 'Python'}

# 字典查找元素
a = {"name": "Python", "age": 10}
b = a.get("name")
print(b)  # 输出：Python

# 字典修改元素
a = {"name": "Python", "age": 10}
a["age"] = 12
print(a)  # 输出：{'name': 'Python', 'age': 12}

# 3. Python中的数据类型转换

### 3.1 基本数据类型转换

#### 3.1.1 数值型数据转换

**int()：** 将其他类型转换为整数，如果转换失败则引发 ValueError 异常。

# 将字符串转换为整数
num_str = "123"
num_int = int(num_str)
print(num_int)  # 输出：123

# 将浮点数转换为整数，小数部分将被截断
num_float = 123.45
num_int = int(num_float)
print(num_int)  # 输出：123

**float()：** 将其他类型转换为浮点数，如果转换失败则引发 ValueError 异常。

# 将字符串转换为浮点数
num_str = "123.45"
num_float = float(num_str)
print(num_float)  # 输出：123.45

# 将整数转换为浮点数
num_int = 123
num_float = float(num_int)
print(num_float)  # 输出：123.0

#### 3.1.2 字符串型数据转换

**str()：** 将其他类型转换为字符串，如果转换失败则引发 TypeError 异常。

# 将整数转换为字符串
num_int = 123
num_str = str(num_int)
print(num_str)  # 输出：'123'

# 将浮点数转换为字符串
num_float = 123.45
num_str = str(num_float)
print(num_str)  # 输出：'123.45'

#### 3.1.3 布尔型数据转换

**bool()：** 将其他类型转换为布尔值，如果转换失败则引发 TypeError 异常。

# 将字符串转换为布尔值
bool_str = "True"
bool_val = bool(bool_str)
print(bool_val)  # 输出：True

# 将整数转换为布尔值
bool_int = 1
bool_val = bool(bool_int)
print(bool_val)  # 输出：True

### 3.2 复合数据类型转换

#### 3.2.1 列表转换

**list()：** 将其他类型转换为列表，如果转换失败则引发 TypeError 异常。

# 将元组转换为列表
my_tuple = (1, 2, 3)
my_list = list(my_tuple)
print(my_list)  # 输出：[1, 2, 3]

# 将字符串转换为列表，以每个字符为元素
my_str = "abc"
my_list = list(my_str)
print(my_list)  # 输出：['a', 'b', 'c']

#### 3.2.2 元组转换

**tuple()：** 将其他类型转换为元组，如果转换失败则引发 TypeError 异常。

# 将列表转换为元组
my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple)  # 输出：(1, 2, 3)

# 将字符串转换为元组，以每个字符为元素
my_str = "abc"
my_tuple = tuple(my_str)
print(my_tuple)  # 输出：('a', 'b', 'c')

#### 3.2.3 字典转换

**dict()：** 将其他类型转换为字典，如果转换失败则引发 TypeError 异常。

# 将列表转换为字典，以列表中的元素作为键值对
my_list = [('a', 1), ('b', 2), ('c', 3)]
my_dict = dict(my_list)
print(my_dict)  # 输出：{'a': 1, 'b': 2, 'c': 3}

# 将元组转换为字典，以元组中的第一个元素作为键，第二个元素作为值
my_tuple = (('a', 1), ('b', 2), ('c', 3))
my_dict = dict(my_tuple)
print(my_dict)  # 输出：{'a': 1, 'b': 2, 'c': 3}

# 4. Python中的数据类型应用

### 4.1 数据类型在文件操作中的应用

#### 4.1.1 文件读写操作

Python提供了丰富的文件读写操作函数，可以使用不同的数据类型来处理文件内容。

**代码块 1：文件读写操作**

# 打开文件
with open('test.txt', 'w') as f:
    # 写入字符串
    f.write('Hello, world!')

# 打开文件
with open('test.txt', 'r') as f:
    # 读取文件内容
    content = f.read()

# 打印文件内容
print(content)

**逻辑分析：**

- `open()` 函数打开一个文件，第一个参数是文件名，第二个参数是打开模式。
- `w` 模式用于写入文件，如果文件不存在则创建新文件。
- `write()` 方法将字符串写入文件。
- `r` 模式用于读取文件，如果文件不存在则会报错。
- `read()` 方法读取文件内容并返回一个字符串。

#### 4.1.2 文件权限和属性操作

Python提供了 `os` 模块来操作文件的权限和属性。

**代码块 2：文件权限和属性操作**

import os

# 获取文件权限
permissions = os.stat('test.txt').st_mode

# 打印文件权限
print(permissions)

# 设置文件权限
os.chmod('test.txt', 0o755)

**逻辑分析：**

- `os.stat()` 函数获取文件的属性，返回一个 `stat` 对象。
- `st_mode` 属性包含文件的权限信息。
- `os.chmod()` 函数设置文件的权限，第一个参数是文件名，第二个参数是权限掩码。

### 4.2 数据类型在网络编程中的应用

#### 4.2.1 网络编程命令和函数

Python提供了 `socket` 模块来进行网络编程，可以使用不同的数据类型来表示网络地址和数据。

**代码块 3：网络编程命令和函数**

import socket

# 创建一个 socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 绑定 socket 到一个地址
s.bind(('127.0.0.1', 8080))

# 监听 socket
s.listen(5)

# 接受连接
conn, addr = s.accept()

# 发送数据
conn.send(b'Hello, world!')

# 关闭连接
conn.close()

**逻辑分析：**

- `socket.socket()` 函数创建一个 socket，第一个参数是地址族，第二个参数是套接字类型。
- `bind()` 方法将 socket 绑定到一个地址。
- `listen()` 方法使 socket 进入监听状态。
- `accept()` 方法接受一个连接，返回一个连接对象和客户端地址。
- `send()` 方法发送数据到连接的客户端。
- `close()` 方法关闭连接。

#### 4.2.2 Socket编程实例

**代码块 4：Socket编程实例**

import socket

# 创建一个 socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 连接到服务器
s.connect(('www.example.com', 80))

# 发送 HTTP 请求
request = 'GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n'
s.send(request.encode())

# 接收 HTTP 响应
response = s.recv(1024)

# 打印 HTTP 响应
print(response.decode())

# 关闭连接
s.close()

**逻辑分析：**

- `connect()` 方法将 socket 连接到一个服务器。
- `send()` 方法发送 HTTP 请求到服务器。
- `recv()` 方法接收 HTTP 响应从服务器。
- `decode()` 方法将字节数据解码为字符串。

### 4.3 数据类型在系统管理中的应用

#### 4.3.1 系统信息获取和监控

Python提供了 `psutil` 模块来获取和监控系统信息。

**代码块 5：系统信息获取和监控**

import psutil

# 获取 CPU 使用率
cpu_usage = psutil.cpu_percent()

# 获取内存使用率
mem_usage = psutil.virtual_memory().percent

# 获取磁盘使用率
disk_usage = psutil.disk_usage('/').percent

# 打印系统信息
print(f'CPU Usage: {cpu_usage}%')
print(f'Memory Usage: {mem_usage}%')
print(f'Disk Usage: {disk_usage}%')

**逻辑分析：**

- `psutil.cpu_percent()` 函数获取 CPU 使用率。
- `psutil.virtual_memory().percent` 属性获取内存使用率。
- `psutil.disk_usage('/').percent` 属性获取磁盘使用率。

#### 4.3.2 进程管理和资源限制

Python提供了 `subprocess` 模块来管理进程和资源限制。

**代码块 6：进程管理和资源限制**

import subprocess

# 启动一个进程
process = subprocess.Popen(['ls', '-l'])

# 等待进程完成
process.wait()

# 获取进程的退出码
exit_code = process.returncode

# 打印进程的退出码
print(exit_code)

**逻辑分析：**

- `subprocess.Popen()` 函数启动一个进程，第一个参数是命令行参数列表。
- `wait()` 方法等待进程完成。
- `returncode` 属性获取进程的退出码。

# 5.1 数据类型的正则表达式操作

正则表达式是一种强大的工具，用于匹配和操作文本数据。Python中提供了`re`模块来支持正则表达式操作。

### 5.1.1 正则表达式的基本语法和元字符

正则表达式由一系列字符组成，其中包括：

* **普通字符：**匹配自身，如"a"、"b"、"c"。
* **元字符：**具有特殊含义的字符，如：
* `.`：匹配任何字符。
* `*`：匹配前一个字符零次或多次。
* `+`：匹配前一个字符一次或多次。
* `?`：匹配前一个字符零次或一次。
* `[]`：匹配方括号内指定的字符。
* `^`：匹配字符串的开头。
* `$`：匹配字符串的结尾。

### 5.1.2 正则表达式的应用

正则表达式在Python中的应用非常广泛，例如：

* **文本匹配：**使用`re.search()`或`re.match()`函数匹配文本中的模式。
* **文本替换：**使用`re.sub()`函数替换文本中的模式。
* **文本分割：**使用`re.split()`函数根据模式分割文本。

# 匹配以"Python"开头的字符串
pattern = "^Python"
result = re.search(pattern, "Python is a powerful language")
if result:
    print("匹配成功")
else:
    print("匹配失败")

# 替换字符串中的所有数字为"0"
pattern = "\d+"
text = "1234567890"
result = re.sub(pattern, "0", text)
print(result)  # 输出：0000000000

# 根据逗号分割字符串
pattern = ","
text = "a,b,c,d,e"
result = re.split(pattern, text)
print(result)  # 输出：['a', 'b', 'c', 'd', 'e']