I'm new to python programming, and I am trying to read a password protected file using python, the code is shown below:
import sys
import win32com.client
xlApp = win32com.client.Dispatch("Excel.Application")
print "Excel library version:", xlApp.Version
filename,password = 'C:\myfiles\foo.xls', 'qwerty12'
xlwb = xlApp.Workbooks.Open(filename, Password=password)
But then the xls file is loaded but still prompt me to provide the password, I can't let python to enter the password for me.
What have I done wrong? Thanks!
解決方案
Open takes two types of password, namely:
Password: password required to open a protected workbook.
WriteResPassword : password required to write to a write-reserved workbook
So in your case , is it write protected or protection on open?
Also there is a discussion on SO that says that this does not work with named parameters, So try providing all parameter values with the defaults
Default values are documented in MSDN
⑵ 使用python演算法如何解
解決方案
從一些測試案例開始總是好的做法。讓我們從小的案例開始，看看能否找到某種規律。
．N=1，1種爬樓方式：[1]
．N=2，2種爬樓方式：[1,1]，[2]
．N=3，3種爬樓方式：[1,2]，[1,1,1]，[2,1]
．N=4，5種爬樓方式：[1,1,2]，[2,2]，[1,2,1]，[1,1,1,1]，[2,1,1]
你有沒有注意到什麼？請看N=3時，爬完3階樓梯的方法數量是3，基於N=1和N=2。存在什麼關系？
爬完N=3的兩種方法是首先達到N=1，然後再往上爬2步，或達到N=2再向上爬1步。所以f(3)=f(2)+f(1)。
這對N=4是否成立呢？是的，這也是成立的。因為我們只能在達到第三個台階然後再爬一步，或者在到了第二個台階之後再爬兩步這兩種方式爬完4個台階。所以f(4)=f(3)+f(2)。
所以關系如下：f(n)=f(n–1)+f(n–2)，且f(1)=1和f(2)=2。這就是斐波那契數列。
deffibonacci(n):
ifn<=1:
return1
returnfibonacci(n-1)+fibonacci(n-2)
當然，這很慢（O(2^N)）——我們要做很多重復的計算！通過迭代計算，我們可以更快：
deffibonacci(n):
a,b=1,2
for_inrange(n-1):
a,b=b,a+b
returna
現在，讓我們嘗試概括我們學到的東西，看看是否可以應用到從集合X中取步數這個要求下的爬樓梯。類似的推理告訴我們，如果X={1,3,5}，那麼我們的演算法應該是f(n)=f(n–1)+f(n–3)+f(n–5)。如果n<0，那麼我們應該返回0，因為我們不能爬負數。
defstaircase(n,X):
ifn<0:
return0
elifn==0:
return1
elifninX:
return1+sum(staircase(n-x,X)forxinXifx<n)
else:
returnsum(staircase(n-x,X)forxinXifx<n)
這也很慢（O(|X|^N)），因為也重復計算了。我們可以使用動態編程來加快速度。
每次的輸入cache[i]將包含我們可以用集合X到達台階i的方法的數量。然後，我們將使用與之前相同的遞歸從零開始構建數組：
defstaircase(n,X):
cache=[0for_inrange(n+1)]
cache[0]=1
foriinrange(n+1):
cache[i]+=sum(cache[i-x]forxinXifi-x>0)
cache[i]+=1ifiinXelse0
returncache[-1]
現在時間復雜度為O(N*|X|)，空間復雜度為O(N)。
⑶ python怎麼連接websocket
websocket是一個瀏覽器和伺服器通信的新的協議，一般而言，瀏覽器和伺服器通信最常用的是http協議，但是http協議是無狀態的，每次瀏覽器請求信息，伺服器返回信息後這個瀏覽器和伺服器通信的信道就被關閉了，這樣使得伺服器如果想主動給瀏覽器發送信息變得不可能了，伺服器推技術在http時代的解決方案一個是客戶端去輪詢，或是使用comet技術，而websocket則和一般的socket一樣，使得瀏覽器和伺服器建立了一個雙工的通道。
具體的websocket協議在rfc6455裡面有，這里簡要說明一下。websocket通信需要先有個握手的過程，使得協議由http轉變為webscoket協議，然後瀏覽器和伺服器就可以利用這個socket來通信了。
首先瀏覽器發送握手信息，要求協議轉變為websocket
GET / HTTP/1.1
Host: example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Origin:
伺服器接收到信息後，取得其中的Sec-WebSocket-Key，將他和一個固定的字元串258EAFA5-E914-47DA-95CA-C5AB0DC85B11做拼接，得到的字元串先用sha1做一下轉換，再用base64轉換一下，就得到了回應的字元串，這樣伺服器端發送回的消息是這樣的
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
這樣握手就完成了，用python來實現這段握手過程的話就是下面這樣。
def handshake(conn):
key =None
data = conn.recv(8192)
if not len(data):
return False
for line in data.split('\r\n\r\n')[0].split('\r\n')[1:]:
k, v = line.split(': ')
if k =='Sec-WebSocket-Key':
key =base64.b64encode(hashlib.sha1(v +'258EAFA5-E914-47DA-95CA-C5AB0DC85B11').digest())
if not key:
conn.close()
return False
response ='HTTP/1.1 101 Switching Protocols\r\n'\
'Upgrade: websocket\r\n'\
'Connection: Upgrade\r\n'\
'Sec-WebSocket-Accept:'+ key +'\r\n\r\n'
conn.send(response)
return True
握手過程完成之後就是信息傳輸了，websocket的數據信息格式是這樣的。
+-+-+-+-+-------+-+-------------+-------------------------------+
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len | Extended payload length |
|I|S|S|S| (4) |A| (7) | (16/64) |
|N|V|V|V| |S| | (if payload len==126/127) |
| |1|2|3| |K| | |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
| Extended payload length continued, if payload len == 127 |
+ - - - - - - - - - - - - - - - +-------------------------------+
| | Masking-key, if MASK set to 1 |
+-------------------------------+-------------------------------+
| Masking-key (continued) | Payload Data |
+-------------------------------- - - - - - - - - - - - - - - - +
: Payload Data continued ... :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Payload Data continued ... |
+---------------------------------------------------------------+
值得注意的是payload len這項，表示數據的長度有多少，如果小於126，那麼payload len就是數據的長度，如果是126那麼接下來2個位元組是數據長度，如果是127表示接下來8個位元組是數據長度，然後後面會有四個位元組的mask，真實數據要由payload data和mask做異或才能得到，這樣就可以得到數據了。發送數據的格式和接受的數據類似，具體細節可以去參考rfc6455，這里就不過多贅述了。
Python的Websocket客戶端：Websocket-Client
Websocket-Client 是 Python 上的 Websocket 客戶端。它只支持 hybi-13，且所有的 Websocket API 都支持同步。
Installation
This mole is tested on Python 2.7 and Python 3.x.
Type "python setup.py install" or "pip install websocket-client" to install.
Caution!
from v0.16.0, we can install by "pip install websocket-client" for python 3.
This mole depend on
six
backports.ssl_match_hostname for Python 2.x
Python通過websocket與js客戶端通信示例分析
這里，介紹如何使用 Python 與前端 js 進行通信。
websocket 使用 HTTP 協議完成握手之後，不通過 HTTP 直接進行 websocket 通信。
於是，使用 websocket 大致兩個步驟：使用 HTTP 握手，通信。
js 處理 websocket 要使用 ws 模塊； Python 處理則使用 socket 模塊建立 TCP 連接即可，比一般的 socket ，只多一個握手以及數據處理的步驟。
包格式
js 客戶端先向伺服器端 python 發送握手包，格式如下：
GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Origin:
Sec-WebSocket-Protocol: chat, superchat
Sec-WebSocket-Version: 13
伺服器回應包格式：
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
Sec-WebSocket-Protocol: chat
其中， Sec-WebSocket-Key 是隨機的，伺服器用這些數據構造一個 SHA-1 信息摘要。
方法為： key+migic ， SHA-1 加密， base-64 加密
Python 中的處理代碼:
MAGIC_STRING = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
res_key = base64.b64encode(hashlib.sha1(sec_key + MAGIC_STRING).digest())
握手完整代碼
js 端
js 中有處理 websocket 的類，初始化後自動發送握手包，如下：
var socket = new WebSocket('ws://localhost:3368');
Python 端
Python 用 socket 接受得到握手字元串，處理後發送
HOST = 'localhost'
PORT = 3368
MAGIC_STRING = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
HANDSHAKE_STRING = "HTTP/1.1 101 Switching Protocols\r\n" \
"Upgrade:websocket\r\n" \
"Connection: Upgrade\r\n" \
"Sec-WebSocket-Accept: {1}\r\n" \
"WebSocket-Location: ws://{2}/chat\r\n" \
"WebSocket-Protocol:chat\r\n\r\n"
def handshake(con):
#con為用socket，accept()得到的socket
headers = {}
shake = con.recv(1024)
if not len(shake):
return False
header, data = shake.split('\r\n\r\n', 1)
for line in header.split('\r\n')[1:]:
key, val = line.split(': ', 1)
headers[key] = val
if 'Sec-WebSocket-Key' not in headers:
print ('This socket is not websocket, client close.')
con.close()
return False
sec_key = headers['Sec-WebSocket-Key']
res_key = base64.b64encode(hashlib.sha1(sec_key + MAGIC_STRING).digest())
str_handshake = HANDSHAKE_STRING.replace('{1}', res_key).replace('{2}', HOST + ':' + str(PORT))
print str_handshake
con.send(str_handshake)
return True
通信
不同版本的瀏覽器定義的數據幀格式不同， Python 發送和接收時都要處理得到符合格式的數據包，才能通信。
Python 接收
Python 接收到瀏覽器發來的數據，要解析後才能得到其中的有用數據。
固定位元組：
（ 1000 0001 或是 1000 0002 ）這里沒用，忽略
包長度位元組：
第一位肯定是 1 ，忽略。剩下 7 個位可以得到一個整數 (0 ~ 127) ，其中
（ 1-125 ）表此位元組為長度位元組，大小即為長度；
（126）表接下來的兩個位元組才是長度；
（127）表接下來的八個位元組才是長度；
用這種變長的方式表示數據長度，節省數據位。
mark 掩碼：
mark 掩碼為包長之後的 4 個位元組，之後的兄弟數據要與 mark 掩碼做運算才能得到真實的數據。
兄弟數據：
得到真實數據的方法：將兄弟數據的每一位 x ，和掩碼的第 i%4 位做 xor 運算，其中 i 是 x 在兄弟數據中的索引。
完整代碼
def recv_data(self, num):
try:
all_data = self.con.recv(num)
if not len(all_data):
return False
except:
return False
else:
code_len = ord(all_data[1]) & 127
if code_len == 126:
masks = all_data[4:8]
data = all_data[8:]
elif code_len == 127:
masks = all_data[10:14]
data = all_data[14:]
else:
masks = all_data[2:6]
data = all_data[6:]
raw_str = ""
i = 0
for d in data:
raw_str += chr(ord(d) ^ ord(masks[i % 4]))
i += 1
return raw_str
js 端的 ws 對象，通過 ws.send(str) 即可發送
ws.send(str)
Python 發送
Python 要包數據發送，也需要處理
固定位元組：固定的 1000 0001( 『 \x81 ′ )
包長：根據發送數據長度是否超過 125 ， 0xFFFF(65535) 來生成 1 個或 3 個或 9 個位元組，來代表數據長度。
def send_data(self, data):
if data:
data = str(data)
else:
return False
token = "\x81"
length = len(data)
if length < 126:
token += struct.pack("B", length)
elif length <= 0xFFFF:
token += struct.pack("!BH", 126, length)
else:
token += struct.pack("!BQ", 127, length)
#struct為Python中處理二進制數的模塊，二進制流為C，或網路流的形式。
data = '%s%s' % (token, data)
self.con.send(data)
return True
⑷ Python的特點（優點和缺點）
| Python有什麼優勢?
1、Python作為高級語言，面向對象自然不用說，但是相對於其他語言來說，Python是全對象語言，這是Python的一大特色。
2、Python語法簡潔，相對於其他底層語言和高級語言來說Python的語法簡潔好寫，具體的也不好統計，但是相對於C語言來說，實現同樣的功能C語言要100行代碼，Python一般也就30行左右，當然不同功能代碼量有所不同，而且Python沒有像其他語言那樣各種復雜的標點符號，這一點對書寫代碼的速度有很大提高。
3、使用Python的開發人員多，其實這一點很重要，使用的人多就有很多人來維護，開發它，修復他的漏洞，這樣Python的功能就會更完善，更強大。
4、宜讀：Python的語法類似於我們正常說話的流程，所以學習和書寫都很簡單，開發人員之間的交互也非常容易。
5、Python的解釋器彈性也很強，能嵌入很多其他語言之中。
| Python有哪些缺點?
1、Python和底層硬體交互起來比較費勁，很難實現嵌入式開發，即使實現性能也不是很理想。
2、Python的運行速度相對於其他底層語言來說比較慢，這里也是一樣，不一樣的程序代碼實現也有所不同，從網上發布的一些消息來看，Python比起C語言大概慢了幾十倍，大家不要認為慢了幾十倍就很慢，其實語言的通途有不同的方向，C主要是偏向於底層開發，Python傾向於應用層開發，雖然速度上相差幾十倍，但是0.1秒和0.001秒對於應用層來說幾乎沒有影響。
3、Python2和Python3不兼容，雖然是進步，但是對於很多Python2開發的程序更改起來就比較難，甚至需要重新開發。
4、代碼不能加密，發布出去的代碼就是源碼，不像C和C++那樣能直接編譯成機器碼，這也是C和C++能運行速度快的原因。
⑸ Python中的鎖都具有哪些
大致羅列一下：
一、全局解釋器鎖（GIL）
1、什麼是全局解釋器鎖
每個CPU在同一時間只能執行一個線程，那麼其他的線程就必須等待該線程的全局解釋器，使用權消失後才能使用全局解釋器，即使多個線程直接不會相互影響在同一個進程下也只有一個線程使用cpu，這樣的機制稱為全局解釋器鎖（GIL）。GIL的設計簡化了CPython的實現，使的對象模型包括關鍵的內建類型，如：字典等，都是隱含的，可以並發訪問的，鎖住全局解釋器使得比較容易的實現對多線程的支持，但也損失了多處理器主機的並行計算能力。
2、全局解釋器鎖的好處
1）、避免了大量的加鎖解鎖的好處
2）、使數據更加安全，解決多線程間的數據完整性和狀態同步
3、全局解釋器的缺點
多核處理器退化成單核處理器，只能並發不能並行。
4、GIL的作用：
多線程情況下必須存在資源的競爭，GIL是為了保證在解釋器級別的線程唯一使用共享資源（cpu）。
二、同步鎖
1、什麼是同步鎖？
同一時刻的一個進程下的一個線程只能使用一個cpu，要確保這個線程下的程序在一段時間內被cpu執，那麼就要用到同步鎖。
2、為什麼用同步鎖？
因為有可能當一個線程在使用cpu時，該線程下的程序可能會遇到io操作，那麼cpu就會切到別的線程上去，這樣就有可能會影響到該程序結果的完整性。
3、怎麼使用同步鎖？
只需要在對公共數據的操作前後加上上鎖和釋放鎖的操作即可。
4、同步鎖的所用：
為了保證解釋器級別下的自己編寫的程序唯一使用共享資源產生了同步鎖。
三、死鎖
1、什麼是死鎖？
指兩個或兩個以上的線程或進程在執行程序的過程中，因爭奪資源或者程序推進順序不當而相互等待的一個現象。
2、死鎖產生的必要條件？
互斥條件、請求和保持條件、不剝奪條件、環路等待條件
3、處理死鎖的基本方法？
預防死鎖、避免死鎖（銀行家演算法）、檢測死鎖（資源分配）、解除死鎖：剝奪資源、撤銷進程
四、遞歸鎖
在Python中為了支持同一個線程中多次請求同一資源，Python提供了可重入鎖。這個RLock內部維護著一個Lock和一個counter變數，counter記錄了acquire的次數，從而使得資源可以被多次require。直到一個線程所有的acquire都被release，其他的線程才能獲得資源。遞歸鎖分為可遞歸鎖與非遞歸鎖。
五、樂觀鎖
假設不會發生並發沖突，只在提交操作時檢查是否違反數據完整性。
六、悲觀鎖
假定會發生並發沖突，屏蔽一切可能違反數據完整性的操作。
python常用的加鎖方式：互斥鎖、可重入鎖、迭代死鎖、互相調用死鎖、自旋鎖大致羅列一下：
一、全局解釋器鎖（GIL）
1、什麼是全局解釋器鎖
每個CPU在同一時間只能執行一個線程，那麼其他的線程就必須等待該線程的全局解釋器，使用權消失後才能使用全局解釋器，即使多個線程直接不會相互影響在同一個進程下也只有一個線程使用cpu，這樣的機制稱為全局解釋器鎖（GIL）。GIL的設計簡化了CPython的實現，使的對象模型包括關鍵的內建類型，如：字典等，都是隱含的，可以並發訪問的，鎖住全局解釋器使得比較容易的實現對多線程的支持，但也損失了多處理器主機的並行計算能力。
2、全局解釋器鎖的好處
1）、避免了大量的加鎖解鎖的好處
2）、使數據更加安全，解決多線程間的數據完整性和狀態同步
3、全局解釋器的缺點
多核處理器退化成單核處理器，只能並發不能並行。
4、GIL的作用：
多線程情況下必須存在資源的競爭，GIL是為了保證在解釋器級別的線程唯一使用共享資源（cpu）。
二、同步鎖
1、什麼是同步鎖？
同一時刻的一個進程下的一個線程只能使用一個cpu，要確保這個線程下的程序在一段時間內被cpu執，那麼就要用到同步鎖。
2、為什麼用同步鎖？
因為有可能當一個線程在使用cpu時，該線程下的程序可能會遇到io操作，那麼cpu就會切到別的線程上去，這樣就有可能會影響到該程序結果的完整性。
3、怎麼使用同步鎖？
只需要在對公共數據的操作前後加上上鎖和釋放鎖的操作即可。
4、同步鎖的所用：
為了保證解釋器級別下的自己編寫的程序唯一使用共享資源產生了同步鎖。
三、死鎖
1、什麼是死鎖？
指兩個或兩個以上的線程或進程在執行程序的過程中，因爭奪資源或者程序推進順序不當而相互等待的一個現象。
2、死鎖產生的必要條件？
互斥條件、請求和保持條件、不剝奪條件、環路等待條件
3、處理死鎖的基本方法？
預防死鎖、避免死鎖（銀行家演算法）、檢測死鎖（資源分配）、解除死鎖：剝奪資源、撤銷進程
四、遞歸鎖
在Python中為了支持同一個線程中多次請求同一資源，Python提供了可重入鎖。這個RLock內部維護著一個Lock和一個counter變數，counter記錄了acquire的次數，從而使得資源可以被多次require。直到一個線程所有的acquire都被release，其他的線程才能獲得資源。遞歸鎖分為可遞歸鎖與非遞歸鎖。
五、樂觀鎖
假設不會發生並發沖突，只在提交操作時檢查是否違反數據完整性。
六、悲觀鎖
假定會發生並發沖突，屏蔽一切可能違反數據完整性的操作。
python常用的加鎖方式：互斥鎖、可重入鎖、迭代死鎖、互相調用死鎖、自旋鎖
⑹ 相似圖片檢測：感知哈希演算法之dHash的Python實現
某些情況下，我們需要檢測圖片之間的相似性，進行我們需要的處理：刪除同一張圖片、標記盜版等。
如何判斷是同一張圖片呢？最簡單的方法是使用加密哈希（例如MD5, SHA-1）判斷。但是局限性非常大。例如一個txt文檔，其MD5值是根據這個txt的二進制數據計算的，如果是這個txt文檔的完全復製版，那他們的MD5值是完全相同的。但是，一旦改變副本的內容，哪怕只是副本的縮進格式，其MD5也會天差地別。因此加密哈希只能用於判斷兩個完全一致、未經修改的文件，如果是一張經過調色或者縮放的圖片，根本無法判斷其與另一張圖片是否為同一張圖片。
那麼如何判斷一張被PS過的圖片是否與另一張圖片本質上相同呢？比較簡單、易用的解決方案是採用感知哈希演算法（Perceptual Hash Algorithm)。
感知哈希演算法是一類演算法的總稱，包括aHash、pHash、dHash。顧名思義，感知哈希不是以嚴格的方式計算Hash值，而是以更加相對的方式計算哈希值，因為「相似」與否，就是一種相對的判定。
如果我們要計算上圖的dHash值，第一步是把它 縮放到足夠小 。為什麼需要縮放呢？因為原圖的解析度一般都非常高。一張 200*200 的圖片，就有整整4萬個像素點，每一個像素點都保存著一個RGB值，4萬個RGB，是相當龐大的信息量，非常多的細節需要處理。因此，我們需要把圖片縮放到非常小，隱藏它的細節部分，只見森林，不見樹木。建議縮放為9*8，雖然可以縮放為任意大小，但是這個值是相對合理的。而且寬度為9，有利於我們轉換為hash值，往下面看，你就明白了。
(感謝評論區 隔壁萬能的小黑 同學，建議在 image.resize 中加上Image.ANTIALIAS參數，加上此參數將會對所有可以影響輸出像素的輸入像素進行高質量的重采樣濾波)
dHash全名為差異值hash，通過計算相鄰像素之間的顏色強度差異得出。我們縮放後的圖片，細節已經被隱藏，信息量已經變少。但是還不夠，因為它是彩色的，由RGB值組成。白色表示為（255,255,255）,黑色表示為（0,0,0），值越大顏色越亮，越小則越暗。每種顏色都由3個數值組成，也就是紅、綠、藍的值 。如果直接使用RGB值對比顏色強度差異，相當復雜，因此我們轉化為灰度值——只由一個0到255的整數表示灰度。這樣的話就將三維的比較簡化為了一維比較。
差異值是通過計算每行相鄰像素的強度對比得出的。我們的圖片為9*8的解析度，那麼就有8行，每行9個像素。差異值是每行分別計算的，也就是第二行的第一個像素不會與第一行的任何像素比較。每一行有9個像素，那麼就會產生8個差異值，這也是為何我們選擇9作為寬度，因為8bit剛好可以組成一個byte，方便轉換為16進制值。
如果前一個像素的顏色強度大於第二個像素，那麼差異值就設置為True（也就是1），如果不大於第二個像素，就設置為False（也就是0）。
我們將差異值數組中每一個值看做一個bit，每8個bit組成為一個16進制值，將16進制值連接起來轉換為字元串，就得出了最後的dHash值。
漢明距離這個概念不止運用於圖片對比領域，也被使用於眾多領域，具體的介紹可以參見Wikipedia。
漢明距離表示將A修改成為B，需要多少個步驟。比如字元串「abc」與「ab3」，漢明距離為1，因為只需要修改「c」為「3」即可。
dHash中的漢明距離是通過計算差異值的修改位數。我們的差異值是用0、1表示的，可以看做二進制。二進制0110與1111的漢明距離為2。
我們將兩張圖片的dHash值轉換為二進制difference，並取異或。計算異或結果的「1」的位數，也就是不相同的位數，這就是漢明距離。
如果傳入的參數不是兩張圖的dHash值，而是直接比較兩張圖片，那麼不需要生成dHash值，直接用Step3中的difference數組，統計不相同的位數，就是漢明距離。
一般來說，漢明距離小於5，基本就是同一張圖片。大家可以根據自己的實際情況，判斷漢明距離臨界值為多少。
https://github.com/hjaurum/DHash
⑺ Python 常用的標准庫以及第三方庫有哪些
標准庫
Python擁有一個強大的標准庫。Python語言的核心只包含數字、字元串、列表、字典、文件等常見類型和函數，而由Python標准庫提供了系統管理、網路通信、文本處理、資料庫介面、圖形系統、XML處理等額外的功能。
Python標准庫的主要功能有：
1.文本處理，包含文本格式化、正則表達式匹配、文本差異計算與合並、Unicode支持，二進制數據處理等功能
2.文件處理，包含文件操作、創建臨時文件、文件壓縮與歸檔、操作配置文件等功能
3.操作系統功能，包含線程與進程支持、IO復用、日期與時間處理、調用系統函數、日誌（logging）等功能
4.網路通信，包含網路套接字，SSL加密通信、非同步網路通信等功能
5.網路協議，支持HTTP，FTP，SMTP，POP，IMAP，NNTP，XMLRPC等多種網路協議，並提供了編寫網路伺服器的框架
6.W3C格式支持，包含HTML，SGML，XML的處理。
7.其它功能，包括國際化支持、數學運算、HASH、Tkinter等
Python社區提供了大量的第三方模塊，使用方式與標准庫類似。它們的功能覆蓋科學計算、Web開發、資料庫介面、圖形系統多個領域。第三方模塊可以使用Python或者C語言編寫。SWIG,SIP常用於將C語言編寫的程序庫轉化為Python模塊。Boost C++ Libraries包含了一組函式庫，Boost.Python，使得以Python或C++編寫的程式能互相調用。Python常被用做其他語言與工具之間的「膠水」語言。
著名第三方庫
1.Web框架
Django： 開源Web開發框架，它鼓勵快速開發,並遵循MVC設計，開發周期短。
ActiveGrid： 企業級的Web2.0解決方案。
Karrigell： 簡單的Web框架，自身包含了Web服務，py腳本引擎和純python的資料庫PyDBLite。
Tornado： 一個輕量級的Web框架，內置非阻塞式伺服器，而且速度相當快
webpy： 一個小巧靈活的Web框架，雖然簡單但是功能強大。
CherryPy： 基於Python的Web應用程序開發框架。
Pylons： 基於Python的一個極其高效和可靠的Web開發框架。
Zope： 開源的Web應用伺服器。
TurboGears： 基於Python的MVC風格的Web應用程序框架。
Twisted： 流行的網路編程庫，大型Web框架。
Quixote： Web開發框架。
2.科學計算
Matplotlib： 用Python實現的類matlab的第三方庫，用以繪制一些高質量的數學二維圖形。
SciPy： 基於Python的matlab實現，旨在實現matlab的所有功能。
NumPy： 基於Python的科學計算第三方庫，提供了矩陣，線性代數，傅立葉變換等等的解決方案。
3.GUI
PyGtk： 基於Python的GUI程序開發GTK+庫。
PyQt： 用於Python的QT開發庫。
WxPython： Python下的GUI編程框架，與MFC的架構相似。
4.其它
BeautifulSoup： 基於Python的HTML/XML解析器，簡單易用。
PIL： 基於Python的圖像處理庫，功能強大，對圖形文件的格式支持廣泛。
PyGame： 基於Python的多媒體開發和游戲軟體開發模塊。
Py2exe： 將python腳本轉換為windows上可以獨立運行的可執行程序。
⑻ python生成的py文件怎麼加密
使用任意加密演算法，或者按照隨機的密鑰進行錯亂擺放，即可起到加密的效果。這兩種方法都沒有破解方案
⑼ 如何使用python解決網站的反爬蟲
1、從用戶請求的Headers反爬蟲是最常見的反爬蟲策略。
偽裝header。很多網站都會對Headers的User-Agent進行檢測，還有一部分網站會對Referer進行檢測（一些資源網站的防盜鏈就是檢測Referer）。如果遇到了這類反爬蟲機制，可以直接在爬蟲中添加Headers，將瀏覽器的User-Agent復制到爬蟲的Headers中；或者將Referer值修改為目標網站域名[評論：往往容易被忽略，通過對請求的抓包分析，確定referer，在程序中模擬訪問請求頭中添加]。對於檢測Headers的反爬蟲，在爬蟲中修改或者添加Headers就能很好的繞過。
2、基於用戶行為反爬蟲
還有一部分網站是通過檢測用戶行為，例如同一IP短時間內多次訪問同一頁面，或者同一賬戶短時間內多次進行相同操作。[這種防爬，需要有足夠多的ip來應對]
（1）、大多數網站都是前一種情況，對於這種情況，使用IP代理就可以解決。可以專門寫一個爬蟲，爬取網上公開的代理ip，檢測後全部保存起來。有了大量代理ip後可以每請求幾次更換一個ip，這在requests或者urllib中很容易做到，這樣就能很容易的繞過第一種反爬蟲。
編寫爬蟲代理：
步驟：
1.參數是一個字典{'類型'：'代理ip：埠號'}
proxy_support=urllib.request.ProxyHandler({})
2.定製、創建一個opener
opener=urllib.request.build_opener(proxy_support)
3a.安裝opener
urllib.request.install_opener(opener)
3b.調用opener
opener.open(url)
用大量代理隨機請求目標網站，應對反爬蟲
⑽ python遠程操作windows伺服器有什麼方案
可以使用python+paramiko。 paramiko是用python語言寫的一個模塊，遵循SSH2協議，支持以加密和認證的方式，進行遠程伺服器的連接。 使用paramiko可以很好的解決以下問題： 需要使用windows客戶端， 遠程連接到Linux伺服器，查看上面的日誌狀態，批量配置遠程伺服器，文件上傳，文件下載等 具體可以參考： http://www.paramiko.org/