视频：https://www.bilibili.com/video/BV12E411A7ZQ的笔记

Linux安装python环境

建议安装桌面linux组件

1. 到官网下载linux的tar安装包

tar -zxf Python-3.7.3.tar.xz

1. 安装需要的环境附属

yum install -y gcc zlib zlib-devel openssl-devel readline readline-develide

1. 进入解压的安装包中进行编译

./configure --prefix=/usr/local/python --with-ssl

1. 编译安装

make && make install

1. 配置环境变量

export PYTHON_HOME=/usr/local/python3.10
export PATH=${PYTHON_HOME}/bin:$PATH

此时使用命令：pyhthon3 就可以进入python3环境了。

Linux下IDE的安装

1. 到pycharm下载安装包，要是.tar结尾的！

tar -zxf pycharm

1. 进入解压的文件夹中的bin目录，执行./pycharm.sh

cd pycharm

cd bin && ./pycharm.sh

Linxu创建虚拟环境

python3 -m venv ~/mypy
source ~/mypy /bin/activate

Python语法基础

print 输出

输出

age = 18 #创建变量
print("我的名字是%s,我的国籍是%s" %("里奥","中国")) #输出占位符
print("我的年龄是:%d岁" %age) #输出变量

• %s 字符占位符
• %d 数字占位符

sep 设置输出时连接符号

print("aaa","bbb","ccc") #python会默认用 空格 连接
print("www","baidu","com",sep=".") #sep 设置连接符号

end 设置末尾操作

因为print是默认换行的，所以可以在末尾添加 end="" 进行操作和限制

print("www",end="") #取消换行
print("wuhu",end="\t") #多一段距离
print("world",end="\n")#换行

• \t 如同按一下Tab键
• \n 进行换行

input 输入

获取用户在键盘上的输入信息

password = input("请输入密码") #获取键盘的输入，并转为string
print("您输入的密码为:%s" %password)

type() 查看数据类型

type(a) 查看变量a的数据类型

a,b,c,d = 20 , 5.5 , True , 4+3a
print(type(a),type(b),type(c),type(d))
#运行:
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

类型转换

注意：布尔型转换时，true为1flase为0。

运算符

算数运算符

两个比较特殊的
>>> 2 // 4 # 除法，得到一个整数
0
>>> 2 ** 5 # 乘方
32

成员运算符

in 如果在指定的序列中找到值，返回true，否则返回false
not in 如果在指定的序列中没有找到值，返回false，否则返回true

身份运算符

is 判断两个标识符是否引用同一个对象 x is y 类似 id(x) == id(y)
is not 判断两个标识符是否引用不同对象 x is not y 类似 id(a) != id(b)

id(x) 是取对象的内存地址

逻辑运算符

and or not 与 或 非。

逻辑运算符的特殊用法：

a = 36
a < 10 and print("hello world")
#当and前面的结果是false的情况下，后面的结果不会执行。
a = 50
a > 10 or print("hello world")
#因为前面的等式成立了，所以后面的代码并不会执行

判断语句和循环语句

循环时不需要使用{} 大括号，只需使用缩进，对其即可。

: 不能缺少代表着 条件 的结束 语句 的开始。

if True:
    print("true")
else:
    print("false")

如果出现没有对齐的情况，要么报错，要么执行位置不对：

if True:
    print("qwq")
    print("qwq")
        print("false") #第四行出现错误
else:
    print("false")
   print("false")#此行少了一格，如果没有第四行
#则会直接输出，不会进行if中的判断

多重条件判断

python的if语句中的多重判断，不是else if : 而是 elif :

score = 70
if score <=100 and score >=90:
    print("考试成绩优秀")
elif score < 90 and score >=80:
    print("还可以")
else:
    print("及格")

只有在最后时，才是else，其余的多重条件判断都用elif

if嵌套

因为没了{} 所以嵌套时要注意缩进各个代码之间的位置。

并且为了方便写代码，部分编辑器在嵌套时会有提示线

xingbie = 1 
danshen = 1
if xingbie == 1:
    print("男生") #执行语句和条件语句位置一样
    if danshen == 1:
        print("我现在单身，帅哥一枚")
    else:
        print("我不是单身")
else :
    print("女生")
    if danshen == 1:
        print("我是单身，求撩啊！")
    else:
        print("我不是单身！")

随机数

import random 导入随机数库，可以使用其中的函数了！

import random #导入库
x = random.randint(0,10) #设置x为int类型的0-10的随机数
print(x)

循环语句

for循环

for i in range(5):    #从0开始到4，每次加1
    print(i)
#range():范围
for i in range(0,10,3):    #从0开始每次加3，峰值为10
    print(i)
for i in range(-10,-100,-30): #哪怕是负数都可以
    print(i)
name = 'liao'
for x in name:
    print(x,end='\t')        #是字符的话，会逐个打印字符串内容
a = ["aa","bb","cc"]        #列表也可以自动遍历
for i in a:                    #遍历列表的字符
    print(i)
for i in range(len(a)):        #遍历列表的数量+字符
    print(i,a[i])

