1. 为什么需要Python与C#对照学习？
作为同时活跃在Python和C#两个技术栈的开发者，我经常遇到需要在两种语言间快速切换的场景。最初这种切换让我头疼不已——明明在Python中习以为常的写法，到了C#里却要完全重构；而C#的某些特性在Python中又找不到直接对应。这种认知摩擦促使我开始系统整理两种语言的对照笔记。
Python和C#都是现代编程语言中的佼佼者，但设计哲学迥异：
- Python以"一种明确的方式做一件事"为理念，强调可读性和简洁性
- C#作为静态类型语言，更注重类型安全和性能优化
- Python采用动态类型和鸭子类型（duck typing）
- C#从1.0到10.0版本逐步引入了更多函数式特性
这种差异使得对照学习变得极具价值。当你在Python中遇到yield时，如果能联想到C#的IEnumerable，理解就会更加深刻；反过来，C#的LINQ查询在Python中对应着列表推导式和生成器表达式。这种跨语言的认知迁移能显著提升编程思维的灵活性。
2. 基础语法对照手册
2.1 变量与类型系统
Python采用动态类型，变量声明时不需指定类型：
python复制x = 42 # 整数
name = "Alice" # 字符串
lst = [1,2,3] # 列表
C#则是静态类型语言：
csharp复制int x = 42; // 显式类型声明
string name = "Alice"; // 注意string是小写
List<int> lst = new() {1,2,3}; // 泛型集合
类型推断方面：
- Python 3.6+支持类型提示（Type Hints），但运行时不会检查：
python复制def greet(name: str) -> str:
return f"Hello, {name}"
- C# 9.0引入的
var关键字允许局部变量类型推断：
csharp复制var message = "Hello"; // 编译器推断为string类型
注意：Python的类型提示需要配合mypy等工具才能实现静态检查，而C#的类型推断在编译时就会确定具体类型。
2.2 控制结构对比
条件语句的语法差异：
python复制# Python使用缩进表示代码块
if x > 10:
print("大于10")
elif x > 5:
print("大于5")
else:
print("其他")
csharp复制// C#使用大括号
if (x > 10)
{
Console.WriteLine("大于10");
}
else if (x > 5)
{
Console.WriteLine("大于5");
}
else
{
Console.WriteLine("其他");
}
循环结构对照表：
| 循环类型 | Python示例 | C#示例 |
|---|---|---|
| for循环 | for i in range(10): |
for(int i=0; i<10; i++) |
| foreach | for item in collection: |
foreach(var item in collection) |
| while | while condition: |
while(condition) {...} |
3. 面向对象编程的差异
3.1 类定义与继承
Python的类定义非常简洁：
python复制class Person:
def __init__(self, name): # 构造方法
self.name = name
def greet(self):
return f"Hi, I'm {self.name}"
class Student(Person): # 单继承
def __init__(self, name, major):
super().__init__(name)
self.major = major
C#的类系统更为正式：
csharp复制public class Person
{
public string Name { get; } // 属性
public Person(string name) // 构造函数
{
Name = name;
}
public virtual string Greet() // 虚方法
{
return $"Hi, I'm {Name}";
}
}
public class Student : Person // 继承
{
public string Major { get; }
public Student(string name, string major) : base(name)
{
Major = major;
}
public override string Greet() // 方法重写
{
return $"{base.Greet()} and I study {Major}";
}
}
关键差异点：
- Python使用
self作为实例引用，C#使用this - C#要求显式声明
virtual和override来实现多态 - Python支持多重继承，C#只支持单继承（但可通过接口实现类似效果）
3.2 接口与抽象类
C#中的接口：
csharp复制public interface ILogger
{
void Log(string message);
}
public class FileLogger : ILogger
{
public void Log(string message)
{
File.AppendAllText("log.txt", message);
}
}
Python中没有原生接口概念，但可以通过ABC模块模拟：
python复制from abc import ABC, abstractmethod
class Logger(ABC):
@abstractmethod
def log(self, message):
pass
class FileLogger(Logger):
def log(self, message):
with open("log.txt", "a") as f:
f.write(message)
4. 函数式编程特性对比
4.1 Lambda表达式
Python的lambda较为简单：
python复制square = lambda x: x * x
filtered = filter(lambda x: x > 0, [-1, 0, 1, 2])
C#的lambda更强大，可转换为委托或表达式树：
csharp复制Func<int, int> square = x => x * x;
var filtered = new[] {-1, 0, 1, 2}.Where(x => x > 0);
4.2 LINQ vs Python推导式
C#的LINQ查询：
csharp复制var evenSquares = numbers
.Where(n => n % 2 == 0)
.Select(n => n * n);
Python的等价实现：
python复制even_squares = [n**2 for n in numbers if n % 2 == 0]
生成器表达式（对应C#的延迟执行）：
python复制even_squares = (n**2 for n in numbers if n % 2 == 0)
5. 异步编程模型
5.1 Python的async/await
Python 3.5+的协程模型：
python复制import asyncio
async def fetch_data(url):
print(f"开始获取 {url}")
await asyncio.sleep(1) # 模拟IO操作
return f"{url}的数据"
async def main():
task1 = asyncio.create_task(fetch_data("url1"))
task2 = asyncio.create_task(fetch_data("url2"))
results = await asyncio.gather(task1, task2)
print(results)
asyncio.run(main())
5.2 C#的async/await
C#的异步模型：
csharp复制using System.Threading.Tasks;
async Task<string> FetchDataAsync(string url)
{
Console.WriteLine($"开始获取 {url}");
await Task.Delay(1000); // 模拟IO操作
return $"{url}的数据";
}
async Task Main()
{
var task1 = FetchDataAsync("url1");
var task2 = FetchDataAsync("url2");
var results = await Task.WhenAll(task1, task2);
Console.WriteLine(string.Join(", ", results));
}
await Main();
核心差异：
- Python使用
asyncio库作为事件循环实现 - C#的
Task比Python的Future更丰富，支持取消、进度报告等 - Python的协程是真正的协程（可暂停/恢复），而C#的async/await是基于状态机的编译器魔法
6. 实际开发中的转换技巧
6.1 集合操作对照表
| 操作需求 | Python实现 | C#实现 |
|---|---|---|
| 列表/数组初始化 | lst = [1,2,3] |
var arr = new[] {1,2,3}; |
| 字典/字典初始化 | d = {'a':1, 'b':2} |
var dict = new Dictionary<string,int> { {"a",1}, {"b",2} }; |
| 列表筛选 | [x for x in lst if x>0] |
lst.Where(x => x > 0).ToList() |
| 列表转换 | [str(x) for x in lst] |
lst.Select(x => x.ToString()).ToList() |
| 聚合操作 | sum(lst) |
lst.Sum() |
6.2 常用设计模式实现差异
以观察者模式为例：
Python实现（使用ABC）：
python复制from abc import ABC, abstractmethod
class Observer(ABC):
@abstractmethod
def update(self, subject):
pass
class ConcreteObserver(Observer):
def update(self, subject):
print(f"状态变更为: {subject.state}")
class Subject:
def __init__(self):
self._observers = []
self._state = None
def attach(self, observer):
self._observers.append(observer)
def notify(self):
for observer in self._observers:
observer.update(self)
@property
def state(self):
return self._state
@state.setter
def state(self, value):
self._state = value
self.notify()
C#实现（使用事件）：
csharp复制public class Subject
{
private int _state;
public event Action<Subject> StateChanged;
public int State
{
get => _state;
set
{
_state = value;
StateChanged?.Invoke(this);
}
}
}
public class Observer
{
public Observer(Subject subject)
{
subject.StateChanged += Update;
}
private void Update(Subject subject)
{
Console.WriteLine($"状态变更为: {subject.State}");
}
}
7. 性能关键场景的选择建议
经过多年双语言开发，我总结出以下经验法则：
-
选择Python的场景：
- 快速原型开发
- 数据分析和科学计算（借助NumPy/Pandas）
- 脚本和小型工具开发
- Web后端（Django/Flask）
- 机器学习项目
-
选择C#的场景：
- Windows桌面应用（WPF/WinForms）
- 高性能后端服务（.NET Core）
- 游戏开发（Unity引擎）
- 需要强类型检查的大型项目
- 与企业系统集成（如SQL Server）
-
性能对比实测数据（参考我的基准测试）：
- 数值计算：C#通常比纯Python快10-100倍
- IO密集型任务：两者差异不大，Python的async性能优秀
- 启动时间：C#编译后启动更快，Python解释器启动较慢
实际项目中，我经常混合使用两者——用Python做数据探索和原型，用C#实现核心性能模块。通过Python.NET或IronPython还可以实现两者互操作。