从C#6天学会Python：速通基础语法(第一天)-CSDN博客

本文链接：https://blog.csdn.net/www376422613/article/details/149423629

一、引言：开启 Python 学习之旅

作为一名深耕 C# 开发领域的程序员，熟练运用.net 4.5 等框架，对 html、javascript、jquery 以及 oracle、sqlserver 数据库了如指掌，我一直对技术保持着强烈的探索欲望。在技术飞速发展的今天，单一技术栈已经很难满足多样化的开发需求。Python 作为一门简洁、高效且拥有丰富生态的编程语言，在数据科学、人工智能、Web 开发等领域展现出了巨大的优势，这也让我决心开启 Python 的学习之旅。

为了能在最短时间内掌握 Python，我制定了一个 6 天的学习计划。今天是学习的第一天，主要聚焦于 Python 的基础语法，通过与熟悉的 C# 知识进行对比，快速掌握 Python 的核心要点。

二、Python 基础语法快速入门

（一）变量与数据类型

1. 动态类型系统与 C# 静态类型对比

在 C# 中，变量在声明时必须指定其数据类型，这是一种静态类型系统。例如，要声明一个整数变量a并赋值为 1，代码如下：

int a = 1;

如果尝试将不同类型的值赋给这个变量，在编译阶段就会报错，因为静态类型系统在编译时就确定了变量的类型，不允许随意更改。

而 Python 采用的是动态类型系统，变量在声明时无需指定类型，类型是在运行时根据所赋的值来确定的。例如：

a = 1

这里a被赋值为 1，Python 解释器会自动识别a为整数类型。并且，在后续代码中可以随时改变a的类型，比如：

a = "hello"

此时a的类型就变成了字符串类型，这种动态类型的特性使得 Python 代码更加灵活，但在大型项目中，可能需要更谨慎地处理类型相关的问题，以免出现运行时错误。

2. 常用内置类型

Python 拥有丰富的内置数据类型，其中列表（List）、元组（Tuple）、字典（Dict）、集合（Set）是非常常用的数据结构。

列表（List）：是一种有序的可变序列，可以包含不同类型的元素。在 C# 中，与之对应的是List<T>泛型集合。例如在 Python 中创建一个列表：

my_list = [1, "apple", 3.14]

在 C# 中创建一个类似的List<int>集合：

List<int> myList = new List<int>() { 1, 2, 3 };

列表支持通过索引访问元素、添加元素、删除元素等操作，如my_list.append(4)向列表末尾添加元素 4。

元组（Tuple）：是一种有序的不可变序列，一旦创建，其元素不能被修改。在 C# 中，元组可以通过ValueTuple来表示。Python 中创建元组：

my_tuple = (1, "apple", 3.14)

C# 中创建元组：

var myTuple = (1, "apple", 3.14);

元组常用于存储一组相关的数据，例如表示一个坐标点(x, y)。

字典（Dict）：是一种无序的键值对集合，键必须是唯一且不可变的，用于快速查找和存储数据。C# 中对应的是Dictionary<TKey, TValue>。Python 中创建字典：

my_dict = {"name": "John", "age": 30}

C# 中创建字典：

Dictionary<string, object> myDict = new Dictionary<string, object>()
{
    {"name", "John"},
    {"age", 30}
};

可以通过键来访问字典中的值，如my_dict["name"]获取John。

集合（Set）：是一种无序的、不包含重复元素的集合，主要用于成员检测和消除重复元素。C# 中对应的是HashSet<T>。Python 中创建集合：


my_set = {1, 2, 3, 2} # 重复的2会被自动去除

C# 中创建集合：


HashSet<int> mySet = new HashSet<int>() { 1, 2, 3, 2 };

集合支持交集、并集、差集等操作，如set1.intersection(set2)求两个集合的交集。

3. 性能对比

查找操作：Python 字典和 C# 字典在查找操作上都具有较高的效率，平均时间复杂度都为 O (1)。这是因为它们都基于哈希表实现，通过计算键的哈希值来快速定位对应的值。但在极端情况下，比如哈希冲突严重时，Python 字典的查找性能可能会下降。

插入操作：在一般情况下，Python 字典和 C# 字典的插入操作平均时间复杂度也为 O (1) 。然而，当字典中的元素数量接近哈希表的容量时，为了保持哈希表的性能，Python 字典和 C# 字典都可能需要进行扩容操作，扩容操作的时间复杂度较高，为 O (n)，其中 n 为字典中已有的元素数量。