while循环

i = 0
while i<5:
    print("当前是第%d次循环"%(i+1))
    print("i=%d"%i)
    i+=1

1-100求和

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

while中的else

当跳出while循环时，会执行的命令。

count = 0
while count < 5:
    print(count,"small than 5")
    count += 1
else:
    print(count,"no small than 5")

break，continue和pass

break：跳出for，while循环

continue：跳过当前循环，进入下一个循环

pass：空语句，常用来当做占位符，不做任何事

1-50偶数的和

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

字符串，列表，元祖，字典

String

python中字符串可以用，单引号，双引号，三引号括起来。使用反斜杠转义特殊字符。

word = '字符串'
wuhu = "这是一个芜湖"
duanluo = """
    这是   一个             段落
    我    在这里    能
    随便写
"""
print(word)
print(wuhu)
print(duanluo)

单引与双引号中的转义字符

stu = "I'm stu"
print(stu)
#I'm stu
stu = 'I\'m stu'
print(stu)        
#I'm stu
stu = "Jason said \"I like you\"".
print(stu)
#Jason said "I like you"

字符串截取

str = "liaowuhu"
print(str[2])        #取单个字符
print(str[1:])        #取第2个之后的全部字符
print(str[1:5])        #取第2到6个字符
print(str[0::3])    #取第1到之后的全部字符，每次跳3
print(str[:7:3])    #取第8个之前的全部字符，每次跳3
print(str[0:8:2])    #取第1到8个个字符，每次跳2

字符串的一些用法

#字符串的链接
print(str + ',你好')        #直接添加字符
print(str,",芜湖~")        #直接添加字符,默认会有个空格
#字符串的复制
print(str*3)             #将字符str 复制3个并打印。

转义字符

print('wewqe\nqwe')        #\n 会给字符回车
print(r'wewqe\nqwe')    #在前面加个r 会取消全部的转义字符

字符串高级用法

列表

List

• 列表可以完成大多数集合类的数据结构实现，列表中元素的类型可以不相同，他支持数字，字符，包括嵌套。
• 列表卸载方括号[]之间，用逗号分隔开的元素列表。
• 列表索引开头是以0开始，末尾是以-1开始。
• 列表可以使用 + 操作服进行拼接，用 * 表示重复。
• 当我们获得多个数据的时候，那么我们可以将它储存到列表中，然后直接列表访问。

#打印namelist
namelist = ["里奥",'liao',123,'test',1.213]
print(namelist[0])
print(namelist[3])
for name in namelist:        #for循环遍历
    print(name)
print(len(namelist))
length = len(namelist)        #获得长度值赋给length
i = 0
while i < length:
    print(namelist[i])        
    i += 1

增删改查

常用操作

index:查找第一次出现的下标，并且告诉你在列表中的位置。找不到就报错

a = ["a","as","e3","wda","das","sadc"]
print(index("wda",2,5))
#3

count:统计出现的次数

a = ["a","as","e3","wda","das","sadc","a","a"]
print(a.count("a"))
#3

reverse:将列表所有元素反转

a = ["a","as","e3","wda","das","sadc","a","a"]
a.reverse()
print(a)
#反转输出

sort:排序输出

a = [1,213,34789,67,590,556,423,316,24,6,93]
a.sort()                #正序排序
print(a)
a.sort(reverse=True)    #倒叙排序
print(a)

二维数组

schoolName = [['123',123],[123,676],["12312","56756"]]
print(schoolName[1][0])

实例：

import random
offices = [[],[],[]]
names = ["1","2","3","4","5","6","7","8"]
for name in names:
    index = random.randint(0,2)
    offices[index].append(name)
i = 1
for office in offices:
    print("office:%d number:%d"%(i,len(office)))
    i+=1
    for name in office:
        print("%s"%name,end="\t")
    print("\n")

元组

tuple与list类似，不同之处在于tuple的元素不能修改。tuple写在小括号里，元素之间用逗号隔开。

元祖的元素不可变，但可以包含可变对象。如list

tup1 = ()
print(type(tup1))    #输出tuple
tup2 = (123)        #int
tup3 = (123,)        #tuple
tup4 = (123,48,16,"aaa")    #tuple
print(tup4(0))        #123
print(tup4(-1))        #aaa
print(tup4(1:3))    #48,16,aaa

增：

• 两个元祖添加，并且赋值给另一个元祖

• tup1 = (123,1232,312)
  tup2 = ("WQe","WDs","jy")
  tup = tup1+tup2
  #(123,1232,312,"WQe","WDs","jy")

删：

• def直接删除整个元祖

  tup1 = (123,123,54)
  del tup1
  print(tup1)    #报错

改：

• 不支持直接赋值修改

  tup1=(123,12312,12312)
  tup1[0] = 123 #这是错误的

字典

• 字典是无序的对象集合，使用键-值(key-value)存储，具有极快的查找速度。
• 键(key)必须使用不可变类型
• 同一个字典中，键(key)必须是唯一的
• 爬虫中经常使用字典。

