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

  - 我有一个梦想 + 我有一个梦想 * 我有一个梦想

表格

1
2
3
4
5
6
7
8
9

| language  | learn  | Time|
| :-        | :-:    | -:  |
| Javascript| first  | 10  |
| python    | second | 20  |
| Java      | third  | 30  |

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

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()

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()