Python 入门教程:第 1 课 - 认识 Python¶

Python 是一种通用的、高级的编程语言。它易于学习和使用,具有丰富的库和工具,广泛应用于 Web 开发、数据科学、机器学习、人工智能等领域。

1. Python 简介¶

Python 由 Guido van Rossum 于 1989 年发明,是一种解释型语言,这意味着它不需要编译成机器代码就可以运行。Python 语法简洁明了,代码风格接近自然语言,因此易于学习和阅读。

Python 具有以下特点:

  • 易于学习和使用
  • 通用性强
  • 丰富的库和工具
  • 开源免费
  • 社区活跃

2. Python 环境搭建¶

学习 Python 之前,我们需要先搭建 Python 环境。

Windows 系统

  1. 下载 Python 安装程序:https://www.python.org/downloads/
  2. 运行安装程序,按照提示完成安装
  3. 验证 Python 是否安装成功:在命令行窗口中输入 python,如果出现 Python 版本信息,则说明安装成功

Mac 系统

  1. 使用 Homebrew 安装 Python:brew install python
  2. 验证 Python 是否安装成功:在终端中输入 python,如果出现 Python 版本信息,则说明安装成功

Linux 系统

  1. 使用系统自带的包管理器安装 Python:
sudo apt install python3
  1. 验证 Python 是否安装成功:在终端中输入 python3,如果出现 Python 版本信息,则说明安装成功

3. Python 基本语法¶

Python 语法由以下几部分组成:

  • 关键字:用于控制程序流程的特殊单词,例如 if、else、for、while 等
  • 标识符:用于命名变量、函数、类等对象的名称
  • 运算符:用于进行数学运算、逻辑运算和比较运算
  • 数据类型:用于表示数据的类型,例如数字、字符串、列表、字典等
  • 语句:用于控制程序流程的基本单位,例如赋值语句、条件语句、循环语句等

下面是一个简单的 Python 代码示例:

这个代码首先定义了一个名为 name 的变量,并将其值赋值为 "小明"。然后,使用 print() 函数打印变量的值。接着,进行数学运算,将 1 和 2 相加,并将结果赋值给变量 sum。最后,使用 if 语句判断条件,如果 sum 大于 2,则打印 "sum 大于 2",否则打印 "sum 小于或等于 2"。

In [ ]:
# 定义一个变量
name = "小明"

# 打印变量的值
print(name)

# 进行数学运算
sum = 1 + 2

# 判断条件
if sum > 2:
    print("sum 大于 2")
else:
    print("sum 小于或等于 2")
小明
sum 大于 2

4. 总结¶

第一节我们介绍了 Python 的基本知识,包括 Python 的简介、环境搭建和基本语法。通过这节课的学习,你应该能够:

  • 了解 Python 的特点和优势
  • 安装 Python 环境
  • 编写简单的 Python 代码

Python 入门教程:第 2 课 - Python 数据类型¶

在上一节课中,我们学习了 Python 的基本知识,包括 Python 的简介、环境搭建和基本语法。在这一节课中,我们将学习 Python 的数据类型。

1. 什么是数据类型¶

数据类型是用来表示数据的类型。在 Python 中,数据类型可以分为以下几类:

  • 数值类型:用于表示数字,例如整数、浮点数和复数
  • 字符串类型:用于表示由字符组成的文本
  • 列表类型:用于表示一组有序的数据
  • 字典类型:用于表示一组无序的键值对
  • 元组类型:用于表示一组不可变的数据
  • 集合类型:用于表示一组无序且不重复的数据
  • 布尔类型:用于表示 True 或 False 两种值

2. 数值类型¶

数值类型是 Python 中最常用的数据类型之一。它用于表示数字,包括整数、浮点数和复数。

  • 整数:整数是没有小数点的数字,例如 1、2、3 等。
  • 浮点数:浮点数是小数点数字,例如 1.2、3.14 等。
  • 复数:复数是由实部和虚部组成的数字,例如 1+2j、3-4j 等。

在 Python 中,可以使用以下方法来判断一个变量的数据类型:

  • 使用 type() 函数
  • 使用 isinstance() 函数
In [ ]:
# 判断变量 x 的数据类型
x = 1
print(type(x))  # <class 'int'>

# 判断变量 y 的数据类型
y = 1.2
print(type(y))  # <class 'float'>

# 判断变量 z 的数据类型
z = 1+2j
print(type(z))  # <class 'complex'>

# 判断变量 x 是否是整数
print(isinstance(x, int))  # True

# 判断变量 y 是否是浮点数
print(isinstance(y, float))  # True

# 判断变量 z 是否是复数
print(isinstance(z, complex))  # True

3. 字符串类型¶

字符串类型是 Python 中常用的另一种数据类型。它用于表示由字符组成的文本。

字符串可以使用单引号、双引号或三引号括起来。例如:

In [ ]:
# 使用单引号定义字符串
name = '小明'

# 使用双引号定义字符串
sentence = "Hello, world!"

# 使用三引号定义字符串
paragraph = '''
This is a multi-line string.
It can span multiple lines.
'''

字符串可以使用以下方法来进行操作:

  • 连接:使用 + 运算符
  • 切片:使用 [] 运算符
  • 查找:使用 in 运算符
  • 替换:使用 replace() 方法
In [ ]:
# 连接字符串
name = '小明'
age = 18
print(name + ' 的年龄是 ' + str(age))  # 小明的年龄是 18

# 切片字符串
sentence = "Hello, world!"
print(sentence[0:5])  # Hello

# 查找字符串
paragraph = '''
This is a multi-line string.
It can span multiple lines.
'''
print('is' in paragraph)  # True

# 替换字符串
sentence = "Hello, world!"
print(sentence.replace('world', 'Python'))  # Hello, Python!

4. 总结¶

