Python筆記

power(x,y),x**y，表示x的y次方
進位制數表示：十進位制，二進位制0b或0B，八進位制0o或0O，十六禁止0x或0X
10//3=3整數商
round(x,y)，四捨五入函式，x是數字，y是保留幾位小數；abs()取絕對值；divmod(x,y)輸出商和餘數，divmod(10,3)=(3,1)；pow(x,y[,z])=(x**y)%z
複數z，z.real表示實部，z.imag表示虛部；max(x1,x2…)輸出最大值；min(x1,x2…)輸出最小值
int(x)取整數，float(x)取浮點數，complex(x,y)=x+y*j，x可以使字串
eval(x)表示去雙引號

字串操作
切片[M:N:K],M缺失表開頭，N缺失表示結尾，K缺失表示1，取不到N
\轉義符，\b回退 \n換行 \r回車表示游標回到本行行首 
print(“”,end=””)不換行
x+y 連線兩個字串
x*n或n*x將字串x複製n次
x in s 判斷x是否在s內，如果在返回True
上面三種序列、列表、字串都可以用
len(x)字串的長度
str(x)返回字串
hex(x),oct(x)返回整數十六進位制或八進位制小寫形式
chr(x) x表示Unicode編碼，返回字元
ord(x) x表示字元，返回unicode編碼
str.lower(),str.upper()，將字串全部大寫或小寫
str.split(seq),將str根據seq切割，返回列表
str.count(sub),返回子串出現的次數
str.replace(old,new),替換
str.center(width[,fillchar]),居中，用fillchar填充
str.strip(chars),刪除str左右側出現在chars的字元
str.join(iter),在item每個元素之間後面都插入str，再生成字串

"{索引:<>}".format()
<填充符號>
<格式>^居中<左對齊>右對齊
<寬度>
<,>千位分隔符
<.精度>浮點數精度或字串輸出最大長度
<資料型別>整數：bcdoxX,浮點數：eEf%

time庫
獲取時間time.time()時間戳，time.ctime()人類可以讀的時間,time.gmtime()計算機可以處理的時間
時間格式化:time.strftime(x,y)設定返回時間格式x是字串，y是gmtime返回的資料,time.strptime(x，y)，x是時間，y是x的時間格式，返回計算機可以處理的格式（結構體）
%Y年 m月 B月份名稱 b月份名稱縮寫 d日期 A星期 a星期縮寫 H小時(24時制) I小時(12時制) p上下午a/pm M分鐘 S秒
程式計時：time.sleep(),time.perf_counter()

程式的控制結構：順序控制，分支控制，迴圈控制
range(N)表示0到N-1，range(M,N,K)，M開始，取不到N，K為步長
for c in s,取字串中的每一個字元進行迴圈
for in 還可以對列表，檔案進行遍歷

break;跳出並結束當前迴圈，執行迴圈後的語句，只能跳出一層迴圈
continue;結束當次迴圈，繼續執行後續次數迴圈
迴圈＋else
for in/while :
	<語句塊1>
else:
	<語句塊2>
如果迴圈沒有被break	語句退出，執行else後的語句塊2
try:
except Namerror:
except:
else:
finally:
出錯執行except，不出錯執行else，出不出錯都要執行finally

random庫的使用呢隨機數標準庫 import random
random.seed(10)#產生種子10對應的序列，初始化給定的隨機種子，預設當前的系統時間
random.random()#產生0到1之間的隨機小數,隨機種子是10的話，第一個隨機小數試試0.57
randomint(a,b)#產生a到b的隨機整數
random.randrange(M,N[,K])#產生一個M開始，不到N的隨機整數，以K為步長
random.getrandbits(k)#生成k位元長的隨機整數
random.uniform(a,b)#生成a到b的一個隨機小數	
random.choice(seq)#從seq序列中隨機選取一個元素
random.shuffle(seq)#對seq重新隨機排列，返回打亂後的順序
\使程式碼換行增加可讀性

Import random as r#用r代替random，避免random太長
import random #使用時需要random.函式，等於r.函式
form import等於把函式寫在這個名稱空間內，不推薦使用，可能會重名

函式的引數是必選和可選的，必選在前，可選在後並賦值
函式的引數若是不確定個數，那麼在形參哪裡定義*b
在for迴圈中，若是不用索引，則可以不用range函式，直接遍歷其內容
傳遞引數分為位置傳遞和名稱傳遞

