python——爬虫与脚本

`1.` Python简介

`1.1.` Python起源

`1.1.1`语言作者

贵铎·范·罗萨姆（Guido van Rossum）荷兰人于1989年圣诞节创建了python。

底层语言为C语言

1991年初，python发布了第一个公开发行版。
用于自动化
金融行业、数据分析
网络安全工具等领域

`1.1.2` python名字由来

Monty python 是英国的喜剧团队

`1.2.` python特点

特点	说明
高级	有高级的数据结构，缩短开发时间与代码量
面向对象	为数据和逻辑相分离的结构化和过程化编程添加了新的活力
可升级	提供了基本的开发模块，可以在它上面开发软件，实现代码的重用
可扩展	通过将其分离为多个文件或模块加以组织管理
可移植性	python的底层语言是c，由于c的可移植性使得python可以运行在任何带有ANSI C编译器的平台上
易学	python关键字少、结构简单、语法清晰
易读	没有其他语言通常用来访问变量、定义代码和进行模式匹配的命令式符号
内存管理器	内存管理是由python解释器负责的

`2.` Python环境安装

`2.1.` python下载

python官网

python有两个大版本

python2

旧版本，由于仍有大量的py2程序所以不能被取代
python3

新版本，规范了py语法

`2.2.` Windows 环境安装python

