python——爬虫与脚本_python爬虫脚本

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特点

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
1
2
3
4

2.2.3开发工具

• Vscode
• pycharm
• …

3. Python初识

py官方参考文档

3.1. py语法结构

3.1.1 基本输出

# 01-基本输出 
print("Hello World")
1
2
'
运行
运行

3.1.2 注释

# 02-注释方法
'''
	这是注释
'''
"""
	这也是注释
"""
1
2
3
4
5
6
7
'
运行
运行

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")
1
2
3
4
5
'
运行
运行

3.2. python变量

3.2.1 变量

​ 变量名称约定：

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

一般变量的使用过程

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

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

3.2.2 变量赋值

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

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

username = 2022

print("Welcome," + username)
print("Welcome,{}!".format(username))
print(f"Welcome,{username}!")
1
2
3
4
5

赋值运算符

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

​ Python也支持链式多重赋值

>>> x=y=10
>>> x
10
>>> y
10
>>>
1
2
3
4
5
6

增量赋值

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

>>> x=3
>>> x=x+1
>>> x
4
>>> x ++
  File "<stdin>", line 1
    x ++
        ^
SyntaxError: invalid syntax
>>> x+=1
>>> x
5
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13

多元赋值

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

>>> x,y,z=1,2,3
>>> x
1
>>> y
2
>>> z
3
>>>
1
2
3
4
5
6
7
8

3.2.3 捕获输入

​ 根据用户的输入打印信息

username = input("Please input your name:")
print("Welcome," + username)
1
2
'
运行
运行

3.3. 运算符

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

3.3.1 算术运算符

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

3.3.2 比较运算符

>>> 10 =='10'
False
1
2

3.3.3 逻辑运算符

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']
1
2
3
4
5

3.4.2 builtins

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

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

内置函数

​ 保留的常量：

• True
• False
• None

3.5. 基本风格

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

#！/usr/bin/env python3
# -*- coding:gbk -*-                            #起始行
'this is a test module'                         #模块文档字符串

import sys                                      #导入模块
import os

debug = True                                    #全局变量声明
class FooClass(object):                         #类定义
    'Foo class'
    pass

def test():                                     #函数定义
    "test function"
    foo = Fooclass()
    
if __name__ == '__main__':                      #程序主体
    test()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.变量类型

“一切皆对象”

4.1. 对象

4.1.1 py对象特征

Python对象特征

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

4.1.2 Python对象属性方法

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

4.2. 数字

4.2.1 基本数字类型

4.2.2 进制间转换

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

4.2.3 数字类型函数

4.2.4 仅用于整数的函数

4.3. 字符串

4.3.1 字符串定义

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

username = 'Maple'

username = "Maple"

username = '''Maple'''

username = """Maple"""

print(username)
1
2
3
4
5
6
7
8
9
'
运行
运行

4.3.2 字符串拼接

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

username = "Maple"
print("Welcome," + username)
1
2
'
运行
运行

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

>>> username = "Maple"
>>> username * 3
'MapleMapleMaple'
>>>
1
2
3
4

4.3.3 字母与ASCII

4.3.4 字符串操作

4.3.5 字符串格式化输出

​ f 修饰符，新特性

>>> username = 'Maple'
>>> f"Welcome,{username}"
'Welcome,Maple'
>>>
1
2
3
4

4.3.6 字符串常用内建函数

4.4. 列表

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

4.4.1 列表的定义

# 09-列表的定义

stu1 = ['张三',True,24,59.9]
stu2 = ['李四',True,25,61.9]
stu3 = ['王五',True,25,99.9]
1
2
3
4
5
'
运行
运行

4.4.2 列表元素访问

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

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
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4.4.4 用于作用列表的函数

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

4.4.5 列表内建函数

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
>>>
1
2
3
4
5
6
7
8
9
10
11
12
13

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'>
>>>
1
2
3
4

4.6.2 创建字典

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

4.6.3 访问字典元素

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

>>> stu1['score']
89.9
>>> stu1['score'] += 0.1
>>> stu1['score']
90.0
>>>
1
2
3
4
5
6

4.6.4 更新字典元素

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

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

4.6.5 用作于字典的函数

4.6.6 字典的内建方法

5. 流程控制

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

5.1. 条件分支

​ 如果…，则…，否则…

​ 通过if语句进行分支

5.1.1 单向条件分支

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

# 08 - 单项条件分支
score = 99.9
if score >=60:
    print('Congratulations!')
1
2
3
4
'
运行
运行

5.1.2 双向条件分支

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

# 09 - 双项条件分支
score = 99.9
if score >=60:
    print('Congratulations!')