这节课我们学习了 Python 的数据类型,包括数值类型、字符串类型、列表类型、字典类型、元组类型、集合类型和布尔类型。通过这节课的学习,你应该能够:

  • 了解 Python 中常用的数据类型
  • 判断一个变量的数据类型
  • 进行字符串的操作

Python 入门教程:第 3 课 - Python 运算符¶

在上一节课中,我们学习了 Python 的数据类型。在这一节课中,我们将学习 Python 的运算符。

1. 什么是运算符¶

运算符是用来对操作数进行运算的符号。在 Python 中,运算符可以分为以下几类:

  • 算术运算符:用于进行数学运算,例如加、减、乘、除、取余、幂等
  • 逻辑运算符:用于进行逻辑运算,例如与、或、非等
  • 比较运算符:用于进行比较运算,例如大于、小于、等于等
  • 赋值运算符:用于将值赋值给变量
  • 成员运算符:用于判断某个元素是否属于某个集合
  • 身份运算符:用于判断两个对象是否指向同一个内存地址

2. 算术运算符¶

算术运算符是 Python 中最常用的运算符之一。它用于进行数学运算,包括加、减、乘、除、取余、幂等。

以下是 Python 中常用的算术运算符:

运算符 含义
+ 加
- 减
* 乘
/ 除
% 取余
** 幂

例如:

# 加法
x = 1 + 2
print(x)  # 3

# 减法
y = 3 - 1
print(y)  # 2

# 乘法
z = 4 * 5
print(z)  # 20

# 除法
a = 10 / 2
print(a)  # 5.0

# 取余
b = 11 % 3
print(b)  # 2

# 幂
c = 2 ** 3
print(c)  # 8

3. 逻辑运算符¶

逻辑运算符是用于进行逻辑运算的符号。它用于判断两个或多个表达式的真假值。

以下是 Python 中常用的逻辑运算符:

运算符 含义
and 与
or 或
not 非

例如:

# 与运算符
x = True and False
print(x)  # False

# 或运算符
y = True or False
print(y)  # True

# 非运算符
z = not True
print(z)  # False

4. 比较运算符¶

比较运算符是用于进行比较运算的符号。它用于比较两个表达式的值的大小或相等性。

以下是 Python 中常用的比较运算符:

运算符 含义
== 等于
!= 不等于
< 小于
> 大于
<= 小于或等于
>= 大于或等于

例如:

# 等于
x = 1 == 1
print(x)  # True

# 不等于
y = 2 != 1
print(y)  # True

# 小于
z = 3 < 4
print(z)  # True

# 大于
a = 4 > 3
print(a)  # True

# 小于或等于
b = 5 <= 5
print(b)  # True

# 大于或等于
c = 6 >= 5
print(c)  # True

5. 总结¶

这节课我们学习了 Python 的运算符,包括算术运算符、逻辑运算符、比较运算符、赋值运算符、成员运算符和身份运算符。通过这节课的学习,你应该能够:

  • 了解 Python 中常用的运算符
  • 使用运算符进行数学运算、逻辑运算和比较运算

Python 入门教程:第 4 课 - Python 控制流语句¶

在上一节课中,我们学习了 Python 的运算符。在这一节课中,我们将学习 Python 的控制流语句。

1. 什么是控制流语句¶

控制流语句是用于控制程序执行流程的语句。它可以使程序根据不同的条件执行不同的代码块。

Python 中常用的控制流语句包括:

  • if 语句:根据条件执行不同的代码块
  • else 语句:用于 else if 语句或作为 if 语句的补充
  • elif 语句:用于 else if 语句
  • for 循环:用于循环执行一段代码
  • while 循环:用于循环执行一段代码
  • break 语句:用于跳出循环
  • continue 语句:用于跳过本次循环,继续执行下一次循环

2. if 语句¶

if 语句是 Python 中最常用的控制流语句之一。它根据条件执行不同的代码块。

if 语句的基本语法如下:

if condition:
    # 条件为 True 时执行的代码块
else:
    # 条件为 False 时执行的代码块

例如:

# 判断一个数字是否为偶数
x = 10

if x % 2 == 0:
    print(x, "是偶数")
else:
    print(x, "是奇数")

输出:

10 是偶数

3. for 循环¶

for 循环是用于循环执行一段代码的控制流语句。

for 循环的基本语法如下:

for variable in sequence:
    # 循环体

例如:

# 遍历一个列表
fruits = ["apple", "banana", "orange"]

for fruit in fruits:
    print(fruit)

输出:

apple
banana
orange

4. while 循环¶

while 循环是用于循环执行一段代码的控制流语句。

while 循环的基本语法如下:

while condition:
    # 循环体

例如:

# 循环打印 1 到 10
x = 1

while x <= 10:
    print(x)
    x += 1

输出:

1
2
3
4
5
6
7
8
9
10

5. 总结¶

这节课我们学习了 Python 的控制流语句,包括 if 语句、else 语句、elif 语句、for 循环、while 循环、break 语句和 continue 语句。通过这节课的学习,你应该能够:

  • 了解 Python 中常用的控制流语句
  • 使用控制流语句控制程序执行流程

Python 入门教程:第 5 课 - Python 函数¶

在上一节课中,我们学习了 Python 的控制流语句。在这一节课中,我们将学习 Python 的函数。

1. 什么是函数¶

函数是一段具有特定功能的、可重用的语句组。它可以将一段代码封装成一个独立的单元,以便在需要时调用。

2. 函数定义¶

函数的定义格式如下:

def 函数名(参数1, 参数2, ...):
    # 函数体

例如:

def add_numbers(a, b):
    """
    两个数字相加

    Args:
        a: 第一个数字
        b: 第二个数字

    Returns:
        两个数字相加的结果
    """
    return a + b

# 调用函数
result = add_numbers(1, 2)
print(result)  # 3

3. 函数参数¶

函数可以接受参数,参数用于向函数传递数据。

参数可以是必选参数或可选参数。必选参数必须在调用函数时指定,而可选参数可以不指定。

例如:

