当前位置：首页 > article >正文

【Python爬虫(1)】专栏开篇：夯实Python基础

article 2025/2/21 18:31:20

【Python爬虫】专栏简介：本专栏是 Python 爬虫领域的集大成之作，共 100 章节。从 Python 基础语法、爬虫入门知识讲起，深入探讨反爬虫、多线程、分布式等进阶技术。以大量实例为支撑，覆盖网页、图片、音频等各类数据爬取，还涉及数据处理与分析。无论是新手小白还是进阶开发者，都能从中汲取知识，助力掌握爬虫核心技能，开拓技术视野。

一、引言

在如今这个数据驱动的时代，数据就如同宝贵的资源，而 Python 爬虫则是获取这些资源的有力工具。无论是从网页中提取新闻资讯、从电商平台获取商品信息，还是从社交媒体收集用户评论，Python 爬虫都能大显身手。

然而，要想熟练掌握 Python 爬虫技术，扎实的 Python 基础是必不可少的。这就好比建造高楼大厦，Python 基础就是那稳固的基石。只有打好了这个基础，我们才能在爬虫的学习道路上稳步前行，理解并运用各种爬虫技术和框架。接下来，就让我们一起回顾那些重要的 Python 基础知识吧。

二、Python 语法基础

2.1 变量

在 Python 中，变量就像是一个标签，我们可以把数据贴在这个标签上，方便后续使用。变量的命名需要遵循一定的规则：

首先，变量名必须以字母或者下划线开头，后续字符可以是字母、数字或者下划线，比如my_variable、_name、count123都是合法的变量名，而2hello、my-var就是不合法的。
同时，我们不能使用 Python 的保留字（关键字）作为变量名，像if、for、while这些都是保留字，是不能用来命名变量的。
此外，为了提高代码的可读性，我们尽量使用有意义的名字作为变量名，比如用age表示年龄，name表示姓名，而不是用单个字母a、n等。

变量的赋值使用等号=，比如age = 20，这就把整数 20 赋值给了变量age，之后我们使用age时，就相当于使用 20 这个值。Python 是动态类型语言，变量不需要预先声明类型，它会根据赋值自动确定类型。我们还可以在一行内给多个变量赋值，如x = y = z = 0，这样x、y、z都被赋值为 0；也可以同时给多个不同变量赋不同的值，a, b, c = 1, 2, “hello”，此时a为 1，b为 2，c为"hello"。

2.2 数据类型

