Python学习入门

多个维度详细对比 Python、Java 和 C# 的优缺点和特性。

核心特性快速对比表

特性	Python	Java	C#
设计哲学/类型	动态类型、强类型、解释型语言	静态类型、强类型、编译型（到字节码）	静态类型、强类型、编译型（到中间语言）
核心执行方式	解释执行（源码 -> 字节码 -> 解释器）	编译为字节码，由JVM运行（JIT编译）	编译为IL，由CLR运行（JIT编译）
运行速度	较慢	快（JIT优化，性能稳定）	非常快（JIT优化，与Java相当或略优）
语法风格	简洁、灵活、类似伪代码	严谨、略显冗长	优雅、现代、兼具严谨与灵活
学习曲线	非常平缓，适合初学者	中等，需要理解面向对象和JVM概念	中等，与Java类似，但现代语法更友好
主要应用领域	Web后端、AI/ML、数据分析、自动化脚本、科学计算	大型企业级应用、Android开发、金融系统、大数据	Windows应用、游戏开发（Unity）、企业Web应用、云服务
内存管理	自动垃圾回收（引用计数+分代回收）	自动垃圾回收（成熟的GC算法）	自动垃圾回收（高性能的GC，可控制）
跨平台性	优秀（解释器跨平台）	优秀（"一次编写，到处运行"，JVM跨平台）	优秀（.NET 5+ 实现真正跨平台）
典型框架	Django, Flask, FastAPI, Pandas, PyTorch	Spring, Spring Boot, Hibernate, Android SDK	ASP.NET Core, Entity Framework, Windows Forms, WPF

一.基础语法

1.HalloWorld

python 复制代码

def main():
    print('Hello World')
if __name__ == "__main__":
    main()

2.输入

python 复制代码

def main():
    name = input('please enter your name: ')
    print('Hello,', name)
if __name__ == "__main__":
    main()

3.数据类型和变量

python 复制代码

def main():
    # python是动态语言，不像java是静态语言要指定类型，例如： ia是整数类型变量,int ia = 123;
    a = 1 # a是整数
    print(' a是整数,', a)
    a = 'ABC'  # a变为字符串
    print('a变为字符串',a)
    Answer = True
    print('Boolean类型,', Answer)
if __name__ == "__main__":
    main()

强类型 vs. 弱类型 ：指类型检查的严格程度。

共同点 ：Python, Java, C# 都是强类型语言。
含义 ：语言会严格限制不合理的类型转换。例如，你不能直接将一个字符串 "100"和一个整数 10相加，除非你显式地进行类型转换

python 复制代码

# Python (强类型)
# print("100" + 10)  # 会报错：TypeError
print(int("100") + 10) # 正确，需要显式转换 -> 110

java 复制代码

// Java (强类型)
// System.out.println("100" + 10); // 不会报错，结果是 "10010"，因为 `+` 对字符串是重载的拼接操作。
// 但如果是不同类型数字运算，则非常严格：
int a = 10;
double b = a; // 可以，隐式向上转换（小范围转大范围）
// int c = b; // 报错，需要显式转换 (int)b
System.out.println(b);

静态类型 vs. 动态类型 ：指类型检查发生的时间。

Java 和 C#：静态类型
- 变量类型在编译时就必须确定，并且不能改变。
- 优点：
  - 早期错误检测：很多类型错误在编译阶段就能发现，而不是在运行时崩溃。
  - 工具支持好：IDE 能提供更准确的代码补全、重构和导航。
  - 运行性能高：编译器在编译时就知道类型信息，可以进行更多优化。
- 缺点：代码相对冗长，需要声明类型。

java 复制代码

// Java
String name = "Hello"; // 变量 name 被声明为 String 类型
name = 100; // 编译错误！不能将 int 赋给 String

Python：动态类型
- 变量类型在运行时才确定，并且同一个变量可以被重新赋值为不同类型的值。
- 优点：
  - 代码灵活简洁：无需声明类型，写起来快。
  - 鸭子类型：关注对象的行为（有什么方法），而不是对象的类型，非常灵活。
- 缺点：
  - 运行时错误风险：类型错误只有在运行到那一行代码时才会暴露。
  - 重构困难：在大型项目中，没有类型的帮助，重构和理解代码会更困难。
python 复制代码
```
# Python
name = "Hello"  # name 现在是一个字符串
name = 100      # 现在 name 是一个整数，这是允许的
# 但如果后续代码期望 name 是字符串，这里就可能埋下 bug
print('name'+name)
```
补充 ：现代 Python 和 C# 都支持类型提示 ，可以在代码中注明期望的类型，但不会影响运行时的动态性，只是帮助 IDE 和工具（如 mypy）进行静态检查，结合了两者的优点。

4.使用list和tuple

python 复制代码

def main():
    classmates = ['Michael', 'Bob', 'Tracy']
    classmates.append('Adam')
    print( classmates)
    classmates.insert(1, 'Jack')
    print( classmates.pop(1))
    s = ['python', 'java', ['asp', 'php'], 'scheme']
    print( len(s))
    # tuple和list非常类似，但是tuple一旦初始化就不能修改
    classmates = ('Michael', 'Bob', 'Tracy')
if __name__ == "__main__":
    main()

5.条件判断

python 复制代码