def add_numbers(a, b, c=0):
    """
    两个数字相加

    Args:
        a: 第一个数字
        b: 第二个数字
        c: 第三个数字,默认为 0

    Returns:
        两个数字相加的结果
    """
    return a + b + c

# 调用函数
result1 = add_numbers(1, 2)  # c 默认为 0
print(result1)  # 3

result2 = add_numbers(1, 2, 3)
print(result2)  # 6

4. 函数返回值¶

函数可以返回一个值,返回值用于将函数执行结果传递给调用函数。

例如:

def add_numbers(a, b):
    """
    两个数字相加

    Args:
        a: 第一个数字
        b: 第二个数字

    Returns:
        两个数字相加的结果
    """
    return a + b

# 调用函数
result = add_numbers(1, 2)
print(result)  # 3

5. 总结¶

这节课我们学习了 Python 的函数,包括函数定义、函数参数和函数返回值。通过这节课的学习,你应该能够:

  • 了解 Python 函数的基本概念
  • 定义和调用函数
  • 使用函数参数和返回值

Python 入门教程:第 6 课 - Python 模块¶

在上一节课中,我们学习了 Python 的函数。在这一节课中,我们将学习 Python 的模块。

1. 什么是模块¶

模块是 Python 中的文件,它包含了函数、类、变量等 Python 对象。模块可以被其他 Python 文件导入,以便在其他文件中使用模块中的对象。

2. 模块导入¶

使用 import 语句可以导入模块。

例如:

import math

# 调用模块中的函数
print(math.pi)  # 3.141592653589793

3. 模块别名¶

可以使用 as 关键字为模块指定别名。

例如:

import math as m

# 调用模块中的函数
print(m.pi)  # 3.141592653589793

4. 模块中的成员¶

可以使用 dir() 函数查看模块中的成员。

例如:

import math

print(dir(math))

输出:

