pythonhttps伺服器

㈠ python如何使用https請求

是發送請求吧，要發送請求的話，可以去網上下載request庫，自行調用，然後可以去csdn尋找使用方法，python內部是不支持發送網路請求包的哦QwQ。

㈡ python 怎麼發布到伺服器

使用pip或easy_install可以管理和安裝python的package包，實際上它們都是從pypi伺服器中搜索和下載package的。目前在pypi伺服器上，有超過三萬多個package，同時還允許我們將自己的代碼也上傳發布到伺服器上。這樣，世界上的所有人都能使用pip或easy_install來下載使用我們的代碼了。

具體步驟如下：

首先創建項目文件和setup文件。

目錄文件結構如下：

project/
simpletest/
__init__.py
test.py
setup.py

假設項目文件只有一個simpletest包，裡面有一個test.py文件。

創建的setup.py文件格式大致如下，其中，install_requires欄位可以列出依賴的包信息，用戶使用pip或easy_install安裝時會自動下載依賴的包。詳細的格式參考文檔。

from setuptools import setup, find_packages

setup(
name = 'simpletest',
version = '0.0.1',
keywords = ('simple', 'test'),
description = 'just a simple test',
license = 'MIT License',
install_requires = ['simplejson>=1.1'],

author = 'yjx',
author_email = '[email protected]',

packages = find_packages(),
platforms = 'any',
)

然後將代碼打包。

打包只需要執行python
setup.py xxx命令即可，其中xxx是打包格式的選項，如下：

# 以下所有生成文件將在當前路徑下 dist 目錄中
python setup.py bdist_egg # 生成easy_install支持的格式
python setup.py sdist # 生成pip支持的格式，下文以此為例

發布到pypi。

發布到pypi首先需要注冊一個賬號，然後進行如下兩步：

注冊package。輸入python setup.py register。
上傳文件。輸入python setup.py sdist upload。

安裝測試

上傳成功後，就可以使用pip來下載安裝了。

另外，pypi還有一個測試伺服器，可以在這個測試伺服器上做測試，測試的時候需要給命令指定額外的"-r"或"-i"選項，如python
setup.py register -r "https://testpypi.python.org/pypi",python
setup.py sdist upload -r "https://testpypi.python.org/pypi",pip
install -i "https://testpypi.python.org/pypi" simpletest。

發布到測試伺服器的時候，建議在linux或cygwin中發布，如果是在windows中，參考文檔，需要生成.pypirc文件，參考另一篇博文。

㈢ python最佳入門教程(1): python的安裝

本教程基於python3.x, 是針對初學者的一系列python入門教程，在知乎上常有人問我計算機該怎麼學，如何自學編程，筆者也是通過自學編程而進入IT這一行業的，回顧入行的這幾年，從音視頻流媒體輾轉到人工智慧深度學習，機器視覺，我是下了不少苦心的，對於如何學習有自己的一套理論和實踐方法，很多人自言學編程不得其門，把學不會歸咎於天分，其實芸芸眾生，智力無別，你現在所看到的是技術大牛們一個個超凡絕頂(然知此絕頂非彼絕頂)，看不到的是曾經的他們，也在每個晝夜裡用心苦學。再者學一門技術，需要勤學刻苦，是需要講究方法和基礎的，方法對了就事半功倍，所謂的天才也無不是建立在扎實的基礎之上。
在windows中安裝python
首先打開python官網https://www.python.org/，點擊頁面downloads導航按鈕，下載windows最新的基於web安裝的安裝器，右鍵以管理員身份運行 安裝包，會出現如下界面：
將Add Python 3.7 to PATH 進行勾選，勾選此項的目的在於將python解釋器加入系統環境變數，則在後續的python開發中可直接在windows 命令行中執行python腳本。所謂的環境變數是系統運行環境的一系列參數，比如這里的系統環境變數是PATH，PATH保存了與路徑相關的參數，系統在路徑查找中，會對PATH保存的路徑進行搜索。
點擊install Now按鈕執行python的安裝
打開windows命令行界面(按windows鍵輸入cmd命令),輸入python -V，出現python版本的相關輸出，即表示安裝成功。
在Linux系統中安裝python
筆者的系統是CentOS, Linux系統默認有安裝python,但是其版本是2.x,在這里筆者以源碼安裝的形式來安裝python 3.X。首先進入python源碼包頁面 點擊下載最新的gzip格式的python源碼包，上傳到伺服器然後進行解壓，解壓後的目錄結構如下圖所示：
Linux中的configure與make
configure是Linux中的腳本配置工具，用來對源碼的當前安裝環境進行檢測，若檢測無誤，會在當前目錄生成一個供源碼編譯的Makefile腳本文件。
make是Linux系統下的編譯安裝工具，用來解釋執行makefile文件中的腳本命令，編譯命令。
現在我們開始編譯安裝python
(1) 在當前目錄執行./configure(2) 輸入 make && sudo make install
若無指定安裝目錄，python會被默認安裝在/usr/local目錄中, 讀者可以執行./configure --prefix=「你自定義的安裝目錄」來配置安裝路徑。安裝完畢以後進入/usr/local/bin目錄，輸入 「python3.x -V」 (這里的python3.x為你所安裝的python版本)，若出現與python版本的相關輸出，即表示安裝成功。
為安裝的python設置軟鏈接
安裝的python可以以絕對路徑的方式來執行，每次敲一大段路徑來執行python未免麻煩，通常我們會給安裝的python設置軟鏈接，這里的軟鏈接類似於windows的快捷方式。
輸入以下命令來給python設置軟鏈接,筆者安裝的版本是python3.7, pip是python的包管理工具，會在教程的後續章節中進行詳細講解。
ln -s /usr/bin/python3 /usr/local/bin/python3.7 # 表示設置python3 為 /usr/local/bin/python3.7的快捷方式ln -s /usr/bin/pip3 /usr/local/bin/pip3.7 # 表示設置pip3 為 /usr/local/bin/pip3.7的快捷方式