删除操作：对于 Python 字典和 C# 字典，删除操作的平均时间复杂度同样为 O (1)。但与插入操作类似，在删除元素后，哈希表可能需要进行调整以保持性能，在某些情况下，调整操作可能会导致时间复杂度上升。

在实际应用中，性能还可能受到数据量、硬件环境等多种因素的影响。例如，当数据量非常大时，C# 由于其静态类型和编译型语言的特性，在内存管理和执行效率上可能会表现得更为稳定；而 Python 由于其动态特性和解释执行的方式，在灵活性上更具优势，但在性能上可能稍逊一筹。同时，如果硬件资源有限，例如内存较小，那么数据结构的性能表现也会受到影响。

（二）控制流与函数

1. 缩进代替花括号

在 C# 中，代码块是通过花括号{}来定义的。例如，一个简单的if语句块：

int num = 5;
if (num > 3)
{
    Console.WriteLine("num is greater than 3");
}
else
{
    Console.WriteLine("num is less than or equal to 3");
}

花括号清晰地界定了if和else代码块的范围，即使代码块只有一行语句，花括号也可以保留（虽然在只有一行语句时可以省略，但为了代码的可读性和一致性，通常不建议省略）。

而在 Python 中，代码块是通过缩进进行定义的，缩进的空格数通常为 4 个（也可以是其他数量，但在同一个项目中应保持一致），且冒号:用于表示代码块的开始。例如：

num = 5
if num > 3:
    print("num is greater than 3")
else:
    print("num is less than or equal to 3")

这种缩进方式使得 Python 代码具有更强的可读性，代码结构一目了然。但如果缩进不正确，比如同一代码块内的缩进不一致，就会导致语法错误。

2. 条件与循环语法差异

if/elif/else 语法：在 C# 中，使用if - else if - else结构进行条件判断。例如：

int score = 85;
if (score >= 90)
{
    Console.WriteLine("A");
}
else if (score >= 80)
{
    Console.WriteLine("B");
}
else
{
    Console.WriteLine("C");
}

在 Python 中，对应的是if - elif - else结构，注意elif是 Python 特有的写法：

score = 85
if score >= 90:
    print("A")
elif score >= 80:
    print("B")
else:
    print("C")

for 循环语法：C# 中的for循环通常用于已知循环次数的情况，通过计数器来控制循环。例如：

for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}

而 Python 的for循环主要用于遍历可迭代对象（如列表、元组、字符串等），使用迭代器来遍历元素。例如：

my_list = [1, 2, 3, 4, 5]
for num in my_list:
    print(num)

如果要实现类似 C# 中基于计数器的循环，Python 可以使用range()函数，range(start, stop, step)生成一个整数序列，默认start为 0，step为 1 。例如：

for i in range(5):
    print(i)

while 循环语法：C# 和 Python 的while循环语法较为相似，都是当条件为真时执行循环体。C# 示例：

int count = 0;
while (count < 5)
{
    Console.WriteLine(count);
    count++;
}

Python 示例：

count = 0
while count < 5:
    print(count)
    count += 1

需要注意的是，在循环中一定要有改变条件的语句，否则可能会导致死循环。

3. 函数定义与参数传递

在 Python 中，定义函数使用def关键字，函数参数可以有默认值，并且支持可变参数*args（用于接收任意数量的位置参数，以元组形式传递）和**kwargs（用于接收任意数量的关键字参数，以字典形式传递）。例如：

def greet(name, message="Hello"):
    print(f"{message}, {name}")


def calculate_sum(*args):
    return sum(args)


def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")


greet("John")  # 输出：Hello, John
greet("John", "Hi")  # 输出：Hi, John
result = calculate_sum(1, 2, 3)  # result为6
print_info(name="John", age=30, city="New York")

在 C# 中，定义方法使用public/private/static等修饰符（这里以public为例），参数可以有默认值，但不支持 Python 中这种灵活的可变参数形式。如果要实现类似可变参数的功能，可以使用数组作为参数。例如：

public static void Greet(string name, string message = "Hello")
{
    Console.WriteLine($"{message}, {name}");
}


public static int CalculateSum(params int[] args)
{
    int sum = 0;
    foreach (int num in args)
    {
        sum += num;
    }
    return sum;
}


public static void PrintInfo(Dictionary<string, object> kwargs)
{
    foreach (var pair in kwargs)
    {
        Console.WriteLine($"{pair.Key}: {pair.Value}");
    }
}


Greet("John");
Greet("John", "Hi");
int result = CalculateSum(1, 2, 3);
Dictionary<string, object> info = new Dictionary<string, object>()
{
    {"name", "John"},
    {"age", 30},
    {"city", "New York"}
};
PrintInfo(info);