['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isfinite', 'isinf', 'isnan', 'ldexp', 'log', 'log10', 'log1p', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

5. 总结¶

这节课我们学习了 Python 的模块,包括模块导入、模块别名和模块中的成员。通过这节课的学习,你应该能够:

  • 了解 Python 模块的基本概念
  • 导入模块
  • 使用模块中的对象

在接下来的课程中,我们将继续学习 Python 的更多知识,包括面向对象编程、异常处理、文件操作等。

6. 练习¶

  • 尝试导入 os 模块并使用其中的 getcwd() 函数获取当前工作目录。
  • 尝试导入 random 模块并使用其中的 randint() 函数生成一个随机数。
  • 尝试编写一个模块,包含一个函数用于计算两个数字的乘积,并导入该模块并在其他文件中使用该函数。

1. 定义模块

创建一个名为 my_module.py 的文件,并添加以下代码:

def multiply_numbers(a, b):
    """
    两个数字相乘

    Args:
        a: 第一个数字
        b: 第二个数字

    Returns:
        两个数字相乘的结果
    """
    return a * b

2. 导入模块

在另一个文件中,例如 main.py,使用 import 语句导入模块:

import my_module

# 调用模块中的函数
result = my_module.multiply_numbers(2, 3)
print(result)  # 6

3. 使用模块中的函数

在导入模块之后,就可以使用模块中的函数了。在 main.py 文件中,我们使用 my_module.multiply_numbers() 函数计算了 2 和 3 的乘积,并将结果输出到控制台。

Python 入门教程:第 7 课 - Python 面向对象编程¶

在上一节课中,我们学习了 Python 的模块。在这一节课中,我们将学习 Python 的面向对象编程。

1. 什么是面向对象编程¶

面向对象编程是一种编程范式,它将程序组织成对象。对象是一个数据结构,它包含数据和操作数据的方法。

面向对象编程的主要特点包括:

  • 封装:将数据和方法封装成对象,对外隐藏对象的内部实现细节。
  • 继承:允许一个类继承另一个类的属性和方法。
  • 多态:允许不同的对象对同一个消息做出不同的响应。

2. 类和对象¶

类是对象的模板,它定义了对象的属性和方法。

使用 class 关键字定义类。

例如:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print("Hello, my name is {} and I am {} years old.".format(self.name, self.age))


# 创建对象
p1 = Person("小明", 18)
p2 = Person("小红", 19)

# 调用对象的方法
p1.say_hello()
p2.say_hello()

输出:

Hello, my name is 小明 and I am 18 years old.
Hello, my name is 小红 and I am 19 years old.

3. 继承¶

继承允许一个类继承另一个类的属性和方法。

使用 class 关键字定义子类,并使用 super().__init__() 语句调用父类的构造函数。

例如:

class Student(Person):
    def __init__(self, name, age, school):
        super().__init__(name, age)
        self.school = school

    def say_hello(self):
        super().say_hello()
        print("I am a student in {}.".format(self.school))


# 创建对象
s1 = Student("小明", 18, "计算机专业")

# 调用对象的方法
s1.say_hello()

输出:

Hello, my name is 小明 and I am 18 years old.
I am a student in 计算机专业.

4. 多态¶

多态允许不同的对象对同一个消息做出不同的响应。

例如:

class Animal:
    def speak(self):
        raise NotImplementedError

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")


# 创建对象
d1 = Dog()
c1 = Cat()

# 调用对象的方法
d1.speak()
c1.speak()

输出:

Woof!
Meow!

5. 总结¶

这节课我们学习了 Python 的面向对象编程,包括类和对象、继承和多态。通过这节课的学习,你应该能够:

  • 了解 Python 面向对象编程的基本概念
  • 定义类和创建对象
  • 使用继承和多态

Python 入门教程:第 8 课 - Python 异常处理¶

在上一节课中,我们学习了 Python 的面向对象编程。在这一节课中,我们将学习 Python 的异常处理。

1. 什么是异常¶

异常是程序执行过程中发生错误或意外情况。

2. 异常处理¶

异常处理是指程序捕获和处理异常的能力。

Python 中使用 try、except 和 finally 语句进行异常处理。

try-except 语句

try:
    # 代码块
except Exception as e:
    # 处理异常

try-finally 语句

try:
    # 代码块
finally:
    # 无论是否发生异常,都会执行的代码块

3. 常见异常¶

以下是 Python 中常见的异常:

  • TypeError: 类型错误
  • ValueError: 值错误
  • IndexError: 索引错误
  • KeyError: 键错误
  • ZeroDivisionError: 零除错
  • ImportError: 导入错误

4. 总结¶

这节课我们学习了 Python 的异常处理,包括 try-except 语句、try-finally 语句和常见异常。通过这节课的学习,你应该能够:

  • 了解 Python 异常处理的基本概念
  • 使用 try-except 语句捕获和处理异常
  • 使用 try-finally 语句确保代码块最终执行

在接下来的课程中,我们将继续学习 Python 的更多知识,包括文件操作、网络编程等。

5. 练习¶

  • 尝试编写一个 Python 程序,打开一个不存在的文件,并使用异常处理捕获并处理 FileNotFoundError 异常。
  • 尝试编写一个 Python 程序,将一个字符串转换为整数,并使用异常处理捕获并处理 ValueError 异常。

练习解答¶

1. 打开不存在的文件¶

try:
    with open("myfile.txt", "r") as f:
        contents = f.read()
except FileNotFoundError:
    print("File not found")

解释:

  • try 语句用于尝试打开文件。
  • with 语句用于确保文件即使发生异常也会被关闭。
  • open() 函数用于打开文件。
  • f.read() 方法用于读取文件内容。
  • except FileNotFoundError 语句用于捕获 FileNotFoundError 异常。
  • print("File not found") 语句用于输出错误信息。

2. 将字符串转换为整数¶

try:
    number = int(input("请输入一个数字: "))
except ValueError:
    print("输入的不是数字")

解释:

  • try 语句用于尝试将字符串转换为整数。
  • input() 函数用于输入字符串。
  • int() 函数用于将字符串转换为整数。
  • except ValueError 语句用于捕获 ValueError 异常。
  • print("输入的不是数字") 语句用于输出错误信息。

总结¶

通过这两个练习,你应该能够:

  • 使用 try-except 语句捕获和处理异常
  • 使用 with 语句确保文件即使发生异常也会被关闭
  • 使用 input() 函数输入字符串
  • 使用 int() 函数将字符串转换为整数

Python 入门教程:第 9 课 - Python 文件操作¶

在上一节课中,我们学习了 Python 的异常处理。在这一节课中,我们将学习 Python 的文件操作。

1. 打开文件¶

使用 open() 函数打开文件。

f = open("myfile.txt", "r")

参数:

  • filename: 文件名
  • mode: 打开模式,可以是 "r"(读取)、"w"(写入)、"a"(追加)等

2. 读取文件¶

使用 read() 方法读取文件内容。

contents = f.read()

返回值:

  • 文件内容

3. 写入文件¶

使用 write() 方法写入文件内容。

f.write("This is some text.")

参数:

  • content: 要写入的内容

4. 关闭文件¶

使用 close() 方法关闭文件。

f.close()

重要:

  • 即使发生异常,也要确保文件被关闭。
  • 可以使用 with 语句确保文件即使发生异常也会被关闭。

5. 总结¶

这节课我们学习了 Python 的文件操作,包括打开文件、读取文件、写入文件和关闭文件。通过这节课的学习,你应该能够:

  • 使用 open() 函数打开文件
  • 使用 read() 方法读取文件内容
  • 使用 write() 方法写入文件内容
  • 使用 close() 方法关闭文件
  • 使用 with 语句确保文件即使发生异常也会被关闭

6. 练习¶

  • 尝试编写一个 Python 程序,创建一个新的文本文件并写入一些内容。
  • 尝试编写一个 Python 程序,打开一个现有文本文件并读取其内容。

练习解答¶

1. 创建新的文本文件并写入内容¶

# 创建一个新的文本文件并写入一些内容
with open("myfile.txt", "w") as f:
    f.write("This is some text.")

解释:

  • with 语句用于确保文件即使发生异常也会被关闭。
  • open() 函数用于打开文件,并指定模式为 "w"(写入)。
  • f.write() 方法用于写入文件内容。

2. 打开现有文本文件并读取内容¶

# 打开一个现有文本文件并读取其内容
with open("myfile.txt", "r") as f:
    contents = f.read()
    print(contents)

解释:

  • with 语句用于确保文件即使发生异常也会被关闭。
  • open() 函数用于打开文件,并指定模式为 "r"(读取)。
  • f.read() 方法用于读取文件内容。
  • print(contents) 语句用于输出文件内容。

总结¶

通过这两个练习,你应该能够:

  • 使用 with 语句确保文件即使发生异常也会被关闭
  • 使用 open() 函数打开文件
  • 使用 read() 方法读取文件内容
  • 使用 write() 方法写入文件内容
  • 使用 print() 函数输出文件内容

Python 入门教程:第 10 课 - Python 网络编程¶

在上一节课中,我们学习了 Python 的文件操作。在这一节课中,我们将学习 Python 的网络编程。

1. 什么是网络编程¶

网络编程是指编写程序在网络上进行通信。

2. Python 网络编程¶

Python 提供了强大的网络编程功能,包括:

  • 客户端编程:编写程序连接到服务器
  • 服务器端编程:编写程序提供服务

3. 客户端编程¶

使用 socket 模块进行客户端编程。

import socket

# 创建一个 socket 对象
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 连接到服务器
s.connect(("localhost", 80))

# 发送数据
s.send("GET / HTTP/1.1\r\n\r\n")

# 接收数据
data = s.recv(1024)

# 关闭 socket
s.close()

解释:

  • socket.socket() 函数用于创建 socket 对象。
  • socket.AF_INET 表示 IPv4 地址
  • socket.SOCK_STREAM 表示 TCP 流式套接字
  • s.connect() 方法用于连接到服务器
  • s.send() 方法用于发送数据
  • s.recv() 方法用于接收数据
  • s.close() 方法用于关闭 socket

4. 服务器端编程¶

使用 socketserver 模块进行服务器端编程。

import socketserver

class MyHandler(socketserver.BaseRequestHandler):

    def handle(self):
        # 接收数据
        data = self.request.recv(1024)

        # 发送数据
        self.request.sendall(b"Hello, world!")

# 创建一个服务器
server = socketserver.TCPServer(("", 80), MyHandler)

# 运行服务器
server.serve_forever()

解释:

  • socketserver.BaseRequestHandler 类是服务器端处理程序的基类
  • handle() 方法是处理程序的核心方法,用于处理来自客户端的请求
  • self.request 是一个 socket 对象,用于与客户端进行通信
  • self.request.recv() 方法用于接收来自客户端的数据
  • self.request.sendall() 方法用于向客户端发送数据
  • socketserver.TCPServer() 类用于创建 TCP 服务器
  • server.serve_forever() 方法用于运行服务器

5. 总结¶

这节课我们学习了 Python 的网络编程,包括客户端编程和服务器端编程。通过这节课的学习,你应该能够:

  • 了解 Python 网络编程的基本概念
  • 使用 socket 模块进行客户端编程
  • 使用 socketserver 模块进行服务器端编程

6. 练习¶

  • 尝试编写一个 Python 程序,编写一个简单的 HTTP 客户端,可以向指定的 URL 发送 GET 请求并接收响应。
  • 尝试编写一个 Python 程序,编写一个简单的 HTTP 服务器,可以响应 GET 请求并返回 "Hello, world!"。

练习解答¶

1. HTTP 客户端¶

import socket

def get_http_response(url):
    # 创建一个 socket 对象
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 连接到服务器
    host, port = url.split(":")[0], int(url.split(":")[1])
    s.connect((host, port))

    # 发送 GET 请求
    request = "GET / HTTP/1.1\r\nHost: {}\r\n\r\n".format(host)
    s.send(request.encode())

    # 接收响应
    response = b""
    while True:
        data = s.recv(1024)
        if not data:
            break
        response += data

    # 关闭 socket
    s.close()

    return response.decode()

# 测试
url = "www.baidu.com:80"
response = get_http_response(url)
print(response)

解释:

  • get_http_response() 函数用于发送 GET 请求并接收响应
  • host 和 port 分别是服务器的主机名和端口号
  • request 是 HTTP 请求报文
  • response 是 HTTP 响应报文

2. HTTP 服务器¶

import socketserver

class MyHandler(socketserver.BaseRequestHandler):

    def handle(self):
        # 接收请求
        data = self.request.recv(1024)

        # 发送响应
        response = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nHello, world!"
        self.request.sendall(response.encode())

# 创建一个服务器
server = socketserver.TCPServer(("", 80), MyHandler)

# 运行服务器
server.serve_forever()

解释:

  • MyHandler 类是服务器端处理程序
  • handle() 方法用于处理来自客户端的请求
  • response 是 HTTP 响应报文

总结¶

通过这两个练习,你应该能够:

  • 使用 socket 模块编写简单的 HTTP 客户端
  • 使用 socketserver 模块编写简单的 HTTP 服务器
  • 发送和接收 HTTP 请求和响应

Python 入门教程:第 11 课 - Python 数据库操作¶

在上一节课中,我们学习了 Python 的网络编程。在这一节课中,我们将学习 Python 的数据库操作。

1. 什么是数据库¶

数据库是一种用于存储和管理数据的软件系统。

2. Python 数据库操作¶

Python 提供了多种数据库操作模块,包括:

  • sqlite3: 用于操作 SQLite 数据库
  • mysqlclient: 用于操作 MySQL 数据库
  • psycopg2: 用于操作 PostgreSQL 数据库

3. SQLite 数据库¶

SQLite 是一个轻量级的嵌入式数据库,不需要单独的服务器。

import sqlite3

# 创建一个数据库连接
conn = sqlite3.connect("mydb.db")

# 创建一个游标
c = conn.cursor()

# 执行 SQL 语句
c.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)")