㈣ python作為IIS伺服器後台，客戶端訪問HTTPS 亂碼求高人指點！！

查看文件，是不是utf-8編碼問題

㈤ 虛擬機不能訪問https://www.python.org/

1.首先還是需要查看虛擬機的網路設置（這邊要注意子網IP啥的哦）

2.查看網路連接

這邊的VMnet8如果是已經被禁用的話要記得啟用哦。

3.編輯VMnet8的屬性

使用手動配置的方法：保證IP地址和虛擬機的IP地址在同一個網段哦~ 不知道怎麼配置的同學，可以參考

https://blog.csdn.net/qq_30421153/article/details/86065073（這邊詳細解釋了如何設置虛擬機IP）

設置完成之後，打開xshell或者其他的遠程連接工具，就可以使用

一台虛機不可訪問一般以下幾個原因：
ESXi主機出現問題
vCenter出現問題
數據存儲出現問題

解決方案：
在所有三種情況下，以下是三個故障排除步驟：

第一步重新啟動ESXi中的管理代理。

1.使用SSH遠程登陸ESXi主機
2.執行以下命令重啟管理代理

/etc/init.d/hostd restart
/etc/init.d/vpxa restart

或者
services.sh restart

如果這一步不管用，嘗試第二步。

第二步是從清單中刪除VM，並使用vmx文件添加

右鍵點擊受影響虛擬機
選擇『Remove from the Inventory』（注意，不要選刪除VM）
之後找到VM的vmx位置
右鍵點擊虛擬機 『Add to the Inventory』
此步驟肯定會解決問題。但是需要我們知道VM的vmx位置，才能執行此步驟。如果不確定vmx的位置，則會導致添加錯誤的VM。

請記住，當VM不可訪問時，無法訪問vmdk位置來找到vmx路徑。

在這種情況下，最好的方法是使用命令行，即第三步

使用SSH登錄不可訪問虛擬機所在的主機
執行以下命令來獲取VM的vmid
vim-cmd vmsvc/getallvms

在這里插入圖片描述

將收到消息「Skippinginvalid VM 『144』』」以及有效VM的詳細信息。

跳過的VM將是無效的VM。值「 144」代表虛擬機的vmid。

現在運行以下命令重新載入無效的虛擬機

vim-cmd vmsvc/reload vmid #其中vmid是無效VM的ID

㈥ Python爬蟲筆記（二）requests模塊get，post，代理

  import requests

  base_url = 'https://www..com'

  response = requests.get(base_url)

        url=請求url，

        headers =請求頭字典，

        params = 請求參數字典。

        timeout = 超時時長，

    )---->response對象

  伺服器響應包含：狀態行（協議，狀態碼）、響應頭，空行，響應正文

    字元串格式：response.text

    bytes類型：response.content

        response.headers['cookie']

    response.text獲取到的字元串類型的響應正文，

    其實是通過下面的步驟獲取的：

        response.text = response.content.decode(response.encoding)

    產生的原因：編碼和解碼的編碼格式不一致造成的。

        str.encode('編碼')---將字元串按指定編碼解碼成bytes類型

        bytes.decode('編碼')---將bytes類型按指定編碼編碼成字元串。

    a、response.content.decode('頁面正確的編碼格式')

        <meta http-equiv="content-type" content="text/html;charset=utf-8">

    b、找到正確的編碼，設置到response.encoding中

        response.encoding = 正確的編碼

        response.text--->正確的頁面內容。

  a、沒有請求參數的情況下，只需要確定url和headers字典。

  b、get請求是有請求參數。

    在chrome瀏覽器中，下面找query_string_params,

    將裡面的參數封裝到params字典中。

  c、分頁主要是查看每頁中，請求參數頁碼欄位的變化，

  找到變化規律，用for循環就可以做到分頁。

  requests.post(

    url=請求url，

    headers = 請求頭字典，

    data=請求數據字典

    timeout=超時時長

  )---response對象

  post請求一般返回數據都是json數據。

（1）response.json()--->json字元串所對應的python的list或者dict

（2）用 json 模塊。

    json.loads(json_str)---->json_data(python的list或者dict)

    json.mps(json_data)--->json_str

  post請求能否成功，關鍵看**請求參數**。

  如何查找是哪個請求參數在影響數據獲取？

  --->通過對比，找到變化的參數。

  變化參數如何找到參數的生成方式，就是解決這個ajax請求數據獲取的途徑。

