少有人走的路（六）和C#的List<T>的类比，以及常用的操作
在Python中，与C#的List<T>相对应的类型是列表（list）。
两者都是有序、可变的集合类型，但Python的列表更加灵活，
因为它可以存储不同类型的元素，
而C#的List<T>是泛型集合，只能存储指定类型的元素。
Python列表（list）的常见操作
1. 创建列表
# 创建空列表
songs = []
# 或使用list()函数
songs = list()
# 创建包含元素的列表
songs = ["青花瓷", "七里香", "晴天"]
# 混合类型（Python特色）
mixed_list = [1, "hello", True, 3.14]
2. 访问元素
# 通过索引访问（索引从0开始）
first_song = songs[0] # "青花瓷"
# 负数索引（从末尾开始）
last_song = songs[-1] # "晴天"
3. 添加元素
# 在末尾添加单个元素
songs.append("夜曲")
# 在指定位置插入元素
songs.insert(1, "菊花台") # 在索引1处插入
# 合并两个列表
songs.extend(["东风破", "双截棍"]) # 相当于C#的AddRange# 或使用 + 运算符
songs = songs + ["不能说的秘密"]
4. 删除元素
# 根据值删除元素
songs.remove("晴天")
# 根据索引删除元素并返回其值
removed_song = songs.pop(0) # 删除并返回第一个元素
# 删除最后一个元素并返回其值
last_removed = songs.pop() # 相当于C#的RemoveAt(list.Count-1)
# 清空列表
songs.clear()
5. 修改元素
# 直接通过索引修改
songs[0] = "稻香"
6. 列表长度和检查
# 获取列表长度
length = len(songs) # 相当于C#的Count属性
# 检查元素是否在列表中
is_exist = "青花瓷" in songs # 相当于C#的Contains方法
7. 列表切片（获取子列表）
# 获取从索引1到索引3（不包含）的元素
sublist = songs[1:3]
# 获取从开头到索引2的元素
sublist = songs[:2]
# 获取从索引2到末尾的元素
sublist = songs[2:]
8. 列表排序和反转
# 升序排序（会修改原列表）
songs.sort()
# 降序排序
songs.sort(reverse=True)
# 返回排序后的新列表（不修改原列表）
sorted_songs = sorted(songs)
# 反转列表（会修改原列表）
songs.reverse()
# 返回反转后的新列表（不修改原列表）
reversed_songs = list(reversed(songs))
9. 其他常用操作
# 计算元素在列表中出现的次数
count = songs.count("青花瓷")
# 查找元素的索引（如果不存在会抛出异常）
index = songs.index("七里香")
# 复制列表
songs_copy = songs.copy() # 浅拷贝
# 或使用切片
songs_copy = songs[:]
Python列表与C# List的主要区别
1.类型限制：Python列表可以包含不同类型的元素，
而C#的List<T>只能包含指定类型的元素
2.类型转换：Python列表操作更灵活，很多操作会返回新的列表，
而C#的List<T>更多是直接修改原列表
3.方法命名：Python使用更简洁的方法名（如append、remove），
而C#使用更明确的方法名（如Add、Remove）
4.切片操作：Python的列表切片是一个强大的特性，允许方便地获取子列表，
而C#需要使用LINQ或循环来实现类似功能
（五）基础数据类型对比
Python的基础数据类型与C#有一定的对应关系，但也存在一些差异。
以下是Python的主要基础数据类型及其与C#的类比：
1. 数值类型
Python：
整数（int）：表示任意大小的整数，没有固定大小限制
示例：x = 100, y = -200, z = 1000000000000000000000000
浮点数（float）：表示带小数点的数值，相当于C#的double
示例：x = 3.14, y = -0.5
复数（complex）：表示复数，C#中没有直接对应的内置类型
示例：x = 1 + 2j
C#类比：
int、long、short → Python的int（Python会自动处理大小）
float、double → Python的float（Python只有一种浮点类型，相当于double）
decimal → Python没有直接对应，但可以使用第三方库如decimal模块
2. 字符串（str）
Python：
表示文本数据，用单引号、双引号或三引号括起来
不可变类型，支持各种字符串操作和方法
示例：s1 = 'hello', s2 = "world",
s3 = '''多行 字符串'''
C#类比：
string → Python的str
C#的char在Python中用长度为1的字符串表示
3. 布尔值（bool）
Python：
表示真或假，只有两个值：True和False
常用于条件判断和逻辑运算
示例：is_valid = True, has_error = False
C#类比：
bool → Python的bool
4. 列表（list）
Python：
有序、可变的元素集合，可以包含不同类型的元素
用方括号[]定义
示例：lst = [1, "hello", True, 3.14]
C#类比：
List→ Python的list（但Python的list更灵活，可包含不同类型）
5. 元组（tuple）
Python：
有序、不可变的元素集合，类似于列表但不能修改
用圆括号()定义，或省略括号
示例：t = (1, "hello", True)或t = 1, "hello", True
C#类比：
ValueTuple → Python的tuple（但C#的ValueTuple是可变的，而Python的tuple不可变）
6. 集合（set）
Python：
无序、不重复的元素集合，支持集合运算
用大括号{}定义，或使用set()函数
示例：s = {1, 2, 3}, s = set([1, 2, 3])
C#类比：
HashSet→ Python的set
7. 字典（dict）
Python：
无序的键值对集合，键必须是不可变类型
用大括号{}定义，键值对用冒号:分隔
示例：d = {"name": "John", "age": 30, "city": "New York"}
C#类比：
Dictionary<TKey, TValue> → Python的dict
8. None类型
Python：
表示空值或缺失值，类似于C#的null
是一个特殊的常量，用None表示
示例：x = None
C#类比：
null → Python的None
主要区别：
1.类型系统：Python是动态类型语言，变量不需要声明类型；C#是静态类型语言，变量必须声明类型
2.类型转换：Python中类型转换更灵活，很多操作会自动转换类型；C#中类型转换更严格，通常需要显式转换
3.整数大小：Python的int可以表示任意大小的整数；C#的整数类型有固定大小限制
4.字符类型：Python没有单独的char类型，单个字符就是长度为1的字符串；C#有单独的char类型
5.可变与不可变：Python明确区分可变类型（列表、集合、字典）和不可变类型（整数、浮点数、字符串、元组）
（四）在py文件中可以定义些什么（类比C#的cs文件）
在Python中，一个.py文件（通常称为模块）可以定义多种内容，与C#有相似之处也有一些差异：
Python文件中可以定义的内容：
1. 1.
类（Class） ：
- 与C#类似，可以在文件中定义一个或多个类
- 支持类继承、多态、封装等面向对象特性
- 示例： class SongDB:
2. 2.
函数（Function） ：
- 可以定义多个全局函数
- 支持普通函数、lambda函数、嵌套函数等
- 示例： def add_song(song_name, singer):
在C#中，所有的方法（函数）必须定义在类或结构体内部，
C#是一种纯粹的面向对象编程语言，不支持全局函数的概念。
而在Python中，函数可以定义在类的外面，作为模块级别的全局函数，
也可以定义在类的内部作为方法。这是Python与C#在语法设计上的一个重要区别。
3. 3.
全局变量 ：
- 可以定义全局变量，在模块内可见
- 从其他模块导入时可以通过模块名访问
- 示例： DATABASE_NAME = 'songs.db'
4. 4.
数据结构 ：
- Python没有单独的 struct 关键字，但可以用类模拟结构体行为
- 支持枚举（通过 enum 模块）
- 可以直接定义列表、字典、集合等复合数据类型
- 示例： from enum import Enum; class Status(Enum): ACTIVE = 1; INACTIVE = 2
5. 5.
导入语句 ：
- 引入其他模块或模块中的内容
- 示例： from Sqllib import SongDB
6. 6.
执行代码 ：
- Python文件可以包含直接执行的代码（不在函数或类内）
- 这些代码在模块被导入或直接运行时执行
- 通常用 if __name__ == "__main__": 来区分直接运行和被导入的情况
Python 与C#的主要区别：
1. 1.
Python没有命名空间（namespace） ：而是通过模块和包来组织代码
2. 2.
Python没有单独的struct类型 ：用类或数据类（dataclass）替代
3. 3.
Python模块级别代码的执行方式 ：C#中Main方法是入口，而Python中模块级代码会在导入时执行
4. 4.
Python的动态类型系统 ：与C#的静态类型系统有区别
总的来说，Python的模块（.py文件）比C#的.cs文件更加灵活，可以包含多种类型的定义和可执行代码。
（三）python和C#命名空间的区别
Python 和 C# 在引用命名空间（模块/包）方面有显著差异，主要体现在以下几个方面：
1. 概念和术语差异
C#：使用 namespace 关键字定义命名空间，通过 using 语句引入命名空间
Python：没有显式的命名空间关键字，而是通过模块（module）和包（package）来组织代码，使用 import 语句导入模块或模块中的特定内容
2. 导入语法和机制
C#：
using System; // 导入整个命名空间
using System.Collections.Generic; // 导入嵌套命名空间
导入后，命名空间中的所有公共类型都可以直接使用
命名空间具有层次结构，使用点号（.）分隔
Python：
import math # 导入整个模块
from math import sqrt # 从模块中导入特定函数
from math import * # 导入模块中的所有公共内容（不推荐）
import numpy as np # 导入模块并使用别名
导入模块后，通常需要通过模块名访问其内容（如 math.sqrt(4)）
可以通过 from module import name 直接导入特定内容，无需模块名前缀
Python 的包是包含 __init__.py 文件的目录，用于组织相关模块
3. 命名空间的可见性
C#：
命名空间中的类型默认具有命名空间作用域
不同命名空间中的同名类型可以通过完全限定名区分（如 System.Text.StringBuilder 和 MyProject.StringBuilder）
Python：
每个模块都有自己独立的命名空间
导入模块不会自动将其内容添加到当前命名空间，除非使用 from module import *
可以通过 globals() 和 locals() 函数查看当前作用域的命名空间
4. 静态导入和动态导入
C#：主要是静态导入，在编译时解析命名空间
Python：
支持静态导入（使用 import 语句）
也支持动态导入（使用 __import__(), importlib.import_module() 等函数）
import importlib
module = importlib.import_module('math')
result = module.sqrt(4)
5. 命名冲突解决
C#：
使用完全限定名
使用命名空间别名（如 using IO = System.IO;）
Python：
使用模块名前缀访问
使用导入别名（如 import pandas as pd）
通过 from module import name as alias 为特定内容创建别名
6. 程序集和模块结构
C#：
代码组织为项目，编译为程序集（DLL或EXE）
一个程序集可以包含多个命名空间
需要添加对其他程序集的引用才能使用其命名空间
Python：
代码组织为模块（.py文件）和包（目录）
模块可以直接从文件系统导入，无需显式引用
通过 PYTHONPATH 环境变量或 .pth 文件指定模块搜索路径
总体而言，Python 的导入机制更加灵活，而 C# 的命名空间系统更加结构化和严格。
Python 强调模块级别的组织，而 C# 强调命名空间的层次结构。
（二）常用符号的操作
C#中的这些操作在Python中的对应表示方法如下：
1. 不等于操作符
- C#： !=
- Python：同样使用 !=
==和=和C#一样的：
x = 5 # 赋值操作，将5赋给变量x
y = 5
print(x == y) # 比较操作，检查x和y的值是否相等，输出True
2. 取模运算符（%）
- C#： %
- Python：同样使用 %
3. 阶乘（!）
- C#：没有内置阶乘运算符，需自行实现或使用第三方库
- Python：使用 math.factorial() 函数
```
import math
result = math.factorial(5) # 结
果为120
4. 整数取整
- C#： Math.Floor() , Math.Ceiling() , Math.Round() , Convert.ToInt32() 等
- Python：
- 向下取整（地板除）： // 运算符
- 向上取整： math.ceil()
- 四舍五入： round()
a = 5 // 2 # 结果为2
import math
b = math.ceil(5 / 2) # 结果为3
c = round(5.5) # 结果为6
5. 浮点数取整
- C#： Math.Floor() , Math.Ceiling() , Math.Round() 等
- Python：与整数取整类似，使用 math.floor() , math.ceil() , round() 函数
import math
a = math.floor(5.7) # 结果为5
b = math.ceil(5.2) # 结果为6
c = round(5.3) # 结果为5
6. 字符和字符串
- C#： char 类型表示单个字符， string 类型表示字符串
- Python：没有单独的 char 类型，单个字符也是字符串（长度为1的字符串）
char_var = 'A' # 单个字符，实际上是
字符串
str_var = "Hello"
7. 字符串转数值
- C#： int.Parse() , double.Parse() , Convert.ToInt32() 等
- Python：
- 转整数： int()
- 转浮点数： float()
num1 = int("123")
num2 = float("3.14")
8. 数值转字符串
- C#： ToString() 方法
- Python：
- str() 函数
str_num = str(123)
str_float = str(3.14)
9. 数值显示格式（例如显示为指定位数的小数）
- C#：格式化字符串或 ToString() 方法的格式说明符
- Python：
- 使用格式化字符串
- 使用 format() 方法
- 使用f-string（Python 3.6+）
num = 3.1415
# 方法1：格式化字符串
formatted = "%.2f" % num # 结果为"3.14"
# 方法2：format()方法
formatted = "{:.2f}".format(num) # 结果为"3.14"
# 方法3：f-string
formatted = f"{num:.2f}" # 结果为"3.14"
（一）入口函数的定义
if __name__ == "__main__": 语句的作用就是判断该文件是否被直接运行，如果是，则调用 main() 函数来启动程序。
如果该文件被其他程序导入为模块，则不会执行 main() 函数，从而避免了不必要的代码执行。
if __name__ == "__main__": main()
__name__和字符串“__main__"，前者是内定义的变量，后者为内定的字符串。
main()函数是用户定义的，不是关键字，名字可以任意。
