Python 是一种通用的、高级的编程语言。它易于学习和使用,具有丰富的库和工具,广泛应用于 Web 开发、数据科学、机器学习、人工智能等领域。
Python 由 Guido van Rossum 于 1989 年发明,是一种解释型语言,这意味着它不需要编译成机器代码就可以运行。Python 语法简洁明了,代码风格接近自然语言,因此易于学习和阅读。
Python 具有以下特点:
学习 Python 之前,我们需要先搭建 Python 环境。
Windows 系统
python
,如果出现 Python 版本信息,则说明安装成功Mac 系统
brew install python
python
,如果出现 Python 版本信息,则说明安装成功Linux 系统
sudo apt install python3
python3
,如果出现 Python 版本信息,则说明安装成功Python 语法由以下几部分组成:
if
、else
、for
、while
等下面是一个简单的 Python 代码示例:
这个代码首先定义了一个名为 name
的变量,并将其值赋值为 "小明"。然后,使用 print()
函数打印变量的值。接着,进行数学运算,将 1 和 2 相加,并将结果赋值给变量 sum
。最后,使用 if
语句判断条件,如果 sum
大于 2,则打印 "sum 大于 2",否则打印 "sum 小于或等于 2"。
# 定义一个变量
name = "小明"
# 打印变量的值
print(name)
# 进行数学运算
sum = 1 + 2
# 判断条件
if sum > 2:
print("sum 大于 2")
else:
print("sum 小于或等于 2")
小明 sum 大于 2
第一节我们介绍了 Python 的基本知识,包括 Python 的简介、环境搭建和基本语法。通过这节课的学习,你应该能够:
在上一节课中,我们学习了 Python 的基本知识,包括 Python 的简介、环境搭建和基本语法。在这一节课中,我们将学习 Python 的数据类型。
数据类型是用来表示数据的类型。在 Python 中,数据类型可以分为以下几类:
数值类型是 Python 中最常用的数据类型之一。它用于表示数字,包括整数、浮点数和复数。
在 Python 中,可以使用以下方法来判断一个变量的数据类型:
type()
函数isinstance()
函数# 判断变量 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
# 使用单引号定义字符串
name = '小明'
# 使用双引号定义字符串
sentence = "Hello, world!"
# 使用三引号定义字符串
paragraph = '''
This is a multi-line string.
It can span multiple lines.
'''
字符串可以使用以下方法来进行操作:
+
运算符[]
运算符in
运算符replace()
方法# 连接字符串
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!
这节课我们学习了 Python 的数据类型,包括数值类型、字符串类型、列表类型、字典类型、元组类型、集合类型和布尔类型。通过这节课的学习,你应该能够:
在上一节课中,我们学习了 Python 的数据类型。在这一节课中,我们将学习 Python 的运算符。
运算符是用来对操作数进行运算的符号。在 Python 中,运算符可以分为以下几类:
算术运算符是 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
逻辑运算符是用于进行逻辑运算的符号。它用于判断两个或多个表达式的真假值。
以下是 Python 中常用的逻辑运算符:
运算符 | 含义 |
---|---|
and | 与 |
or | 或 |
not | 非 |
例如:
# 与运算符
x = True and False
print(x) # False
# 或运算符
y = True or False
print(y) # True
# 非运算符
z = not True
print(z) # False
比较运算符是用于进行比较运算的符号。它用于比较两个表达式的值的大小或相等性。
以下是 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
这节课我们学习了 Python 的运算符,包括算术运算符、逻辑运算符、比较运算符、赋值运算符、成员运算符和身份运算符。通过这节课的学习,你应该能够:
在上一节课中,我们学习了 Python 的运算符。在这一节课中,我们将学习 Python 的控制流语句。
控制流语句是用于控制程序执行流程的语句。它可以使程序根据不同的条件执行不同的代码块。
Python 中常用的控制流语句包括:
if 语句是 Python 中最常用的控制流语句之一。它根据条件执行不同的代码块。
if 语句的基本语法如下:
if condition:
# 条件为 True 时执行的代码块
else:
# 条件为 False 时执行的代码块
例如:
# 判断一个数字是否为偶数
x = 10
if x % 2 == 0:
print(x, "是偶数")
else:
print(x, "是奇数")
输出:
10 是偶数
for 循环是用于循环执行一段代码的控制流语句。
for 循环的基本语法如下:
for variable in sequence:
# 循环体
例如:
# 遍历一个列表
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
print(fruit)
输出:
apple
banana
orange
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
这节课我们学习了 Python 的控制流语句,包括 if 语句、else 语句、elif 语句、for 循环、while 循环、break 语句和 continue 语句。通过这节课的学习,你应该能够:
在上一节课中,我们学习了 Python 的控制流语句。在这一节课中,我们将学习 Python 的函数。
函数是一段具有特定功能的、可重用的语句组。它可以将一段代码封装成一个独立的单元,以便在需要时调用。
函数的定义格式如下:
def 函数名(参数1, 参数2, ...):
# 函数体
例如:
def add_numbers(a, b):
"""
两个数字相加
Args:
a: 第一个数字
b: 第二个数字
Returns:
两个数字相加的结果
"""
return a + b
# 调用函数
result = add_numbers(1, 2)
print(result) # 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
函数可以返回一个值,返回值用于将函数执行结果传递给调用函数。
例如:
def add_numbers(a, b):
"""
两个数字相加
Args:
a: 第一个数字
b: 第二个数字
Returns:
两个数字相加的结果
"""
return a + b
# 调用函数
result = add_numbers(1, 2)
print(result) # 3
这节课我们学习了 Python 的函数,包括函数定义、函数参数和函数返回值。通过这节课的学习,你应该能够:
在上一节课中,我们学习了 Python 的函数。在这一节课中,我们将学习 Python 的模块。
模块是 Python 中的文件,它包含了函数、类、变量等 Python 对象。模块可以被其他 Python 文件导入,以便在其他文件中使用模块中的对象。
使用 import
语句可以导入模块。
例如:
import math
# 调用模块中的函数
print(math.pi) # 3.141592653589793
可以使用 as
关键字为模块指定别名。
例如:
import math as m
# 调用模块中的函数
print(m.pi) # 3.141592653589793
可以使用 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']
这节课我们学习了 Python 的模块,包括模块导入、模块别名和模块中的成员。通过这节课的学习,你应该能够:
在接下来的课程中,我们将继续学习 Python 的更多知识,包括面向对象编程、异常处理、文件操作等。
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 的模块。在这一节课中,我们将学习 Python 的面向对象编程。
面向对象编程是一种编程范式,它将程序组织成对象。对象是一个数据结构,它包含数据和操作数据的方法。
面向对象编程的主要特点包括:
类是对象的模板,它定义了对象的属性和方法。
使用 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.
继承允许一个类继承另一个类的属性和方法。
使用 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 计算机专业.
多态允许不同的对象对同一个消息做出不同的响应。
例如:
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!
这节课我们学习了 Python 的面向对象编程,包括类和对象、继承和多态。通过这节课的学习,你应该能够:
在上一节课中,我们学习了 Python 的面向对象编程。在这一节课中,我们将学习 Python 的异常处理。
异常是程序执行过程中发生错误或意外情况。
异常处理是指程序捕获和处理异常的能力。
Python 中使用 try
、except
和 finally
语句进行异常处理。
try-except 语句
try:
# 代码块
except Exception as e:
# 处理异常
try-finally 语句
try:
# 代码块
finally:
# 无论是否发生异常,都会执行的代码块
以下是 Python 中常见的异常:
TypeError
: 类型错误ValueError
: 值错误IndexError
: 索引错误KeyError
: 键错误ZeroDivisionError
: 零除错ImportError
: 导入错误这节课我们学习了 Python 的异常处理,包括 try-except 语句、try-finally 语句和常见异常。通过这节课的学习,你应该能够:
在接下来的课程中,我们将继续学习 Python 的更多知识,包括文件操作、网络编程等。
FileNotFoundError
异常。ValueError
异常。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")
语句用于输出错误信息。try:
number = int(input("请输入一个数字: "))
except ValueError:
print("输入的不是数字")
解释:
try
语句用于尝试将字符串转换为整数。input()
函数用于输入字符串。int()
函数用于将字符串转换为整数。except ValueError
语句用于捕获 ValueError
异常。print("输入的不是数字")
语句用于输出错误信息。通过这两个练习,你应该能够:
在上一节课中,我们学习了 Python 的异常处理。在这一节课中,我们将学习 Python 的文件操作。
使用 open()
函数打开文件。
f = open("myfile.txt", "r")
参数:
filename
: 文件名mode
: 打开模式,可以是 "r"(读取)、"w"(写入)、"a"(追加)等使用 read()
方法读取文件内容。
contents = f.read()
返回值:
使用 write()
方法写入文件内容。
f.write("This is some text.")
参数:
content
: 要写入的内容使用 close()
方法关闭文件。
f.close()
重要:
with
语句确保文件即使发生异常也会被关闭。这节课我们学习了 Python 的文件操作,包括打开文件、读取文件、写入文件和关闭文件。通过这节课的学习,你应该能够:
# 创建一个新的文本文件并写入一些内容
with open("myfile.txt", "w") as f:
f.write("This is some text.")
解释:
with
语句用于确保文件即使发生异常也会被关闭。open()
函数用于打开文件,并指定模式为 "w"(写入)。f.write()
方法用于写入文件内容。# 打开一个现有文本文件并读取其内容
with open("myfile.txt", "r") as f:
contents = f.read()
print(contents)
解释:
with
语句用于确保文件即使发生异常也会被关闭。open()
函数用于打开文件,并指定模式为 "r"(读取)。f.read()
方法用于读取文件内容。print(contents)
语句用于输出文件内容。通过这两个练习,你应该能够:
在上一节课中,我们学习了 Python 的文件操作。在这一节课中,我们将学习 Python 的网络编程。
网络编程是指编写程序在网络上进行通信。
Python 提供了强大的网络编程功能,包括:
使用 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使用 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()
方法用于运行服务器这节课我们学习了 Python 的网络编程,包括客户端编程和服务器端编程。通过这节课的学习,你应该能够:
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 响应报文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 响应报文通过这两个练习,你应该能够:
在上一节课中,我们学习了 Python 的网络编程。在这一节课中,我们将学习 Python 的数据库操作。
数据库是一种用于存储和管理数据的软件系统。
Python 提供了多种数据库操作模块,包括:
sqlite3
: 用于操作 SQLite 数据库mysqlclient
: 用于操作 MySQL 数据库psycopg2
: 用于操作 PostgreSQL 数据库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()
方法用于关闭数据库连接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
是数据库名称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 的自增类型这节课我们学习了 Python 的数据库操作,包括 SQLite 数据库、MySQL 数据库和 PostgreSQL 数据库。通过这节课的学习,你应该能够:
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()
方法用于关闭数据库连接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():
循环用于遍历查询结果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()
方法用于关闭数据库连接通过这三个练习,你应该能够:
在上一节课中,我们学习了 Python 的数据库操作。在这一节课中,我们将学习 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()
方法用于获取匹配到的子字符串正则表达式语法由以下基本元素组成:
常用的元字符包括:
.
:匹配任何字符*
:匹配前面的字符零次或多次?
:匹配前面的字符零次或一次+
:匹配前面的字符一次或多次^
:匹配字符串的开头$
:匹配字符串的结尾常用的字符类包括:
\d
:匹配数字\w
:匹配字母、数字和下划线\s
:匹配空白字符.
:匹配任何字符常用的限定符包括:
?
:匹配前面的字符零次或一次+
:匹配前面的字符一次或多次*
:匹配前面的字符零次或多次{m}
:匹配前面的字符 m 次{m,n}
:匹配前面的字符 m 到 n 次这节课我们学习了 Python 的正则表达式,包括正则表达式的基本概念、语法和常用元素。通过这节课的学习,你应该能够:
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()
方法类似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
) 以外的任何字符+
匹配前面的字符一次或多次?
匹配前面的字符零次或一次@
匹配 @
符号[]
匹配字符类中的任何字符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}
匹配两位数字通过这三个练习,你应该能够:
在上一节课中,我们学习了 Python 的正则表达式。在这一节课中,我们将学习 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()
方法用于等待线程结束多线程的优势包括:
多线程需要注意以下问题:
这节课我们学习了 Python 的多线程,包括多线程的基本概念、优势和注意事项。通过这节课的学习,你应该能够:
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
属性获取线程的返回值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
列表存储要下载的文件 URLnum_threads
变量指定线程数量threads
列表存储所有线程requests
模块用于下载文件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 的多线程。在这一节课中,我们将学习 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()
函数创建一个 socketbind()
方法将 socket 绑定到一个端口listen()
方法开始监听 socketaccept()
方法接受连接recv()
方法接收数据send()
方法发送数据close()
方法关闭连接TCP 和 UDP 都是网络传输协议。
HTTP 是超文本传输协议,用于在网络上传输超文本数据。
这节课我们学习了 Python 的网络编程,包括网络编程的基本概念、TCP 和 UDP 协议、以及 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()
解释:
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 请求https://www.google.com
网页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)
解释:
https://www.example.com/api/v1/users
服务器通过这三个练习,你应该能够: