Python 安装与语法基础入门教程

a = 1

这种操作称为赋值，意思为将数值 1 赋给了变量 a。 注意：Python 中语句结束不需要以分号结束，变量不需要提前定义。

现在有变量 a 和变量 b，可以通过下面代码进行变量 a、b 值的对换。

a = 4
b = 5
t = a  # 把 a 值赋给 t 变量
a = b  # 把 b 值赋给 a 变量
b = t  # 把 t 值赋给 b 变量
print(a, b)  # result 5 4

这种方法类似于将两个杯子中的饮料对换，只需要多加一个杯子，即可完成饮料的对换工作。

2. 字符串的'加法'和'乘法'

由于 Python 爬虫的对象大部分为文本，所以字符串的用法尤为重要。在 Python 中，字符串由双引号或单引号和引号中的字符组成。首先，通过下面代码看看字符串的'加法'：

a = 'I'
b = ' love'
c = ' Python'
print(a + b + c)  # 字符串相加
# result I love Python

在爬虫代码中，会经常构造 URL，例如，在爬取一个网页链接时，只有一部分/u/9104ebf5e177，这部分链接是无法访问的，还需要 http://www.jianshu.com，这时可以通过字符串的'加法'进行合并。

Python 的字符串不仅可以相加，也可以乘以一个数字：

a = 'word'
print(a * 3)  # 字符串乘法
# result wordwordword

字符串乘以一个数字，意思就是将字符串复制这个数字的份数。

3. 字符串的切片和索引

字符串的切片和索引就是通过 string[x]，获取字符串的一部分信息：

a = 'I love python'
print(a[0])  # 取字符串第一个元素
# result I
print(a[0:5])  # 取字符串第一个到第五个元素
# result I lov
print(a[-1])  # 取字符串最后一个元素
# result n

通过图 1.3 就能清楚地理解字符串的切片和索引。

[图 1.3 字符串切片和索引]

注意：a[0:5] 中的第 5 个是不会选择的。

在爬虫实战中，经常会通过字符串的切片和索引，提取需要的部分，剔除一些不需要的部分。

4. 字符串方法

Python 作为面向对象的语言，每个对象都有相应的方法，字符串也一样，拥有多种方法，在这里介绍爬虫技术中常用的几种方法。

4.1 split() 方法

a = 'www.baidu.com'
print(a.split('.'))  # result ['www', 'baidu', 'com']

字符串的 split() 方法就是通过给定的分隔符（在这里为'.'），将一个字符串分割为一个列表（后面将详细讲解列表）。 注意：如果没有提供任何分隔符，程序会把所有的空格作为分隔符（空格、制表、换行等）。

4.2 replace() 方法

a = 'There is apples'
b = a.replace('is', 'are')
print(b)  # result There are apples

这种方法类似文本中的'查找和替换'功能。

4.3 strip() 方法

a = ' python is cool '
print(a.strip())  # result python is cool

strip() 方法返回去除两侧（不包括内部）空格的字符串，也可以指定需要去除的字符，将它们列为参数中即可。

a = '**python *is *good**'
print(a.strip('*!'))  # result python *is *good

这个方法只能去除两侧的字符，在爬虫得到的文本中，文本两侧常会有多余的空格，只需使用字符串的 strip() 方法即可去除多余的空格部分。

4.4 format() 方法

最后，再讲解下好用的字符串格式化符，首先看以下代码：

a = '{} is my love'.format('Python')
print(a)  # result Python is my love

字符串格式化符就像是做选择题，留了空给做题者选择。在爬虫过程中，有些网页链接的部分参数是可变的，这时使用字符串格式化符可以减少代码的使用量。 例如，Pexels 素材网，当搜索图片时，网页链接也会发生变化。 如在搜索栏中输入 book，网页跳转为 https://www.pexels.com/search/book/，可以设计如下代码，笔者只需输入搜索内容，便可返回网页链接。

content = input('请输入搜索内容：')
url_path = 'https://www.pexels.com/search/{}/'.format(content)
print(url_path)

运行程序并输入 book，便可返回网页链接，单击网页链接便可访问网页了，如图 1.4 所示。

[图 1.4 字符串格式化符演示]