可以看到，Python 在函数参数传递上更加简洁和灵活，尤其是*args和**kwargs的使用，使得函数可以接收任意数量和类型的参数，这在处理不确定参数的场景中非常方便。

（三）面向对象编程

1. 类与继承

在 Python 中，类的定义使用class关键字，Python 支持单继承，即一个子类只能有一个直接父类。例如：

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} makes a sound.")


class Dog(Animal):
    def bark(self):
        print(f"{self.name} barks.")


dog = Dog("Buddy")
dog.speak()  # 输出：Buddy makes a sound.
dog.bark()  # 输出：Buddy barks.

在 C# 中，类的定义同样使用class关键字，但 C# 支持多接口实现，通过实现多个接口，一个类可以具备多种行为。例如：

interface IAnimal
{
    void Speak();
}


interface IBarkable
{
    void Bark();
}


class Dog : IAnimal, IBarkable
{
    private string name;

    public Dog(string name)
    {
        this.name = name;
    }

    public void Speak()
    {
        Console.WriteLine($"{name} makes a sound.");
    }

    public void Bark()
    {
        Console.WriteLine($"{name} barks.");
    }
}


Dog dog = new Dog("Buddy");
dog.Speak();
dog.Bark();

Python 的单继承使得类的层次结构更加简单明了，而 C# 的多接口实现则提供了更大的灵活性，一个类可以从多个接口获取不同的行为。

2. 访问控制

在 Python 中，并没有像 C# 那样严格的访问修饰符（如public、private、protected）。Python 采用一种约定俗成的方式来表示访问权限，通常在属性或方法名前加一个下划线_表示该属性或方法为 “私有”，虽然在外部仍然可以访问，但这是一种提示，告诉其他开发者这个属性或方法不应该被外部直接调用。例如：

class MyClass:
    def __init__(self):
        self._private_variable = 10

    def _private_method(self):
        print("This is a private method.")


obj = MyClass()
print(obj._private_variable)  # 可以访问，但不建议
obj._private_method()  # 可以调用，但不建议

在 C# 中，使用private修饰符可以真正限制成员只能在类内部访问，使用public修饰符表示成员可以在任何地方访问，protected修饰符表示成员只能在类内部和子类中访问。例如：

class MyClass
{
    private int privateVariable = 10;

    public int PublicVariable { get; set; }

    private void PrivateMethod()
    {
        Console.WriteLine("This is a private method.");
    }

    public void PublicMethod()
    {
        PrivateMethod();
    }
}


MyClass obj = new MyClass();
// 下面这行代码会报错，因为privateVariable是私有的，不能在外部访问
// Console.WriteLine(obj.privateVariable);
obj.PublicVariable = 20;
obj.PublicMethod();

C# 的访问控制更加严格和明确，有助于提高代码的安全性和封装性；而 Python 则更强调开发者的自觉和代码的可读性。

3. 魔法方法

Python 中的魔法方法是指以双下划线__开头和结尾的特殊方法，它们具有特殊的用途和行为。例如__init__方法类似于 C# 中的构造函数，用于在创建对象时初始化对象的属性：

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y


point = Point(1, 2)

__str__方法类似于 C# 中的ToString()方法，用于返回对象的字符串表示形式：

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"Point({self.x}, {self.y})"


point = Point(1, 2)
print(point)  # 输出：Point(1, 2)

在 C# 中，构造函数是与类名相同的特殊方法，用于初始化对象：

class Point
{
    public int X { get; set; }
    public int Y { get; set; }

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    public override string ToString()
    {
        return $"Point({X}, {Y})";
    }
}


Point point = new Point(1, 2);
Console.WriteLine(point);

魔法方法是 Python 面向对象编程的一个重要特性，通过定义这些魔法方法，可以让类的行为更加符合 Python 的编程习惯，增强类的功能性和灵活性。

三、学习建议与避坑指南

（一）对比学习法

在学习 Python 的过程中，对比学习法是非常有效的。当遇到 Python 的新概念、新特性时，不要孤立地去理解它，而是先回顾 C# 中类似的实现方式。例如，在学习 Python 的列表推导式时，可以先想想 C# 中的 LINQ 查询表达式，两者都用于对集合进行筛选、转换等操作。通过这样的对比，能快速抓住 Python 特性的核心要点，同时也能加深对 C# 知识的理解。比如在 C# 中使用 LINQ 查询从一个整数列表中筛选出偶数并计算其平方：