info = {"name":"liao","age":19}        #定义字典
print(info["name"])                    #字典的访问
print(info.get["gender","没有这个键"])#如果没有这个键，则返回指定字符

增：

直接添加就好了

info = {"name":"里奥","age":18}
newID= input("请输入学号:")
info["id"]=newID
print(info["id"])
print(info)
#10
#{'name': '里奥', 'age': 18, 'id': '10'}

删：

• del 删除。删除的是全部键值队。
• clear 清空。将全部键值队清空，但是字典还在。

改：

直接修改

info = {"name":"里奥","age":18}
info["age"] = 20
print(info["age"])

查：

• info.keys() #列出所有的键
• info.values() #列出所有的值
• info.items() #列出所有的项，每个键就是一个元祖

info = {"name":"里奥","age":18,"id":1}
print(info.keys())        #列出所有的键
print(info.values())    #列出所有的值
print(info.items())        #列出所有的项，每个键就是一个元祖
#打印遍历
for key,value in info.items():
    print("key=%s,value=%s"%(key,value))

枚举函数，同时获得下标和数值

mylist = ["a","b","c","d","e"]
for i,x in enumerate(mylist):
    print(i+1,x)

set集合

set和dict类似，也是一组key的组合，但是不存储value。由于key不能重复，所以在set中，没有重复的key。会去除重复。

set是无序的，重复元素在set中自动被过滤。

函数

def 函数名():
    代码

定义与调用

def printinfo():
    print("-------------------")
    print("     人生苦短，我用python   ")
    print("-------------------")
printinfo()

有参函数

def addNum(x,y):
    print(x+y)
addNum(10,20)

带返回值

def addNums(x,y):
    return x+y
print(addNums(17,29))

返回多个值

def chuyi(x,y):
    shang = x/y
    yu = x%y
    return shang,yu
chu,yu = chuyi(20,2)    #需要多个值保存返回内容
print(chu,yu)

全局变量和局部变量

在函数中的全局变量使用global 进行修改，并且之后使用会生效。

lambda

sum = lambda x,y:x+y
print(sum(7,6))

lambda操作简单，适合实现一些简单的函数操作

eval

num = 10
result = eval("3 * num")
print(result)
list_str = "[1,2,3]"
tuple_str = "(1,2,4)"
dict_str = "{1:'wd',2:'dsad',3:'qwed'}"
list_eval = eval(list_str)
tuple_eval = eval(tuple_str)
dict_eval = eval(dict_str)
print("[list]序列数据：%s,序列类型%s"%(list_eval,type(list_eval)))
print("[tuple]序列数据：%s,序列类型%s"%(tuple_eval,type(tuple_eval)))
print("[dict]序列数据：%s,序列类型%s"%(dict_eval,type(dict_eval)))

eval可以不用进行强制转换，运行字符串中的程序代码。但是只能解析其中的单个字符串的信息

exec

作用和eval差不多，但是可以进行多行的字符串操作

文件操作

打开/创建文件

f = open("test.txt","w")        #打开文件，文件不存在，就新建。
f.close()

访问模式

给文件内容编辑

#写入
f = open("test.txt","w")
f.write("芜湖~~")
f.close()                #必须执行关闭，才会保存你的操作。
#读    开始时定位在文件头部，每次执行一次向后移动指定字符数
f = open("test.txt","r")
content = f.read(3)        #读取5个字符
print(content)
f.close()
#一次读取全部信息
f = open("test.txt","r")
content = f.readlines()        #读取全部内容为列表
i = 1
for temp in content:
    print(i,temp)
    i+=1
f.close()
#读取单行信息
f = open("test.txt","r")
content = f.readline()
print(content)
content = f.readline()
print(content)
content = f.readline()
print(content)
content = f.readline()
print(content)
f.close()

文件的序列化和反序列化

默认情况下，我们只能将字符串写入到文件中。所以无法写入对象。不过可以通过序列化写入到文件中。

序列化的两种方式

import json

dumps():将对象转换为字符串

import json
#导入json模块到文件中，序列化
f=open('test.txt',"w")
#创建文件
name = ["QWeqw",123123,"xcawe"]
#定义一个列表
name_list = json.dumps(name)
#将python对象变成json的字符串
print(type(name_list))
f.write(name_list)
#将转换后的对象写入到文件中
f.close()

dump():在将对象转换为字符串的同时，指定一个文件夹的对象，然后把转换后的字符串写入到这个文件里。

import json
#导入json包
f = open('test.txt','w')
name_list = ["wqexz",'vwer',12321]
json.dump(name_list,f)
#将name_list转换为str，并且写入到文件f中
f.close()

反序列化

将json字符串转换为python对象

json.loads()

import json
fp = open("test.txt","r")
a = fp.read()
#读取文件
print(a)
print(type(a))
#读取文件类型 str
b = json.loads(a)
#将json字符串转换为python对象
print(type(b))
fp.close()

json.load()

import json
fp = open("test.txt","r")
a = json.load(fp)
#直接写文件
print(a)
print(type(a))
fp.close()