03 函数与控制语句

本节主要介绍 Python 函数的定义与使用方法，介绍 Python 的判断和循环两种爬虫技术中常用的控制语句。

1. 函数

'脏活累活交给函数来做'，首先，看看 Python 中定义函数的方法。

def 函数名 (参数 1，参数 2…): 
    return '结果'

制作一个输入直角边就能计算出直角三角形的面积函数：

def function(a, b):
    return '1/2*a*b'
# 也可以这样写
def function(a, b):
    print(1/2*a*b)

注意：读者不需要太纠结二者的区别，用 return 是返回一个值，而第二个是调用函数执行打印功能。

通过输入 function(2,3)，便可以调用函数，计算直角边为 2 和 3 的直角三角形的面积。现在来做一个综合练习：读者都知道网上公布的电话号码，如 156****9354，中间的数值用其他符号代替了，而用户输入手机号时却是完整地输入，下面就通过 Python 函数来实现这种转换功能。

def change_number(number):
    hiding_number = number.replace(number[3:7], '*'*4)
    print(hiding_number)
change_number('15648929354')  # result 156****9354

注意：这里的手机号码是随意输入的，不是真实的号码。

代码说明如下：

• 定义了一个名为 change_number 的函数。
• 对输入的参数进行切片，把参数的 [3:7] 部分替换为'*'号，并打印出来。
• 调用函数。

2. 判断语句

在爬虫实战中也会经常使用判断语句，Python 的判断语句格式如下：

if condition:
    do
else:
    do
# 注意：冒号和缩进不要忘记了
# 再看一下多重条件的格式
if condition:
    do
elif condition:
    do
else:
    do

在平时使用密码时，输入的密码正确即可登录，密码错误时就需要再次输入密码。

def count_login():
    password = input('password:')
    if password == '12345':
        print('输入成功！')
    else:
        print('错误，再输入')
    count_login()
    count_login()

程序说明如下：

• 运行程序，输入密码后按 Enter 键。
• 如果输入的字符串为 12345，则打印'输入成功！'，程序结束。
• 如果输入的字符串不是 12345，则打印'错误，再输入'，继续运行程序，直到输入正确为止。

读者也可以将程序设计得更为有趣，例如，'3 次输入失败后，退出程序'等。

3. 循环语句

Python 的循环语句包括 for 循环和 while 循环，代码如下：

#for 循环
for item in iterable:
    do  # item 表示元素，iterable 是集合
for i in range(1, 11):
    print(i)  # 其结果为依次输出 1 到 10，切记 11 是不输出的，range 为 Python 内置函数
#while 循环
while condition:
    do

例如，设计一个小程序，计算 1～100 的和：

i = 0
sum = 0
while i < 100:
    i = i + 1
    sum = sum + i
print(sum)  # result 5050

04 Python 数据结构

数据结构是存放数据的容器，本节主要讲解 Python 的 4 种基本数据结构，即列表、字典、元组和集合。

1. 列表

在爬虫实战中，使用最多的就是列表数据结构，不论是构造出的多个 URL，还是爬取到的数据，大多数都为列表数据结构。下面首先介绍列表最显著的特征：

• 列表中的每一个元素都是可变的。
• 列表的元素都是有序的，也就是说每个元素都有对应的位置（类似字符串的切片和索引）。
• 列表可以容纳所有的对象。

列表中的每个元素都是可变的，这意味着可以对列表进行增、删、改操作，这些操作在爬虫中很少使用，因此这里不再给读者添加知识负担。 列表的每个元素都有对应的位置，这种用法与字符串的切片和索引很相似。

list = ['peter', 'lilei', 'wangwu', 'xiaoming']
print(list[0])
print(list[2:])  # result peter ['wangwu', 'xiaoming']

如果为切片，返回的也是列表的数据结构。 列表可以容纳所有的对象：

list = [1, 1.1, 'string', True, [1, 2], (1, 2), {'key', 'value'}]

列表中会经常用到多重循环，因此读者有必要去了解和使用多重循环。现在，摆在读者面前有两个列表，分别是姓名和年龄的列表：

names = ['xiaoming', 'wangwu', 'peter']
ages = [23, 15, 58]