List<int> numbers = new List<int>() { 1, 2, 3, 4, 5 };
var result = numbers.Where(n => n % 2 == 0).Select(n => n * n).ToList();

在 Python 中使用列表推导式实现相同功能：

numbers = [1, 2, 3, 4, 5]
result = [n ** 2 for n in numbers if n % 2 == 0]

通过对比这两段代码，可以清晰地看到两种语言在实现类似功能时的语法差异和各自的特点，从而更好地掌握 Python 的列表推导式。

（二）交互式练习

Jupyter Notebook 是一个非常强大的交互式计算环境，特别适合用于验证 Python 与 C# 的语法差异。在 Jupyter Notebook 中，可以逐行执行 Python 代码，并立即看到执行结果，方便进行代码测试和调试。例如，在学习 Python 的字典操作时，可以在 Jupyter Notebook 中创建一个字典，然后尝试各种操作，如添加键值对、删除键值对、获取值等，并与 C# 中字典的操作进行对比。同时，Jupyter Notebook 还支持在代码中添加 Markdown 文本，方便记录学习笔记和心得，将代码和解释说明结合在一起，形成一个完整的学习文档。例如，在一个 Jupyter Notebook 单元格中编写 Python 字典操作代码：

my_dict = {"name": "John", "age": 30}
# 添加键值对
my_dict["city"] = "New York"
# 获取值
print(my_dict["name"])  
# 删除键值对
del my_dict["age"]
print(my_dict)

在另一个单元格中，可以使用 Markdown 语法记录对这些操作的理解和与 C# 字典操作的对比：

在 C# 中，添加键值对使用Add方法，获取值通过索引，删除键值对使用Remove方法。而在 Python 中，添加和获取值都通过索引语法，删除使用del关键字，这种语法上的差异需要特别注意。

（三）避坑指南

1.变量作用域：在 C# 中，变量的作用域由花括号界定，块级作用域非常明确。而在 Python 中，虽然也有局部作用域和全局作用域之分，但规则略有不同。例如，在 Python 中，如果在函数内部没有使用global关键字声明变量，那么即使变量名与全局变量相同，也会被视为局部变量。

x = 10
def test():
    x = 20  # 这里的x是局部变量，与全局变量x不同
    print(x)


test()  # 输出20
print(x)  # 输出10

2.浅拷贝 / 深拷贝：在处理可变对象（如列表、字典）时，Python 的浅拷贝和深拷贝容易混淆。浅拷贝只是复制了对象的引用，当修改拷贝后的对象中的嵌套对象时，原始对象也会受到影响；而深拷贝则会递归地复制所有层级的对象，得到一个完全独立的副本。

import copy

original_list = [1, 2, [3, 4]]
shallow_copy = original_list.copy()
deep_copy = copy.deepcopy(original_list)

shallow_copy[2][0] = 5
print(original_list)  # 输出：[1, 2, [5, 4]]，浅拷贝会影响原始对象

deep_copy[2][0] = 6
print(original_list)  # 输出：[1, 2, [5, 4]]，深拷贝不会影响原始对象

在 C# 中，对于引用类型的复制，也需要注意是引用复制还是对象复制，但概念和实现方式与 Python 有所不同，需要特别留意。

第一天的 Python 学习，通过对基础语法的深入探索和与 C# 的对比分析，我们已经迈出了坚实的一步。后续的学习中，将继续深入挖掘 Python 的特色语法、高级特性以及丰富的生态系统，不断提升自己的 Python 编程能力。

四、总结与展望

第一天的 Python 学习之旅，我们深入探索了 Python 的基础语法，从变量与数据类型、控制流与函数，再到面向对象编程，每一个知识点都通过与熟悉的 C# 进行对比分析，让我们快速掌握了 Python 的独特之处。基础语法是学习 Python 的基石，只有扎实掌握这些基础知识，才能在后续的学习和实践中更加得心应手。

在学习过程中，要注重实践，通过实际编写代码来巩固所学知识。可以尝试完成一些简单的 Python 项目，如实现一个简单的数学计算工具、数据处理脚本等，将理论知识转化为实际能力。同时，不要忘记使用对比学习法、交互式练习以及避坑指南等学习建议，帮助自己更好地理解和掌握 Python。

后续的学习中，我们将继续深入 Python 的世界，探索 Python 的特色语法与高级特性、文件操作与异常处理、丰富的生态系统与常用库，以及通过实践项目来提升综合编程能力。相信在不断的学习和实践中，我们一定能够成为熟练的 Python 开发者。