OS模块

import os
os.rename("test.txt","test123.txt")        #修改名称
os.mkdir("fild")                        #创建文件夹
os.getcwd                                #获取当前目录
os.remove("test123.txt")                #删除文件
os.chdir("../")                            #改变默认目录
os.listdir("./")                        #获取目录列表
os.rmdir("fild")                        #删除文件夹

错误与异常

错误：不可预料，不可知的。当出现错误，后面代码无法继续执行。

异常：可预料，能改变的。

异常捕获

#单个异常捕获
try:
    print("-"*30)
    f=open("123.txt","r")        #只读模式，打开文件。此时文件不存在，会报错
    print("*"*30)
except IOError:                    #如果是IOError的报错
    pass                        #捕获异常，使用pass占位报错。
#多个异常捕获
try:
    print(num)
except (NameError,IOError):        #将可能的错误都放到小括号中
    print("出现了名称错误")

错误信息提示

try:
    print(num)
except (NameError,IOError) as result:        #将错误提示赋值给result
    print("出现了名称错误")
    print(result)
#name 'num' is not defined

Execption

Exception 所有异常的父类，不知道写哪个异常，用它就对了。

finally与嵌套

finally：不管有没有报错，都是会执行的。

import time
try:
    f = open("123.txt","r")            #尝试读取123.txt
    try:
        while True:                    #一直循环
            content = f.readline()    #content等于文件的行
            if len(content) == 0:    #如果没有值,当无法被赋值，则退出
                break
            time.sleep(2)
            print(content)
    finally:
        f.close()
        print("文件关闭")
except Exception:
    print("发生异常")
finally:
    print("文件关闭")

python爬虫

准备工作

首行代码，使得代码包含中文。

 #-*- codeing = utf-8 -*-

加入main函数用于测试程序

if _name_ == "_main_"

当程序被调用执行时，先从该代码块执行

从其他文件夹导入类

from 文件夹名 import 类名
from test1 import t1

常用包

import bs4                            #网页解析，获取数据
import re                            #正则表达式，网页匹配
import urllib.request,urllib.error    #制定url，获取网页内容
import xlwt                            #进行Excel操作
import sqlite3                        #进行sqlite数据库操作

爬虫流程

• 爬取网页

baseurl = "https://movie.douban.com/top250?start="    #设置url
def getdata(baseurl):
    datalist = []
    #逐一解析数据
    return datalist
datalist = getdata(baseurl)        #爬取网页

• 解析数据
• 保存数据

savepath=r".\豆瓣电影top250.xls"
saveDate(savepath)
def saveDate(savepath):

获取数据

#得到指定的一个url网页内容
def askURL(url):    
    #首先指定头部信息,设置用户代理，告诉服务器我们是什么类型的机器。
    head = {    #模拟浏览器
        "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36 Edg/94.0.992.50"
    }
    url

from bs4 import BeautifulSoup
import urllib.request
import urllib.error
import sqlite3
import xlwt
import re
def main():
    baseurl = "https://movie.douban.com/top250?start="    #设置url
    datalist = getdata(baseurl)  # 爬取网页
    savepath = r".\豆瓣电影top250.xls"
    #saveDate(savepath)
    askURL("https://movie.douban.com/top250?start=")
def getdata(baseurl):
    datalist = []
    #逐一解析数据
    return datalist
#得到指定的一个url网页内容
def askURL(url):    #首先指定头部信息
    head = {
        "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.81 Safari/537.36 Edg/94.0.992.50"
    }
    requests = urllib.request.Request(url,headers=head)
    html = ""
    try:
        response = urllib.request.urlopen(requests)
        html = response.read().decode("utf-8")
        print(html)
    except urllib.error.URLError as e :
        if hasattr(e,"code"):
            print(e.code)
        if hasattr(e,"reason"):
            print(e.reason)
    #return  html
def saveDate(savepath):
    print() 
if __name__ == '__main__':
    main()

urllib

获取baidu的页面代码

import urllib.request
#1.定义一个url，就是你需要访问的数据
url = 'http://www.baidu.com'
#2.模拟浏览器向服务器发送请求，此时服务器会给你一个响应反馈
#response 响应
response = urllib.request.urlopen(url)
#3获取响应中的页面源码
#content内容
#read方法 返回字节形式的二进制数据。要将二进制的数据转换为字符串
#二进制 -》字符串 解码 decode('编码格式')
content = response.read().decode('utf-8')
#4打印数据
print(content)

1个类型和6个方法

import urllib.request
url = 'http://www.baidu.com'
response = urllib.request.urlopen(url)
#模拟浏览器想服务器发送请求
#一个类型和六个方法
#print(type(response))
#<class 'http.client.HTTPResponse'>
#按照一个字节一个字节的读
content = response.read(5)
print(content)
#读取一行
content = response.readline()
print(content)
#读取全部
content = response.readlines()
print(content)
#返回状态码 200就是没问题
print(response.getcode())
#返回url地址
print(response.geturl())
#获取一些状态信息
print(response.getheaders())