def main():
    age = 3
    if age >= 18:
        print('your age is', age)
        print('adult')
    else:
        print('your age is', age)
        print('teenager')
if __name__ == "__main__":
    main()

6.For循环

python 复制代码

def main():
    names = ['Michael', 'Bob', 'Tracy']
    for name in names:
        print(name)
if __name__ == "__main__":
    main()

7.dict和set

python 复制代码

def main():
    names = ['Michael', 'Bob', 'Tracy']
    scores = [95, 75, 85]
    d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
    print(d['Michael'])

    s = {1, 2, 3}
    s.add(4)
    print(s)
if __name__ == "__main__":
    main()

二.函数与高级特性

1.函数

python 复制代码

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x
if __name__ == "__main__":
    print(my_abs(-99))

2.递归函数

python 复制代码

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)
if __name__ == "__main__":
    print(fact(7))

3.切片（类似于java的sublist）

三.面向对象编程

1.类和实例

python 复制代码

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def print_score(self):
        print('%s: %s' % (self.name, self.score))
if __name__ == "__main__":
     bart = Student('Bart Simpson', 59)
     bart.print_score()

python 复制代码

class Animal(object):
    def run(self):
        print('Animal is running...')
class Dog(Animal):
    def run(self):
        print('Dog is running...')

    def eat(self):
        print('Eating meat...')

class Cat(Animal):
    def run(self):
        print('Cat is running...')
if __name__ == "__main__":
    dog = Dog()
    dog.run()

    cat = Cat()
    cat.run()

    b = Animal()
    print("isinstance(b, Animal) =",isinstance(b, Dog))

2.使用__slots__

四.IO编程,异步IO

五.进程与线程

六.网络编程

python 复制代码

import requests
r = requests.get('https://httpbin.org/basic-auth/user/pass', auth=('user', 'pass'))
print(r.status_code)
print(r.headers['content-type'])
print(r.encoding)
print(r.json())

七.其它特性

1.Python执行机制

Python是解释型语言，不需要像C#或Java那样必须有main方法作为程序入口

Python解释器会从上到下执行代码文件中的语句

执行方式：

当使用python 文件名.py 命令运行此脚本时

python 复制代码

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def print_score(self):
        print('%s: %s' % (self.name, self.score))

    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'

sx = Student('SX', 100)
sx.print_score()
bart = Student('Bart Simpson', 59)
lisa = Student('Lisa Simpson', 87)
bart.print_score()
lisa.print_score()
print(lisa.name, lisa.get_grade())
print(bart.name, bart.get_grade())

Python：解释型语言

工作方式 ：Python 代码在执行前会先被编译成一种中间形式------字节码 （保存在 .pyc文件中）。然后，Python 虚拟机（如 CPython）会解释执行这些字节码。
优点：
- 开发效率高：无需编译步骤，写完后可直接运行，非常适合快速原型开发和脚本编写。
- 跨平台：只要有对应平台的 Python 解释器，代码就能运行。
缺点 ：运行速度慢：解释执行的速度天然比直接运行机器码慢。

而Java 和 C#：编译型语言（但属于一种特殊形式）

工作方式：它们不是直接编译成特定 CPU 的机器码，而是先编译成一种中间语言：
- Java -> 字节码（.class 文件）
- C# -> 中间语言（IL，保存在 .dll 或 .exe 中）
然后，这些中间代码分别在 Java 虚拟机（JVM） 和 .NET 公共语言运行时（CLR） 上运行。运行时环境的核心是 JIT 编译器 ，它会在程序运行时将频繁执行的代码（热点代码）动态编译成本地机器码，从而获得接近本地代码的运行速度。
优点：
- 性能优异：JIT 编译结合了编译型语言的速度和解释型语言的灵活性。
- "一次编写，到处运行"：字节码/IL 是跨平台的，只要有所在平台的 JVM/CLR 就能执行。
缺点：
- 需要运行时环境：目标机器上必须安装 JVM 或 .NET Runtime。
- 启动时间：相比本地编译的语言（如 C++），启动时会有短暂的 JIT 编译开销。

2.生态系统与应用领域

Python：
- 优势领域：
  - 数据科学与人工智能：拥有统治级地位的库（NumPy, Pandas, Scikit-learn, TensorFlow, PyTorch）。
  - Web开发：Django, Flask 等框架让后端开发非常高效。
  - 自动化与脚本：是系统管理、DevOps 领域的首选。
- 生态特点：库极其丰富，尤其在科学计算和AI领域无出其右。
Java：
- 优势领域：
  - 大型企业级后端：Spring 框架是事实上的标准，拥有极其成熟稳定的生态。
  - Android 应用开发：是官方主要支持语言。
  - 大数据：Hadoop, Spark 等大量大数据工具基于JVM。
- 生态特点：生态庞大、成熟、稳定，经过数十年企业级应用的考验。
C#：
- 优势领域：
  - 游戏开发：Unity 引擎的官方语言，在游戏领域占比极高。
  - Windows 桌面应用：与Windows平台深度集成，开发WPF、WinForms应用非常方便。
  - 跨平台Web开发：ASP.NET Core 是一个高性能的Web框架。
- 生态特点：与微软生态紧密结合，工具链（尤其是Visual Studio）非常强大。