# 插入数据
c.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("John Doe", 30))

# 提交事务
conn.commit()

# 关闭数据库连接
conn.close()

解释:

  • sqlite3.connect() 函数用于创建数据库连接
  • conn.cursor() 方法用于创建游标
  • c.execute() 方法用于执行 SQL 语句
  • c.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("John Doe", 30)) 语句用于插入数据
  • conn.commit() 方法用于提交事务
  • conn.close() 方法用于关闭数据库连接

4. MySQL 数据库¶

MySQL 是一个流行的关系数据库管理系统。

import mysqlclient

# 创建一个数据库连接
conn = mysqlclient.connect(
    host="localhost",
    user="root",
    password="password",
    database="mydb",
)

# 创建一个游标
c = conn.cursor()

# 执行 SQL 语句
c.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)")

# 插入数据
c.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("John Doe", 30))

# 提交事务
conn.commit()

# 关闭数据库连接
conn.close()

解释:

  • mysqlclient.connect() 函数用于创建数据库连接
  • host 是数据库服务器的主机名
  • user 是数据库用户名
  • password 是数据库用户密码
  • database 是数据库名称
  • 其他参数与 SQLite 数据库类似

5. PostgreSQL 数据库¶

PostgreSQL 是一个功能强大的开源关系数据库。

import psycopg2

# 创建一个数据库连接
conn = psycopg2.connect(
    host="localhost",
    user="postgres",
    password="password",
    database="mydb",
)

# 创建一个游标
c = conn.cursor()

# 执行 SQL 语句
c.execute("CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name TEXT, age INTEGER)")

# 插入数据
c.execute("INSERT INTO users (name, age) VALUES (%s, %s)", ("John Doe", 30))

# 提交事务
conn.commit()