下载图片/视频/网页

import urllib.request
#下载网页
url = 'http://www.baidu.com'
#url代表下载路径，filename文件的名字
urllib.request.urlretrieve(url,'baidu.html')
#下载图片
url_img = 'https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fb-ssl.duitang.com%2Fuploads%2Fitem%2F201608%2F20%2F20160820091644_etiFR.jpeg&refer=http%3A%2F%2Fb-ssl.duitang.com&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg?sec=1638861798&t=667fc36288ddaf4cb6dd24d9cd129af8'
urllib.request.urlretrieve(url_img,'leimu.jpg')
#下载视频
url_video = 'https://vd3.bdstatic.com/mda-mjvdqf1qkkijh90e/sc/cae_h264_clips/1635589295180348540/mda-mjvdqf1qkkijh90e.mp4?auth_key=1636271907-0-0-3d7d201b6754c7c0d6fd76f777c0b472&bcevod_channel=searchbox_feed&pd=1&pt=3&abtest='
urllib.request.urlretrieve(url_video,'test.mp4')

请求对象的定制

大部分网站都是https的协议，这个自带一个反爬。需要在爬时，添加请求头，使用Request方法。

URL = 'https://www.baidu.com'
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36 Edg/95.0.1020.40"
}
#正常来说，咱们使用urlopen。会被https反爬，此时需要用到Request，将header添加进来
response = urllib.request.urlopen(url)
#因为urlopen的方法中，不能存储字典，所以header不能传进去
#请求对象的定制
request = urllib.request.Request(url=URL,headers=headers)
response = urllib.request.urlopen(request)
content = response.read().decode('utf8')
print(content)

Get请求的quote方法

import urllib.request
import urllib.parse #该库用来设置quote
#获取该网页的源码，此时wd=后面没有写东西
URL = 'https://www.baidu.com/s?wd='
#设置请求头
headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36 Edg/95.0.1020.40"
}
#将 蕾姆 变成unicode编码的格式
#我们将依赖urllib.parse
name = urllib.parse.quote('蕾姆')
URL = URL + name
#请求对象定制
request = urllib.request.Request(url=URL,headers=headers)
#模拟浏览器想服务器发送请求
response = urllib.request.urlopen(request)
#获取响应的内容
content = response.read().decode('utf-8')
print(content)

Get请求的urlencode方法

有时候会有很多的字符需要转换成unicode编码

import urllib.request
import urllib.parse
#获取该网页的源码
URL = 'http://www.baidu.com/s?'
#将字符转换成unicode编码
data = {
    'wd':'蕾姆',
    'sex':'女',
    'location':'异世界'
}
new_data = urllib.parse.urlencode(data)
url = URL + new_data
header = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36 Edg/95.0.1020.40"
}
#请求对象的定制
requests = urllib.request.Request(url=url,headers=header)
#模拟浏览器想服务器发送请求
response = urllib.request.urlopen(requests)
#获取网页源码的数据
content = response.read().decode('utf-8');
print(content)

Post请求百度翻译①

post请求的参数，是不会拼接在url后面的 而是需要放在请求对象定制的参数中

设置请求头——设置post请求数值——将请求参数进行编码——模拟浏览器发送请求——请求对象的定制——模拟浏览器想服务器发送请求——获取响应的数据——将响应的数据转换为python变量

import urllib.request
import urllib.parse
import json
url = 'https://fanyi.baidu.com/sug'    #设置url
header = {        #设置请求头
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36 Edg/95.0.1020.40"
}
data = {
    'kw':'apple'
}
#post的请求的参数必须要进行编码
data = urllib.parse.urlencode(data).encode('utf-8')
#post请求的参数，是不会拼接在url后面的 而是需要放在请求对象定制的参数中
#post请求的参数，必须要执行编码
#请求对象的定制
requests = urllib.request.Request(url=url,data=data,headers=header)
#模拟浏览器向服务器发送请求
response = urllib.request.urlopen(requests)
#获取响应的数据
content = response.read().decode('utf-8')
print(content)  #此时还是json对象
#post请求的参数 必须编码      data = urllib.parse.urlencode(data)
#编码之后必须调用encode方法   data = urllib.parse.urlencode(data).encode('utf-8')
#参数是放在请求对象定制的方法中 requests = urllib.request.Request(url=url,data=data,headers=header)
a = json.loads(content)
print(a)

Post请求百度翻译②