整型（int）：用来表示整数，没有小数部分，如age = 25，count = -10。在 Python 中，整型的范围很大，基本可以满足我们日常的计算需求。
浮点型（float）：表示带有小数部分的数字，比如pi = 3.14，salary = 5000.5 。需要注意的是，浮点数在计算机中存储时可能存在精度问题，例如0.1 + 0.2在数学上等于0.3，但在 Python 中输出结果可能是0.30000000000000004，这是因为浮点数在计算机中是以二进制形式存储的，某些十进制小数无法精确地用二进制表示。
布尔型（bool）：只有两个值，True和False，常用于条件判断和逻辑运算。比如is_student = True，is_adult = False 。在 Python 中，True本质上是 1，False本质上是 0，所以布尔型也可以参与一些算术运算，如True + 1结果为 2，False + 5结果为 5。
字符串（str）：由一系列字符组成，用于表示文本数据。可以用单引号（‘）、双引号（"）或三引号（’'‘或"“”）括起来，比如name = ‘Alice’，message = “Hello, World!”，poem = “”“This is a multi - line poem.
It has multiple lines.
“”” 。字符串支持很多操作，如拼接first_name = “John”，last_name = “Doe”，full_name = first_name + " " + last_name，此时full_name的值为"John Doe"；还可以通过索引获取单个字符，message[0]得到的是’H’ 。
列表（list）：是一种可变的有序序列，可以包含多个不同类型的元素，用方括号[]表示，如fruits = [‘apple’, ‘banana’, ‘cherry’]，numbers = [1, 2, 3, 4]，mixed = [1, ‘two’, 3.5, True] 。列表可以通过索引访问元素，fruits[0]得到’apple’ ，也可以通过append()方法添加元素，fruits.append(‘date’)，此时fruits变为[‘apple’, ‘banana’, ‘cherry’, ‘date’] ，还可以使用del语句删除元素，del fruits[1]，fruits就变为[‘apple’, ‘cherry’, ‘date’] 。
元组（tuple）：与列表类似，也是有序的序列，但元组是不可变的，一旦创建就不能修改其内容，用圆括号()表示，例如coordinates = (10, 20)，colors = (‘red’, ‘green’, ‘blue’) 。虽然元组不能修改元素，但可以通过索引访问元素，coordinates[0]得到 10。元组通常用于存储一些固定的数据，比如坐标、日期等。
字典（dict）：是一种可变的无序映射类型，用于存储键值对，用花括号{}表示，每个键值对之间用冒号:分隔，不同键值对之间用逗号,分隔，如person = {‘name’: ‘Bob’, ‘age’: 30, ‘city’: ‘New York’} 。可以通过键来访问对应的值，person[‘name’]得到’Bob’ ，也可以修改值person[‘age’] = 31 ，还能添加新的键值对person[‘job’] = ‘Engineer’ 。
集合（set）：是一个无序的、不包含重复元素的集合，用花括号{}或set()函数来定义，如nums = {1, 2, 3, 3, 4}，实际存储的nums为{1, 2, 3, 4} ，重复的 3 被自动去除了。集合可以进行交集、并集、差集等运算，set1 = {1, 2, 3}，set2 = {3, 4, 5}，set1.intersection(set2)得到{3} ，set1.union(set2)得到{1, 2, 3, 4, 5} ，set1.difference(set2)得到{1, 2} 。

2.3 运算符

算术运算符：用于基本的数学运算，包括+（加）、-（减）、*（乘）、/（除）、%（取模，即取除法的余数）、**（幂运算）、//（取整除，返回商的整数部分）。例如：