# 关闭数据库连接
conn.close()

解释:

  • psycopg2.connect() 函数用于创建数据库连接
  • host 是数据库服务器的主机名
  • user 是数据库用户名
  • password 是数据库用户密码
  • database 是数据库名称
  • SERIAL 是 PostgreSQL 的自增类型
  • 其他参数与 SQLite 数据库类似

6. 总结¶

这节课我们学习了 Python 的数据库操作,包括 SQLite 数据库、MySQL 数据库和 PostgreSQL 数据库。通过这节课的学习,你应该能够:

  • 了解 Python 数据库操作的基本概念
  • 使用 sqlite3 模块操作 SQLite 数据库
  • 使用 mysqlclient 模块操作 MySQL 数据库
  • 使用 psycopg2 模块操作 PostgreSQL 数据库

7. 练习¶

  • 尝试编写一个 Python 程序,创建一个新的 SQLite 数据库并插入一些数据。
  • 尝试编写一个 Python 程序,连接到一个现有的 MySQL 数据库并查询数据。
  • 尝试编写一个 Python 程序,连接到一个现有的 PostgreSQL 数据库并更新数据。

练习解答¶

1. 创建新的 SQLite 数据库并插入数据¶

import sqlite3

# 创建一个数据库连接
conn = sqlite3.connect("mydb.db")

# 创建一个游标
c = conn.cursor()

# 执行 SQL 语句
c.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)")

# 插入数据
c.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("John Doe", 30))
c.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("Jane Doe", 25))

# 提交事务
conn.commit()

# 关闭数据库连接
conn.close()

解释:

  • sqlite3.connect() 函数用于创建数据库连接
  • conn.cursor() 方法用于创建游标
  • c.execute() 方法用于执行 SQL 语句
  • c.execute("INSERT INTO users (name, age) VALUES (?, ?)", ("John Doe", 30)) 语句用于插入数据
  • conn.commit() 方法用于提交事务
  • conn.close() 方法用于关闭数据库连接

2. 连接到一个现有的 MySQL 数据库并查询数据¶

import mysqlclient

# 创建一个数据库连接
conn = mysqlclient.connect(
    host="localhost",
    user="root",
    password="password",
    database="mydb",
)

# 创建一个游标
c = conn.cursor()

# 执行 SQL 语句
c.execute("SELECT * FROM users")

# 遍历查询结果
for row in c.fetchall():
    print(row)

# 关闭数据库连接
conn.close()

解释:

  • mysqlclient.connect() 函数用于创建数据库连接
  • host 是数据库服务器的主机名
  • user 是数据库用户名
  • password 是数据库用户密码
  • database 是数据库名称
  • c.execute("SELECT * FROM users") 语句用于查询数据
  • c.fetchall() 方法用于获取所有查询结果
  • for row in c.fetchall(): 循环用于遍历查询结果

3. 连接到一个现有的 PostgreSQL 数据库并更新数据¶

import psycopg2

# 创建一个数据库连接
conn = psycopg2.connect(
    host="localhost",
    user="postgres",
    password="password",
    database="mydb",
)

# 创建一个游标
c = conn.cursor()

# 执行 SQL 语句
c.execute("UPDATE users SET age = 31 WHERE id = 1")

# 提交事务
conn.commit()

# 关闭数据库连接
conn.close()

解释:

  • psycopg2.connect() 函数用于创建数据库连接
  • host 是数据库服务器的主机名
  • user 是数据库用户名
  • password 是数据库用户密码
  • database 是数据库名称
  • c.execute("UPDATE users SET age = 31 WHERE id = 1") 语句用于更新数据
  • conn.commit() 方法用于提交事务
  • conn.close() 方法用于关闭数据库连接

总结¶

通过这三个练习,你应该能够:

  • 使用 sqlite3 模块创建新的 SQLite 数据库并插入数据
  • 使用 mysqlclient 模块连接到一个现有的 MySQL 数据库并查询数据
  • 使用 psycopg2 模块连接到一个现有的 PostgreSQL 数据库并更新数据

Python 入门教程:第 12 课 - Python 正则表达式¶

在上一节课中,我们学习了 Python 的数据库操作。在这一节课中,我们将学习 Python 的正则表达式。

1. 什么是正则表达式¶

正则表达式是一种用于匹配文本模式的工具。

2. Python 正则表达式¶

Python 提供了 re 模块用于支持正则表达式。

import re

# 匹配字符串中的数字
pattern = r"\d+"
text = "This is a string with 123 numbers."

# 使用 re.search() 方法进行匹配
match = re.search(pattern, text)

# 如果匹配成功,则输出匹配结果
if match:
    print(match.group())

解释:

  • re.search() 方法用于在字符串中搜索匹配模式的第一个子字符串
  • match.group() 方法用于获取匹配到的子字符串

3. 正则表达式语法¶

正则表达式语法由以下基本元素组成:

  • 元字符:用于匹配特殊字符
  • 字符类:用于匹配一组字符
  • 限定符:用于匹配字符出现的次数

4. 元字符¶

常用的元字符包括:

  • .:匹配任何字符
  • *:匹配前面的字符零次或多次
  • ?:匹配前面的字符零次或一次
  • +:匹配前面的字符一次或多次
  • ^:匹配字符串的开头
  • $:匹配字符串的结尾

5. 字符类¶

常用的字符类包括:

  • \d:匹配数字
  • \w:匹配字母、数字和下划线
  • \s:匹配空白字符
  • .:匹配任何字符

6. 限定符¶

常用的限定符包括:

  • ?:匹配前面的字符零次或一次
  • +:匹配前面的字符一次或多次
  • *:匹配前面的字符零次或多次
  • {m}:匹配前面的字符 m 次
  • {m,n}:匹配前面的字符 m 到 n 次

7. 总结¶