这时可以通过多重循环让 name 和 age 同时打印在屏幕上：

names = ['xiaoming', 'wangwu', 'peter']
ages = [23, 15, 58]
for name, age in zip(names, ages):
    print(name, age)  # result xiaoming 23 wangwu 15 peter 58

注意：多重循环前后变量要一致。

在爬虫中，经常请求多个网页，通常情况下会把网页存到列表中，然后循环依次取出并访问爬取数据。这些网页都有一定的规律，如果是手动将这些网页 URL 存入到列表中，不仅花费太多时间，也会造成代码冗余。这时可通过列表推导式，构造出这样的列表，例如某个网站每页的 URL 是这样的（一共 13 页）： http://bj.xiaozhu.com/search-duanzufang-p1-0/ ... 通过以下代码即可构造出 13 页 URL 的列表数据：

urls = ['http://bj.xiaozhu.com/search-duanzufang-p{}-0/'.format(number) for number in range(1, 14)]
for url in urls:
    print(url)

通过一行代码即可构造出来，通过 for 循环打印出每个 URL，如图 1.5 所示。

[图 1.5 列表推导式构造 URL 列表]

注意：本网站为小猪短租网。

2. 字典

Python 的字典数据结构与现实中的字典类似，以键值对（'key'-'value'）的形式表现出来。本文中只讲解字典的创造，字典的操作在后面会详细介绍。字典的格式如下：

user_info = {
    'name': 'xiaoming',
    'age': '23',
    'sex': 'man'
}

注意：插入 MongoDB 数据库需用字典结构。

3. 元组和集合

在爬虫中，元组和集合很少用到，因此这里只做简单介绍。元组类似于列表，但是元组的元素不能修改只能查看，元组的格式如下：

tuple = (1, 2, 3)

集合的概念类似数学中的集合。每个集合中的元素是无序的，不可以有重复的对象，因此可以通过集合把重复的数据去除。

list = ['xiaoming', 'zhangyun', 'xiaoming']
set = set(list)
print(set)  # result {'zhangyun', 'xiaoming'}

注意：集合是用大括号构建的。

05 Python 文件操作

在爬虫初期的工作中，常常会把数据存储到文件中。本节主要讲解 Python 如何打开文件和读写数据。

1. 打开文件

Python 中通过 open() 函数打开文件，语法如下：

open(name[, mode[, buffering]])

open() 函数使用文件名作为唯一的强制参数，然后返回一个文件对象。模式（mode）和缓冲（buffering）是可选参数。在 Python 的文件操作中，mode 参数的输入是有必要的，而 buffering 使用较少。 如果在本机上有名为 file.txt 的文件（读者可以在本机中新建一个文本文件），其存储路径为 C:\Users\Administrator\Desktop，那么可以通过下面代码打开文件：

f = open('C:/Users/Administrator/Desktop/file.txt')

注意：此代码为 Windows 系统下的路径写法。

如果文件不存在，则会出现如图 1.6 所示的错误。

[图 1.6 文件不存在报错信息]

如果 open() 函数只是加入文件的路径这一个参数，则只能打开文件并读取文件的相关内容。如果要向文件中写入内容，则必须加入模式这个参数了。下面首先来看看 open() 函数中模式参数的常用值，如表 1.1 所示。

[表 1.1 open() 函数中模式参数的常用值]

2. 读写文件

上一节中有了名为 f 的类文件对象，那么就可以通过 f.write() 方法和 f.read() 方法写入和读取数据了。

f = open('C:/Users/Administrator/Desktop/file.txt', 'w+')
f.write('hello world')

这时，在本机上打开 file.txt 文件，可以看到如图 1.7 所示的结果。

[图 1.7 Python 写文件]

注意：如果没有建立文件，运行上面代码也可以成功。 如果再次运行程序，txt 文件中的内容不会继续添加，可以修改模式参数为'r+'，便可一直写入文件。 Python 读取文件通过 read() 方法，下面尝试把 f 的类文件对象写入的数据读取出来，使用如下代码即可完成操作：

f = open('C:/Users/Administrator/Desktop/file.txt', 'r')
content = f.read()
print(content)
# result hello world

