少有人走的路勇哥注：
这个系列贴子，勇哥站在C#开发角度来学习python。
我以C#常用知识点来类比python，共4篇。
你看完后，就明白，所谓python简单易学只是表面。这门语言的语法体量很大不输给C#，它其实是很好的把复杂性隐藏了，给人入门简单的印象，其实想精通它困难是比较大的。
C#开发者快速学习python（1）：入口函数，运算符，模块与包，py文件 ，基础数据类型，列表
C#开发者快速学习python（2）：枚举，装饰器，self，类的三种类型，特殊方法，oop，代码格式，方法 ，方法返回类型，识别函数返回类型
C#开发者快速学习python（3）：有无数组？字符串方法，读写文件，序列化，配置文件，异常处理，循环和选择，模块与包，调试手段
C#开发者快速学习python（4）：与C#不同点，鸭子类型，多线程，多进程编程，访问控制，事件委托实现，lambda表达式，常用内置库，为啥说python简单易用？
（九）调试手段
主要是下面的方法：
- 简单的print语句调试
- 使用assert断言
- 使用Python内置的pdb调试器
- IDE中的调试功能（如PyCharm、VS Code等）
- 使用第三方调试工具（如ipdb、pudb等）
- 日志调试（使用logging模块）
- 远程调试
- 单元测试进行调试
1. 打印调试（Print Debugging）
这是最简单直接的调试方法，通过在代码中插入 print() 语句输出变量值和执行流程。
示例 ：
def calculate(a, b):
print(f"输入参数: a={a}, b={b}")
result = a + b # 假设这里有问题
print(f"计算结果: {result}")
return result
calculate(3, 5)2. 断言调试（Assertion Debugging）
使用 assert 语句验证代码中的条件是否满足，不满足时会抛出 AssertionError 异常。
示例 ：
def divide(a, b): assert b != 0, "除数不能为零" return a / b divide(10, 0) # 会抛出AssertionError并显示错误信息
3. 内置调试器（pdb）
Python内置了 pdb 模块，可以进行交互式调试，支持断点设置、变量查看、单步执行等功能。
使用方法 ：
- 在代码中插入断点：
import pdb def my_function(): x = 10 pdb.set_trace() # 设置断点 y = x * 2 return y my_function()
命令行启动调试：
python -m pdb my_script.py
常用pdb命令 ：
- n (next): 执行下一行
- s (step): 进入函数
- c (continue): 继续执行到下一个断点
- p (print): 打印变量值
- q (quit): 退出调试
- l (list): 显示当前代码
### 4. IDE调试器
现代IDE（如PyCharm、VS Code、Spyder等）提供了图形化调试工具，使用更加直观方便。
VS Code调试示例 ：
1. 1. 点击行号左侧设置断点
2. 2. 按F5或点击调试按钮启动调试
3. 3. 使用调试工具栏控制执行（继续、单步、步入、步出）
4. 4. 在调试面板查看变量值和调用栈
5. 第三方调试工具
- ipdb : pdb 的增强版，提供语法高亮和自动补全等功能
pip install ipdb python -m ipdb my_script.py
pudb : 基于控制台的全屏调试器，界面类似GUI调试器
pip install pudb python -m pudb my_script.py
6. 日志调试
使用Python的 logging 模块记录程序执行状态，可控制日志级别和输出位置。
示例 ：
import logging
# 配置日志
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
def process_data(data):
logger.debug(f"处理数据: {data}")
result = data * 2
logger.info(f"处理结果: {result}")
return result
process_data(42)7. 远程调试
对于无法直接运行的环境，可以使用远程调试工具。
- ptvsd : Visual Studio和VS Code的Python远程调试器
- pydevd : PyCharm的远程调试器
8. 单元测试调试
编写单元测试不仅可以验证代码功能，也是一种有效的调试手段。
示例 ：
import unittest def add(a, b): return a + b class TestAddFunction(unittest.TestCase): def test_add_positive_numbers(self): self.assertEqual(add(1, 2), 3) def test_add_negative_numbers(self): self.assertEqual(add(-1, -2), -3) if __name__ == '__main__': unittest.main()
调试最佳实践
- 从小段代码开始调试，逐步扩大范围
- 先理解问题再进行调试
- 利用调试器的条件断点功能定位特定情况
- 记录调试过程，避免重复调试相同问题
- 对于复杂问题，考虑使用二分法缩小问题范围
（八）模块和包
包的概念和使用
当项目变得复杂时，可以使用包（package）来组织相关的模块。
包是一个包含多个模块的目录，必须包含一个特殊的 __init__.py 文件
（Python 3.3+后这个文件可以为空）。
创建包的结构
my_package/ ├── __init__.py ├── module1.py └── module2.py
使用包中的模块
# 导入包中的特定模块 import my_package.module1 # 使用模块中的函数 result = my_package.module1.function1() # 从包中导入特定模块并指定别名 import my_package.module1 as m1 # 从包中直接导入模块中的函数 from my_package.module2 import function2
## 模块的搜索路径
当导入一个模块时，Python会按照以下顺序搜索模块：
1. 1. 当前目录
2. 2. PYTHONPATH环境变量中列出的目录
3. 3. Python标准库目录
4. 4. 任何.pth文件中列出的目录
可以通过 sys.path 查看Python的搜索路径：
import sys print(sys.path)
相对导入
在包内的模块中，可以使用相对导入来引用包内的其他模块
# 在my_package/module2.py中 from . import module1 # 导入同一包中的模块1 from .module1 import function1 # 导入同一包中模块1的函数 from .. import other_module # 导入父包中的模块
示例：创建和使用自定义工具包
# 目录结构 utils/ ├── __init__.py ├── file_utils.py └── math_utils.py
file_utils.py 内容：
def read_file(file_path): """读取文件内容""" with open(file_path, 'r', encoding='utf-8') as f: return f.read() def write_file(file_path, content): """写入内容到文件""" with open(file_path, 'w', encoding='utf-8') as f: f.write(content)
math_utils.py 内容
def calculate_average(numbers): """计算列表的平均值""" if not numbers: return 0 return sum(numbers) / len(numbers)
使用自定义包：
from utils.file_utils import read_file, write_file
from utils.math_utils import calculate_average
# 使用文件工具
content = read_file("data.txt")
write_file("output.txt", f"处理后的数据: {content}")
# 使用数学工具
numbers = [1, 2, 3, 4, 5]
average = calculate_average(numbers)
print(f"平均值: {average}")Python的模块系统提供了一种优雅的方式来组织和重用代码，通过合理使用模块和包，
可以使代码结构更清晰，更易于维护和扩展。
（七）循环和选择判断
Python中的条件判断使用 if-elif-else 结构，主要特点：
# 基本if语句
age = 18
if age >= 18:
print("已成年")
else:
print("未成年")
# 多条件判断（if-elif-else）
score = 85
if score >= 90:
print("优秀")
elif score >= 80:
print("良好")
elif score >= 60:
print("及格")
else:
print("不及格")
# 条件表达式（三元运算符）
result = "及格" if score >= 60 else "不及格"
print(result)Python条件判断的特点：
- 使用缩进（4个空格）代替C#的花括号 {} 来表示代码块
- 使用冒号 : 标记条件语句的开始
- 支持逻辑运算符 and 、 or 、 not 组合多个条件
- 可以在条件中使用赋值表达式（Python 3.8+）： if (n := len(a)) > 10:
## Python的循环语句
Python提供了两种主要的循环结构： for 循环和 while 循环。
for循环
# 遍历列表
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
print(fruit)
# 使用range()函数生成数字序列
for i in range(5): # 0-4
print(i)
# 遍历字典
person = {"name": "张三", "age": 30, "city": "北京"}
for key, value in person.items():
print(f"{key}: {value}")
# 带索引的遍历
for index, fruit in enumerate(fruits):
print(f"第{index+1}个水果: {fruit}")
# 列表推导式（简洁的for循环）
squares = [i*i for i in range(10)]
print(squares) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]在Python中，如果想在for循环中实现类似C#中 i += 3 的步长操作，
可以使用 range() 函数的第三个参数来指定步长。
for i in range(start, end, step): # 循环体代码
其中：
- start ：起始值（包含）
- end ：结束值（不包含）
- step ：步长值（每次增加的数量）
while循环
# 基本while循环
count = 0
while count < 5:
print(f"计数: {count}")
count += 1
# 带else的循环（循环正常结束时执行else）
count = 0
while count < 5:
print(f"计数: {count}")
count += 1
else:
print("循环正常结束")
# 无限循环（通常需要break跳出）
while True:
user_input = input("请输入内容（输入'退出'结束）: ")
if user_input == "退出":
break
print(f"你输入的是: {user_input}")循环控制语句
Python提供了 break 、 continue 和 pass 来控制循环流程：
# break：跳出当前循环 for i in range(10): if i == 5: break # 当i等于5时跳出循环 print(i) # continue：跳过当前循环的剩余部分，进入下一次循环 for i in range(10): if i % 2 == 0: continue # 跳过偶数 print(i) # 只打印奇数 # pass：空语句，用作占位符 for i in range(10): if i < 5: pass # 不做任何操作 else: print(i)
（六）异常处理
Python使用 try-except-else-finally 结构处理异常，主要特点如下：
# Python异常处理基本结构
try:
# 可能引发异常的代码
result = 10 / 0
except ZeroDivisionError:
# 处理特定异常
print("除数不能为零")
except Exception as e:
# 处理其他异常
print(f"发生错误: {e}")
else:
# 没有异常时执行的代码
print(f"计算结果: {result}")
finally:
# 无论是否有异常都会执行的代码
print("执行结束")Python异常处理的特点：
- 支持捕获多种特定类型的异常
- 可以使用 as 关键字获取异常对象
- else 块在没有异常时执行
- finally 块始终执行，常用于资源清理
- 可以自定义异常类（继承自Exception）
- 使用 raise 关键字主动抛出异常
C#的异常处理机制
C#使用 try-catch-finally 结构处理异常，主要特点如下：
// C#异常处理基本结构
try
{
// 可能引发异常的代码
int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
// 处理特定异常
Console.WriteLine("除数不能为零");
}
catch (Exception ex)
{
// 处理其他异常
Console.WriteLine($"发生错误: {ex.Message}");
}
finally
{
// 无论是否有异常都会执行的代码
Console.WriteLine("执行结束");
}C#异常处理的特点：
- 同样支持捕获多种特定类型的异常
- 使用 catch 块参数获取异常对象
- 没有直接对应Python的 else 块功能
- finally 块始终执行
- 可以自定义异常类（继承自Exception）
- 使用 throw 关键字主动抛出异常
- 支持异常过滤器（C# 6及以上版本）
Python与C#异常处理的主要区别
1. 1.
语法结构差异 ：
- Python使用 try-except-else-finally ，而C#使用 try-catch-finally
- Python使用缩进表示代码块，C#使用花括号 {}
2. 2.
异常继承体系 ：
- Python中所有异常都是Exception的子类
- C#中异常继承自System.Exception类
3. 3.
else块的使用 ：
- Python有 else 块，在try块成功执行（无异常）时运行
- C#没有直接对应的 else 块，但可在try块末尾执行类似逻辑
4. 4.
资源管理 ：
- Python 3.6+引入 contextlib.suppress 和上下文管理器简化特定异常处理
- C#有 using 语句（类似Python的上下文管理器）和 try-finally 组合管理资源
- C# 8.0+有更简洁的 using 声明
5. 5.
异常过滤器 ：
- C#支持异常过滤器（ catch (Exception ex) when (条件) ）
- Python需在except块内使用if条件判断实现类似功能
6. 6.
异常信息 ：
- Python异常对象包含 args 、 message 等属性
- C#异常对象通常有 Message 、 StackTrace 、 InnerException 等属性
7. 7.
异常处理的粒度 ：
- Python倾向于"请求原谅而不是许可"(EAFP)的编程风格
- C#更倾向于"先检查后执行"(LBYL)的风格
实际应用示例对比
Python中的文件操作异常处理 ：
try:
with open("file.txt", "r") as f:
content = f.read()
except FileNotFoundError:
print("文件不存在")
except IOError as e:
print(f"IO错误: {e}")
else:
print(f"文件内容长度: {len(content)} 字节")
finally:
print("文件操作尝试完成")C#中的文件操作异常处理 ：
string content = null;
try
{
using (StreamReader sr = new StreamReader("file.txt"))
{
content = sr.ReadToEnd();
Console.WriteLine($"文件内容长度: {content.Length} 字节（五）读写配置文件
Python中读写配置文件的常见方式有多种，以下是最常用的几种方法及其适用场景：
1. INI格式配置文件（使用configparser模块）
configparser 是Python标准库，用于处理类似Windows INI格式的配置文件，适合简单的分层配置。
示例配置文件（config.ini）
[Database] host = localhost port = 3306 username = root password = 123456 h[App] name = MyApplication version = 1.0.0 debug = true
读取INI配置
import configparser
# 创建配置解析器
config = configparser.ConfigParser()
# 读取配置文件
config.read('config.ini', encoding='utf-8')
# 获取配置值
host = config.get('Database', 'host')
port = config.getint('Database', 'port') # 转换为整数
debug = config.getboolean('App', 'debug') # 转换为布尔值
print(f"数据库地址: {host}, 端口: {port}")
print(f"应用名称: {config['App']['name']}, 调试模式: {debug}")写入INI配置
import configparser
config = configparser.ConfigParser()
# 添加配置节和选项
config['Database'] = {
'host': 'localhost',
'port': '3306',
'username': 'root',
'password': '123456'
}
config['App'] = {
'name': 'MyApplication',
'version': '1.0.0',
'debug': 'true'
}
# 写入配置文件
with open('config.ini', 'w', encoding='utf-8') as configfile:
config.write(configfile)2. JSON格式配置文件（使用json模块）
JSON格式适合存储结构化配置数据，易于阅读和跨平台使用。
示例配置文件（config.json）
{
"database": {
"host": "localhost",
"port": 3306,
"credentials": {
"username": "root",
"password": "123456"
}
},
"app": {
"name": "MyApplication",
"version": "1.0.0",
"debug": true
}
}读取JSON配置
import json
# 读取JSON配置文件
with open('config.json', 'r', encoding='utf-8') as file:
config = json.load(file)
# 获取配置值
host = config['database']['host']
port = config['database']['port']
username = config['database']['credentials']['username']
print(f"数据库: {host}:{port}, 用户: {username}")写入JSON配置
import json
# 准备配置数据
config = {
"database": {
"host": "localhost",
"port": 3306,
"credentials": {
"username": "root",
"password": "123456"
}
},
"app": {
"name": "MyApplication",
"version": "1.0.0",
"debug": True
}
}
# 写入JSON文件（indent参数美化输出）
with open('config.json', 'w', encoding='utf-8') as file:
json.dump(config, file, ensure_ascii=False, indent=4)3. YAML格式配置文件（使用pyyaml库）
YAML格式比JSON更灵活，支持注释和复杂数据结构，需要安装第三方库 pyyaml 。
安装pyyaml
pip install pyyaml
示例配置文件（config.yaml）
database: host: localhost port: 3306 credentials: username: root password: 123456 app: name: MyApplication version: "1.0.0" # 支持注释 debug: true
读取YAML配置
import yaml
# 读取YAML配置文件
with open('config.yaml', 'r', encoding='utf-8') as file:
config = yaml.safe_load(file) # 使用safe_load更安全
# 获取配置值
print(f"应用名称: {config['app']['name']}")
print(f"调试模式: {config['app']['debug']}")写入YAML配置
import yaml
# 准备配置数据
config = {
'database': {
'host': 'localhost',
'port': 3306,
'credentials': {
'username': 'root',
'password': '123456'
}
},
'app': {
'name': 'MyApplication',
'version': '1.0.0',
'debug': True
}
}
# 写入YAML文件
with open('config.yaml', 'w', encoding='utf-8') as file:
yaml.dump(config, file, allow_unicode=True, default_flow_style=False)4. 环境变量与.env文件（使用python-dotenv库）
对于敏感配置（如API密钥、数据库密码），推荐使用环境变量或 .env 文件。
安装python-dotenv
pip install python-dotenv
示例.env文件
DB_HOST=localhost DB_PORT=3306 DB_USERNAME=root DB_PASSWORD=123456 APP_DEBUG=true
读取.env配置
from dotenv import load_dotenv
import os
# 加载.env文件中的环境变量
load_dotenv()
# 读取环境变量
host = os.getenv('DB_HOST')
port = os.getenv('DB_PORT')
password = os.getenv('DB_PASSWORD')
# 转换类型
debug = os.getenv('APP_DEBUG').lower() == 'true'
print(f"数据库地址: {host}, 端口: {port}")
print(f"调试模式: {debug}")5. 使用Python模块读写配置
这种方式是将配置直接定义在Python文件中，然后通过导入模块的方式读取配置。
它的优点是可以使用Python的全部语法，支持复杂的数据结构、动态计算等。
示例配置文件（config.py）
# 数据库配置
DB_HOST = "localhost"
DB_PORT = 3306
DB_USERNAME = "root"
DB_PASSWORD = "123456"
# 应用配置
APP_NAME = "MyApplication"
APP_VERSION = "1.0.0"
DEBUG = True
# 支持复杂数据结构
ALLOWED_IPS = ["127.0.0.1", "192.168.1.0/24"]
# 支持字典
LOGGING_CONFIG = {
"level": "INFO",
"file": "/var/log/myapp.log",
"format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
}
# 支持动态计算
import os
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DATA_DIR = os.path.join(BASE_DIR, "data")读取Python模块配置
# 直接导入配置模块
import config
# 访问配置值
print(f"数据库地址: {config.DB_HOST}")
print(f"应用名称: {config.APP_NAME}")
print(f"调试模式: {config.DEBUG}")
print(f"日志配置: {config.LOGGING_CONFIG}")
print(f"数据目录: {config.DATA_DIR}")选择建议
- INI格式 ：适合简单的分层配置，使用标准库，无需额外安装
- JSON格式 ：适合结构化数据，跨语言支持好，使用标准库
- YAML格式 ：适合复杂配置，支持注释，可读性强，但需要安装第三方库
- 环境变量/.env ：适合存储敏感信息，安全性高
最佳实践
1. 1.
敏感配置（如密码、API密钥）避免明文写在配置文件中，优先使用环境变量
2. 2.
配置文件应加入 .gitignore ，避免将敏感信息提交到代码仓库
3. 3.
根据配置复杂度选择合适的格式
4. 4.
读取配置时添加错误处理，确保程序稳定性
（四）序列化与反序列化对象
Python提供了类似C#的对象序列化与反序列化功能，主要通过以下几种方式实现：
1. JSON序列化（常用）
Python的 json 模块可以实现Python对象与JSON格式之间的转换，
类似于C#中的 Newtonsoft.Json 或 System.Text.Json 。
import json
# 定义一个类
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
# 创建对象
person = Person("张三", 30)
# 序列化为JSON：需要先转换为字典
person_dict = {"name": person.name, "age": person.age}
json_str = json.dumps(person_dict, ensure_ascii=False) # ensure_ascii=False保留中文
print(json_str) # 输出: {"name": "张三", "age": 30}
# 反序列化为字典
new_dict = json.loads(json_str)
print(new_dict["name"]) # 输出: 张三
# 反序列化为对象
new_person = Person(new_dict["name"], new_dict["age"])2. Pickle序列化（Python特有）
pickle 模块可以序列化任何Python对象（包括自定义类实例），但序列化结果是二进制格式，且只能在Python环境中使用。
import pickle
# 定义类和创建对象同上
person = Person("张三", 30)
# 序列化到文件
with open("person.pkl", "wb") as file:
pickle.dump(person, file)
# 从文件反序列化
with open("person.pkl", "rb") as file:
loaded_person = pickle.load(file)
print(loaded_person.name) # 输出: 张三
print(loaded_person.age) # 输出: 30
# 序列化到内存
pickle_data = pickle.dumps(person)
# 从内存反序列化
restored_person = pickle.loads(pickle_data)3. 高级自定义序列化
对于更复杂的类，可以定义特殊方法来自定义序列化行为：
import json
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
self.skills = ["Python", "C#"]
# 自定义JSON序列化方法
def to_json(self):
return {
"name": self.name,
"age": self.age,
"skills": self.skills
}
# 使用自定义方法
person = Person("李四", 25)
json_str = json.dumps(person.to_json(), ensure_ascii=False)
print(json_str)
# 也可以创建JSON编码器类
class PersonEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, Person):
return obj.to_json()
return super().default(obj)
# 使用编码器
json_str = json.dumps(person, cls=PersonEncoder, ensure_ascii=False)与C#序列化的对比
- JSON序列化 ：Python的 json 模块类似于C#的 System.Text.Json ，都可以将对象转换为JSON字符串
- 二进制序列化 ：Python的 pickle 类似于C#的 BinaryFormatter ，
但 pickle 只能在Python中使用
- 类型处理 ：C#的序列化通常需要添加特性标记（如 [Serializable] ），
而Python更加灵活
- 安全性 ： pickle 不适合处理不可信来源的数据，存在安全风险，
这点与C#的二进制序列化类似
根据实际需求，可以选择适合的序列化方式：需要跨平台或跨语言时使用 json ，仅在Python环境内使用时可以选择 pickle 。
（三）读写文件
Python提供了多种文件读写操作方法，以下是最常用的操作方式和最佳实践：
1. 文件打开方式
Python推荐使用 with 语句打开文件，它会自动处理文件关闭，避免资源泄露：
# 基本语法
with open('filename.txt', 'mode')
as file:
# 文件操作代码
2. 文件打开模式
常用模式包括：
- 'r' : 只读模式（默认）
- 'w' : 写入模式（覆盖原有内容，文件不存在则创建）
- 'a' : 追加模式（在文件末尾添加内容，文件不存在则创建）
- 'r+' : 读写模式
- 'b' : 二进制模式（与其他模式结合使用，如'rb', 'wb'）
3. 读取文件
3.1 读取全部内容
with open('filename.txt', 'r',
encoding='utf-8') as file:
content = file.read() # 读取整个文件
print(content)
3.2 逐行读取
with open('filename.txt', 'r',
encoding='utf-8') as file:
for line in file:
print(line.strip()) # strip()去除换行符
3.3 读取所有行到列表
with open('filename.txt', 'r',
encoding='utf-8') as file:
lines = file.readlines() # 返回
包含所有行的列表
for line in lines:
print(line.strip())
4. 写入文件
4.1 写入字符串
with open('output.txt', 'w',
encoding='utf-8') as file:
file.write('Hello, World!\n')
# 注意手动添加换行符
file.write('This is a test file.
')
4.2 写入多行
lines = ['First line', 'Second
line', 'Third line']
with open('output.txt', 'w',
encoding='utf-8') as file:
file.writelines([line + '\n'
for line in lines]) # 需要手动添加换行符
4.3 追加内容
with open('output.txt', 'a',
encoding='utf-8') as file:
file.write('This is additional
content.\n')
5. 二进制文件操作
# 读取二进制文件
with open('image.jpg', 'rb') as
file:
data = file.read()
# 写入二进制文件
with open('copy.jpg', 'wb') as file:
file.write(data)
6. 文件操作的最佳实践
1. 1. 始终使用 with 语句处理文件，确保文件正确关闭
2. 2. 指定合适的编码（如 encoding='utf-8' ），避免编码问题
3. 3. 读写大文件时，考虑使用逐行读取而不是一次性读取全部内容
4. 4. 处理文件操作时，适当使用异常处理机制
7. 异常处理示例
try:
with open('filename.txt', 'r',
encoding='utf-8') as file:
content = file.read()
except FileNotFoundError:
print('文件不存在')
except PermissionError:
print('没有权限访问文件')
except Exception as e:
print(f'发生错误: {e}')
这些是Python文件读写的基础操作，根据具体需求可以选择合适的方法和模式。
（二）字符串常用方法
Python中提供了丰富的字符串处理方法，以下是最常用的几类及其功能：
1. 基础操作
- len(s) : 获取字符串长度
- s1 + s2 : 字符串连接
- s * n : 字符串重复n次
- s[n] : 获取索引为n的字符
2. 查找与替换
- s.find(sub) : 查找子串位置，不存在返回-1
- s.index(sub) : 查找子串位置，不存在抛出异常
- s.replace(old, new) : 替换子串
- s.count(sub) : 统计子串出现次数
3. 大小写转换
- s.lower() : 转换为小写
- s.upper() : 转换为大写
- s.title() : 首字母大写
- s.capitalize() : 第一个字符大写
4. 去除空白
- s.strip() : 去除两端空白
- s.lstrip() : 去除左端空白
- s.rstrip() : 去除右端空白
5. 分割与连接
- s.split(sep) : 按分隔符分割字符串
- s.rsplit(sep) : 从右侧开始分割
- s.splitlines() : 按换行符分割
- sep.join(iterable) : 用sep连接可迭代对象
6. 判断方法
- s.startswith(prefix) : 是否以prefix开头
- s.endswith(suffix) : 是否以suffix结尾
- s.isalpha() : 是否全为字母
- s.isdigit() : 是否全为数字
- s.isspace() : 是否全为空白
- s.islower() : 是否全为小写
- s.isupper() : 是否全为大写
7. 格式化
- f-string : f"Hello, {name}"
- format() : "Hello, {}".format(name)
- %格式化 : "Hello, %s" % name
8. 切片操作
- s[start:end:step] : 截取子串
代码示例
# 示例字符串
text = " Hello, Python World! "
# 常用方法示例
print(len(text)) # 输出: 24
print(text.strip()) # 输出: "Hello, Python World!"
print(text.lower()) # 输出: " hello, python world! "
print(text.split(",")) # 输出: [' Hello', ' Python World! ']
print("-".join(["apple", "banana"])) # 输出: "apple-banana"
print(text.find("Python")) # 输出: 8
print(f"Length: {len(text)}") # 输出: "Length: 24"（一）python有没有数组
Python中没有C#那样严格的数组概念，但有类似的数据结构。以下是详细对比：
Python中的类似结构
1. 1. 列表（List） ：
最常用，相当于C#中动态数组，支持不同类型元素、可变长度
2. 2. 数组模块（array） ：
更接近C#数组，存储同类型数据，效率更高
3. 3. NumPy数组 ：
科学计算中使用，功能强大的数值数组
与C#数组的主要区别
- 类型严格性 ：C#数组要求所有元素同类型，Python列表允许混合类型
- 固定长度 ：C#数组创建后长度固定，Python列表长度可变
- 性能特点 ：Python的array模块和NumPy数组在处理大量同类型数据时性能接近C#数组
- 语法差异 ：Python用 [] 创建列表，array模块需指定类型码
代码示例对比
C#数组：
int[] numbers = new int[5]; // 固定长度的整型数组 numbers[0] = 1; // 赋值
Python列表（最常用）：
numbers = [1, 2, 3, 4, 5] # 动态可变的列表 numbers.append(6) # 可直接添加元素
Python array模块：
import array
numbers = array.array('i', [1, 2, 3, 4, 5]) # 同类型整型数组