这节课我们学习了 Python 的正则表达式,包括正则表达式的基本概念、语法和常用元素。通过这节课的学习,你应该能够:

  • 了解 Python 正则表达式的基本概念
  • 使用 re 模块进行正则表达式匹配
  • 掌握正则表达式语法
  • 使用元字符、字符类和限定符进行匹配

8. 练习¶

  • 尝试编写一个 Python 程序,匹配字符串中的所有数字。
  • 尝试编写一个 Python 程序,匹配字符串中的所有电子邮件地址。
  • 尝试编写一个 Python 程序,提取字符串中的日期和时间。

练习解答¶

1. 匹配字符串中的所有数字¶

import re

# 匹配字符串中的所有数字
pattern = r"\d+"
text = "This is a string with 123 numbers."

# 使用 re.findall() 方法进行匹配
matches = re.findall(pattern, text)

# 输出匹配结果
for match in matches:
    print(match)

解释:

  • re.findall() 方法用于在字符串中查找所有匹配模式的子字符串
  • 其他部分与 re.search() 方法类似

2. 匹配字符串中的所有电子邮件地址¶

import re

# 匹配字符串中的所有电子邮件地址
pattern = r"[^@]+@[^@]+\.[^@]+"
text = "This is a string with john@example.com and jane@doe.org."

# 使用 re.findall() 方法进行匹配
matches = re.findall(pattern, text)

# 输出匹配结果
for match in matches:
    print(match)

解释:

  • . 匹配除换行符 (\n) 以外的任何字符
  • + 匹配前面的字符一次或多次
  • ? 匹配前面的字符零次或一次
  • @ 匹配 @ 符号
  • [] 匹配字符类中的任何字符

3. 提取字符串中的日期和时间¶

import re

# 提取字符串中的日期和时间
pattern = r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}"
text = "This is a string with 2023-11-16 10:23:54."

# 使用 re.search() 方法进行匹配
match = re.search(pattern, text)

# 如果匹配成功,则输出匹配结果
if match:
    print(match.group())

解释:

  • \d{4} 匹配四位数字
  • - 匹配 - 符号
  • \d{2} 匹配两位数字

总结¶

通过这三个练习,你应该能够:

  • 使用 re 模块匹配字符串中的数字、电子邮件地址和日期时间
  • 使用正则表达式语法进行复杂匹配

Python 入门教程:第 13 课 - Python 多线程¶

在上一节课中,我们学习了 Python 的正则表达式。在这一节课中,我们将学习 Python 的多线程。

1. 什么是多线程¶

多线程是指在一个进程中同时执行多个线程。

2. Python 多线程¶

Python 提供了 threading 模块用于支持多线程。

import threading

# 定义一个线程
def my_thread():
    print("This is a thread.")

# 创建一个线程
thread = threading.Thread(target=my_thread)

# 启动线程
thread.start()

# 等待线程结束
thread.join()

解释:

  • threading.Thread() 函数用于创建线程
  • target 参数指定线程要执行的函数
  • start() 方法用于启动线程
  • join() 方法用于等待线程结束

3. 多线程的优势¶

多线程的优势包括:

  • 提高程序的执行效率
  • 提高程序的响应速度
  • 更好地利用多核 CPU

4. 多线程的注意事项¶

多线程需要注意以下问题:

  • 线程安全问题
  • 线程同步问题

5. 总结¶

这节课我们学习了 Python 的多线程,包括多线程的基本概念、优势和注意事项。通过这节课的学习,你应该能够:

  • 了解 Python 多线程的基本概念
  • 使用 threading 模块创建和管理线程
  • 掌握多线程的优势和注意事项

6. 练习¶

  • 尝试编写一个 Python 程序,使用多线程计算 1 到 100 的累加和。
  • 尝试编写一个 Python 程序,使用多线程下载多个文件。
  • 尝试编写一个 Python 程序,使用多线程模拟龟兔赛跑。

练习解答¶

1. 使用多线程计算 1 到 100 的累加和¶

import threading

# 定义一个函数计算累加和
def sum_numbers(start, end):
    sum = 0
    for i in range(start, end + 1):
        sum += i
    return sum

# 定义线程数量
num_threads = 4

