gzl的博客

  • 首页

  • 关于

  • 标签

  • 分类

  • 归档

markdown基础

发表于 2018-09-28 更新于 2019-07-19 分类于 markdown

markdown简单语法学习

上面为效果,下面为写法

超链接写法

翔工作室博客
gzl’s blog
郭霖

1
2
3
[翔工作室博客](http://blog.flyingstudio.online) 
[gzl’s blog](https://xunzhanggzl.github.io/)
[郭霖](https://blog.csdn.net/guolin_blog)

在文中突出字体(粗体、斜体、块状)

是的,小时候,我们常常把“亲戚”看得多么美好和重要。一旦长大成人,开始独立生活,我们便很快知道,亲戚关系常常是庸俗的;互相设法沾光,沾不上光就翻白眼;甚至你生活中最大的困难也常常是亲戚们造成的;生活同样会告诉你,亲戚往往不如朋友对你真诚。

1
2
3
4
是的,小时候,我们常常把**“亲戚”**看得多么美好和重要。一旦`长大成人`,
开始独立生活,我们便很快知道,亲戚关系常常是**庸俗的**;互相设法沾光,
沾不上光就`翻白眼`;甚至你生活中**最大的困难**也常常是亲戚们造成的;
*生活同样会告诉你,亲戚往往不如**朋友**对你真诚。*

分割线


1
----------

引用

一个平平常常的日子,细蒙蒙的雨丝夹着一星半点的雪花,正纷纷淋淋地向大地飘洒着。时令已快到惊蛰,雪当然再也不会存留,往往还没等落地,就已经消失得无影无踪了。黄土高原严寒而漫长的冬天看来就要过去,但那真正温暖的春天还远远地没有到来。

1
2
3
4
> 一个平平常常的日子,细蒙蒙的雨丝夹着一星半点的雪花,
正纷纷淋淋地向大地飘洒着。时令已快到惊蛰,雪当然再也不会存留,
往往还没等落地,就已经消失得无影无踪了。黄土高原严寒而漫长的
冬天看来就要过去,但那真正温暖的春天还远远地没有到来。

列表

有序列表

  1. 我有一个梦想
  2. 我有一个梦想
  3. 我有一个梦想
    1
    2
    3
    1. 我有一个梦想
    2. 我有一个梦想
    3. 我有一个梦想

无序列表

  • 我有一个梦想
  • 我有一个梦想
  • 我有一个梦想
    1
    2
    3
    - 我有一个梦想
    + 我有一个梦想
    * 我有一个梦想

表格

language learn Time
Javascript first 10
python second 20
Java third 30
1
2
3
4
5
6
7
8
9
| language  | learn  | Time|
| :- | :-: | -: |
| Javascript| first | 10 |
| python | second | 20 |
| Java | third | 30 |

:- 表示左对齐
:-:表示居中对齐
-: 表示右对齐

python Re库入门与实战

发表于 2018-09-27 更新于 2019-10-01 分类于 python

Re库入门

正则表达式的常用操作符

.      表示任何单个字符

[]     字符集,对单个字符给出取值范围        [abc]表示a、b、c,[a‐z]表示a到z单个字符

[^]    非字符集,对单个字符给出排除范围      [^abc]表示非a或b或c的单个字符

*      前一个字符0次或无限次扩展            abc* 表示 ab、abc、abcc、abccc等

+      前一个字符1次或无限次扩展            abc+ 表示 abc、abcc、abccc等

?      前一个字符0次或1次扩展               abc? 表示 ab、abc

|      左右表达式任意一个                   abc|def 表示 abc、def

{m}    扩展前一个字符m次                    ab{2}c表示abbc

{m,n}  扩展前一个字符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_]

正则表达式语法实例

P(Y|YT|YTH|YTHO)?N             'PN'、'PYN'、'PYTN'、'PYTHN'、'PYTHON'

PYTHON+                        'PYTHON'、'PYTHONN'、'PYTHONNN' …

PY[TH]ON                       'PYTON'、'PYHON'

PY[^TH]?ON                     'PYON'、'PYaON'、'PYbON'、'PYcON'…

PY{:3}N                        'PN'、'PYN'、'PYYN'、'PYYYN'…

经典正则表达式实例

^[A‐Za‐z]+$                     由26个字母组成的字符串

^[A‐Za‐z0‐9]+$                  由26个字母和数字组成的字符串

^‐?\d+$                         整数形式的字符串

^[0‐9]*[1‐9][0‐9]*$             正整数形式的字符串

[1‐9]\d{5}                      中国境内邮政编码,6位

[\u4e00‐\u9fa5]                 匹配中文字符

\d{3}‐\d{8}|\d{4}‐\d{7}         国内电话号码,010‐68913536

                                匹配IP地址的正则表达式

(([1‐9]?\d|1\d{2}|2[0‐4]\d|25[0‐5]).){3}([1‐9]?\d|1\d{2}|2[0‐4]\d|25[0‐5])

正则表达式的表达类型

re库采用raw string类型表示正则表达式,表示为:r'text'
例如:r'[1‐9]\d{5}'       r'\d{3}‐\d{8}|\d{4}‐\d{7}'

re库也可以采用string类型表示正则表达式,但更繁琐
例如:'[1‐9]\\d{5}'       '\\d{3}‐\\d{8}|\\d{4}‐\\d{7}'

Re库的主要功能函数

re.search()        在一个字符串中搜索匹配正则表达式的第一个位置,返回match对象

re.match()         从一个字符串的开始位置起匹配正则表达式,返回match对象

re.findall()       搜索字符串,以列表类型返回全部能匹配的子串

re.split()         将一个字符串按照正则表达式匹配结果进行分割,返回列表类型

re.finditer()      搜索字符串,返回一个匹配结果的迭代类型,每个迭代元素是match对象

re.sub()           在一个字符串中替换所有匹配正则表达式的子串,返回替换后的字符串

例如:
re.search(pattern, string, flags=0)
    ∙ pattern : 正则表达式的字符串或原生字符串表示
    ∙ string : 待匹配字符串
    ∙ flags : 正则表达式使用时的控制标记

常用标记                           说明
re.I           re.IGNORECASE 忽略正则表达式的大小写,[A‐Z]能够匹配小写字符
re.M           re.MULTILINE 正则表达式中的^操作符能够将给定字符串的每行当作匹配开始
re.S           re.DOTALL 正则表达式中的.操作符能够匹配所有字符,默认匹配除换行外的所有字符

Re库的另一种等价用法

regex = re.compile(pattern, flags=0)
    ∙ pattern : 正则表达式的字符串或原生字符串表示
    ∙ flags : 正则表达式使用时的控制标记
regex = re.compile(r'[1‐9]\d{5}')

函数式用法:一次性操作
rst = re.search(r'[1‐9]\d{5}', 'BIT 100081')

面向对象用法:编译后的多次操作
pat = re.compile(r'[1‐9]\d{5}')
rst = pat.search('BIT 100081')

Match对象介绍

Match对象是一次匹配的结果,包含匹配的很多信息
1
2
3
4
5
match = re.search(r'[1‐9]\d{5}', 'BIT 100081')
if match:
print(match.group(0))
type(match)
<class '_sre.SRE_Match'>

Match对象的属性

 属性                             说明

.string                      待匹配的文本

.re                       匹配时使用的patter对象(正则表达式)

.pos                      正则表达式搜索文本的开始位置

.endpos                   正则表达式搜索文本的结束位置

Match对象的方法

 方法                             说明

.group(0)                 获得匹配后的字符串

.start()                  匹配字符串在原始字符串的开始位置

.end()                    匹配字符串在原始字符串的结束位置

.span()                   返回(.start(), .end())

Re库默认采用贪婪匹配,即输出匹配最长的子串

最小匹配操作符

 操作符                            说明

*?                        前一个字符0次或无限次扩展,最小匹配

+?                        前一个字符1次或无限次扩展,最小匹配

??                        前一个字符0次或1次扩展,最小匹配

{m,n}?                    扩展前一个字符m至n次(含n),最小匹配

Re库实战

淘宝商品比价定向爬虫

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import requests
import re

def getHTMLText(url):
try:
r = requests.get(url, timeout = 30)
r.raise_for_status()
r.encoding = r.apparent_encoding
return r.text
except:
return ""

def parsePage(ilt, html):
try:
plt = re.findall(r'\"view_price\"\:\"[\d\.]*\"',html)
tlt = re.findall(r'\"raw_title\"\:\".*?\"',html)
for i in range(len(plt)):
price = eval(plt[i].split(':')[1])
title = eval(tlt[i].split(':')[1])
ilt.append([price, title])
except:
print("")

def printGoodsList(ilt):
tplt = "{:4}\t{:8}\t{:16}"
print(tplt.format("序号","价格","商品名称"))
count = 0
for g in ilt:
count = count + 1
print(tplt.format(count, g[0], g[1]))

def main():
goods = '书包'
depth = 2
start_url = 'http://s.taobao.com/search?q=' + goods
infoList = []
for i in range(depth):
try:
url = start_url + '&s=' + str(44*i)
html = getHTMLText(url)
parsePage(infoList, html)
except:
continue
printGoodsList(infoList)
main()

股票数据定向爬虫

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
import requests
from bs4 import BeautifulSoup
import traceback
import re
def getHTMLText(url, code="utf-8"):
try:
r = requests.get(url)
r.raise_for_status()
r.encoding = code
return r.text
except:
return ""
def getStockList(lst, stockURL):
html = getHTMLText(stockURL, "GB2312")
soup = BeautifulSoup(html, 'html.parser')
a = soup.find_all('a')
for i in a:
try:
href = i.attrs['href']
lst.append(re.findall(r"[s][hz]\d{6}", href)[0])
except:
continue
def getStockInfo(lst, stockURL, fpath):
count = 0
for stock in lst:
url = stockURL + stock + ".html"
html = getHTMLText(url)
try:
if html == "":
continue
infoDict = {}
soup = BeautifulSoup(html, 'html.parser')
stockInfo = soup.find('div', attrs={'class': 'stock-bets'})

name = stockInfo.find_all(attrs={'class': 'bets-name'})[0]
infoDict.update({'股票名称': name.text.split()[0]})

keyList = stockInfo.find_all('dt')
valueList = stockInfo.find_all('dd')
for i in range(len(keyList)):
key = keyList[i].text
val = valueList[i].text
infoDict[key] = val

with open(fpath, 'a', encoding='utf-8') as f:
f.write(str(infoDict) + '\n')
count = count + 1
print("\r当前进度: {:.2f}%".format(count * 100 / len(lst)), end="")
except:
count = count + 1
print("\r当前进度: {:.2f}%".format(count * 100 / len(lst)), end="")
continue
def main():
stock_list_url = 'http://quote.eastmoney.com/stocklist.html'
stock_info_url = 'http://gupiao.baidu.com/stock/'
output_file = 'D:/BaiduStockInfo.txt'
slist = []
getStockList(slist, stock_list_url)
getStockInfo(slist, stock_info_url, output_file)
main()

python BeautifulSoup库入门与实战

发表于 2018-09-26 更新于 2019-11-25 分类于 python

BeautifulSoup库入门

引入

1
2
from bs4 import BeautifulSoup
import bs4

约定引用方式如下,即主要是用BeautifulSoup类

BeautifulSoup类的基本元素

1.Tag             标签,最基本的信息组织单元,分别用<>和</>标明开头和结尾

2.Name            标签的名字,<p>…</p>的名字是'p',格式:<tag>.name

3.Attributes      标签的属性,字典形式组织,格式:<tag>.attrs

4.NavigableString 标签内非属性字符串,<>…</>中字符串,格式:<tag>.string

5.Comment         标签内字符串的注释部分,一种特殊的Comment类型

bs4库的prettify()方法

.prettify()为HTML文本<>及其内容增加更加'\n'

.prettify()可用于标签,方法:<tag>.prettify()

bs4库的编码

bs4库将任何HTML输入都变成utf‐8编码

Python 3.x默认支持编码是utf‐8,解析无障碍

基于bs4库的HTML内容遍历方法

  • 标签树的下行遍历
    .contents 子节点的列表,将所有儿子节点存入列表
    .children 子节点的迭代类型,与.contents类似,用于循环遍历儿子节点
    .descendants 子孙节点的迭代类型,包含所有子孙节点,用于循环遍历

  • 标签树的上行遍历

    .parent 节点的父亲标签
    .parents 节点先辈标签的迭代类型,用于循环遍历先辈节点

  • 标签树的平行遍历

    .next_sibling 返回按照HTML文本顺序的下一个平行节点标签
    .previous_sibling 返回按照HTML文本顺序的上一个平行节点标签
    .next_siblings 迭代类型,返回按照HTML文本顺序的后续所有平行节点标签
    .previous_siblings 迭代类型,返回按照HTML文本顺序的前续所有平行节点标签

三种信息标记形式的比较

XML 最早的通用信息标记语言,可扩展性好,但繁琐,Internet上的信息交互与传递

JSON 信息有类型,适合程序处理(js),较XML简洁,移动应用云端和节点的信息通信,无注释

YAML 信息无类型,文本信息比例最高,可读性好,各类系统的配置文件,有注释易读

获取网页全部链接

1
2
3
4
5
6
7
import requests
from bs4 import BeautifulSoup
r = requests.get("https://www.douyu.com/138243")
demo = r.text
soup = BeautifulSoup(demo,"html.parser")
for link in soup.find_all('a'):
print(link.get('href'))

常见方法

<>.find_all(name, attrs, recursive, string, **kwargs)
返回一个列表类型,存储查找的结果
name : 对标签名称的检索字符串
attrs: 对标签属性值的检索字符串,可标注属性检索
recursive: 是否对子孙全部检索,默认True
string: <>…</>中字符串区域的检索字符串

<tag>(..) 等价于 <tag>.find_all(..)

soup(..) 等价于 soup.find_all(..)

扩展方法

<>.find()                    搜索且只返回一个结果,同.find_all()参数

<>.find_parents()            在先辈节点中搜索,返回列表类型,同.find_all()参数

<>.find_parent()             在先辈节点中返回一个结果,同.find()参数

<>.find_next_siblings()      在后续平行节点中搜索,返回列表类型,同.find_all()参数

<>.find_next_sibling()       在后续平行节点中返回一个结果,同.find()参数

<>.find_previous_siblings()  在前序平行节点中搜索,返回列表类型,同.find_all()参数

<>.find_previous_sibling()   在前序平行节点中返回一个结果,同.find()参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
"""just测试"""
import requests
from bs4 import BeautifulSoup
r = requests.get("https://www.icourse163.org/home.htm?userId=1145095816#/home/course")
demo = r.text
soup = BeautifulSoup(demo,'html.parser')
tag = soup.a # 获取第一个a标签
print(r.text)
print(demo)
print(soup)
print(tag)
print(tag.name)
print(tag.parent.name)
print(tag.parent.parent.name)
print(tag.attrs)
print(type(tag.attrs))
print(soup.title)
print(type(tag))
print(tag.attrs['href'])
print(tag.string)
print(type(soup.p.string))

BeautifulSoup实战:中国大学排名爬虫

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import requests
from bs4 import BeautifulSoup
import bs4
import re
def getHTMLText(url):
try:
r = requests.get(url)
r.raise_for_status()
r.encoding = r.apparent_encoding
return r.text
except:
return ""

def fillUnivList(ulist, html):
soup = BeautifulSoup(html, "html.parser")
for tr in soup.find('tbody').children:
if isinstance(tr, bs4.element.Tag):
tds = tr('td')
ulist.append([tds[0].string, tds[1].string, tds[3].string])

def printUnivList(ulist, num):
tplt = "{0:^8}\t{1:{3}^8}\t{2:^8}"
print(tplt.format("排名", "学校名称", "总分", chr(12288)))
for i in range(num):
u = ulist[i]
print(tplt.format(u[0], u[1], u[2], chr(12288)))

def main():
uinfo = []
url = 'http://www.zuihaodaxue.com/zuihaodaxuepaiming2018.html'
html = getHTMLText(url)
fillUnivList(uinfo, html)
printUnivList(uinfo, 20) # 20 univs

main()
1…29303132

gzl

96 日志
14 分类
37 标签
© 2020 gzl
由 Hexo 强力驱动 v3.7.1
|
主题 – NexT.Pisces v7.2.0