[,,]列表型別(,,)元組型別
全域性變數和區域性變數：區域性變數是函式內部的佔位符，可能與全域性變數重名，但是不同；函式結束後，區域性變數被釋放；可以用global保留字在函式內部使用全域性變數

global s#宣告s是區域性變數
組合資料型別未在函式中宣告 則是全域性變數
ls.append(a)，在列表s中增加一個a元素，字串不是組合邏輯型別，列表、陣列是組合邏輯型別

lambda用於定義簡單的，能夠在一行內表示的函式
<函式名>=lambda<引數>:表示式
f=lambda x,y:x+y
f(10,15)

turtle.fd(d)#前進的距離	
turtle.left(a)#箭頭向左轉的角度
turtle.right(a)#箭頭向右轉的角度
turtle.pendowm()#畫筆落下
turtle.penup()#提起畫筆
turtle.write(“”,font=())#繪製漢字
turtle.pencolor()#顏色
s[::-1]#將字串s翻轉輸出
turtle.setup(x,y,startx,starty);設定大小和開始位置
turtle.goto(x,y)#移動到x，y座標
turtle.backword(d)#向後移動d的距離
turtle.circle(r,extent=None) #根據半徑r繪製extent角度的弧形
turtle.pencolor(r,g,b)
組合資料型別分類：集合型別、序列型別（元組、列表）、字典型別
***集合型別***
多個元素的無序組合；無序、不存在相同元素；集合元素不能更改，不能是可變資料型別,
表示方法 {,}
建立集合型別用{}，或set(),如果是建立空集合，必須用set()
集合操作符：
並、差、交、補，S|T(返回一個集合，包括S和T中的所有元素)，S-T(返回一個集合，包括S但是不包括T中的元素)，S&T（返回一個集合，包括同時在S和T中的元素），S^T,（返回一個集合，包括S和T中的非相同元素），S<=T或S<T(返回True或者False，表示S是否在T內)，S>=T或S>T(返回True或者False，表示T是否在S內)
集合處理方法：
S.add(x)#如果x不在S中,增加x到S;
S.discard(x)#移除S中的x，如果x不在S中，不報錯
S.remove(x)#移除S中的x，如果x不在S中，報KeyError的異常
S.clear()#移除S中的所有元素
S.pop()#隨機返回S中的一個元素，更新S，若S為空，返回KeyErrir的異常
S.copy()#返回一個與S一個的集合副本
len(S)#返回集合S的元素個數
x in S#判斷S中元素的個數，x在集合S中，返回True，否則返回False
x not in S，與上面相反
set(x)#將其他型別變數x轉變為集合型別 
應用場景，集合包含關係比較，資料去重
***序列型別***
定義：序列是具有一組具有先後關係的元素，元素型別可以不同，序列是一個基類型別，衍生出了：字串型別、元組型別、列表型別
常用操作符，x in s,s*n,s+t,len(s),min(s),max(s)(若是不同型別不能比較，將報錯)，s.index(x)或x.index(x,i,j)第一次出現x元素的位置（從i到j），s.count(x)返回x出現的位置
***元組型別***一旦被建立就不能被修改，使用()或者tuple()建立，元素之間用逗號分隔，可以用小括號表示，也可以不適用小括號表示，如 return 1,2;其實返回的是一個元組型別資料，a=1,2;a表示的也是一個元組型別，用於元素不改變的應用場景，更多用於固定搭配，如函式的返回值return
lt=tuple(ls)，元組型別保護資料不被修改
***列表操作符***ls[i]=x，ls[i:j:k]=lt.del ls[i],del ls[i:j:k],ls+=lt,ls*=n,del ls[::3]
ls.append(x);在列表後增加一個元素
ls.clear();清除ls
ls.copy(); 
ls.insert(i,x);在第i個位置插入x元素
ls.pop(i);將第i個位置的元素去除並刪除，
ls.remove(x);出現的第一個x元素刪除
ls.reverse();將列表ls旋轉

***基本資料統計值***
總個數：len()
求和：for in
平均值、方差、中位數
string=input();
while string!=””:
	srting=input();
#上述程式碼指的是輸入回車結束
sorted()#對陣列進行排序	