**尋找的辦法**有以下幾種：

    （1）寫死在頁面。

    （2）寫在js中。

    （3）請求參數是在之前的一條ajax請求的數據裡面提前獲取好的。

  代理形象的說，他是網路信息中轉站。

  實際上就是在本機和伺服器之間架了一座橋。

  a、突破自身ip訪問現實，可以訪問一些平時訪問不到網站。

  b、訪問一些單位或者團體的資源。

  c、提高訪問速度。代理的伺服器主要作用就是中轉，

  所以一般代理服務裡面都是用內存來進行數據存儲的。

  d、隱藏ip。

    ftp代理伺服器---21,2121

    HTTP代理伺服器---80,8080

    SSL/TLS代理：主要用訪問加密網站。埠：443

    telnet代理 ：主要用telnet遠程式控制制，埠一般為23

    高度匿名代理：數據包會原封不動轉化，在服務段看來，就好像一個普通用戶在訪問，做到完全隱藏ip。

    普通匿名代理：數據包會做一些改動，伺服器有可能找到原ip。

    透明代理：不但改動數據，還會告訴服務，是誰訪問的。

    間諜代理：指組織或者個人用於記錄用戶傳輸數據，然後進行研究，監控等目的的代理。   

  proxies = {

    '代理伺服器的類型':'代理ip'

  }

  response = requests.get(proxies = proxies)

  代理伺服器的類型:http,https,ftp

  代理ip:http://ip:port

㈦ Python要求扔了sslerror問題，怎麼解決

我在使用requests訪問某個https網站時出現錯誤
error:14090086:SSL routines:SSL3_GET_SERVER_CERTIFICATE:certificate verify failed

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Session Objects會話對象

Session對象在請求時允許你堅持一定的參數。此外，還堅持由Session實例的所有請求的cookie。

讓我們堅持在請求時使用

s = requests.Session()

s.get('httpsokie/123456789')
r = s.get("httrg/cookies")

print r.text
# '{"cookies": {"sessioncookie":"123456789"}}'

會話也可以用於提供默認的數據的請求的方法。這是通過提供的數據會話對象的屬性：

s = requests.Session()
s.auth = ('user', 'pass')
s.headers.update({'x-test': 'true'})