3. 关闭文件

当完成读写工作后，应该牢记使用 close() 方法关闭文件。这样可以保证 Python 进行缓冲的清理（出于效率考虑而把数据临时存储在内存中）和文件的安全性。通过下面代码即可关闭文件。

f = open('C:/Users/Administrator/Desktop/file.txt', 'r')
content = f.read()
print(content)
f.close()

06 Python 面向对象

Python 作为一个面向对象的语言，很容易创建一个类和对象。本节主要讲解类的定义及其相关使用方法。

1. 定义类

类是用来描述具有相同属性和方法的对象集合。人可以通过不同的肤色划分为不同的种族，食物也有不同的种类，商品也是形形色色。但划分为同一类的物体，肯定具有相似的特征和行为方式。 对于同一款自行车而言，它们的组成结构都是一样的，如车架、车轮和脚踏板等。通过 Python 可以定义这个自行车的类：

class Bike:
    compose = ['frame', 'wheel', 'pedal']

通过使用 class 定义一个自行车的类，类中的变量 compose 称为类的变量，专业术语为类的属性。这样，顾客购买的自行车组成结构就是一样的了。

my_bike = Bike()
you_bike = Bike()
print(my_bike.compose)
print(you_bike.compose)  # 类的属性都是一样的

结果如图 1.8 所示。

[图 1.8 类属性引用]

在左边写上变量名，右边写上类的名称，这个过程称之为类的实例化，而 my_bike 就是类的实例。通过'.'加上类的属性，就是类属性的引用。类的属性会被类的实例共享，所以结果都是一样的。

2. 实例属性

对于同一款自行车来说，有些顾客买回去后会改造下，如加一个车筐可以放东西等。

class Bike:
    compose = ['frame', 'wheel', 'pedal']
    my_bike = Bike()
    my_bike.other = 'basket'
    print(my_bike.other)  # 实例属性

结果如图 1.9 所示。

[图 1.9 实例属性]

说明：通过给类的实例属性进行赋值，也就是实例属性。compose 属性属于所有的该款自行车，而 other 属性只属于 my_bike 这个类的实例。

3. 实例方法

读者是否还记得字符串的 format() 方法。方法就是函数，方法是对实例进行使用的，所以又叫实例方法。对于自行车而言，它的方法就是骑行。

class Bike:
    compose = ['frame', 'wheel', 'pedal']
    def use(self):
        print('you are riding')
my_bike = Bike()
my_bike.use()

结果如图 1.10 所示。

[图 1.10 实例方法]

注意：这里的 self 参数就是实例本身。

和函数一样，实例方法也是可以有参数的。

class Bike:
    compose = ['frame', 'wheel', 'pedal']
    def use(self, time):
        print('you ride {}m'.format(time * 100))
my_bike = Bike()
my_bike.use(10)

结果如图 1.11 所示。

[图 1.11 实例方法多参数]

Python 的类中有一些'魔法方法'，init() 方法就是其中之一。在我们创造实例的时候，不需要引用该方法也会被自动执行。

class Bike:
    compose = ['frame', 'wheel', 'pedal']
    def __init__(self):
        self.other = 'basket'
    def use(self, time):
        print('you ride {}m'.format(time * 100))
my_bike = Bike()
print(my_bike.other)

结果如图 1.12 所示。

[图 1.12 魔术方法]

4. 类的继承

共享单车的出现，方便了人们的出行。共享单车和原来的自行车组成结构类似，但多了付费的功能。

class Bike:
    compose = ['frame', 'wheel', 'pedal']
    def __init__(self):
        self.other = 'basket'  # 定义实例的属性
    def use(self, time):
        print('you ride {}m'.format(time * 100))

class Share_bike(Bike):
    def cost(self, hour):
        print('you spent {}'.format(hour * 2))

bike = Share_bike()
print(bike.other)
bike.cost(2)

结果如图 1.13 所示。

[图 1.13 类的继承]

在新的类 Share_bike 后面的括号中加入 Bike，表示 Share_bike 继承了 Bike 父类。父类中的变量和方法可以完全被子类继承，在特殊情况下，也可以对其覆盖。