从 C# 到 Python：6 天极速入门（第二天）

发布于：2025-07-19 ⋅ 阅读:(15) ⋅ 点赞:(0)

作为一名资深 C# 开发者，我们在第一天已经掌握了 Python 的基础语法框架。今天我们将深入 Python 的特色语法与高级特性，通过实际项目开发场景的代码对比，理解这些特性在真实业务中的应用价值。

一、简洁语法糖：项目开发中的实战应用

1. 列表推导式（替代 C# 的 LINQ）

在实际项目中，列表推导式常用于数据转换和过滤，比如处理用户输入、日志分析等场景。

场景 1：批量处理日期格式

// C#处理日期列表（例如从数据库查询的时间戳转换）
var timestamps = new List<long> { 1620000000, 1620086400, 1620172800 };
var dates = timestamps.Select(ts => 
    new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)
        .AddSeconds(ts)
        .ToString("yyyy-MM-dd")
).ToList();
# Python处理日期列表
import datetime
timestamps = [1620000000, 1620086400, 1620172800]
dates = [
    datetime.datetime.fromtimestamp(ts).strftime("%Y-%m-%d") 
    for ts in timestamps
]
print(dates)  # ['2021-05-03', '2021-05-04', '2021-05-05']

场景 2：数据清洗中的类型转换

// C#处理用户输入的字符串数字列表
var input = new List<string> { "123", "45.6", "789", "abc" };
var numbers = input
    .Where(s => double.TryParse(s, out _))
    .Select(double.Parse)
    .ToList();

# Python处理用户输入的字符串数字列表
input = ["123", "45.6", "789", "abc"]
numbers = [float(s) for s in input if s.replace(".", "", 1).isdigit()]
print(numbers)  # [123.0, 45.6, 789.0]

2. 字典推导式（项目实战场景）

在配置处理、数据映射等场景中，字典推导式比 C# 的ToDictionary更灵活。

场景 1：配置项转换

// C#处理配置字典（将字符串值转换为对应类型）
var configStr = new Dictionary<string, string> {
    {"timeout", "300"},
    {"max_connections", "50"},
    {"enable_log", "true"}
};
var config = configStr.ToDictionary(
    k => k.Key,
    v => new { 
        IntValue = int.TryParse(v.Value, out int i) ? i : 0,
        BoolValue = bool.TryParse(v.Value, out bool b) ? b : false
    }
);

# Python处理配置字典
config_str = {
    "timeout": "300",
    "max_connections": "50",
    "enable_log": "true"
}
config = {
    key: {
        "int_value": int(value) if value.isdigit() else 0,
        "bool_value": value.lower() == "true"
    } 
    for key, value in config_str.items()
}
print(config["enable_log"]["bool_value"])  # True

场景 2：API 响应数据处理

// C#处理API返回的用户列表
var apiUsers = new List<Dictionary<string, object>> {
    new() {{"id", 1}, {"name", "Alice"}, {"age", "25"}},
    new() {{"id", 2}, {"name", "Bob"}, {"age", "30"}}
};
var userMap = apiUsers.ToDictionary(
    u => (int)u["id"],
    u => new { Name = (string)u["name"], Age = int.Parse((string)u["age"]) }
);

# Python处理API返回的用户列表
api_users = [
    {"id": 1, "name": "Alice", "age": "25"},
    {"id": 2, "name": "Bob", "age": "30"}
]
user_map = {
    user["id"]: {
        "name": user["name"],
        "age": int(user["age"])
    } 
    for user in api_users
}
print(user_map[1]["age"])  # 25

3. 解包操作（项目中的实用技巧）

在函数参数传递、数据拆分等场景中，解包操作比 C# 的元组访问更高效。

场景 1：函数多返回值处理

// C#处理函数返回的多值
(int total, int success, int failed) CalculateStats(List<int> results) {
    return (results.Count, results.Count(r => r == 0), results.Count(r => r < 0));
}

var stats = CalculateStats(new List<int> {0, 0, -1, 0, -2});
int total = stats.total;
int success = stats.success;
int failed = stats.failed;
# Python处理函数返回的多值
def calculate_stats(results):
    total = len(results)
    success = sum(1 for r in results if r == 0)
    failed = sum(1 for r in results if r < 0)
    return total, success, failed

# 直接解包赋值
total, success, failed = calculate_stats([0, 0, -1, 0, -2])
print(f"成功率: {success/total:.2f}")  # 成功率: 0.60