# both 'x-test' and 'x-test2' are sent
s.get('ht, headers={'x-test2': 'true'})

任何字典將被合並session級別的設置的值傳遞給請求方法。方法級別的參數覆蓋會話參數。

從一個字典參數中取值

如果你想在一個session中刪除一個參數，那麼你只需要設置它為none，他便自動被刪去。

在一個session中的所有值都包含直接提供給你。參閱Session API文檔了解更多信息。

請求和響應對象

>>> r = requests.get('hia.org/wiki/Monty_Python')

查看

>>> r.headers
{'content-length': '56170', 'x-content-type-options': 'nosniff','x-cache':
'HIT from cp1006.eqiad.wmnet, MISS from cp1010.eqiad.wmnet','content-encoding':
'gzip', 'age': '3080', 'content-language': 'en', 'vary':'Accept-Encoding,Cookie',
'server': 'Apache', 'last-modified': 'Wed, 13 Jun 2012 01:33:50 GMT',
'connection': 'close', 'cache-control': 'private, s-maxage=0, max-age=0,
must-revalidate', 'date': 'Thu, 14 Jun 2012 12:59:39 GMT', 'content-type':
'text/html; charset=UTF-8', 'x-cache-lookup': 'HIT fromcp1006.eqiad.wmnet:3128,
MISS from cp1010.eqiad.wmnet:80'}

但是，如果我們想要得到我們的伺服器發送的報頭，我們只需訪問請求，然後請求標頭：

>>> r.request.headers
{'Accept-Encoding': 'identity, deflate, compress, gzip',
'Accept': '*/*', 'User-Agent': 'python-requests/1.2.0'}

准備請求

當你在API呼叫或會話呼叫收到一個Response對象，請求屬性實際上是PreparedRequest使用。在某些情況下，發送請求之前，你不妨做一些額外的工作，身體或頭（或任何其他真的）。這個簡單的配方如下：

from requests import Request, Session

s = Session()
prepped = Request('GET', # or any other method, 'POST', 'PUT', etc.
url,
data=data
headers=headers
# ...
).prepare()
# do something with prepped.body
# do something with prepped.headers
resp = s.send(prepped,
stream=stream,
verify=verify,
proxies=proxies,
cert=cert,
timeout=timeout,
# etc.
)
print(resp.status_code)

既然你沒有做什麼特別的請求對象，你准備立即修改的PreparedRequest的對象。然後，您可以發送您所要發送的請求的其他參數。*或Sesssion中。*。

SSL證書驗證

請求可以驗證SSL證書的HTTPS請求，就像一個網路瀏覽器。檢查主機的SSL證書，您可以使用校驗參數：

>>> requests.get('httpreitz.com', verify=True)
requests.exceptions.SSLError: hostname 'kennethreitz.com' doesn't matcheither of '*.herokuapp.com', 'herokuapp.com'

我沒有對這個域的SSL設置，所以它的失敗。好極了 Github上雖然沒有：

>>> requests.get('httpb.com', verify=True)
<Response [200]>

您也可以通過驗證一個私人證書CA_BUNDLE文件的路徑。您還可以設置環境變數的REQUESTS_CA_BUNDLE。

如果你設置驗證設置為False，也可以忽略驗證SSL證書。

>>> requests.get('httpethreitz.com',cert=('/path/server.crt', '/path/key'))
<Response [200]>

如果指定了錯誤的路徑或無效的證書：

>>> requests.get('htreitz.com',cert='/wrong_path/server.pem')
SSLError: [Errno 336265225] _ssl.c:347: error:140B0009:SSLroutines:SSL_CTX_use_PrivateKey_file:PEM lib

主體內容工作流程

默認情況下，當你提出一個請求時，機體的反應是立即下載。您可以重寫此行為，並推遲下載響應的身體，直到您訪問Response.content，與流參數的屬性：

tarball_url = 'httnnethreitz/requests/tarball/master'
r = requests.get(tarball_url, stream=True)

僅在這一點上已下載的響應頭和連接保持打開狀態，從而使我們能夠使內容檢索條件：

if int(r.headers['content-length']) < TOO_LONG:
content = r.content
...

您可以進一步控制的使用的Response.iter_content和Response.iter_lines方法的工作流程，或從基本的urllib3 urllib3.HTTPResponse在Response.raw閱讀。

保持活動

需要注意的是發布的連接會回到池會重用所有以讀取的數據：
確保為設置數據流false或閱讀Response對象的內容屬性。

流上傳

請求支持它允許你發送大量的沒有讀取到內存的流或文件流上傳，。要流和上傳，只需為你的身體提供了一個類似文件的對象：

with open('massive-body') as f:
requests.post('httpl/streamed', data=f)

塊編碼請求：

還請支持分塊傳輸編碼傳出和傳入的請求。要發送一個數據塊編碼的請求，只是提供一個生成器（或任何沒有長度的迭代器）為您的BODY：

def gen():
yield 'hi'
yield 'there'

requests.post('http:/chunked', data=gen())

事件鉤子：

請求有一個鉤子，系統，你可以用它來處理申請過程中的部分或信號事件的處理。

您可以指定一個鉤子函數在每個請求的基礎上，通過一個{hook_name：callback_function}字典的鉤請求參數：

hooks=dict(response=print_url)

那CALLBACK_FUNCTION將收到的數據塊作為第一個參數。

>>> requests.get('httbin.org',hooks=dict(response=print_url))
<Response [200]>

自定義身份驗證

這callback_function將收到一大塊的數據作為第一個參數。

from requests.auth import AuthBase

class PizzaAuth(AuthBase):
"""Attaches HTTP Pizza Authentication tothe given Request object."""
def __init__(self, username):
# setup any auth-related datahere
self.username = username

def __call__(self, r):
# modify and return the request
r.headers['X-Pizza'] =self.username
return r

Then, we can make a request using our Pizza Auth:

>>> requests.get('httrg/admin',auth=PizzaAuth('kenneth'))
<Response [200]>

代理

import requests

proxies = {
"http": "ht:3128",
"https": "htt0.1.10:1080",
}

requests.get("hple.org", proxies=proxies)

您還可以配置代理伺服器環境HTTP_PROXY and HTTPS_PROXY.

$ export HTTP_PROXY="http://10.10.1.10:3128"
$ export HTTPS_PROXY="http://10.10.1.10:1080"
$ python
>>> import requests
>>> requests.get("hple.org")

To use HTTP Basic Auth with your proxy, use the http://user:password@host/syntax:

proxies = {
"http":"[email protected]:3128/",
}

遵守:

要求是為了符合相關的規范和RFC的合規性，不會造成困難，為用戶。這受到關注，可能會導致一些看似尋常的行為，可能對那些不熟悉有關規范。

編碼：

如果沒有明確的字元集是在HTTP頭中的Content-Type頭中包含文本。在這種情況下，RFC 2616指定默認的字元集必須是ISO-8859-1

HTTP動詞

要求提供訪問幾乎是全方位的HTTP動詞：GET，OPTIONS，HEAD，POST，PUT，PATCH和DELETE。下面提供了詳細的例子，使用這些不同的動詞在請求中，使用GitHub的API。

>>> import requests
>>> r =requests.get('httcom/repos/kennethreitz/requests/git/commits/')

因此，GitHub的返回JSON。我們可以使用r.json的方法來解析為Python對象。

>>> commit_data = r.json()
>>> print commit_data.keys()
[u'committer', u'author', u'url', u'tree', u'sha', u'parents', u'message']
>>> print commit_data[u'committer']
{u'date': u'2012-05-10T11:10:50-07:00', u'email': u'[email protected]',u'name': u'Kenneth Reitz'}
>>> print commit_data[u'message']
makin' history

請求可以很容易地使用各種形式的認證，包括很常見的基本身份驗證。

>>> from requests.auth import HTTPBasicAuth
>>> auth = HTTPBasicAuth('[email protected]','not_a_real_password')
>>> r = requests.post(url=url, data=body, auth=auth)
>>> r.status_code
201
>>> content = r.json()
>>> print content[u'body']
Sounds great! I'll get right on it.

㈧ python 鏈接https安裝什麼軟體

今天寫代碼時碰到一個問題，花了幾個小時的時間google，

首先需要安裝openssl，更新到最新版本後，在瀏覽器里看是否可訪問，如果是可以的，所以應該不是openssl有問題。
然後使用 curl嘗試訪問

curl -v
可以查看ssl版本，如果不能訪問，嘗試更換ssl版本

1
2
3
4
5

curl
-1

curl
-2 h

curl
-3

分別用上面的三句腳本去測試連接情況，發現第三種可以連接正常（-1,2,3，數字分別代碼tlsv1,sslv2,sslv3三個不同的SSL版本）。說明這個https連接所在的伺服器是基於SSLV3版本的。找到的問題，就很容易知道怎麼改寫Python代碼了。

1
2
3
4
5
6
7
8
9

class MyAdapter(HTTPAdapter):
def init_poolmanager(self,
connections, maxsize):
self.poolmanager
= PoolManager(num_pools=connections,
maxsize=maxsize,
ssl_version=ssl.PROTOCOL_SSLv3)

s
= requests.Session()
s.mount('https://',
MyAdapter())#所有的https連接都用ssl.PROTOCOL_SSLV3去連接
s.get('')

urllib2實現：

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

#
custom HTTPS opener, banner's oracle 10g server supports SSLv3 only
import httplib,
ssl, urllib2, socket
class HTTPSConnectionV3(httplib.HTTPSConnection):
def __init__(self,
*args,
**kwargs):
httplib.HTTPSConnection.__init__(self,
*args,
**kwargs)

def connect(self):
sock
= socket.create_connection((self.host,
self.port),
self.timeout)
if self._tunnel_host:
self.sock
= sock
self._tunnel()
try:
self.sock
= ssl.wrap_socket(sock,
self.key_file,
self.cert_file,
ssl_version=ssl.PROTOCOL_SSLv3)
except ssl.SSLError,
e:
print("Trying
SSLv3.")
self.sock
= ssl.wrap_socket(sock,
self.key_file,
self.cert_file,
ssl_version=ssl.PROTOCOL_SSLv23)

class HTTPSHandlerV3(urllib2.HTTPSHandler):
def https_open(self,
req):
return self.do_open(HTTPSConnectionV3,
req)
#
install opener
urllib2.install_opener(urllib2.build_opener(HTTPSHandlerV3()))

if __name__
== "__main__":
r
= urllib2.urlopen("https://ui2web1.apps.uillinois.e/BANPROD1/bwskfcls.P_GetCrse")
print(r.read())

可以看到這兩種方案的原理都是一樣，就是自定義連接處理器，改變連接時ssl的版本號。

㈨ python 運維常用腳本

Python 批量遍歷目錄文件,並修改訪問時間

import os

path = "D:/UASM64/include/"
dirs = os.listdir(path)
temp=[];

for file in dirs:
temp.append(os.path.join(path, file))
for x in temp:
os.utime(x, (1577808000, 1577808000))
Python 實現的自動化伺服器管理

import sys
import os
import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

def ssh_cmd(user,passwd,port,userfile,cmd):

def ssh_put(user,passwd,source,target):

while True:
try:
shell=str(input("[Shell] # "))
if (shell == ""):
continue
elif (shell == "exit"):
exit()
elif (shell == "put"):
ssh_put("root","123123","./a.py","/root/a.py")
elif (shell =="cron"):
temp=input("輸入一個計劃任務: ")
temp1="(crontab -l; echo "+ temp + ") |crontab"
ssh_cmd("root","123123","22","./user_ip.conf",temp1)
elif (shell == "uncron"):
temp=input("輸入要刪除的計劃任務: ")
temp1="crontab -l | grep -v " "+ temp + "|crontab"
ssh_cmd("root","123123","22","./user_ip.conf",temp1)
else:
ssh_cmd("lyshark","123123","22","./user_ip.conf",shell)

遍歷目錄和文件

import os

def list_all_files(rootdir):
import os
_files = []
list = os.listdir(rootdir) #列出文件夾下所有的目錄與文件
for i in range(0,len(list)):
path = os.path.join(rootdir,list[i])
if os.path.isdir(path):
_files.extend(list_all_files(path))
if os.path.isfile(path):
_files.append(path)
return _files

a=list_all_files("C:/Users/LyShark/Desktop/a")
print(a)
python檢測指定埠狀態

import socket

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.settimeout(1)

for ip in range(0,254):
try:
sk.connect(("192.168.1."+str(ip),443))
print("192.168.1.%d server open "%ip)
except Exception:
print("192.168.1.%d server not open"%ip)

sk.close()

python實現批量執行CMD命令

import sys
import os
import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

print("------------------------------> ")
print("使用說明,在當前目錄創建ip.txt寫入ip地址")
print("------------------------------> ")

user=input("輸入用戶名:")
passwd=input("輸入密碼:")
port=input("輸入埠:")
cmd=input("輸入執行的命令:")

file = open("./ip.txt", "r")
line = file.readlines()

for i in range(len(line)):
print("對IP: %s 執行"%line[i].strip(' '))

python3-實現釘釘報警

import requests
import sys
import json

dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='

data = {"msgtype": "markdown","markdown": {"title": "監控","text": "apche異常"}}

headers = {'Content-Type':'application/json;charset=UTF-8'}

send_data = json.mps(data).encode('utf-8')
requests.post(url=dingding_url,data=send_data,headers=headers)

import psutil
import requests
import time
import os
import json

monitor_name = set(['httpd','cobblerd']) # 用戶指定監控的服務進程名稱

proc_dict = {}
proc_name = set() # 系統檢測的進程名稱
monitor_map = {
'httpd': 'systemctl restart httpd',
'cobblerd': 'systemctl restart cobblerd' # 系統在進程down掉後，自動重啟
}

dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='

while True:
for proc in psutil.process_iter(attrs=['pid','name']):
proc_dict[proc.info['pid']] = proc.info['name']
proc_name.add(proc.info['name'])

判斷指定埠是否開放

import socket

port_number = [135,443,80]

for index in port_number:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((飗.0.0.1', index))
if result == 0:
print("Port %d is open" % index)
else:
print("Port %d is not open" % index)
sock.close()

判斷指定埠並且實現釘釘輪詢報警

import requests
import sys
import json
import socket
import time

def dingding(title,text):
dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='
data = {"msgtype": "markdown","markdown": {"title": title,"text": text}}
headers = {'Content-Type':'application/json;charset=UTF-8'}
send_data = json.mps(data).encode('utf-8')
requests.post(url=dingding_url,data=send_data,headers=headers)

def net_scan():
port_number = [80,135,443]
for index in port_number:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((飗.0.0.1', index))
if result == 0:
print("Port %d is open" % index)
else:
return index
sock.close()

while True:
dingding("Warning",net_scan())
time.sleep(60)

python-實現SSH批量CMD執行命令

import sys
import os
import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

def ssh_cmd(user,passwd,port,userfile,cmd):
file = open(userfile, "r")
line = file.readlines()
for i in range(len(line)):
print("對IP: %s 執行"%line[i].strip(' '))
ssh.connect(hostname=line[i].strip(' '),port=port,username=user,password=passwd)
cmd=cmd
stdin, stdout, stderr = ssh.exec_command(cmd)
result = stdout.read()

ssh_cmd("lyshark","123","22","./ip.txt","free -h |grep 'Mem:' |awk '{print $3}'")

用python寫一個列舉當前目錄以及所有子目錄下的文件，並列印出絕對路徑

import sys
import os

for root,dirs,files in os.walk("C://"):
for name in files:
print(os.path.join(root,name))
os.walk()

按照這樣的日期格式（xxxx-xx-xx）每日生成一個文件，例如今天生成的文件為2013-09-23.log， 並且把磁碟的使用情況寫到到這個文件中。

import os
import sys
import time

new_time = time.strftime("%Y-%m-%d")
disk_status = os.popen("df -h").readlines()

str1 = ''.join(disk_status)
f = open(new_time+'.log','w')
f.write("%s"%str1)

f.flush()
f.close()

統計出每個IP的訪問量有多少？（從日誌文件中查找）

import sys

list = []

f = open("/var/log/httpd/access_log","r")
str1 = f.readlines()
f.close()

for i in str1:
ip=i.split()[0]
list.append(ip)

list_num=set(list)

for j in list_num:
num=list.count(j)
print("%s -----> %s" %(num,j))

寫個程序，接受用戶輸入數字，並進行校驗，非數字給出錯誤提示，然後重新等待用戶輸入。

import tab
import sys

while True:
try:
num=int(input("輸入數字：").strip())
for x in range(2,num+1):
for y in range(2,x):
if x % y == 0:
break
else:
print(x)
except ValueError:
print("您輸入的不是數字")
except KeyboardInterrupt:
sys.exit(" ")

ps 可以查看進程的內存佔用大小，寫一個腳本計算一下所有進程所佔用內存大小的和。

import sys
import os

list=[]
sum=0

str1=os.popen("ps aux","r").readlines()

for i in str1:
str2=i.split()
new_rss=str2[5]
list.append(new_rss)
for i in list[1:-1]:
num=int(i)
sum=sum+num

print("%s ---> %s"%(list[0],sum))

關於Python 命令行參數argv

import sys

if len(sys.argv) < 2:
print ("沒有輸入任何參數")
sys.exit()

if sys.argv[1].startswith("-"):
option = sys.argv[1][1:]

利用random生成6位數字加字母隨機驗證碼

import sys
import random

rand=[]

for x in range(6):
y=random.randrange(0,5)
if y == 2 or y == 4:
num=random.randrange(0,9)
rand.append(str(num))
else:
temp=random.randrange(65,91)
c=chr(temp)
rand.append(c)
result="".join(rand)
print(result)

自動化-使用pexpect非交互登陸系統

import pexpect
import sys

ssh = pexpect.spawn('ssh [email protected]')
fout = file('sshlog.txt', 'w')
ssh.logfile = fout

ssh.expect("[email protected]'s password:")

ssh.sendline("密碼")
ssh.expect('#')

ssh.sendline('ls /home')
ssh.expect('#')

Python-取系統時間

import sys
import time

time_str = time.strftime("日期：%Y-%m-%d",time.localtime())
print(time_str)

time_str= time.strftime("時間：%H:%M",time.localtime())
print(time_str)

psutil-獲取內存使用情況

import sys
import os
import psutil

memory_convent = 1024 * 1024
mem =psutil.virtual_memory()

print("內存容量為:"+str(mem.total/(memory_convent))+"MB ")
print("已使用內存:"+str(mem.used/(memory_convent))+"MB ")
print("可用內存:"+str(mem.total/(memory_convent)-mem.used/(1024*1024))+"MB ")
print("buffer容量:"+str(mem.buffers/( memory_convent ))+"MB ")
print("cache容量:"+str(mem.cached/(memory_convent))+"MB ")

Python-通過SNMP協議監控CPU
注意：被監控的機器上需要支持snmp協議 yum install -y net-snmp*

import os

def getAllitems(host, oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid + '|grep Raw|grep Cpu|grep -v Kernel').read().split(' ')[:-1]
return sn1

def getDate(host):
items = getAllitems(host, '.1.3.6.1.4.1.2021.11')

if name == ' main ':

Python-通過SNMP協議監控系統負載
注意：被監控的機器上需要支持snmp協議 yum install -y net-snmp*

import os
import sys

def getAllitems(host, oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split(' ')
return sn1

def getload(host,loid):
load_oids = Ƈ.3.6.1.4.1.2021.10.1.3.' + str(loid)
return getAllitems(host,load_oids)[0].split(':')[3]

if name == ' main ':

Python-通過SNMP協議監控內存
注意：被監控的機器上需要支持snmp協議 yum install -y net-snmp*

import os

def getAllitems(host, oid):

def getSwapTotal(host):

def getSwapUsed(host):

def getMemTotal(host):

def getMemUsed(host):

if name == ' main ':

Python-通過SNMP協議監控磁碟
注意：被監控的機器上需要支持snmp協議 yum install -y net-snmp*

import re
import os

def getAllitems(host,oid):

def getDate(source,newitem):

def getRealDate(item1,item2,listname):

def caculateDiskUsedRate(host):

if name == ' main ':

Python-通過SNMP協議監控網卡流量
注意：被監控的機器上需要支持snmp協議 yum install -y net-snmp*

import re
import os

def getAllitems(host,oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split(' ')[:-1]
return sn1

def getDevices(host):
device_mib = getAllitems(host,'RFC1213-MIB::ifDescr')
device_list = []

def getDate(host,oid):
date_mib = getAllitems(host,oid)[1:]
date = []

if name == ' main ':

Python-實現多級菜單

import os
import sys

ps="[None]->"
ip=["192.168.1.1","192.168.1.2","192.168.1.3"]
flage=1

while True:
ps="[None]->"
temp=input(ps)
if (temp=="test"):
print("test page !!!!")
elif(temp=="user"):
while (flage == 1):
ps="[User]->"
temp1=input(ps)
if(temp1 =="exit"):
flage=0
break
elif(temp1=="show"):
for i in range(len(ip)):
print(i)

Python實現一個沒用的東西

import sys

ps="[root@localhost]# "
ip=["192.168.1.1","192.168.1.2","192.168.1.3"]

while True:
temp=input(ps)
temp1=temp.split()

檢查各個進程讀寫的磁碟IO

import sys
import os
import time
import signal
import re

class DiskIO:
def init (self, pname=None, pid=None, reads=0, writes=0):
self.pname = pname
self.pid = pid
self.reads = 0
self.writes = 0

def main():
argc = len(sys.argv)
if argc != 1:
print ("usage: please run this script like [./lyshark.py]")
sys.exit(0)
if os.getuid() != 0:
print ("Error: This script must be run as root")
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
os.system('echo 1 > /proc/sys/vm/block_mp')
print ("TASK PID READ WRITE")
while True:
os.system('dmesg -c > /tmp/diskio.log')
l = []
f = open('/tmp/diskio.log', 'r')
line = f.readline()
while line:
m = re.match(
'^(S+)(d+)(d+): (READ|WRITE) block (d+) on (S+)', line)
if m != None:
if not l:
l.append(DiskIO(m.group(1), m.group(2)))
line = f.readline()
continue
found = False
for item in l:
if item.pid == m.group(2):
found = True
if m.group(3) == "READ":
item.reads = item.reads + 1
elif m.group(3) == "WRITE":
item.writes = item.writes + 1
if not found:
l.append(DiskIO(m.group(1), m.group(2)))
line = f.readline()
time.sleep(1)
for item in l:
print ("%-10s %10s %10d %10d" %
(item.pname, item.pid, item.reads, item.writes))
def signal_handler(signal, frame):
os.system('echo 0 > /proc/sys/vm/block_mp')
sys.exit(0)

if name ==" main ":
main()

利用Pexpect實現自動非交互登陸linux

import pexpect
import sys

ssh = pexpect.spawn('ssh [email protected]')
fout = file('sshlog.log', 'w')
ssh.logfile = fout

ssh.expect("[email protected]'s password:")

ssh.sendline("密碼")

ssh.expect('#')
ssh.sendline('ls /home')
ssh.expect('#')

利用psutil模塊獲取系統的各種統計信息

import sys
import psutil
import time
import os

time_str = time.strftime( "%Y-%m-%d", time.localtime( ) )
file_name = "./" + time_str + ".log"

if os.path.exists ( file_name ) == False :
os.mknod( file_name )
handle = open ( file_name , "w" )
else :
handle = open ( file_name , "a" )

if len( sys.argv ) == 1 :
print_type = 1
else :
print_type = 2

def isset ( list_arr , name ) :
if name in list_arr :
return True
else :
return False

print_str = "";

if ( print_type == 1 ) or isset( sys.argv,"mem" ) :
memory_convent = 1024 * 1024
mem = psutil.virtual_memory()
print_str += " 內存狀態如下: "
print_str = print_str + " 系統的內存容量為: "+str( mem.total/( memory_convent ) ) + " MB "
print_str = print_str + " 系統的內存以使用容量為: "+str( mem.used/( memory_convent ) ) + " MB "
print_str = print_str + " 系統可用的內存容量為: "+str( mem.total/( memory_convent ) - mem.used/( 1024*1024 )) + "MB "
print_str = print_str + " 內存的buffer容量為: "+str( mem.buffers/( memory_convent ) ) + " MB "
print_str = print_str + " 內存的cache容量為:" +str( mem.cached/( memory_convent ) ) + " MB "

if ( print_type == 1 ) or isset( sys.argv,"cpu" ) :
print_str += " CPU狀態如下: "
cpu_status = psutil.cpu_times()
print_str = print_str + " user = " + str( cpu_status.user ) + " "
print_str = print_str + " nice = " + str( cpu_status.nice ) + " "
print_str = print_str + " system = " + str( cpu_status.system ) + " "
print_str = print_str + " idle = " + str ( cpu_status.idle ) + " "
print_str = print_str + " iowait = " + str ( cpu_status.iowait ) + " "
print_str = print_str + " irq = " + str( cpu_status.irq ) + " "
print_str = print_str + " softirq = " + str ( cpu_status.softirq ) + " "
print_str = print_str + " steal = " + str ( cpu_status.steal ) + " "
print_str = print_str + " guest = " + str ( cpu_status.guest ) + " "

if ( print_type == 1 ) or isset ( sys.argv,"disk" ) :
print_str += " 硬碟信息如下: "
disk_status = psutil.disk_partitions()
for item in disk_status :
print_str = print_str + " "+ str( item ) + " "

if ( print_type == 1 ) or isset ( sys.argv,"user" ) :
print_str += " 登錄用戶信息如下: "
user_status = psutil.users()
for item in user_status :
print_str = print_str + " "+ str( item ) + " "

print_str += "--------------------------------------------------------------- "
print ( print_str )
handle.write( print_str )
handle.close()

import psutil

mem = psutil.virtual_memory()
print mem.total,mem.used,mem
print psutil.swap_memory() # 輸出獲取SWAP分區信息

cpu = psutil.cpu_stats()
printcpu.interrupts,cpu.ctx_switches

psutil.cpu_times(percpu=True) # 輸出每個核心的詳細CPU信息
psutil.cpu_times().user # 獲取CPU的單項數據 [用戶態CPU的數據]
psutil.cpu_count() # 獲取CPU邏輯核心數，默認logical=True
psutil.cpu_count(logical=False) # 獲取CPU物理核心數

psutil.disk_partitions() # 列出全部的分區信息
psutil.disk_usage('/') # 顯示出指定的掛載點情況【位元組為單位】
psutil.disk_io_counters() # 磁碟總的IO個數
psutil.disk_io_counters(perdisk=True) # 獲取單個分區IO個數

psutil.net_io_counter() 獲取網路總的IO，默認參數pernic=False
psutil.net_io_counter(pernic=Ture)獲取網路各個網卡的IO

psutil.pids() # 列出所有進程的pid號
p = psutil.Process(2047)
p.name() 列出進程名稱
p.exe() 列出進程bin路徑
p.cwd() 列出進程工作目錄的絕對路徑
p.status()進程當前狀態[sleep等狀態]
p.create_time() 進程創建的時間 [時間戳格式]
p.uids()
p.gids()
p.cputimes() 【進程的CPU時間，包括用戶態、內核態】
p.cpu_affinity() # 顯示CPU親緣關系
p.memory_percent() 進程內存利用率
p.meminfo() 進程的RSS、VMS信息
p.io_counters() 進程IO信息，包括讀寫IO數及位元組數
p.connections() 返回打開進程socket的nametples列表
p.num_threads() 進程打開的線程數

import psutil
from subprocess import PIPE
p =psutil.Popen(["/usr/bin/python" ,"-c","print 'helloworld'"],stdout=PIPE)
p.name()
p.username()
p.communicate()
p.cpu_times()

psutil.users() # 顯示當前登錄的用戶，和Linux的who命令差不多

psutil.boot_time() 結果是個UNIX時間戳，下面我們來轉換它為標准時間格式，如下：
datetime.datetime.fromtimestamp(psutil.boot_time()) # 得出的結果不是str格式，繼續進行轉換 datetime.datetime.fromtimestamp(psutil.boot_time()).strftime('%Y-%m-%d%H:%M:%S')

Python生成一個隨機密碼

import random, string
def GenPassword(length):

if name == ' main ':
print (GenPassword(6))