import urllib.request
import urllib.parse
import json
url = "https://fanyi.baidu.com/v2transapi?from=en&to=zh"
header = {
'Cookie': 'FANYI_WORD_SWITCH=1; REALTIME_TRANS_SWITCH=1; SOUND_SPD_SWITCH=1; HISTORY_SWITCH=1; SOUND_PREFER_SWITCH=1; Hm_lvt_64ecd82404c51e03dc91cb9e8c025574=1636282101,1636283407; BAIDUID_BFESS=D97104299B0231E843C8B065363FA834:FG=1; BAIDUID=D97104299B0231E852C4592CEFEF4223:FG=1; Hm_lpvt_64ecd82404c51e03dc91cb9e8c025574=1636285675; __yjs_duid=1_2528c66efbdff8f58d954589e0c966b71636285675145; __yjs_st=2_Y2Q2YzJkOGVlZGUzYTNlNzAyMGFkMDZhNDA3YjM1YTA2MjUwNTA4M2MwZDU1MTQ2ODc5YjkwMDNjN2YwMTgwZWIzMGJkNzI5M2RiMWVjMjkzYzI5NzU5ZDhiN2EyODA3MzA3MzkyMWMzOWJiMDYwODRkYjlhNTkzZGViOWVhMTdmMTNhZDRiYWU4NzRkOGU1NzI1MjA5MGYzYTZlNzQyZTU4MThkNjg5MTU0NGRkNzk5NDRmZWEyZmE0NTZkODMzYjMyYTNhMGE5ZmE5YTY1ODQwNTFkZDI4MzI1OTgwZTczOTQ5ODE3YTAzYTk0OWI4MDg3Y2I1YTY2NDZjZDFmNl83X2I3ZDViNWY0; ab_sr=1.0.1_MWYyYjA3ZjgyNzIwNmQyNTdhZTNlNzYzODgxZDYwZWQ2OThlMzJmMjc0ZWIxYjdlYjE0ZGJhZDQ0OTk1MmY3NGJiNzk0NDU2MjVjMDI3N2Y3ZDM0YzRlZTgxYTg5NTE2MmUyZTFlOGVmYjcyMjg2ZTFkYjJiYWZjZmY2OTVhNWRkMWJjNjhkMzI0YzkzM2U4N2I0ZjliYmNlZDg5NzFiNQ==',
'User-Agent':' Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36 Edg/95.0.1020.40',
}
data = {
"from": "en",
"to": "zh",
"query": "eat",
"transtype":"realtime",
"simple_means_flag": 3,
"sign": "25728.296881",
"token": "f2f58e3277099aae3d46dad701d019a8",
"domain": "common",
}
#post请求的参数
data = urllib.parse.urlencode(data).encode('utf-8')
#请求对象定制
request = urllib.request.Request(url = url,data = data,headers = header)
#模拟浏览器向服务器发送请求
response = urllib.request.urlopen(request)
#获取响应的数据
content = response.read().decode('utf-8')
a = json.loads(content)
print(a)

ajax的get请求①

爬取豆瓣电影的第一页

import urllib.request
url = 'https://movie.douban.com/j/chart/top_list?type=5&interval_id=100%3A90&action=&start=0&limit=20'
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
}
# (1) 请求对象的定制
request = urllib.request.Request(url=url,headers=headers)
# （2）获取响应的数据
response = urllib.request.urlopen(request)
content = response.read().decode('utf-8')
# open方法默认情况下使用的是gbk的编码  如果我们要想保存汉字 那么需要在open方法中指定编码格式为utf-8
# encoding = 'utf-8'
fp = open('douban1.json','w',encoding='utf-8')
fp.write(content)
with open('douban1.json','w',encoding='utf-8') as fp:
    fp.write(content)

ajax的get请求②

import urllib.request
import urllib.parse
def create_request(page):
    base_url = 'https://movie.douban.com/j/chart/top_list?type=5&interval_id=100%3A90&action=&'
    #设置url
    data = {
        'start':(page - 1)*20,
        'limit':20
    }
    #设置get请求数据
    header = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
    }
    data = urllib.parse.urlencode(data)        #将get数据转换编码
    url = base_url + data
    request = urllib.request.Request(url=url,headers=header)    #请求对象定制
    return request
def get_content(request):
    #模拟浏览器向服务器发送请求
    response = urllib.request.urlopen(request)
    #获取响应的数据
    content = response.read().decode('utf-8')
    return content
def down_load(page,content):
    #str(page) page本来是int形，需要强制转换为str
    with open("douban" + str(page) + '.json','w',encoding='utf-8') as fp:
        fp.write(content)
#程序入口
if __name__ == '__main__':
    start_page = int(input('起始的页码'))
    #先获取起始和结束的页码
    end_page = int(input('结束的页码'))
    for page in range(start_page,end_page + 1):
        request = create_request(page)
        #获取响应的数据
        content = get_content(request)
        down_load(page,content)

ajax的post请求

import urllib.request
import urllib.parse
def create_request(page):
    base_url = 'http://www.kfc.com.cn/kfccda/ashx/GetStoreList.ashx?op=cname'
    data = {
        "cname": "郑州",
        "pid":"",
        "pageIndex": page,
        "pageSize": 10,
    }
    data = urllib.parse.urlencode(data).encode('utf-8')
    header = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.159 Safari/537.36'
    }
    request = urllib.request.Request(url=base_url,data=data,headers=header)
    return request
def get_content(request):
    reponse = urllib.request.urlopen(request)
    content = reponse.read().decode('utf-8')
    return content
def down_load(page,content):
    with open('kfc_' + str(page) +'.json','w',encoding='utf-8') as fp:
        fp.write(content)
