csdn推荐
SyntaxError
Python 语法错误
TypeError
对类型无效的操作
ValueError
传入无效的参数
ZeroDivisionError
除(或取模)零 (所有数据类型)
10.3 捕获多个异常
#coding=utf-8
try:
print('-----test--1---')
open('123.txt','r') # 如果123.txt文件不存在，那么会产生 IOError 异常
print('-----test--2---')
print(num)# 如果num变量没有定义，那么会产生 NameError 异常
except (IOError,NameError):
#如果想通过一次except捕获到多个异常可以用一个元组的形式
10.4 获取异常的信息描述
10.5 try…finally…
在程序中，如果一个段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用finally。 比如文件关闭，释放锁，把数据库连接返还给连接池等
import time
try:
f = open('test.txt')
try:
while True:
content = f.readline()
if len(content) == 0:
break
time.sleep(2)
print(content)
except:
#如果在读取文件的过程中，产生了异常，那么就会捕获到
#比如 按下了 ctrl+c
pass
finally:
f.close()
print('关闭文件')
except:
print("没有这个文件")
test.txt文件中每一行数据打印，但是我有意在每打印一行之前用time.sleep方法暂停2秒钟。这样做的原因是让程序运行得慢一些。在程序运行的时候，按Ctrl+c中断（取消）程序。
我们可以观察到KeyboardInterrupt异常被触发，程序退出。但是在程序退出之前，finally从句仍然被执行，把文件关闭。
11 Python知识 除法 移位操作 左移（>n，则a' =a//(2^n)，左移 n 位相当于原操作数整除 2^n，原操作数不发生变化。
>>> 2>>1 # 移动一位，相当于是2//2
1
>>> 2>>2 # 相当于先左移一位得到1，结果1再除以2等于0
0
>>> 2>>3 # 相当于2//8
0
>>> -8>>2 # 移动2位，相当于-8//4
-2
>>> -8>>3 # 移动3位，相当于是用结果-2再除以2
-1
>>> -8>>4 # 移动4位，相当于是用结果-1再除以2
-1
如果操作数是正数，那么对之不停进行右移操作，最终结果一定可以得到0；如果操作数是负数，对之不停进行右移操作，最终结果一定可以得到-1。
匿名函数lambda
匿名函数 lambda 是指一类无需定义标识符（函数名）的函数或子程序。
lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。
语法：
lambda [arg1,arg2,.....argn]:expression
冒号前是参数，可以有多个，用逗号隔开，冒号右边的为表达式（只能为一个）。其实lambda返回值是一个函数的地址，也就是函数对象。
lambda arg: print("hello,world",arg)
lambda表达式限制只能包含一行代码，但是其实可以利用元组或列表强行让其包含多行。（但是这么做会严重影响可读性，除非万不得已不要使用）
lambda :(
print("hello"),
print("world"),
)
切片
t=[1,2,3,4,5]
print(t[1:]) 取第二个到最后一个元素
结果：[2 3 4 5]
print(t[:]) 取所有元素
结果：[1 2 3 4 5]
print(t[1:3]) 取t[1]-t[2]
结果：[ 2 3 ]
print(t[:-1]) 除了最后一个取全部
结果：[ 1 2 3 4 ]
print(t[::-1]) 取从后向前（相反）的元素
结果：[ 5 4 3 2 1 ]
print(t[2::-1]) 取从下标为2的元素翻转读取
结果：[ 3 2 1 ]
字符串方法 join(iterable)
获取可迭代对象(iterable)中的所有项目，并将它们连接为一个字符串。
实例1：
myTuple = ("Bill", "Steve", "Elon")
x = "#".join(myTuple)
print(x)
'''
输出：
Bill#Steve#Elon
'''
实例2：
myDict = {"name": "Bill", "country": "USA"}
mySeparator = "TEST"
x = mySeparator.join(myDict)
print(x)
'''
输出：
nameTESTcountry
'''
注释：在使用字典作为迭代器时，返回的值是键，而不是值。
split(separator, max)
将字符串拆分为列表，您可以指定分隔符，默认分隔符是任何空白字符。若指定 max，列表将包含指定数量加一的元素。
实例1：
txt = "welcome to China"
x = txt.split()
print(x)
'''
输出：
['welcome', 'to', 'China']
'''
实例2：
txt = "apple#banana#cherry#orange"
# 将 max 参数设置为 1，将返回包含 2 个元素的列表！
x = txt.split("#", 1)
print(x)
'''
输出：
['apple', 'banana#cherry#orange']
'''
内置函数 enumerate()
用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
实例1：
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
... print i, element
...
0 one
1 two
2 three
实例2：
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1)) # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
exec()
exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。
# 单行语句字符串
>>>exec('print("Hello World")')
Hello World
# 多行语句字符串
>>> exec ("""for i in range(5):
... print ("iter time: %d" % i)
... """)
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4
二、Python爬虫
下面的学习方式是以爬取豆瓣top250网页进行开展的
基本流程: 爬取网页—>解析数据—>保存数据
1 requests库
Requests是一个简单方便的HTTP 库。比Python标准库中的urllib2模块功能强大。Requests 使用的是 urllib3，因此继承了它的所有特性。Requests 支持使用cookie保持会话，支持文件上传，支持自动确定响应内容的编码，支持URL和POST数据自动编码。帮助我们轻松解决关于HTTP的大部分问题。
爬取网页首先要学习requests库或者urllib库的使用,不然你无法看懂下面代码
2 爬取网页 2.1 爬取豆瓣top250第一页数据
#-*- coding =utf-8 -*-
import requests
def askUrl(url):
head = { #模拟浏览器头部信息，向豆瓣服务器发送消息
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.69 Safari/537.36 Edg/81.0.416.34"
# 用户代理：告诉豆瓣服务器，我们是什么类型的浏览器（本质上是告诉浏览器我们可以接收什么水平的文件内容）
}
html="" #用来接收数据
r = requests.get(url, headers = head) #get方式发送请求
html = r.text #接收数据
print(html)
return html
if __name__ == "__main__": # main函数用于测试程序
askUrl("https://movie.douban.com/top250?start=") #调用函数
可以看到成功的爬取到豆瓣top250第一页的数据
2.2 爬取豆瓣top250前10页数据
#-*- coding =utf-8 -*-
import requests
#爬取一个页面
def askUrl(url):
head = { #模拟浏览器头部信息，向豆瓣服务器发送消息
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.69 Safari/537.36 Edg/81.0.416.34"
# 用户代理：告诉豆瓣服务器，我们是什么类型的浏览器（本质上是告诉浏览器我们可以接收什么水平的文件内容）
}
#html=""
r = requests.get(url, headers = head)
html = r.text
print(html)
# 爬取所有页面
def getData(baseurl):
for i in range(0, 10):
url = baseurl + str(i * 25)
html = askUrl(url)
if __name__ == "__main__": # main函数用于测试程序
baseurl = "https://movie.douban.com/top250?start="
getData(baseurl)
可以看到排名250的梦之安魂曲也被成功爬取到
image-250029
3 BeautifulSoup4库
BeautifulSoup4和 lxml 一样，Beautiful Soup 也是一个HTML/XML的解析器，主要的功能也是如何解析和提取 HTML/XML 数据。
假设有这样一个baidu.html，放在py文件目录下，下面的例子都基于该html,具体内容如下：
百度一下，你就知道
3.1 快速使用案例
# 导入模块
from bs4 import BeautifulSoup
# 读取html文件信息（在真实代码中是爬取的网页信息）
file = open("./baidu.html",'rb') #解析器
content = f.read()
f.close()
# 创建解析器
bs = BeautifulSoup(content,"html.parser")
# 输出网页内容：注：此内容已被缩进格式化（自动更正格式），其实这个是在上一步实例化时就已完成
print(bs)
#输出网页中title标签中的内容
print(bs.title.string)
3.2 BeautifulSoup4主要解析器 解析器使用方法优势劣势
Python标准库
BeautifulSoup(markup, “html.parser”)
Python的内置标准库，执行速度适中，文档容错能力强
Python 2.7.3 or 3.2.2前的版本中文档容错能力差
lxml HTML 解析器
BeautifulSoup(markup, “lxml”)
速度快 文档容错能力强
需要安装C语言库
lxml XML 解析器
BeautifulSoup(markup, [“lxml-xml”]) BeautifulSoup(markup, “xml”)
速度快 唯一支持XML的解析器
需要安装C语言库
html5lib
BeautifulSoup(markup, “html5lib”)
最好的容错性，以浏览器的方式解析文档，生成HTML5格式的文档
速度慢、不依赖外部扩展
3.2 BS4四大对象种类
BeautifulSoup4将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为4种
3.2.1 Tag
Tag通俗点讲就是为了获取HTML中的一个个标签
from bs4 import BeautifulSoup
file = open('./baidu.html', 'rb')
content = file.read()
bs = BeautifulSoup(content,"html.parser")
# 获取title标签的所有内容
print(bs.title) #百度一下，你就知道
# 获取head标签的所有内容
print(bs.head)
# 获取第一个a标签的所有内容
print(bs.a)
# 类型
print(type(bs.a)) #
#bs 对象本身比较特殊，它的 name 即为 [document]
print(bs.name) # [document]
# head #对于其他内部标签，输出的值便为标签本身的名称
print(bs.head.name) # head
# 获取a标签里的所有属性，打印输出来，得到的类型是一个字典。
print(bs.a.attrs)
# {'class': ['mnav'], 'href': 'http://news.baidu.com', 'name': 'tj_trnews'}
#还可以利用get方法，传入属性的名称，二者是等价的
print(bs.a['class']) # 等价 bs.a.get('class')
# 可以对这些属性和内容等等进行修改
bs.a['class'] = "newClass"
print(bs.a)
# 还可以对这个属性进行删除
del bs.a['class']
print(bs.a)
3.2.2 NavigableString
既然我们已经得到了标签的内容，那么问题来了，我们要想获取标签内部的文字怎么办呢？很简单，用 .string 即可，例如
from bs4 import BeautifulSoup
file = open('./baidu.html', 'rb')
content = file.read()
bs = BeautifulSoup(content,"html.parser")
#获取title标签中的字符串
print(bs.title.string) #百度一下，你就知道
# 类型
print(type(bs.title.string))
#
3.3.3 BeautifulSoup
BeautifulSoup对象表示的是一个文档的内容。大部分时候，可以把它当作 Tag 对象，是一个特殊的 Tag，我们可以分别获取它的类型，名称，以及属性，例如：
from bs4 import BeautifulSoup
file = open('./baidu.html', 'rb')
content = file.read()
bs = BeautifulSoup(content,"html.parser")
#获取整个文档
print(bs)
print(type(bs)) #
3.3.4 Comment
Comment 对象是一个特殊类型的 NavigableString 对象，其输出的内容不包括注释符号。
from bs4 import BeautifulSoup
file = open('./baidu.html', 'rb')
content = file.read()
bs = BeautifulSoup(content,"html.parser")
print(bs.a)
# a标签如下：
#
print(bs.a.string) # 新闻 #不会输出上面a标签中的注释符号
print(type(bs.a.string))
#
3.3 遍历文档数
.contents：获取Tag的所有子节点，返回一个list
from bs4 import BeautifulSoup
file = open('./baidu.html', 'rb')
content = file.read()
bs = BeautifulSoup(content,"html.parser")
print(bs.head.contents) #获取head下面的所有直接子节点，返回列表
print(bs.head.contents[1 #用列表索引来获取它的某一个元素
.children：获取Tag的所有子节点，返回一个生成器
from bs4 import BeautifulSoup
file = open('./baidu.html', 'rb')
content = file.read()
bs = BeautifulSoup(content,"html.parser")
for child in bs.body.children:
print(child)
.descendants获取Tag的所有子孙节点
.strings
如果Tag包含多个字符串，即在子孙节点中有内容，可以用此获取，而后进行遍历
.stripped_strings
与strings用法一致，只不过可以去除掉那些多余的空白内容
.parent
获取Tag的父节点
.parents
递归得到父辈元素的所有节点，返回一个生成器
.previous_sibling
获取当前Tag的上一个节点，属性通常是字符串或空白，真实结果是当前标签与上一个标签之间的顿号和换行符
.next_sibling
获取当前Tag的下一个节点，属性通常是字符串或空白，真是结果是当前标签与下一个标签之间的顿号与换行符
.previous_siblings
获取当前Tag的上面所有的兄弟节点，返回一个生成器
.next_siblings
获取当前Tag的下面所有的兄弟节点，返回一个生成器
.previous_element
获取解析过程中上一个被解析的对象(字符串或tag)，可能与previous_sibling相同，但通常是不一样的
.next_element
获取解析过程中下一个被解析的对象(字符串或tag)，可能与next_sibling相同，但通常是不一样的
.previous_elements
返回一个生成器，可以向前访问文档的解析内容
.next_elements
返回一个生成器，可以向后访问文档的解析内容
.has_attr
判断Tag是否包含属性
3.4 文档的搜索find_all() name参数
from bs4 import BeautifulSoup
file = open('./baidu.html', 'rb')
content = file.read()
bs = BeautifulSoup(content,"html.parser")
#字符串过滤：会查找与字符串完全匹配的内容
t_list = bs.find_all("a")
t_list = bs.find_all("title")
print(t_list)
#正则表达式过滤：如果传入的是正则表达式，那么BeautifulSoup4会通过search()来匹配内容
import re
t_list = bs.find_all(re.compile("a"))
print(t_list)
函数参数
from bs4 import BeautifulSoup
file = open('./baidu.html', 'rb')
content = file.read()
bs = BeautifulSoup(content,"html.parser")
#定义函数：传入一个函数，根据函数的要求来搜索
def name_is_exists(tag):
return tag.has_attr("name")#搜索包含name的标签
t_list = bs.find_all(name_is_exists)
for item in t_list: #打印列表内容
print(item)
keyword参数
from bs4 import BeautifulSoup
file = open('./baidu.html', 'rb')
content = file.read()
bs = BeautifulSoup(content,"html.parser")
#搜索id=head的内容
t_list = bs.find_all(id="head")
for item in t_list:
print(item)
#搜索class=manav的内容
t_list = bs.find_all(class_="mnav")
for item in t_list:
print(item)
#搜索链接的内容
t_list = bs.find_all(href="https://blog.kaynak.top/?golink=aHR0cDovL25ld3MuYmFpZHUuY29t" )
for item in t_list:
print(item)
text参数
from bs4 import BeautifulSoup
file = open('./baidu.html', 'rb')
content = file.read()
bs = BeautifulSoup(content,"html.parser")
import re
#t_list = bs.find_all(text="hao123")
#t_list = bs.find_all(text=["hao123","贴吧","地图"])
t_list = bs.find_all(text=re.compile("d"))#查找包含数字的文本
for item in t_list:
print(item)
limit 参数
from bs4 import BeautifulSoup
file = open('./baidu.html', 'rb')
content = file.read()
bs = BeautifulSoup(content,"html.parser")
t_list = bs.find_all("a",limit=3)
for item in t_list:
print(item)
3.5 css选择器
from bs4 import BeautifulSoup
file = open('./baidu.html', 'rb')
content = file.read()
bs = BeautifulSoup(content,"html.parser")
#通过标签来查找
t_list = bs.select('title')
#通过类名（.表示类）来查找
t_list = bs.select('.mnav')
#通过id（#表示id）来查找
t_list = bs.select('#u1')
#通过属性来查找 查找a标签中class=bri的内容
t_list = bs.select("a[class='bri']")
#通过父子标签来查找
t_list=bs.select("head > title")
#通过兄弟标签来查找
t_list=bs.select(".mnav ~ .bri")
for item in t_list: #打印列表内容
print(item)
print(t_list[0].get_text()) #拿到t_list中的文本
4 re库
正则表达式(Regular Expression)通常被用来匹配、检索、替换和分割那些符合某个模式(规则)的文本。
4.1 正则表达式常用操作符 操作符说明实例
表示除 “n” 之外的任何单个字符。
[ ]
宇符集，对单个字符给出取值范围
[abc]表示a,b,c;[a-z]表示a到z单个字符
[^ ]
非字符集,对单个字符恰给出排除范围
[^abc]表示非a或非b或c的单个字符
前一个字符0次或无限次扩展
abc* 表示ab、abc、abcc、abcc等
前一个字符1次或无限次扩展
abc+ 表示abc、abcc、abcc等
前一个字符0次或1攻扩展
abc? 表示ab、abc
左右表达式任意一个
abc|def 表示abc、def
扩展前一个字符m次
ab(2}c表示abbc
扩展前一个字符m至n次(含n)
ab{1,2}c表示abc、abbc
匹配字符串开头
^abc表示abc且在一个字符串的开头
匹配字符串结尾
abc$表示abc且在一个字符串的结尾
( )
分组标记,内部只能使用|操作符
(abc)表示abc ,(abc|def)表示abc、def
d
数字,等价于[0-9]
w
单词字符,等价于[A-Za-z0-9_ ]
4.2 re库常用函数 函数说明
pile()
返回一个正则对象的模式。
re. search()
在一个字符串中搜素匹配正则表达式的第一个位置 ,返回match对象
re. match()
从一个字符串的开始位置起匹配正则表达式,返回match对象
re. findall()
搜索字符串,以列表类型返回全部能匹配的子串
re. split()
将一个字符串按照正则表达式匹配结果进行分割,返回列表类型
re. finditer()
擅索字符串。返回一个匹配结果的迭代类型，每个选代元素是match对象
re. sub()
在一个字符串中普换所有匹配正则表达式的子串,返回替换后的字符申
4.2.1 compile()
格式：pile(pattern[,flags=0])
import re
pat=re.compile("A")
m=pat.search("CBA") #等价于 re.search(A,CBA)
print(m)# 表示匹配到了
m=pat.search("CBD")
print(m) #None 表示没匹配到
4.2.2 search()
import re
m = re.search("asd" , "ASDasd" )
print(m)# #匹配到了，返回MatchObject（True）
m = re.search("asd" , "ASDASD" )
print(m) #没有匹配到，返回None（False）
4.2.3 match()
import re
pat=re.compile( "a" )
print(pat.match( "Aasd" )) #输出None
pat=re.compile( "A" )
print(pat.match( "Aasd" )) #输出
4.2.3 findall()
import re
#前面字符串是规则（正则表达式），后面字符串是被校验的字符串
print(re.findall("a","ASDaDFGAa"))
#[a,a] #列表形式返回匹配到的字符串
p = re.compile(r'd+')
print(p.findall('o1n2m3k4'))
#执行结果如下：
#['1', '2', '3', '4']
print(re.findall("[A-Z]","ASDaDFGAa"))
#[ A , S , D , D , F , G , A ]
print(re.findall("[A-Z]+","ASDaDFGAa"))
#[ ASD , DFGA ]
pat = re.compile("[A-Za-z]")
print(pat.findall("ASDcDFGAa"))
#[ A , S , D , c , D , F , G , A , a ]
4.2.4 re. split()
print(re.split('d+','one1two2three3four4five5'))
# 执行结果如下：
# ['one', 'two', 'three', 'four', 'five', '']
4.2.5 finditer() 4.2.6 sub() 4.3 模式修正符
所谓模式修正符，即可以在不改变正则表达式的情况下，通过模式修正符改变正则表达式的含义，从而实现一些匹配结果的调整等功能。
修饰符描述
re.I
使匹配对大小写不敏感
re.L
做本地化识别（locale-aware）匹配
re.M
多行匹配，影响 ^ 和 $
re.S
使 . 匹配包括换行在内的所有字符
re.U
根据Unicode字符集解析字符。这个标志影响 w, W, b, B.
re.X
该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
import re
string = "Python"
pat = "pyt"
rst = re.search(pat,string,re.I) # 第三个参数
print(rst)#文章来源:https://blog.csdn.net/2201_76124692/article/details/139592455
微信扫描下方的二维码阅读本文
暂无评论内容