a = 10
b = 3
print(a + b)  # 输出13
print(a - b)  # 输出7
print(a * b)  # 输出30
print(a / b)  # 输出3.3333333333333335
print(a % b)  # 输出1
print(a ** b)  # 输出1000
print(a // b)  # 输出3

比较运算符：用于比较两个值的大小或是否相等，返回布尔值True或False ，包括==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于）。例如：

x = 5
y = 8
print(x == y)  # 输出False
print(x!= y)  # 输出True
print(x > y)  # 输出False
print(x < y)  # 输出True
print(x >= y)  # 输出False
print(x <= y)  # 输出True

逻辑运算符：用于逻辑运算，返回布尔值，包括and（与）、or（或）、not（非）。and表示两个条件都为True时，结果才为True；or表示只要有一个条件为True，结果就为True；not用于反转条件的值。例如：

condition1 = True
condition2 = False
print(condition1 and condition2)  # 输出False
print(condition1 or condition2)  # 输出True
print(not condition1)  # 输出False

位运算符：对二进制位进行操作，包括&（按位与）、|（按位或）、^（按位异或）、~（按位取反）、<<（左移位）、>>（右移位）。例如：

a = 5  # 二进制为0101
b = 3  # 二进制为0011
print(a & b)  # 输出1，二进制为0001
print(a | b)  # 输出7，二进制为0111
print(a ^ b)  # 输出6，二进制为0110
print(~a)  # 输出-6，二进制为11111010（补码形式）
print(a << 1)  # 输出10，二进制为1010
print(a >> 1)  # 输出2，二进制为0010

赋值运算符：用于给变量赋值，最基本的是=，还有一些复合赋值运算符，如+=（加法赋值）、-=（减法赋值）、*=（乘法赋值）、/=（除法赋值）、%=（取模赋值）、**=（幂赋值）、//=（取整除赋值）。例如：

x = 10
x += 5  # 相当于x = x + 5，此时x的值为15
x -= 3  # 相当于x = x - 3，此时x的值为12
x *= 2  # 相当于x = x * 2，此时x的值为24
x /= 4  # 相当于x = x / 4，此时x的值为6.0

三、流程控制语句

流程控制语句是编程语言的重要组成部分，它允许我们根据不同的条件执行不同的代码块，或者重复执行一段代码。在 Python 中，主要的流程控制语句有if-else语句、for循环和while循环。

3.1 if-else 语句

if-else语句用于根据条件来决定执行哪部分代码，它有三种常见的形式：单分支、双分支和多分支。

单分支：

- 语法：

if 条件表达式:
    语句块

- 说明：当条件表达式的值为True时，执行语句块中的代码；否则，跳过语句块。
- 示例：判断一个数是否大于 10。

num = 15
if num > 10:
    print(f"{num} 大于10")

双分支：

- 语法：

if 条件表达式:
    语句块1
else:
    语句块2

- 说明：如果条件表达式的值为True，执行语句块 1；否则，执行语句块 2。
- 示例：判断一个数是奇数还是偶数。

num = 8
if num % 2 == 0:
    print(f"{num} 是偶数")
else:
    print(f"{num} 是奇数")

多分支：

- 语法：

if 条件表达式1:
    语句块1
elif 条件表达式2:
    语句块2
...
else:
    语句块n

- 说明：依次判断条件表达式的值，当某个条件表达式为True时，执行对应的语句块，然后跳过整个if-elif-else结构；如果所有条件表达式都为False，则执行else中的语句块（else部分可选）。
- 示例：根据学生的成绩给出不同的等级评定。

score = 75
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 70:
    print("中等")
elif score >= 60:
    print("及格")
else:
    print("不及格")

3.2 for 循环

for循环用于遍历可迭代对象（如列表、元组、字符串等）中的每个元素，并对每个元素执行相同的操作。

基本语法：

for 变量 in 可迭代对象:
    语句块

- 说明：依次从可迭代对象中取出每个元素，赋值给变量，然后执行语句块中的代码，直到可迭代对象中的所有元素都被遍历完。
- 示例：遍历列表并打印每个元素。

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

结合 range () 函数使用：range()函数可以生成一个整数序列，常与for循环结合使用来实现指定次数的循环。
- 语法：range(start, stop, step)，其中start是起始值（默认为 0），stop是结束值（不包含在序列中），step是步长（默认为 1）。
- 示例：打印 0 到 4 的数字。

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

- 示例：打印 1 到 10 之间的偶数。

for i in range(2, 11, 2):
    print(i)

break 和 continue 语句：在for循环中，break语句用于立即终止循环，continue语句用于跳过当前循环的剩余部分，直接进入下一次循环。
- 示例：使用break语句提前结束循环。

for num in range(1, 10):
    if num == 5:
        break
    print(num)

- 示例：使用continue语句跳过某些元素。

for num in range(1, 10):
    if num % 2 == 0:
        continue
    print(num)

3.3 while 循环

while循环会在条件表达式为True时，重复执行语句块。

语法：

while 条件表达式:
    语句块

- 说明：首先判断条件表达式的值，如果为True，则执行语句块，然后再次判断条件表达式，如此循环，直到条件表达式的值为False。
- 示例：计算 1 到 10 的累加和。

sum_num = 0
i = 1
while i <= 10:
    sum_num += i
    i += 1
print(f"1到10的累加和为: {sum_num}")

break 和 continue 语句：在while循环中，break和continue语句的作用与在for循环中相同。
- 示例：使用break语句在满足条件时终止循环。

i = 1
while True:
    if i == 5:
        break
    print(i)
    i += 1

- 示例：使用continue语句跳过某些循环。

i = 0
while i < 10:
    i += 1
    if i % 2 == 0:
        continue
    print(i)

四、函数的定义与使用

在 Python 中，函数是组织好的、可重复使用的代码块，用于实现特定的功能。它可以提高代码的复用性和可维护性，让我们的编程工作更加高效。

4.1 函数定义

函数定义使用def关键字，其基本语法如下：

def 函数名(参数列表):
    """函数文档字符串，用于描述函数的功能和使用方法"""
    函数体
    return 返回值

参数列表：可以包含零个或多个参数，参数之间用逗号,分隔。参数是函数接收外部传入数据的变量，通过参数，函数可以处理不同的数据。
函数体：包含了实现函数功能的一系列语句，是函数的核心部分。
return 语句：用于返回函数的执行结果，是可选的。如果没有return语句，函数会默认返回None。

例如，定义一个简单的函数，用于计算两个数的和：

def add_numbers(a, b):
    """
    该函数用于计算两个数的和
    :param a: 第一个数
    :param b: 第二个数
    :return: 两个数的和
    """
    result = a + b
    return result

在这个例子中，add_numbers是函数名，a和b是参数，函数体计算了a和b的和并将结果通过return返回。

4.2 函数调用

函数定义好后，就可以通过函数调用来执行其中的代码。调用函数时，使用函数名加上括号，括号内传入实际的参数值（如果有参数的话）。

例如，调用上面定义的add_numbers函数：

sum_result = add_numbers(3, 5)
print(sum_result)  # 输出8

在这个例子中，add_numbers(3, 5)就是函数调用，3和5是实际传入的参数值，函数执行后返回的结果赋值给了sum_result变量，然后打印出结果。

函数调用时，参数的传递方式有两种：

按位置传参：按照参数定义的顺序依次传入参数值，如上面的add_numbers(3, 5)，3对应参数a，5对应参数b。
按名称传参：通过参数名来指定参数值，这种方式可以不按照参数定义的顺序传参，例如add_numbers(b = 5, a = 3)，结果与按位置传参相同。

4.3 函数参数

必备参数：调用函数时必须传入的参数，数量和顺序都要与函数定义时一致，否则会报错。例如上面的add_numbers函数，a和b就是必备参数。
默认参数：在定义函数时可以为参数指定默认值，调用函数时如果没有传入该参数的值，就会使用默认值。例如：

def greet(name, greeting = "Hello"):
    """
    该函数用于向某人打招呼
    :param name: 姓名
    :param greeting: 问候语，默认为"Hello"
    :return: 打招呼的字符串
    """
    message = f"{greeting}, {name}!"
    return message

调用这个函数时，可以只传入name参数：

print(greet("Alice"))  # 输出Hello, Alice!

也可以传入greeting参数来覆盖默认值：

print(greet("Bob", "Hi"))  # 输出Hi, Bob!

不定长参数：

*args：用于接收任意数量的位置参数，这些参数会被收集成一个元组。例如：

def print_numbers(*args):
    for num in args:
        print(num)


print_numbers(1, 2, 3, 4)

**kwargs：用于接收任意数量的关键字参数，这些参数会被收集成一个字典。例如：

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


print_info(name="Alice", age=25, city="New York")

4.4 局部变量和全局变量

局部变量：在函数内部定义的变量，只在函数内部有效，函数执行结束后，局部变量就会被销毁。例如：

def my_function():
    local_var = 10  # 局部变量
    print(local_var)


my_function()
# print(local_var)  # 这行会报错，因为local_var在函数外不可见

全局变量：在函数外部定义的变量，在整个程序中都可以访问。例如：

global_var = 20  # 全局变量


def my_function():
    print(global_var)


my_function()
print(global_var)

在函数内部修改全局变量时，需要使用global关键字声明，否则 Python 会认为是在创建一个新的局部变量。例如：

global_var = 30


def modify_global():
    global global_var
    global_var = 40
    print(global_var)


modify_global()
print(global_var)

如果不使用global关键字，像下面这样：

global_var = 50


def modify_global():
    global_var = 60  # 创建了一个新的局部变量，而不是修改全局变量
    print(global_var)


modify_global()
print(global_var)  # 输出50，因为全局变量没有被修改