场景 2：批量数据拆分

// C#拆分数据列表
var data = new List<string> { "header", "row1", "row2", "row3", "footer" };
string header = data[0];
var body = data.GetRange(1, data.Count - 2);
string footer = data[data.Count - 1];

# Python拆分数据列表
data = ["header", "row1", "row2", "row3", "footer"]
header, *body, footer = data
print(header)  # header
print(body)    # ['row1', 'row2', 'row3']
print(footer)  # footer

二、函数式编程（项目实战案例）

1. 高阶函数（map/filter/reduce）

在数据清洗、批量处理等场景中，这些函数比 C# 的 LINQ 更简洁。

场景 1：日志数据处理

// C#处理日志列表（提取错误日志并格式化）
var logs = new List<string> {
    "2023-10-01 10:00: INFO: System started",
    "2023-10-01 10:05: ERROR: Connection failed",
    "2023-10-01 10:10: ERROR: Timeout occurred"
};
var errors = logs
    .Where(l => l.Contains("ERROR"))
    .Select(l => new {
        Time = DateTime.Parse(l.Split(": ")[0]),
        Message = string.Join(": ", l.Split(": ").Skip(2))
    })
    .ToList();

# Python处理日志列表
logs = [
    "2023-10-01 10:00: INFO: System started",
    "2023-10-01 10:05: ERROR: Connection failed",
    "2023-10-01 10:10: ERROR: Timeout occurred"
]

# 过滤错误日志
errors = list(filter(lambda l: "ERROR" in l, logs))

# 格式化错误信息
formatted_errors = list(map(
    lambda l: {
        "time": l.split(": ")[0],
        "message": ": ".join(l.split(": ")[2:])
    }, 
    errors
))
print(formatted_errors[0]["message"])  # Connection failed

场景 2：数据聚合计算

// C#计算订单总额
var orders = new List<decimal> { 99.9m, 159.9m, 299.9m };
decimal total = orders.Aggregate(0m, (sum, item) => sum + item * 1.1m);  // 加10%税费
# Python计算订单总额
from functools import reduce
orders = [99.9, 159.9, 299.9]
total = reduce(
    lambda sum, item: sum + item * 1.1,  # 加10%税费
    orders, 
    0  # 初始值
)
print(f"总价: {total:.2f}")  # 总价: 593.67

2. 匿名函数（lambda）实战

在事件处理、临时计算等场景中，Python 的 lambda 比 C# 的匿名函数更轻量。

场景：动态排序

// C#动态排序（按不同字段排序）
var products = new List<Product> {
    new() { Id = 1, Name = "Laptop", Price = 5999, Stock = 10 },
    new() { Id = 2, Name = "Mouse", Price = 99, Stock = 100 }
};
Func<Product, object> sortBy = p => p.Price;  // 可动态切换排序字段
var sorted = products.OrderBy(sortBy).ToList();
# Python动态排序
products = [
    {"id": 1, "name": "Laptop", "price": 5999, "stock": 10},
    {"id": 2, "name": "Mouse", "price": 99, "stock": 100}
]

# 按价格排序（lambda作为排序键）
sorted_by_price = sorted(products, key=lambda x: x["price"])
# 按库存排序
sorted_by_stock = sorted(products, key=lambda x: x["stock"], reverse=True)
print(sorted_by_price[0]["name"])  # Mouse

三、模块与包管理（项目实战）

1. 模块导入（实际项目组织）

大型项目中，Python 的模块导入比 C# 的using更灵活。

场景：工具类导入对比

// C#导入工具类（需引用对应的命名空间）
using MyProject.Utils;
using MyProject.Utils.Validation;  // 多级命名空间

// 使用工具类
var email = "test@example.com";
bool isValid = EmailValidator.Validate(email);
var hash = CryptoUtils.Md5Hash("password");
# Python导入工具模块
import myproject.utils as utils
from myproject.utils.validation import email_validator
from myproject.utils.crypto import md5_hash as crypto_md5  # 别名导入

# 使用工具函数
email = "test@example.com"
is_valid = email_validator.validate(email)
hash = crypto_md5("password")

2. 包管理实战（依赖管理）

在团队协作和部署中，虚拟环境比 C# 的项目依赖更隔离。

场景：项目依赖管理