# 创建线程并计算累加和
threads = []
for i in range(num_threads):
    start = i * (100 // num_threads) + 1
    end = (i + 1) * (100 // num_threads)
    thread = threading.Thread(target=sum_numbers, args=(start, end))
    threads.append(thread)
    thread.start()

# 等待所有线程结束
for thread in threads:
    thread.join()

# 计算最终结果
total_sum = 0
for thread in threads:
    total_sum += thread.result

# 输出结果
print(total_sum)

解释:

  • sum_numbers() 函数计算从 start 到 end 的累加和
  • num_threads 变量指定线程数量
  • threads 列表存储所有线程
  • thread.result 属性获取线程的返回值

2. 使用多线程下载多个文件¶

import threading
import requests

# 定义一个函数下载文件
def download_file(url):
    filename = url.split("/")[-1]
    response = requests.get(url)
    with open(filename, "wb") as f:
        f.write(response.content)

# 定义要下载的文件列表
urls = ["https://www.example.com/file1.zip", "https://www.example.com/file2.zip", "https://www.example.com/file3.zip"]

# 定义线程数量
num_threads = 3

# 创建线程并下载文件
threads = []
for url in urls:
    thread = threading.Thread(target=download_file, args=(url,))
    threads.append(thread)
    thread.start()

# 等待所有线程结束
for thread in threads:
    thread.join()

# 输出结果
print("All files downloaded.")

解释:

  • download_file() 函数下载指定 URL 的文件
  • urls 列表存储要下载的文件 URL
  • num_threads 变量指定线程数量
  • threads 列表存储所有线程
  • requests 模块用于下载文件

3. 使用多线程模拟龟兔赛跑¶

import threading
import time

# 定义兔子和乌龟类
class Rabbit(threading.Thread):
    def __init__(self):
        super().__init__()
        self.distance = 0

    def run(self):
        while self.distance < 100:
            time.sleep(0.1)
            self.distance += 1

class Turtle(threading.Thread):
    def __init__(self):
        super().__init__()
        self.distance = 0

    def run(self):
        while self.distance < 100:
            time.sleep(0.2)
            self.distance += 0.1

# 创建兔子和乌龟线程
rabbit = Rabbit()
turtle = Turtle()

# 开始比赛
rabbit.start()
turtle.start()

# 等待比赛结束
rabbit.join()
turtle.join()

# 判断胜负
if rabbit.distance >= 100:
    print("兔子赢了!")
else:
    print("乌龟赢了!")

解释:

  • Rabbit 和 Turtle 类模拟兔子和乌龟
  • distance 属性表示兔子和乌龟的距离
  • run() 方法模拟兔子和乌龟的移动
  • time 模块用于控制线程睡眠时间

总结¶

通过这三个练习,你应该能够:

  • 使用多线程提高程序的执行效率
  • 使用多线程下载多个文件
  • 使用多线程模拟多任务执行

Python 入门教程:第 14 课 - Python 网络编程¶

在上一节课中,我们学习了 Python 的多线程。在这一节课中,我们将学习 Python 的网络编程。

1. 什么是网络编程¶

网络编程是指编写可以在网络上传输和接收数据的程序。

2. Python 网络编程¶

Python 提供了 socket 模块用于支持网络编程。

import socket

# 创建一个 socket
sock = socket.socket()

# 绑定 socket 到一个端口
sock.bind(("", 8080))

# 监听 socket
sock.listen()

# 接受连接
conn, addr = sock.accept()

# 接收数据
data = conn.recv(1024)

# 发送数据
conn.send(b"Hello, world!")

# 关闭连接
conn.close()
sock.close()

解释:

  • socket.socket() 函数创建一个 socket
  • bind() 方法将 socket 绑定到一个端口
  • listen() 方法开始监听 socket
  • accept() 方法接受连接
  • recv() 方法接收数据
  • send() 方法发送数据
  • close() 方法关闭连接

3. TCP 和 UDP¶

TCP 和 UDP 都是网络传输协议。

  • TCP 是可靠的传输协议,可以保证数据完整性。
  • UDP 是不可靠的传输协议,但速度更快。

4. HTTP¶

HTTP 是超文本传输协议,用于在网络上传输超文本数据。

  • HTTP 请求由方法、URI、头部和主体组成。
  • HTTP 响应由状态码、头部和主体组成。

5. 总结¶

这节课我们学习了 Python 的网络编程,包括网络编程的基本概念、TCP 和 UDP 协议、以及 HTTP 协议。通过这节课的学习,你应该能够:

  • 了解 Python 网络编程的基本概念
  • 使用 socket 模块创建和管理 socket
  • 掌握 TCP 和 UDP 协议
  • 理解 HTTP 协议

6. 练习¶

  • 尝试编写一个 Python 程序,创建一个简单的 HTTP 服务器。
  • 尝试编写一个 Python 程序,使用 HTTP GET 方法请求一个网页。
  • 尝试编写一个 Python 程序,使用 HTTP POST 方法发送数据到一个服务器。

练习解答¶

1. 创建一个简单的 HTTP 服务器¶

import socket

# 创建一个 socket
sock = socket.socket()

# 绑定 socket 到一个端口
sock.bind(("", 8080))

# 监听 socket
sock.listen()

# 循环处理连接
while True:
    # 接受连接
    conn, addr = sock.accept()

    # 接收请求
    request = conn.recv(1024)

    # 解析请求
    method, uri, headers, body = request.decode().split("\r\n")

    # 发送响应
    response = "HTTP/1.1 200 OK\r\n\r\nHello, world!"
    conn.send(response.encode())

    # 关闭连接
    conn.close()

# 关闭 socket
sock.close()

解释:

  • 这个程序创建一个简单的 HTTP 服务器,监听端口 8080
  • 服务器循环处理连接,并对每个连接发送一个简单的响应

2. 使用 HTTP GET 方法请求一个网页¶

import requests

# 发送 HTTP GET 请求
response = requests.get("https://www.google.com")

# 检查响应状态码
if response.status_code == 200:
    # 打印响应内容
    print(response.content)
else:
    # 打印错误信息
    print("Error:", response.status_code)

解释:

  • requests 模块用于发送 HTTP 请求
  • 这个程序使用 HTTP GET 方法请求 https://www.google.com 网页
  • 如果请求成功,则打印响应内容;否则打印错误信息

3. 使用 HTTP POST 方法发送数据到一个服务器¶

import requests

# 发送 HTTP POST 请求
response = requests.post("https://www.example.com/api/v1/users", data={"username": "johndoe", "password": "secret"})

# 检查响应状态码
if response.status_code == 201:
    # 打印响应内容
    print(response.content)
else:
    # 打印错误信息
    print("Error:", response.status_code)

解释:

  • 这个程序使用 HTTP POST 方法发送数据到 https://www.example.com/api/v1/users 服务器
  • 发送的数据包含用户名和密码
  • 如果请求成功,则打印响应内容;否则打印错误信息

总结¶

通过这三个练习,你应该能够:

  • 使用 socket 模块创建简单的 HTTP 服务器
  • 使用 requests 模块发送 HTTP GET 和 POST 请求
  • 理解 HTTP 请求和响应

参考资料¶

  • Python 官方网站: https://www.python.org/
  • Python 教程: https://docs.python.org/3/tutorial/
  • Python 异常处理: https://docs.python.org/3/tutorial/errors.html
  • Python 网络编程: https://docs.python.org/3/library/socket.html
  • Python 服务器端编程: https://docs.python.org/3/library/socketserver.html
  • Python 数据库操作: [https://docs.python.org/3/library
  • Python 正则表达式: https://docs.python.org/3/library/re.html
  • Python 多线程: https://docs.python.org/3/library/threading.html
  • requests 模块: https://pypi.org/project/requests/
  • HTTP: https://www.w3.org/