***字典型別***應用場景，對對映的表達，如資料出現的次數
建立字典：用{}或dict的方法{<鍵1>:<值1>,<鍵2>:<值2>…<鍵n>:<值n>}，可以通過方括號[]的索引得到值,
字典處理方法：
de={}#建立空字串，type(de)檢測de的型別
del d[k]#刪除鍵k對應的資料值
k in d#判斷鍵k是否在字典中，在返回True，不在返回False，for k in d遍歷鍵
d.keys()#返回字典d中所有的鍵的資訊
d.values()#返回字典d中所有值得資訊
d.items()#返回字典d中所有鍵值對的資訊
d.get(k,<default>)#鍵k存在，返回其相對應的值，不存在返回default的值
d.pop(k,<default>)#鍵k存在，取出k相對應的值，刪除相對應的鍵值對，d更新，不存在返回default的值
d.popitem()#隨機取出一個鍵值對，並更新d，以元組型別返回
d.clear()#刪除所有的鍵值對
len()返回所有鍵值對的個數
d[“a”]=1#通過複製的形式新增元素
ls=list(de.items())#字典轉化為列表，a={‘a’:1};ls=list(a.items());
ls[0][1]的值是1
ls.sort(key lambda x:x[1],reverse=True)# 列表排序,使用第二行作為索引，預設從小到大，reverse=True則是從大到小

jieba庫，中文分詞庫
jieba庫三種模式：精確模式，全模式，搜尋引擎模式
精確模式：把文字精確地切分開，不存在冗餘單詞
全模式：把文字所有可能的詞語全部掃描出來，有冗餘
搜尋引擎模式：在精確模式的基礎上，對長詞再次切分
jieba.luct(“中國是一個偉大的國家”)，返回[“中國”,”是”,”一個”,”偉大”,”的”,”國家”]#精確模式，返回一個列表型別的分詞結果list cut
jieba.lcut("中國是一個偉大的國家",cut_all=True)#全模式，存在冗餘，返回['中國', '國是', '一個', '偉大', '的', '國家']
jieba.lcut_for_search(“中華人民共和國是偉大的”)#返回列表型別的分詞結果，存在冗餘，返回值為['中華', '華人', '人民', '共和', '共和國', '中華人民共和國', '是', '偉大', '的']
jieba.add_word(w)#向jieba庫中增加新詞w，w是中文字串		

處理檔案的步驟：開啟、操作、關閉
使用
開啟檔案tf=open(<路徑和名稱>,<開啟模式>);與原始檔同目錄可省名稱，以文字形式開啟或以二進位制形式開啟，讀資訊還是寫資訊D:/PYE/f.txt，
****開啟模式****：
’r’只讀模式，預設值，如果檔案不存在返回FileNotFoundError
’w’覆蓋寫模式，檔案不存在則建立，存在則完全覆蓋
’x’建立寫模式，檔案不存在則覆蓋，存在則返回FileExistsError
’a’追加寫模式，檔案不存在則建立，存在則在最後追加內容
’b’二進位制檔案模式 
’t’文字檔案模式，預設值
’+’與r/w/x/a一同使用，在原功能上增加讀寫功能

****讀檔案操作****
tf.read(size=-1);#預設讀入全部，tf.read(2)，讀入前2個字元：中國
tf.readline(size=-1);#預設讀入一行內容，tf.readline(2)，讀入改行前兩個字元：中國
tf.readlines(hint=-1);#讀入檔案所有行，每行為元素形成一個列表，如果給出引數，讀取前hint行
逐行處理：for line in tf.readlines()或者for line in tf:
寫檔案操作：
tf.write(s);#s是字串
tf.writelines(lines);#lines是列表ls拼接成一行的字串
tf.seek(offset)#改變當前檔案操作指標的位置，offset含義如下，0：檔案開頭，1：當前位置，2：檔案結尾
tf.close();

map(<函式>，<元素>)#將函式作用於後面的每一個元素

CSV格式：逗號分隔值
每行一個以為資料，採用逗號分隔，沒有空行
將列表中的資料寫入csv檔案中
ls=[[],[],[]]
f=open(fname,’w’)
for item in ls:
 f.wirte(‘,’.join(item)+’\n’)
f.close()