# C#项目依赖（.csproj）
<Project Sdk="Microsoft.NET.Sdk">
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
    <PackageReference Include="RestSharp" Version="108.0.3" />
  </ItemGroup>
</Project>

# Python项目依赖（requirements.txt）
requests==2.31.0
pandas==2.0.3
python-dotenv==1.0.0

# 导出当前环境依赖
pip freeze > requirements.txt

# 部署时安装依赖
pip install -r requirements.txt

虚拟环境实战（多项目隔离）

# C#多版本依赖处理（需手动管理项目文件）
dotnet new console -o ProjectA
cd ProjectA
dotnet add package Newtonsoft.Json --version 12.0.3

# 另一个项目使用不同版本
dotnet new console -o ProjectB
cd ProjectB
dotnet add package Newtonsoft.Json --version 13.0.1
# Python多版本依赖处理（自动隔离）
# 项目A使用旧版本
python -m venv projectA_env
source projectA_env/bin/activate  # Linux
projectA_env\Scripts\activate  # Windows
pip install requests==2.25.1

# 项目B使用新版本
deactivate
python -m venv projectB_env
source projectB_env/bin/activate
pip install requests==2.31.0

四、字符串与日期处理专项对比（项目核心场景）

这里通过一段 C# 代码和一段 Python 代码，展示两种语言在字符串处理和日期时间处理上的综合应用，涵盖字符串格式化、正则提取、日期转换及日期运算等常见操作。

// C#字符串与日期处理综合示例
using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
        // 字符串处理
        string name = "Alice";
        int age = 30;
        string userInfo = $"User {name} is {age} years old"; // 字符串格式化
        
        string text = "a,b;c,d";
        string replacedText = text.Replace(",", "|").Replace(";", "|"); // 多字符替换
        
        string log = "Error [2023-10-01] Code: 500";
        Match match = Regex.Match(log, @"Code: (\d+)");
        string errorCode = match.Groups[1].Value; // 正则提取
        
        // 日期处理
        DateTime now = DateTime.Now;
        string isoNow = now.ToString("o"); // 获取当前时间并转为ISO格式
        
        DateTime specificDate = DateTime.ParseExact("2023-10-01", "yyyy-MM-dd", 
            System.Globalization.CultureInfo.InvariantCulture); // 字符串转日期
        
        DateTime tomorrow = now.AddDays(1); // 日期加减
        
        Console.WriteLine(userInfo);
        Console.WriteLine(replacedText);
        Console.WriteLine(errorCode);
        Console.WriteLine(isoNow);
        Console.WriteLine(specificDate.ToString("yyyy-MM-dd"));
        Console.WriteLine(tomorrow.ToString("yyyy-MM-dd"));
    }
}

 

# Python字符串与日期处理综合示例
import re
from datetime import datetime, timedelta

# 字符串处理
name = "Alice"
age = 30
user_info = f"User {name} is {age} years old"  # 字符串格式化

text = "a,b;c,d"
replaced_text = text.replace(",", "|").replace(";", "|")  # 多字符替换

log = "Error [2023-10-01] Code: 500"
match = re.search(r"Code: (\d+)", log)
error_code = match.group(1)  # 正则提取

# 日期处理
now = datetime.now()
iso_now = now.isoformat()  # 获取当前时间并转为ISO格式

specific_date = datetime.strptime("2023-10-01", "%Y-%m-%d")  # 字符串转日期

tomorrow = now + timedelta(days=1)  # 日期加减

print(user_info)
print(replaced_text)
print(error_code)
print(iso_now)
print(specific_date.strftime("%Y-%m-%d"))
print(tomorrow.strftime("%Y-%m-%d"))

今日总结

通过实际项目场景的对比，我们可以发现：

1、在数据处理场景中，Python 的推导式比 LINQ 更简洁，一行代码可完成 C# 多行代码的功能

2、解包操作在函数参数传递、数据拆分时比 C# 的元组访问更直观

3、函数式编程在日志处理、数据聚合等场景中代码更紧凑

4、模块管理与虚拟环境比 C# 的项目依赖管理更轻量，适合快速迭代

下一天我们将学习 Python 的面向对象编程，对比 C# 的类、继承、接口等核心概念，重点分析在 Web 开发、数据处理等场景中的应用差异。建议今天的代码都实际运行一遍，特别是字符串和日期处理的示例，这些都是项目开发的基础技能。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布