else:
    print('you cant pass!')
1
2
3
4
5
6
'
运行
运行

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("此次考试未通过")
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

5.1.4 if判断条件探究

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

# 11 - if判断条件探究
flag = True                 #True
flag = False                #False

flag = 1                    #True
flag = 0                    #False

flag = "Maple"              #True
flag = ""                   #False

flag = ['Maple']            #True
flag = []                   #False

flag = ('Mpale',)           #True
flag = ()                   #False

flag = {'name':"Maple"}     #True
flag = {}                   #False

if flag:
    print(f"{flag} means True")
else:
    print(f"{flag} means False")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
'
运行
运行

基本原则：

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

5.2. While循环

5.2.1 语法结构

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

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

# 12 - while循环
i = 0
while i < 10:
    print(i)
    i += 1
1
2
3
4
5
'
运行
运行

​ 需要注意的问题：

• 需要避免死循环
• 计时器让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)
1
2
3
4
5
6
'
运行
运行

5.3.2 range函数

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

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

5.3.3 列表解析

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

#第一种
list(range(101))
#第二种
[i for i in range(101)]
1
2
3
4
'
运行
运行

5.4. 特殊流程控制语句

5.4.1 break语句

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

# 15 - break语句
while True:
    username = input("Please input your name:")
    if username == 'q':
        break
    print(f"Welcome,{username}!")
1
2
3
4
5
6

5.4.2 continue语句

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

# 16 - continue语句

for i in range(10):
    if i % 2 == 1:
        continue
    print(i)
1
2
3
4
5
6
'
运行
运行

6. 函数

6.1. 函数介绍

6.1.1 函数基本概念

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

6.1.2 创建函数

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

# 17 - 函数的定义与调用
def function_name(args):
    #函数体
    pass
1
2
3
4
'
运行
运行

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

6.1.3 调用函数

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

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

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

test()
1
2
3
4
5
'
运行
运行

​ 函数调用过程：

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

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

def b():
    print("func b is starting...")
    a()
    print("func b is stopped")
b()
1
2
3
4
5
6
7
8
9
'
运行
运行

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
>>>
1
2
3
4
5
6
7
8
9
10

6.1.5 函数返回值

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

• 函数的返回值使用return关键字

• 没有return的话，函数默认返回None

•   # 19 - 函数返回值
    def add():
        x = 10
        y = 3
        sum = x + y
        return sum
    print(add())
  1
  2
  3
  4
  5
  6
  7

6.2. 函数参数

6.2.1 定义参数

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

# 20 - 形参与实参

def add(x,y):
    return x + y

print(add(10,3))
1
2
3
4
5
6
'
运行
运行

​ 传递参数

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

6.2.2 默认参数

# 21 - 默认参数
def add(x = 0,y = 0):
    print(f"x = {x}")
    print(f"y = {y}")
    return x + y
print(add())
1
2
3
4
5
6
'
运行
运行

6.2.3 关键字参数

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

# 22 - 关键字参数

x = 3
y = 10

def add(x = 0,y = 0):
    print(f"x = {x}")
    print(f"y = {y}")
    return x + y

print(add(x = x,y = y))
1
2
3
4
5
6
7
8
9
10
11
'
运行
运行

6.3. 变量作用域

​ 全局和局部的问题

6.3.1 局部与全局变量

局部变量

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

# 23 - 局部变量
from re import X
def test():
    x = 10
    return x

print(test())
print(x)      #NameError: name 'x' is not defined.
1
2
3
4
5
6
7
8

全局变量

​ 在函数外部定义的变量

# 24 - 全局变量
x = 10
def test():
    return x
print(x)
1
2
3
4
5
'
运行
运行

6.3.2 名字空间

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

文件读取

文件读写操作：

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

打开文件

（打开冰箱门）

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

关闭文件

（关闭冰箱门）

>>> f.close()
>>> f.closed
True
>>>
1
2
3
4

文件对象访问模式

即访问文件的mode

常用打开文件的参数：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'
>>>
1
2
3
4

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

Readline( ) 按行读取

Readlines( ) 读取剩余行

文件迭代

f = open("./pass.dic",'r')

for i in f:
    print(i.strip())

f.close()
1
2
3
4
5
6

后续会更新。。。。。。

## Linux Shadow文件读破解

文件写入

write()和writelines()方法

模块介绍

自定义模块

第三方模块

tarfile模块解决

修正index函数问题

python异常处理

所有异常处理

内网主机存活检测程序

类的介绍

类的使用

request模块

re模块

网页信息爬取

request get&post方法

request其他用法

base64&string模块

phpstudy exp编写