wordcloud庫
-wordcloud.WordCloud()#代表一個文字對應的詞雲
-可以根據文字中詞語出現的頻率等引數繪製詞雲
-繪製詞雲的形狀、尺寸和顏色都可以設定
w= wordcloud.WordCloud(<引數>)，width，height，min_font_size（頻率低）, max_font_size（頻率高），font_step,font_path,max_words（最大單詞數量）, stop_words（排除字，可以給定一個集合型別），background_color,mask
from scipy.misc import imread
mk=imread(“pic.png”)
w=wordcloud.WordCloud(mask=mk)
\換行增加可讀性
w.generate(txt)#向WordCloud物件w中載入文字txt，如w.generate(“python and WordCloud”)
w.to_file(filenname)#將詞雲輸出為影像檔案，可以為png或jpg格式，如w.generate(“outfile.png”)
步驟：配置物件引數、載入詞雲文字、輸出詞雲檔案

python 自頂向下的設計和自下而上的進行

os.path庫使用import os.path as op
op.abspath(“檔名”)#返回絕對路徑
op.normpath(“路徑”)#返回歸一化的path表示形式\\
op.relpath(“帶有路徑的檔名”)#返回python程式和檔案的相對路徑
op.dirname(“帶有路徑的檔名”)#返回path目錄的名字 
op.basename（“路徑”）#返回路徑最後的檔名稱
op.join(path,*paths)#將兩個路徑進行組合，返回一個路徑的字串
op.exists(path)#判斷path對應的檔案或者目錄是否存在，返回True或者False
op.isfile(path)#判斷路徑對應的是否是一個存在的檔案
op.isdir(path)#判斷路徑對應的是否是一個存在的目錄
op.getatime(path)#返回path對應的檔案或者目錄最後一次的訪問時間
op.getmtime(path)#返回最後的一次修改時間
op.getctime(path)#返回建立的時間
op.getsize(path)#返回檔案的大小，以位元組為單位
op.system(command)#返回command的結果
import os
os.chdir(path)#改變當前路徑
os.getcwd()#返回當前路徑
os.getlogin()#獲取當前登入使用者的名稱
os.cpucount()#返回當前cpu的數量
os.urandom（n）#產生n位元組長度的隨機字串，通常使用者加解密運算

資料處理
Numpy庫：資料分析, http://www.numpy.org 
Pandas庫：python資料分析高層次應用庫
Scipy庫：數學、科學和工程計算功能庫，類似於MATLAB, http://www.scipy.org 
  
資料視覺化：
Matplotlib庫：高質量的二維資料視覺化功能庫, http://mataplotlib.org 
Seaborn庫：統計類資料視覺化功能庫 http://seaborn.pydata.org
Mayavi庫：三維科學資料視覺化功能庫  http://docs.enthought.com/mayavi/mayavi
文字處理：
python-docx庫;處理word文件
NLTK庫：自然語言文字處理第三方庫  http://www.nltk.org
PyPDF2庫：用於處理PDF檔案的工具集  http://mstamy2.github.io/PyPDF2

機器學習方面：
Scikit-learn庫：機器學習方法工具集 , http://www.scikit-learn.org/
TwnsorFlow：AlphaGo背後的機器學習計算框架   http://www.twnsorflow.org
MXNet：基於神經網路的深度學習計算框架  http://www. incubator.apache.org/


爬蟲庫：Requsts、Scrapy、pyspider
資訊解析：Beautiful Soup、Re、Python-Goose
網站開發：Django、Pyramid、Flask
WeRobot、aip、MyQR
圖形使用者介面（GUI）：PyQt5、wxPython、PyGObject
遊戲開發：PyGame、Panda3D、cocos2D
虛擬現實：VR Zero、pyovr、Vizard
圖形藝術庫:Quads、ascii_art、turtle

import json
json.loads（str）#字串轉字典

python爬蟲筆記
定向網路資料爬取和網頁解析

Requests庫：自動爬取HTML頁面，自動網路請求提交
robots.txt：網路爬蟲排除標準
Beautiful Soup：解析HTML介面
Re庫：正規表示式庫，提取頁面關鍵資訊
Scrapy*：網路爬蟲原理介紹，專業爬蟲框架介紹