if __name__ == '__main__':
    star_page = int(input('请输入起始页码'))
    end_page = int(input('请输入结束页码'))
    for page in range(star_page,end_page+1):
        #请求对象的定制
        request = create_request(page)
        #获取网页源码
        content = get_content(request)
        #下载
        down_load(page,content)

cookie登录

#适用场景：数据采集的时候，需要绕过登录，然后进入到某个页面
#个人信息的页面是utf-8 但还是报错了编码错误，因为并没有进入到个人信息页面，而是进入到了登录界面
import urllib.request
import urllib.parse
url = 'https://weibo.cn/6872551356/info'
header = {
'cookie':' SUB=_2A25MjWedDeRhGeBG7FAU9S_PzjqIHXVvjgnVrDV6PUJbktCOLXfakW1NQe-etiou_OIg_KitV9VcRpKy7ytNczHc; SUBP=0033WrSXqPxfM725Ws9jqgMF55529P9D9WF1PU1h6j8LkpZp6uVUOUjn5NHD95Qc1hMESK-pe0-cWs4DqcjPi--4iKnNiKyhi--fi-2fi-2fqgY7eK2t; SSOLoginState=1636374477; _T_WM=37a11b096a235bbb73e9bf73cb5c1690',
#防盗链 判断当前是否从上一个路径进来的 一般是作用图片的防盗链
'referer': 'https://weibo.cn/',
'user-agent':' Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36 Edg/95.0.1020.44'
}
#请求对象定制
request = urllib.request.Request(url=url,headers=header)
#模拟浏览器向服务器发送请求
response = urllib.request.urlopen(request)
#获取响应的数据
content = response.read().decode('utf-8')
#将数据保存到本地
with open('weibo.html','w',encoding='utf-8')as fp:
    fp.write(content)

handler处理的基本使用

#使用handler来访问百度
import urllib.request
import urllib.parse
base_url = 'http://www.baidu.com/s?ie=utf-8&wd=ip'
header = {
    "User-Agent": "Mozilla / 5.0(Windows NT 10.0;Win64;x64) AppleWebKit / 537.36(KHTML, likeGecko) Chrome / 95.0.4638.69Safari / 537.36Edg / 95.0.1020.44"
}
#请求对象定制
request = urllib.request.Request(url=base_url,headers=header)
#handler    builder_opener      open
#1，获取handler对象
handler = urllib.request.HTTPHandler()
#2，通过hendler获得opener对象
opener = urllib.request.build_opener(handler)
#3，调用open方法
response = opener.open(request)
#4，获取响应数据
content = response.read().decode('utf-8')
print(content)

handler访问百度

#使用handler来访问百度
import urllib.request
import urllib.parse
base_url = 'http://www.baidu.com/s?ie=utf-8&wd=ip&usm=3&rsv_idx=2&rsv_page=1'
header = {
    "User-Agent": "Mozilla / 5.0(Windows NT 10.0;Win64;x64) AppleWebKit / 537.36(KHTML, likeGecko) Chrome / 95.0.4638.69Safari / 537.36Edg / 95.0.1020.44"
}
#请求对象定制
request = urllib.request.Request(url=base_url,headers=header)
#模拟浏览器访问服务器
#response = urllib.request.urlopen(request)
proxies = {
    'http':'112.194.204.79:8085'
}
handler = urllib.request.ProxyHandler(proxies=proxies)
opener = urllib.request.build_opener(handler)
response = opener.open(request)
#获取响应的信息
content = response.read().decode('utf-8')
with open('daili.html','w',encoding='utf-8') as fb:
    fb.write(content)

handler代理池

import urllib.request
import urllib.parse
import random
proxies_pool = [                        #选择性代理
    {'http':'221.125.138.189:8193'},
    {'http':'222.78.6.190:8083'},
]
proxies = random.choice(proxies_pool)
base_url = 'http://www.baidu.com/s?ie=utf-8&wd=ip'
header = {
    "User-Agent": "Mozilla / 5.0(Windows NT 10.0;Win64;x64) AppleWebKit / 537.36(KHTML, likeGecko) Chrome / 95.0.4638.69Safari / 537.36Edg / 95.0.1020.44"
}
#请求对象定制
request = urllib.request.Request(url=base_url,headers=header)
#获取handler对象
handler = urllib.request.ProxyHandler(proxies)
#通过hendler获得opener对象
opener = urllib.request.build_opener(handler)
#调用open方法
response = opener.open(request)
#获得响应数据
content = response.read().decode('utf-8')
with open('daile1.html','w',encoding='utf-8') as fp:
    fp.write(content)

xpath解析

xpath基本语法：
1.路径查询
    //:查找所有子孙节点，不考虑层级关系(找寻他的所有子节点)
    /:找直接子节点(找寻一层节点)
2.谓词查询
    //div[@id="test"]    #查找id为test的值
3.属性查询
    //@class    #查找带有class属性的的值
4.模糊查询
    //div[containse(@id,"he")]
    //div[starts-with(@id,"he")]
5.内容查询
    //div/h1/text()