`2.2.1` 环境变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KjeDqw3q-1660098896713)(https://raw.githubusercontent.com/Li-Ruo/PicGo-picture/main/img/image-20220804171607059.png)]

`2.2.2` 配置 pip 网络源

在当前用户家目录下新建文件夹并命名为pip ，并在该文件夹中新建文件pip.ini

写入如下内容：

[global]
timeout = 6000
index-url = http://pypi.tana.tsinghua.edu.cn/simple
trusted-host = pypi.tana.tsinghua.edu.cn

`2.2.3`开发工具

Vscode
pycharm
…

`3.` Python初识

py官方参考文档

`3.1.` py语法结构

`3.1.1` 基本输出

# 01-基本输出 
print("Hello World")

`3.1.2` 注释

# 02-注释方法
'''这是注释
'''
"""这也是注释
"""

`3.1.3` 缩进

缩进是py与其他编程语言最大的区别

Py代码块通过缩进/对齐表达代码逻辑，而不是使用大括号。缩进表达一个语句属于哪个代码块

缩进风格，空格数量：

1-2个：太短，很难确定代码语句属于哪个块
8-10个：太长，如果代码内嵌层次太多，就会降低代码的可读性
4个：刚刚好，是范·罗萨姆支持的风格

`3.1.1` 续行

一行过长的语句可以使用反斜杠\分解成几行

# 03-续行写法print("I like python very very very very very very very ve\
ry very very very very very very very very very very very\
very very very very very very very very very very much")

`3.2.` python变量

`3.2.1` 变量

变量名称约定：

变量名由字母、数字、下划线组成，不是全部必须有
不能以数字开头
区分大小写

变量名	是否合法
username	合法
userName	合法
UserName	合法
username_1	合法
`__username__`	合法
userN@me	不合法
1userName	不合法

一般变量的使用过程

声明变量（变量名字、变量类型）；
初始化；
变量赋值和反复使用（赋值）；

Python是（动态类型语言）解释型脚本语言，不需要编译，即不需要预先声明变量的类型，直接就能用

`3.2.2` 变量赋值

变量的类型和值在赋值那一刻被初始化，变量赋值通过赋值运算符=来执行

一个变量如果需要使用，就给个值；如果不用，就别让它出现

username = 2022print("Welcome," + username)
print("Welcome,{}!".format(username))
print(f"Welcome,{username}!")

赋值运算符

Python语言中，等号=是主要的赋值运算符。赋值并不是直接将一个值赋给一个变量。在Python中，对象是通过引用传递的。在赋值时，不管这个对象是新创建的，还是一个已经存在的，都是将该对象的引用（并不是值）赋值给变量。

Python也支持链式多重赋值

>>> x=y=10
>>> x
10
>>> y
10
>>>

增量赋值

从python2.0开始，等号可以和一个算术运算符组合在一起，将计算结果重新赋给左边变量，这被称为增量赋值

>>> x=3
>>> x=x+1
>>> x
4
>>> x ++File "<stdin>", line 1x ++^
SyntaxError: invalid syntax
>>> x+=1
>>> x
5
>>>

多元赋值

另一种将多个变量同时赋值的方法称为多元赋值，采用这种方式赋值是，等号两边的对象对视元组

>>> x,y,z=1,2,3
>>> x
1
>>> y
2
>>> z
3
>>>

`3.2.3` 捕获输入

根据用户的输入打印信息

username = input("Please input your name:")
print("Welcome," + username)

`3.3.` 运算符

算术运算符
比较运算符
逻辑运算符

`3.3.1` 算术运算符

参与运算的操作数是数字，结果也是数字

算术运算符	解释
+	若操作数字类型，则进行算术运算若操作字符类型，则进行字符串拼接
-
*	若操作数字类型，则进行算术运算若一个是字符串类型，另一个是数字类型，则将字符串重复输出
/
%	取余
//	整除
**	幂运算

`3.3.2` 比较运算符

比较运算符	解释（运算结果是布尔类型，Ture\|False）
<
<=
>
>=
==	全等概念（下方代码块）
!=

>>> 10 =='10'
False

`3.3.3` 逻辑运算符

逻辑运算符	解释	字符表达
and	逻辑与运算	&
or	逻辑或运算	\|
not	逻辑非运算

`3.4.` 标识符

`3.4.1` 关键字

关键字不能做为变量名，函数名，类名

和其他的高级语言一样，Python也拥有一些被称作关键字的保留字符；任何语言的关键字应该保持稳定，但是由于Python是一门不断成长和进化的而语言，其关键字偶尔会更新；通过keyword模块可以查看关键字信息

>>>import keyword
>>>keyword.iskeyword('pass')
True
>>>>>> keyword.kwlist
['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

`3.4.2` builtins

内置函数，在任何地方都可以调用。

除了关键字之外，python还有可以在任何一段一级代码使用的“内建”的名字集合，这些名字可以由解释器设置或使用，内置函数就在任何时候，任何地方都可以调用的函数。虽然built-in不是关键字，但是应该把它作为“系统保留字”

内置函数

		内置函数
abs()	delattr()	hash()	memoryview()	set()
all()	dict()	help()	min()	setattr()
any()	dir()	hex()	next()	slice()
ascii()	divmod()	id()	object()	sorted()
		…

保留的常量：

True
False
None

`3.5.` 基本风格

在python语言中：{}并不代表代码块

#！/usr/bin/env python3
# -*- coding:gbk -*-                            #起始行
'this is a test module'                         #模块文档字符串import sys                                      #导入模块
import osdebug = True                                    #全局变量声明
class FooClass(object):                         #类定义'Foo class'passdef test():                                     #函数定义"test function"foo = Fooclass()if __name__ == '__main__':                      #程序主体test()

`4.`变量类型

“一切皆对象”

`4.1.` 对象

4.1.1 py对象特征

Python对象特征

所有python对象都拥有三个特性：

特性	说明	例子
身份	每一个对象都有一个唯一的`身份标识` 任何对象的身份可以使用内建函数id()来得到	id(userName)
类型	决定了该对象可以保存什么类型的值，可以进行什么样的操作，以及遵循什么样的规则。用内建函数type()查看对象的类型	type(userName)
值	对象表示的数据项	username

`4.1.2` Python对象属性方法

类：抽象的，概括性的，非具体的描述
对象：实例化的，具体的，真实的
属性：对象中存储的值；
方法：对象的可执行动作；
使用.标记法来访问对象的属性和方法

`4.2.` 数字

`4.2.1` 基本数字类型

关键字	解释	例子
int	有符号整数	自然数
bool boolean	布尔值	True：1 False：0
float	浮点数	π

`4.2.2` 进制间转换

python默认以十进制数显示，也可以使用其他方法表示数字

进制	表达	实例
10进制	默认	11
2进制	数字以0b开头	0b11
8进制	数字以0o开头	0o11
16进制	数字以0x开头	0x11

`4.2.3` 数字类型函数

函数	说明
int( )	将字符类型转化为整型
float( )	将字符类型转化为浮点型

`4.2.4` 仅用于整数的函数

函数	说明
hex（）	10 进制数转换为字符串形式的16 进制数
oct（）	10 进制数转换为字符串形式的8 进制数
bin（）	10 进制数转换为字符串形式的2 进制数

`4.3.` 字符串

`4.3.1` 字符串定义

python中字符串被定义为引号之间的字符集合；python支持使用成对的单引号或双引号定义字符串，无论单引号，还是双引号，表示的意义相同；python还支持三引号（三个连续的单引号或双引号），可以用来包含特殊字符或多行内容；python不区分字符和字符串

username = 'Maple'username = "Maple"username = '''Maple'''username = """Maple"""print(username)

`4.3.2` 字符串拼接

使用+号可以将多个字符串拼接在一起

username = "Maple"
print("Welcome," + username)

使用*号可以将一个字符串重复多次输出

>>> username = "Maple"
>>> username * 3
'MapleMapleMaple'
>>>

`4.3.3` 字母与ASCII

单个字符操作	例子
将单个字符转化成ASCII码	ord(‘a’)
将ASCII码转化位字符	chr(97)

`4.3.4` 字符串操作

字符串操作	实例
比较运算符：字符串按照字符的ASCII码值进行比较	‘b’ < ‘bool’ ‘b’ > ‘abcd’
角标访问：利用偏离量获取字符串中的字符	‘zhangsan’[1]
切片：取子串 str[n:m]，n,m均代表偏移量，m > n，[n,m-1] str[::m]，每n个字母一组，取第一个字母 str[::-1]，字符串反向	‘zhangsan’[1:3] ‘zhangsan’[::3] ‘zhangsan’[::-1]
成员关系：字符串A 是否是字符串B的子串	‘zs’ in ‘zhangsan’ ‘q’ not in ‘zhangsan’

`4.3.5` 字符串格式化输出

f 修饰符，新特性

>>> username = 'Maple'
>>> f"Welcome,{username}"
'Welcome,Maple'
>>>

`4.3.6` 字符串常用内建函数

常用内建函数	说明	实例
s.strip()	删除字符串两端的空白	‘zhangsan’.strip()
s.replace(sub,rep)	搜索s字符串中sub，并替换为rep	‘zhangsan’.replace(‘e’,‘E’)
s.split©	分割字符串，并返回一个列表，可以指定分隔符c，默认为空白	‘127.0.0.1’.split(‘.’)
s.center(width)	返回一个原字符串居中，并使用空格填充至长度width的新字符串	“Maple”.center(11)
s.upper()	转换字符串实例中的小写字母为大写	‘maple’.upper()
s.lower	转换字符串实例中的大写字母为小写	‘MAPLE’.lower()

`4.4.` 列表

类比于PHP中的数组，并且是索引数组

`4.4.1` 列表的定义

# 09-列表的定义stu1 = ['张三',True,24,59.9]
stu2 = ['李四',True,25,61.9]
stu3 = ['王五',True,25,99.9]

`4.4.2` 列表元素访问

>>> stu1 = ['张三',True,24,59.9]
>>> type(stu1)
<class 'list'>
>>> f"{stu1[0]} 的成绩是{stu1[3]}"
'张三 的成绩是59.9'
>>>

`4.4.3` 列表操作

可以通过角标访问的数据类型，叫做序列

序列支持的操作：

加法或乘法：拼接；
切片：截取；
成员关系判断；

>>> stu1 = ['张三',True,24,59.9]
>>> stu2 = ['李四',True,23,84.9]
>>> stu3 = stu1 + stu2
>>> stu3
['张三', True, 24, 59.9, '李四', True, 23, 84.9]
>>>>>> stu1 * 3
['张三', True, 24, 59.9, '张三', True, 24, 59.9, '张三', True, 24, 59.9]>>> stu1[0:2]
['张三', True]
>>> '张三' in stu1
True
>>>

`4.4.4` 用于作用列表的函数

直接向函数中传参，参数为列表

函数	说明	示例
list( )	将序列转化成列表	list(‘张三’)
len( )	长度	len(stu)
max( )	最大值	max(stu)
min( )	最小值	min(stu)
sorted( )	排序	sorted(stu)
enumerate( )	取脚标和元素	list(enumerate(stu))

`4.4.5` 列表内建函数

函数	说明	示例
l.append(new)	向列表中添加一个对象
l.pop(obj)	删除列表中的元素
l.count(obj)	返回一个对象obj在列表中出现的次数
l.index(obj)	obj首次出现的位置
l.insert(index,obj)	在偏移量为index的位置插入对象obj
l.reserve()	反转列表
l.sort()	排序
l.extend(seq)	把序列seq的内容添加到列表中

`4.5.` 元组

元组一旦被定义，就无法更改

`4.5.1` 元组定义

我们可以将元组认为是静态的列表，它具备列表所拥有的特性，但元组的内容不可改变

`4.5.2` 创建元组

通过()或工厂函数tuple()创建元组

>>> stu3 = ('王五',True,25,90)
>>> type(stu3)
<class 'tuple'>
>>> stu1
['张三', True, 24, 59.9,]
>>> stu1[3] += 0.1
>>> stu1
['张三', True, 24, 60.0]
>>> stu3[3] += 0.1
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

`4.5.3` 元组操作

由于元组也是序列类型，所以元组也可以进行

角标访问；
拼接；
切片；
成员关系判断等

`4.5.4` 单元素元组

如果需要定义单元素元组，那么创建该元组的时候，需要在结尾处添加一个逗号

`4.6.` 字典

类似PHP中的关联数组

`4.6.1` 字典定义

字典是由键值（key-value）对构成的映射数据类型，不支持下标操作

>>> stu1 = {'name':"Maple",'sex':True,'age':24,'score':89.9}
>>> type(stu1)
<class 'dict'>
>>>

`4.6.2` 创建字典

除了可以通过{}操作符创建字典。还可以通过dict()的方法创建

`4.6.3` 访问字典元素

字典是映射类型，意味着它没有下标，只有键值对，访问字典中的值需要使用相应的键

>>> stu1['score']
89.9
>>> stu1['score'] += 0.1
>>> stu1['score']
90.0
>>>

`4.6.4` 更新字典元素

通过键名更新字典键值；如果字典中有该键名，则更新对应的键值；如果字典中没有该键名，则向字典中添加键值对

>>> stu1['email'] = '123@qq.com'
>>> stu1
{'name': 'Maple', 'sex': True, 'age': 24, 'score': 90.0, 'email': '123@qq.com'}
>>>

`4.6.5` 用作于字典的函数

函数	说明
len()	返回字典中元素的数目
list()	返回字典中使用的所有键名的列表

`4.6.6` 字典的内建方法

方法	说明
d.copy()	返回字典的一个副本
d.get(key)	对字典dict中的键key，返回它对应值value，如果字典中不存在此键，则返回default的值
d.keys()	返回一个包含字典中键的列表
d.values()	返回一个包含字典中所有值的列表
d.updata(dict2)	将字典dict2的键值对添加到字典dict
d.items()	返回一个包含字典中（键，值）对元组的列表

`5.` 流程控制

对于与编程语言，基本都是遵循从上到下依次执行的规律

`5.1.` 条件分支

如果…，则…，否则…

通过if语句进行分支

`5.1.1` 单向条件分支

例：学生成绩高于60则输出“恭喜”

# 08 - 单项条件分支
score = 99.9
if score >=60:print('Congratulations!')

`5.1.2` 双向条件分支

例：学生成绩高于60则输出“恭喜”，如果低于则输出“你没有通过”

# 09 - 双项条件分支
score = 99.9
if score >=60:print('Congratulations!')
else:print('you cant pass!')

`5.1.3` 多向条件分支

例：可以根据学生成绩分级

成绩大于等于90，定级A
成绩大于等于80，定级B
成绩大于等于70，定级C
成绩大于等于60，定级D
成绩若小于60分，定为不及格

# 10 - 多项条件分支
score = 90.9
if (score >= 90):print("你的等级为A")
elif (score >= 80):print("你的等级为B")
elif (score >= 70):print("你的等级为C")
elif (score >= 60):print("你的等级为D")
else:print("此次考试未通过")

`5.1.4` if判断条件探究

与关键词if相邻的条件判断语句为True，则进入if分支；否则进入else分支，这里面判断语句的值大多数情况下，是非布尔类型变量，这种情况下，就会产生一个问题，什么样的表达式的值会被当作True来看待，什么样的值会当作False来看待

# 11 - if判断条件探究
flag = True                 #True
flag = False                #Falseflag = 1                    #True
flag = 0                    #Falseflag = "Maple"              #True
flag = ""                   #Falseflag = ['Maple']            #True
flag = []                   #Falseflag = ('Mpale',)           #True
flag = ()                   #Falseflag = {'name':"Maple"}     #True
flag = {}                   #Falseif flag:print(f"{flag} means True")
else:print(f"{flag} means False")

基本原则：

大部分非布尔类型的变量都会被认为True值
少部分非布尔类型的变量会被认为False值

`5.2.` While循环

`5.2.1` 语法结构

当需要语句不断的重复执行时，可以使用while循环，while循环中语句块会连续不断的循环执行，知道表达式的值为False

当满足条件时，则执行循环体

# 12 - while循环
i = 0
while i < 10:print(i)i += 1

需要注意的问题：

需要避免死循环
计时器让while循环在恰当的时候结束

`5.3.` for循环

`5.3.1` for循环语法结构

# 13 - for 循环
s = "Maple"
for i in s:print(i)
for i in range(10):print(i)

`5.3.2` range函数

for循环常与range函数一起使用；range函数提供循环条件，完整语法为：

range(start,end,step[默认为1])

`5.3.3` 列表解析

可以使用for语句动态快速创建列表

#第一种
list(range(101))
#第二种
[i for i in range(101)]

`5.4.` 特殊流程控制语句

`5.4.1` break语句

break可以结束当前循环，跳出循环体

# 15 - break语句
while True:username = input("Please input your name:")if username == 'q':breakprint(f"Welcome,{username}!")

`5.4.2` continue语句

当触发continue语句时，程序会忽略下方语句，回到循环的顶端继续循环，意味着本次循环“轮空”

# 16 - continue语句for i in range(10):if i % 2 == 1:continueprint(i)

`6.` 函数

`6.1.` 函数介绍

`6.1.1` 函数基本概念

函数是对程序逻辑进行结构化或过程化的一种编程方法，将整块代码巧妙地隔离成易于管理的小块；把重复代码放到函数中而不是进行大量的拷贝，这样既能节省空间，也有助于保持一致性；通常函数都是用于实现某一种功能

`6.1.2` 创建函数

python中函数是用def语句来创建的，语法如下：

# 17 - 函数的定义与调用
def function_name(args):#函数体pass

标题行由def关键字，函数的名字，以及参数的集合（如果有的话）组成
def子句（函数体）的部分包括：
- (可选)，体现为字符串的函数文档（函数说明信息，以及帮助等）
- (必需）函数体

`6.1.3` 调用函数

同大多数语言相同，python用()调用函数：

~~如果没有加圆括号，就只是对函数的引用；~~
函数调用的时候，会在内存中单独开辟一段内存空间

# 17 - 函数的定义与调用
def test():print("This is func test")test()

函数调用过程：

函数被调用时，会单独开辟一段私有的内存空间
函数运行结束的之后，会回到调用函数的位置，继续向下执行

# 18 - 函数调用过程
def a():print("This is func a.")def b():print("func b is starting...")a()print("func b is stopped")
b()

`6.1.4` 前向引用

先定义后调用

>>> test()
Traceback (most recent call last):File "<stdin>", line 1, in <module>
NameError: name 'test' is not defined
>>> def test():
...     print("This is func test")
...
>>> test()
This is func test
>>>

`6.1.5` 函数返回值

多数情况下，函数并不直接打印数据，而是向调用者返回一个值

函数的返回值使用return关键字
没有return的话，函数默认返回None

  # 19 - 函数返回值def add():x = 10y = 3sum = x + yreturn sumprint(add())

`6.2.` 函数参数

`6.2.1` 定义参数

类似数学上的代数，用字母表示数。参数分为：

参数类型	说明
形式参数	函数定义时紧跟在函数名后（圆括号内）的参数称为形式参数，简称形参由于它不是实际存在变量，所以又称虚拟变量
实际参数	在主调函数中调用一个函数时函数名后面括弧中的参数（也可以是一个表达式）称为"实际参数"，简称实参

# 20 - 形参与实参def add(x,y):return x + yprint(add(10,3))

传递参数

尤其注意：调用函数时，实参的个数需要与形参个数一致
实参讲依次传递给形参
建议：实参要与形参一一对应

`6.2.2` 默认参数

# 21 - 默认参数
def add(x = 0,y = 0):print(f"x = {x}")print(f"y = {y}")return x + y
print(add())

6.2.3 关键字参数

关键字参数的概念仅仅针对函数的调用；这种理念是让调用者通过函数调用中的参数名字来区分参数；这样规范允许参数确实或者不按顺序

# 22 - 关键字参数x = 3
y = 10def add(x = 0,y = 0):print(f"x = {x}")print(f"y = {y}")return x + yprint(add(x = x,y = y))

`6.3.` 变量作用域

全局和局部的问题

`6.3.1` 局部与全局变量

局部变量

局部变量是在函数内部定义的变量，随着函数的调用而被创建，函数调用完毕之后，即销毁，由于局部变量时在函数调用后才被创建，所以其作用范围仅限于函数内部

# 23 - 局部变量
from re import X
def test():x = 10return xprint(test())
print(x)      #NameError: name 'x' is not defined.

全局变量

在函数外部定义的变量

# 24 - 全局变量
x = 10
def test():return x
print(x)

`6.3.2` 名字空间

任何时候，总有一个到三个活动的作用域(分别为全局局部和内建)；标识符（变量名，函数名）的搜索顺序一次是局部、全局和内建；提到名字空间，可以想想“看见”这个标识符

文件读取

文件读写操作：

把大象放冰箱里，一共分几步

常用函数	功能
f = open(‘PATH’)	打开指定路径的文件 f 是文件对象
f . read( )	从文件对象中读取文件内容
f . readline( )	读取一行内容
f . readlines( )	返回一个列表，元素是文件的每一行内容
f . write( )	向文件中写入内容
f . writelines( )	以列表的方式向文件中写入内容
f . close( )	关闭文件
time . sleep( )	沉睡响应的秒数

打开文件

（打开冰箱门）

>>> f = open('pass.dic')
>>> type(f)
<class '_io.TextIOWrapper'>
>>> f
<_io.TextIOWrapper name='pass.dic' mode='r' encoding='cp936'>

关闭文件

（关闭冰箱门）

>>> f.close()
>>> f.closed
True
>>>

文件对象访问模式

即访问文件的mode

访问模式	操作	说明
r	以读方式打开	文件不存在则报错
w	以写方式打开	文件存在则清空，不存在则创建
a	以追加模式打开	不存在则创建
+	以读写模式打开	如r+，w+，a+
b	以二进制模式打开	如rb，wb，ab

常用打开文件的参数：r/w/a/rb/wb/ab

读取文件

（把大象放进去或者拿出来）

>>> f = open("pass.dic",'r')
>>> f.read()
'123456\n123.com\nroot\nadmin\n88888888\n696666666\nqwerty\na1b2c3\nqazwsxedc\ntoor\n'
>>>

Tip：read方式会读取全部文档内容

Readline( ) 按行读取

Readlines( ) 读取剩余行

文件迭代

f = open("./pass.dic",'r')for i in f:print(i.strip())f.close()