Requests庫的使用方法
requests.request()#構造一個請求，支撐以下各方法的基礎方法
requests.get()#獲取HTML網頁的主要方法，對應於HTTP的get
requests.head()#獲取HTML網頁頭資訊的方法，對應於HTTP的head
requests.post()#向HTML網頁提交post請求，對應於HTTP的post
requests.put()#向HTML網頁提交put請求，對應於HTTP的put
requests.patch()#向HTML網頁提交區域性修改請求，對應於HTTP的patch
requests.delete()#向HTML網頁提交刪除請求，對應於HTTP的delete
requests.request(method,url,**kwargs)
method：請求方式GET、HEAD、POST、PUT、PATCH、delete、OPTIONS
**kwargs：控制訪問的引數，作為引數增加到url中
params：字典或位元組序列，作為引數增加到url中
```python
import requests
kv={'key1':'value1','key2':'value2'}
r=requests.request('GET','http://python123.io/ws',params=kv)
print(r.url)

data ：字典、位元組序列或檔案物件，作為Request的內容

import requests
kv={'key1':'value1','key2':'value2'}
r=requests.request('POST','http://python123.io/ws',data=kv)

json：json格式的資料，作為Request的內容
headers：字典，http的定製頭#可以模擬任何瀏覽器

import requests
hd={'user-agent':'Chrome/10'}
r=requests.request('POST','http://python123.io/ws',headers=hd)

cookies：字典或CookieJar，Requests中的cookie
auth：元組型別，支援HTTP認證功能
files：字典型別，傳輸檔案

import requests
fs={'file':open('data.xls','rb')}
r=requests.request('POST','http://python123.io/ws',files=fs)

timeout：超時時間，以秒為單位

r=requests.request('GET','http://python123.io/ws',timeout=30)

proxies：字典型別，設定訪問代理伺服器，可以增加登入認證

import requests
pxs={'http':'http://user:pass@10.10.10.1:1234',\
     'https':'http://10.10.10.1:4321'}
r=requests.request('GET','http://www.baidu.com',proxies=pxs)

allow_redirects:True/False，預設是True，重定向開關
stream：True/False，預設是True，獲取內容立即下載開關
verify: True/False，預設是True，認證SSL證照開關
cert：本地SSL證照路徑

r=requests.get(url)#構造一個向伺服器請求資源的request物件，返回一個包含伺服器資源的response物件，最重要的。返回爬蟲需要的內容
requests.get(url,params,**kwargs)#url：擬獲取頁面的連結；params：url的額外引數，字典或位元組流樣式，可選；**kwargs：12個控制訪問引數
import requests
r=requests.get(“http://www.baidu.com”)
print(r.status_code)#返回狀態碼，如果是200，成功，如果不是200，失敗
r.header #返回get請求介面的頭部資訊，字典型別
Response物件的屬性：
r.status_code #HTTP請求的返回狀態，200表示連線成功，404表示失敗
r.text #http相應內容字串的資訊，即，url對應的頁面內容
r.encoding #從http headers中猜測的響應內容的編碼方式
r.apparent_encoding #從內容中分析出的響應內容編碼方式（備選編碼方式）
r.content #http響應內容的二進位制形式
Requests的異常處理
requests.ConnectionError #網路連線錯誤異常，如DNS查詢失敗、拒絕連線等
requests.HTTPError #HTTP錯誤異常
requests.URLRequired #URL缺失異常
requests.TooManyRedirects #超過最大重定向次數，產生重定向異常
requests.ConnectionTimeout #連線遠端服務超時異常
requests.Timeout #請求URL超時，產生超時異常
r.raise_for_status() #如果不是200，產生異常requests.HTTPErrorr

提交資料程式碼
import requests
payload={'key1':'value1','key2':'value2'}
r=requests.post('http://httpbin.org/post',data=payload)
print(r.text)

HTTP協議：超文字傳輸協議，請求-響應，無狀態
http://host[:port][path]
host:合法的Internet主機域名或者是IP地址
port:埠號，預設埠號是80
path:請求資源的路徑
方法：
GET:請求獲取URL位置的資源
HEAD:請求獲取URL位置資源的響應訊息報告，即頭部資訊
POST:請求向URL位置的資源後附加新的資料
PUT:請求向URL位置儲存一個資源，覆蓋原URL位置的資源
PATCH:請求區域性更新URL位置的資源，即改變該處資源的部分內容
DELETE:請求刪除URL位置儲存的資源

小規模、爬取網頁用Requests庫，對爬取速度不敏感
中規模、爬取系列網站使用Scrapy庫，對爬取速度敏感
大規模、爬取全網、建立搜尋引擎，定製開發，爬取全網
網路爬蟲的限制：來源審查：判斷User-Agent進行限制，釋出公告

獲取url內容

import requests
try:
    hd={'user-agent':'Chrome/10'}
    url="https://www.baidu.com"
    r=requests.get(url,headers=hd)
    r.raise_for_status()
    print(r.text[:1000])
except:
    print("爬蟲失敗")

查詢IP地址的歸屬

import requests
try:
    ip='112.38.203.59'
    hd={'user-agent':'Chrome/10'}
    url="https://www.ip138.com/iplookup.asp"
    kv={'ip':ip,'action':2}
    r=requests.get(url,headers=hd,params=kv)
    r.raise_for_status()
    r.encoding=r.apparent_encoding
    print(r.url+'\n',r.text[:1000])
except:
print("爬蟲失敗")

解析網站資訊

import requests
from bs4 import BeautifulSoup
r=requests.get(url)
demo=r.text
soup=BeautifulSoup(demo,’html.parse’)

BeautifulSoup庫解析器
bs4的HTML解析器：BeautifulSoup(mk,’html.parse’)，條件是安裝bs4庫
lxml的HTML解析器：BeautifulSoup(mk,’lxml’)，條件是pip install lxml
lxml的XML解析器：BeautifulSoup(mk,’xml)，條件是 pip install lxml
html5lib的解析器：BeautifulSoup(mk,’html5lib’)，條件是pip install html5lib
BeautifulSoup的基本元素
Tag：標籤<></>
Name：標籤的名字

……

,p是標籤的名字，.name
Attributes：標籤的屬性，字典形式組織，格式：.attrs
Navigablestring：標籤內，非屬性的字串
Comment：標籤內字串的註釋部分，一種特殊的Comment型別
soup.a後面可以點的東西：parent上一層標籤，name名字，string裡面的字串，attrs屬性
<!註釋部分>
標籤樹的下行遍歷
.contents子節點的列表，將所有的兒子存入列表
.children子節點的迭代型別，與.contents類似，用於迴圈遍歷兒子節點
.descendants子孫節點的迭代型別，包含所有子孫節點，用於迴圈遍歷
標籤樹的上行遍歷
.parent節點的父親標籤
.parents節點先輩標籤的迭代型別，用於迴圈遍歷先輩節點
標籤樹的平行遍歷
.next_sibling按照HTML文字順序的下一個平行節點標籤
.previous_sibling按照HTML文字順序的上一個平行節點標籤
.next_siblings迭代型別，返回按照HTML文字順序的後續所有平行節點標籤
. previous _siblings迭代型別，返回按照HTML文字順序的前續所有平行節點標籤
迭代型別智慧在for in型別遍歷
print(soup.prettify())在每個標籤後加一個’\n’,顯得好看點，也可以對單個標籤進行處理

資訊的三種標識：XML,JSON,YAML
XML標識形式：,,
JSON標識形式：鍵值對，’key’:’value’,’key’:[‘value1’,’value2’],’key1’:{‘key2’:’value’}
YAML標識形式：
key:value
key :#Comment
-value1
-value2
key:
subkey:subvalue
XML:網際網路上的資訊交換和傳遞
JSON：移動應用雲端和節點的資訊通訊，無註釋
YAML：各類系統的配置檔案，有註釋易讀

資訊提取的一般方法
方法1：完整解析資訊的標記形式，在提取關鍵資訊
XML JSON YAML
需要標記解析器，比如果bs4的標籤樹遍歷，資訊解析準確，但是速度慢
方法2：無視標記形式，直接搜尋關鍵資訊
對資訊的文字查詢函式即可，提取速度快，但是準確性不好

soup的函式
soup.find_all(‘a’)#查詢soup中所有的a標籤
soup.find_all([‘a’,’b’])#查詢soup中所有的a，b標籤
soup.find_all(True)#返回soup中的所有標籤
soup.find_all(re.compile(‘b’))#顯示所有以b開頭的標籤，re是正規表示式庫
soup.find_all(‘p’,’course’)#顯示所有帶有course的p標籤
soup.find_all(id=’link1’)#返回屬性中id=‘link1’的標籤元素
soup.find_all(id=re.compile(‘link’))#返回id=以link開頭的標籤
soup.find_all(string=’basic python’)#查詢basic python字串
Ssoup.find_all(string=re.compile(basic python))#查詢出現python的字串
soup.a.get(‘href’)#返回標籤a中的所有href內容
<>.find.all(name,attrs,recursive,string,**kwargs)，<>表示一個節點
返回一個列表型別，儲存查詢的結果
name：對標籤名稱的檢索字串
attrs：對標籤屬性值的檢索字串，可標註屬性檢索
recursive：是否對子孫全部檢索，預設為True
string：查詢字串
(…)等價於.find_all(…)
soup(…)等價於soup.find_all(…)
擴充套件方法
<>.find()#搜尋且只返回一個結果，字串型別，同find_all()引數
<>.findparents()#在先輩節點中搜尋，返回列表
<>.findparent()#在父親節點中返回一個結果，字串型別
<>.find_nextsiblings()#在後續平行節點中搜尋，返回列表
<>.find_nextsibling()#在後續節點中搜尋，返回一個結果，字串
<>.find_previous_siblings()#在前序平行節點中搜尋，返回列表
<>.find_nextsibling()#在前序節點中搜尋，返回一個結果，字串

************************************************************************************************
``
正規表示式：通用的字串表達框架，簡潔表達一組字串的表示式，簡潔+特徵
PN/PYN/PYTN/PYTHN/PYTHON的正規表示式：P(Y|YT|YTH|YTHO)?N
PY/PYY/PYYY/……/PYYYY…的正規表示式：PY+
PY開頭，後續不多於是個字元，後續字元不能是P/Y，PY[^PY](0,10) 
應用：表達文字型別的特徵（病毒，入侵），同時查詢或者替換一組字串，匹配字串的全部或者部分，主要應用在字串匹配中
正規表示式的使用：
編譯：將符合正規表示式語法的字串轉換成正規表示式特徵
正規表示式是由字元和操作符構成的
. #表示任何單個字元
[] #字符集，對單個字元給出取值範圍，[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_]
經典表示方法
^{A-Za-z}+$表示26個字母表示的字串
^{A-Za-z0-9}+&由26個字母和數字表示的字串
^-?\d+$表示整數形式的字串
^[0-9]*[1-9][0-9]*$ 表示正整數字符串
[1-9]\d{5}中國境內郵政編碼，6位
[\u4e00-\u9fa5] 匹配中文字串
ip地址 0-99:[1-9]?\d，100-199:1\d{2}，200-249:2{0-4}\d，250-255:25[0-5]
Re的基本使用
正規表示式的表示型別
原生字串，raw string，不把‘\’作為註釋，表示為 r’text’，如r’[1-9]\d{5}’，當正規表示式包含轉義符的時候使用raw string
re庫的功能函式
re.search() #在一個字串中搜尋匹配正規表示式的第一個位置，返回match物件
re.match()#在一個字串的開始位置匹配正規表示式，返回match物件
re.findall()#搜尋字串,以列表的形式返回全部匹配的字串
re.split(pattern,string,maxsplit=0,flags=0)#將一個字串按照正規表示式匹配結果進行分割，返回列表型別,maxsplit最大分割數，剩餘部分作為最後一個元素輸出
re.finditer()#搜尋字串，返回一個匹配結果的迭代型別，每個迭代元素是match物件，if match: print(match.group(0))
re.sub(pattern,repl,string,count=0,flags=0)#在一個字串中替換所有匹配正規表示式的子串，返回替換後的字串,repl替換匹配正規表示式的字串，count匹配的最大替換數
re.search(pattern,string,flags=0)
在一個字串中搜尋匹配正規表示式的第一個位置，返回match物件
pattern是正規表示式的字串或原生字串表示
string是帶匹配的字串
flags是正規表示式使用時的控制標記，re.I IGNORECASE忽略正規表示式的大小寫，[A-Z]能匹配小寫字元；re.M re.MULTILINE正規表示式中的^操作符能夠將給定的字串的每行當做匹配開始；re.S re.DOTALL 正規表示式中的.操作符能夠匹配所有字元，預設匹配除換行外的所有字元， match=re.search(r'[1-9]\d{5}','BIT 100081')，match.group(0)輸出匹配的字串

rst=re.search(r’[1-9]\d{5}’,’BIT100001’)#函式式用法，一次性操作
pat=re.compile(r’[1-9]\d{5}’);rst=pat.search(‘BIT100001’)#物件導向用法，編譯後多次操作，加快程式的執行

Re庫的match物件及其屬性
.string#待匹配的文字
.re#匹配是使用的pattern物件（正規表示式）
.pos#正規表示式搜尋文字的開始位置
.endpos#正規表示式搜尋文字的結束位置
方法
.group(0)#獲得匹配後的字串
.start()#匹配字串在原始字串的開始位置
.end()#匹配字串在原始字串的結束位置
.span#返回(.start(),.end())
Re庫的貪婪匹配和最小匹配
Re庫預設採用貪婪匹配，即輸出匹配最長的子串，match.group(0)就是輸出最長的子串
match=re.search(r‘PY.*?N’,’PYANBNCNDN’);match.group(0);就是輸出最小的字串，區別在於?
最小匹配操作符
*? #前一個字元0次或無限次擴充套件，最小匹配、
+? #前一個字元1次或無限次擴充套件，最小匹配
?? #前一個字元0次或1次擴充套件，最小匹配
{m,m}? #擴充套件前一個字元m至n次（含n），最小匹配
pat_price=re.compile(r'\"view_price\"\:\"[\d\.]*\"')#匹配並返回”view_price”:數字型別的字串
pat_name=re.compile(r'\"view_title\"\:\".*?\"')
pat_price.findall('"view_price":"119.00"')
pat_name.findall('"view_title":"褲子"')
返回：['"view_price":"119.00"']，列表型別
['"view_title":"褲子"']， 列表型別

scrapy框架，功能強大的網路爬蟲框架，“5+2結構”
ENGINE、SPIDERS、DOWNLOADER、ITEM PIPELENS、SCHEDULER模組
scrapy常用命令：
startproject 常見一個新工程 scrapy startproject <name> [dir]
genspider 建立一個爬蟲 scrapy genspider [opitions]<name>[domain]
settings 獲取爬蟲的配置資訊 scrapy settings [opitions]
crawl 執行一個爬蟲 scrapy crawl <spider>
list 列出工程中所有的爬蟲 scrapy list
shell 啟動URL除錯命令列 scrapy shell [url]

產生步驟
步驟1：建立一個爬蟲工程scrapy startproject python123demo
步驟2：在工程中產生一個爬蟲 scrapy genspider demo python123.io
步驟3：配置產生的spider爬蟲，更改demo.py檔案
步驟4：執行爬蟲，獲取網頁scrapy crawl demo
scrapy爬蟲的使用步驟
步驟1：建立一個工程和spider模板
步驟2：編寫spider
步驟3：編寫Item  Pipelines
步驟4：優化配置策略

yield關鍵字
yield-生成器
	生成器是不斷產生值的函式
	包含yield語句的函式是一個生成器
	生成器每次執行的時候回產生一個值（yield語句），函式被凍結，被喚醒後再產生一個值
例子：
def gen(n):
	for i in range(n):
		yield i**2
for i in gen(5):
	print(i,' ',end='')
0  1  4  9  16
生成器就是生成一些資料，可以在生成器中遍歷這些資料
生成器更節省儲存空間，響應更迅速，使用更靈活

scrapy資料型別
	Requsts類
	Response類
	Item類
Requests類
class scrapy.http.requests()
	Request物件表示一個HTTP請求
	由Spider生成，由Downloder執行
屬性和方法
	.url Response對應的請求URL地址
	.method 對應請求的方法，‘GET‘’POST’等
	.headers 字典型別風格的請求頭
	.body 請求內容的主體，字串型別
	.meta 使用者新增的擴充套件資訊，在Scrapy內部模組間傳遞資訊使用
	.copy() 複製該請求
Response類
class scrapy.http.Response()
	Response物件表示一個http響應
	用Downloader形成，由Spider處理
屬性和方法
	.url  .headers  .body  .copy()
	.status 狀態碼，預設是200（表示成功）
	.flags一組標記
	.request 產生Response型別對應的Requests物件
Item類
class scrapy.item.Item()
	Item物件表示一個從HTML頁面中提取的資訊內容
	由Spider生成，由Item Pipelines處理
	Item型別類似字典型別，可以按照字典型別操作
Scrapy爬蟲支援多種HTML資訊提取方法
	BeautifulSoup
	lxml
	re
	XPath Selector
	CSS Selector
CSS Selector使用方法
<HTML>.css(‘a::attr(href)’).extract()#a是標籤名稱，href是標籤屬性++
setting.py檔案
CONCYRRENT_REQUESTS表示Downloade最大併發請求下載數量，預設32
CONCURRENT_ITEMS表示Item Pipelines最大併發ITEM處理數量，預設100
CONCURRENT_REQUESTS_PER_DOMAIN每個目標域名最大的開發請求數量，預設8
CONCURRENT_REQUESTS_PER_IP每個目標IP最大的併發請求數量，預設0，非0有效