6.逻辑运算
    //div[@id="head" and @class="s_down"]
    //title | //price

例子：

from lxml import etree
#lxml解析
#1.本地文件                                                 etree.parse
#2.服务器响应数据  response.read().decode('utf-8') 常用!      etree.HTML()
#xpath解析本地文件
tree = etree.parse('test.html')
print(tree)
#tree.xpath('xpath路径')
# #查找ul下面的li
li_list = tree.xpath('//body/ul/li')
#查找所有有id的属性li标签
#text() 获取标签内容
li_list = tree.xpath('//ul/li[@id]/text()')
#找到id为l1的li标签
li_list = tree.xpath('//ul/li[@id="l1"]/text()')
#查找到id为l1的li标签的class属性值
li_list = tree.xpath('//ul/li[@id="l1"]/@class')
#查询id中包含l的li标签
li_list = tree.xpath('//ul/li[contains(@id,"l")]/text()')
#查询id的值，以l开头的li标签
li_list = tree.xpath('//ul/li[starts-with(@id,"c")]/text()')
#查询id为l1和class为c1的标签
li_list = tree.xpath('//ul/li[@id="l1" and @class="c1"]/text()')
#判断列表的长度
print(li_list)
print(len(li_list) )

获得百度搜索中的百度一下

# -*- coding: utf-8 -*-
#1.获取百度源码
#2.解析   解析服务器响应的文件
#3.打印
import urllib.request
import urllib.parse
from lxml import etree
url = 'https://www.baidu.com/'
header = {
    "User-Agent": "Mozilla / 5.0(Windows NT 10.0;Win64;x64) AppleWebKit / 537.36(KHTML, likeGecko) Chrome / 95.0.4638.69Safari / 537.36Edg / 95.0.1020.44"
}
#请求对象定制
request = urllib.request.Request(url=url,headers=header)
#模拟浏览器访问服务器
response = urllib.request.urlopen(request)
#获取网页源码
content = response.read().decode('utf-8')
#解析网页源码，获取我们想要的数据
#解析服务器相应的文件
tree = etree.HTML(content)
#获取想要的数据    xpath返回值是列表数据
result = tree.xpath('//input[@id="su"]/@value')[0]
print(result)

爬取站长之家图片

# -*- coding: utf-8 -*-
import urllib.request
import urllib.parse
from lxml import etree
#1.请求对象定制
#2.获取网页源码
#3.下载
#需求：获取前十页的图片
#https://sc.chinaz.com/tu/qinglvtupian.html
#https://sc.chinaz.com/tu/qinglvtupian-2-0-0.html
def create_request(page):
    if(page == 1):
        url = "https://sc.chinaz.com/tu/qinglvtupian.html"
    else:
        url =  "https://sc.chinaz.com/tu/qinglvtupian-"+str(page)+"-0-0"+".html"
    header = {
    "User-Agent": "Mozilla / 5.0(Windows NT 10.0;Win64;x64) AppleWebKit / 537.36(KHTML, likeGecko) Chrome / 95.0.4638.69Safari / 537.36Edg / 95.0.1020.44"
}
    request = urllib.request.Request(url=url,headers=header)
    return request
def get_content(request):
    response=urllib.request.urlopen(request)
    content = response.read().decode('utf-8')
    return content
def down_load(content):
    #下载图片，并不是下载页面
    #urllib.request.urlretrieve("图片地址","文件名称")
    tree = etree.HTML(content)
    name_list = tree.xpath('//div[@id="ulcontent"]//a/img/@alt')
    #一般涉及到图片的网站，涉及到懒加载(此时是src2)
    src_list = tree.xpath('//div[@id="ulcontent"]//a/img/@data-src')
    for i in range(len(name_list)):
        name = name_list[i]
        src = src_list[i]
        src1 = src.replace('\\','/')
        print(src1)
        url = "https:"+src1
        urllib.request.urlretrieve(url=url,filename='./picture/'+name+".jpg")
if __name__ == '__main__':
    start_page=int(input("请输入起始页码"))
    end_page=int(input("请输入结束页码"))
    for page in range(start_page,end_page+1):
        #1.请求对象定制
        request = create_request(page)
        #2.获取网页源码
        content = get_content(request)
        #3.下载
        down_load(content)

jsonpath

{ "store": {
    "book": [
      { "category": "reference",
        "author": "Nigel Rees",
        "title": "Sayings of the Century",
        "price": 8.95
      },
      { "category": "fiction",
        "author": "Evelyn Waugh",
        "title": "Sword of Honour",
        "price": 12.99
      },
      { "category": "fiction",
        "author": "Herman Melville",
        "title": "Moby Dick",
        "isbn": "0-553-21311-3",
        "price": 8.99
      },
      { "category": "fiction",
        "author": "J. R. R. Tolkien",
        "title": "The Lord of the Rings",
        "isbn": "0-395-19395-8",
        "price": 22.99
      }
    ],
    "bicycle": {
      "color": "red",
      "author": "liao",
      "price": 19.95
    }
  }
}