pythoncron

⑴ python怎樣收集數據

這么具體的問題，找通用demo很難啊，個人覺得問題的難點不在Python。
1. 獲取什麼伺服器性能數據和如何獲取，可以請教公司內部運維。
2. 獲取什麼資料庫性能數據和如何獲取，可以請教公司內部DBA。
3. 以上兩點搞定了，才能確定臨時數據存儲結構和最終資料庫表結構。
以上三點是關鍵，Python的事情就簡單多了，提供一種思路：一分鍾一次，實時性不高，每台伺服器用cron部署一個a.py，用於獲取性能數據，在某一台伺服器有一個b.py，負責獲取所有伺服器a.py產生的數據，然後寫入資料庫；a.py如何上報到b.py取決於你擅長什麼，如果熟悉網路編程，用a.py做客戶端上報到服務端b.py，如果熟悉shell的文件同步(如rsync)，a.py只寫本地文件，b.py調用c.sh（封裝rsync）拉取遠程文件。

⑵ 如何解決python中循環的間隔時間控制

樓主說的需要一秒處理一個數據情況需要多線程Threading模塊來實現,下面這個程序是我寫的一個多線程的例子，希望能幫到樓主

=============thread.py===================
#coding:utf8
import time
import random
import datetime
import threading

'''
多線程測試文件
'''

#假定這個方法是樓主所說的處理方法，它需要花費一段時間
def process():
time.sleep(random.random())
print "PROCESS OK!"

#主函數
for x in range(100):
print "> The time is %s." % (datetime.datetime.today().strftime("%H:%M:%S"))
#此處創建一個線程對象
t = threading.Thread(target = process)
t.start()
#一秒處理一個數據
time.sleep(1)

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

看不懂樓主的意思，樓主有運行過我給你的代碼嗎？不是多線程可以解決的問題？

⑶ PHP開發人員的Python基礎知識

PHP（外文名:PHP: Hypertext Preprocessor，中文名：「超文本預處理器」）是一種通用開源腳本語言。語法吸收了C語言、Java和Perl的特點，利於學習，使用廣泛，主要適用於Web開發領域。那麼PHP開發人員的Python基礎知識都有哪些呢？以下僅供參考！

常用縮略語

Ajax：非同步 JavaScript + XML

XML：可擴展標記語言（Extensible Markup Language）

什麼是 Python？

Python 的定義是一種 「通用的高級編程語言」。它以簡潔性和易用性著稱，而且是少有的幾種對空格和縮進有要求的語言之一。Python 的主要作者 Guido Van Rossum 在社區中仍然非常活躍，並且被人們戲稱為仁慈的領導。

Python 的靈活性和緊湊性是值得稱贊的。它支持面向對象編程、結構化編程、面向方面編程以及函數編程等。Python 採用小內核設計，但具備大量擴展庫，從而確保了該語言的緊湊性和靈活性。

從語法的角度來說，您會發現 Python 的簡潔性異常突出——幾乎可以說是一種純粹的境界。PHP 開發人員要麼會對這種方法的語法深深陶醉，要麼會發現它的局限性。這主要取決於您自己的見解。Python 社區推動這種美感的態度是非常明確的，它們更加重視的是美學和簡潔性，而不是靈動的技巧。已形成 Perl 傳統（「可以通過多種方式實現它」）的 PHP 開發人員（像我自己）將面對一種完全相反的哲學（「應該只有一種方法可以實現它」）。

事實上，該社區定義了一種特有的代碼風格術語，即 Python 化（pythonic）。您可以說您的代碼是 Python 化，這是對 Python 術語的良好運用，同時還可展現語言的自然特性。本文並不打算成為 Pythonista（或 Pythoneer），但如果您想繼續 Python 之路，那麼千萬不能錯過本文的知識點。就像 PHP 有自己的編程風格，Perl 有自己的概念方法，學習 Python 語言必然也需要開始用該語言來思考問題。

另一個要點：在撰寫本文時，Python 的最新版本是 V3.0，但本文主要側重於 Python V2.6。Python V3.0 並不能向後兼容之前的版本，而且 V2.6 是使用最為廣泛的版本。當然，您可以根據需求使用自己喜好的版本。

Python 與 PHP 有何不同？

一般來說，PHP 是一種 Web 開發語言。是的，它提供了一個命令行介面，並且甚至可用於開發嵌入式應用程序，但它主要還是用於 Web 開發。相反，Python 是一種腳本語言，並且也可用於 Web 開發。從這方面來說，我知道我會這樣說——它比 PHP 更加接近 Perl。（當然，在其他方面，它們之間並無實際不同。我們繼續往下看。）

PHP 的語法中充斥著美元符號（$）和大括弧（{}），而 Python 相對來說則更加簡潔和干凈。PHP 支持 switch 和 do...while 結構，而 Python 則不盡然。PHP 使用三元操作符（foo?bar:baz）和冗長的函數名列表，而命名約定更是無所不有；相反，您會發現 Python 要簡潔多了。PHP 的數組類型可同時支持簡單列表和字典或散列，但 Python 卻將這兩者分開。

Python 同時使用可變性和不變性的概念：舉例來說，tuple 就是一個不可變的列表。您可以創建 tuple，但在創建之後不能修改它。這一概念可能要花些時間來熟悉，但對於避免錯誤極為有效。當然，更改 tuple 的惟一方法是復制它。因此，如果您發現對不可變對象執行了大量更改，則應該重新考量自己的方法。

之前提到，Python 中的縮進是有含義的：您在剛開始學習該語言時會對此非常難以適應。您還可以創建使用關鍵字作為參數的函數和方法——這與 PHP 中的標准位置參數迥然不同。面向對象的追隨者會對 Python 中真正的面向對象思想感到欣喜，當然還包括它的 「一級」 類和函數。如果您使用非英語語言，則會鍾愛於 Python 強大的.國際化和 Unicode 支持。您還會喜歡 Python 的多線程功能；這也是最開始令我為之著迷的特性之一。

綜上所述，PHP 和 Python 在許多方面都彼此類似。您可以方便地創建變數、循環，使用條件和創建函數。您甚至可以輕松地創建可重用的模塊。兩種語言的用戶社區都充滿活力和激情。PHP 的用戶群體更加龐大，但這主要歸因於它在託管伺服器及 Web 專注性方面的優勢和普及性。

很好 簡要介紹到此為止。我們開始探索之旅。

使用 Python

清單 1 展示了一個基本的 Python 腳本。

清單 1. 一個簡單的 Python 腳本

for i in range(20):

print(i)

清單 2 展示了腳本的必然結果。

清單 2. 清單 1 的結果

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

在深入探索之前，我們先來了解一些預備知識。首先從變數開始。

變數

可以看到，表示變數並不需要任何特殊的字元。變數 i 就是一個純粹的 i——毫無特殊之處。表示代碼塊或語言結束也不需要任何特殊字元（比如分號和括弧）；只需要在 for 行使用一個簡單的冒號即可（:）。還需注意，縮進會向 Python 指示哪些內容屬於 for 循環。舉例來說，清單 3 中的代碼會在循環中為各編號輸出一個說明。

清單 3. 為各循環添加一條語句

for i in range(20):

print(i)

print('all done?')

相反，清單 4 中的代碼會在循環結束處輸出一條說明。

清單 4. 在循環後添加一條語句

for i in range(20):

print(i)

print('all done!')

現在，我第一次看到這樣的代碼時，我認為這完全是無稽之談。什麼？讓我相信換行和縮進能保證代碼的結構和運行？請相信我，不用多久，您就會習慣它（但我需要承認必須到達到分號處才會結束語句的運行）。如果您與其他開發人員共同開發 Python 項目，則會發現這種可讀性的用處是多麼大了。您不再像以前那樣總是猜測 「這個聰明的傢伙在這里究竟想幹些什麼？」

在 PHP，您使用 = 操作符為變數分配值（參見 清單 5）。在 Python 中，您使用相同的操作符，只是需要標記或指向值。對於我來說，它就是賦值操作而已，我不需要過多擔心專門的術語。

清單 5. 創建變數

yorkie = 'Marlowe' #meet our Yorkie Marlowe!

mutt = 'Kafka' #meet our mutt Kafka

print(mutt) #prints Kafka

Python 的變數名稱約定與 PHP 類似：您在創建變數名時只能使用字母、數字和下劃線（_）。同樣，變數名的第一個字元不能是數字。Python 變數名是區分大小寫的，並且您不能使用特定的 Python 關鍵字（比如 if、else、while、def、or、and、not、in 和 is 開始符）作為變數名。這沒有什麼值得奇怪的。

Python 允許您隨意執行基於字元串的操作。清單 6 中的大多數操作應該都是您熟悉的。

清單 6. 常見的基於字元串的操作

yorkie = 'Marlowe'

mutt = 'Kafka'

ylen = len(yorkie) #length of variable yorkie

print(ylen) #prints 7

print(len(yorkie)) #does the same thing

len(yorkie) #also does the same thing, print is implicit

print(yorkie.lower()) #lower cases the string

print(yorkie.strip('aeiou')) #removes vowels from end of string

print(mutt.split('f')) #splits "Kafka" into ['Ka', 'ka']

print(mutt.count('a')) #prints 2, the number of a's in string

yorkie.replace('a','4') #replace a's with 4's

條件語句

您已經了解了如何使用 for 循環；現在，我們來討論條件語句。您會發現 Phyon 中的條件語句與 PHP 基本相同：您可以使用熟悉的 if/else型結構，如清單 7 所示。

清單 7. 一個簡單的條件測試

yorkie = 'Marlowe'

mutt = 'Kafka'

if len(yorkie) > len(mutt):

print('The yorkie wins!')

else:

print('The mutt wins!')

您還可以使用 if/elif/else（elif，等價於 PHP 中的 elseif）創建更加復雜的條件測試，如清單 8 所示。

清單 8. 一個比較復雜的條件測試

yorkie = 'Marlowe'

mutt = 'Kafka'

if len(yorkie) + len(mutt) > 15:

print('The yorkie and the mutt win!')

elif len(yorkie) + len(mutt) > 10:

print('Too close to tell!')

else:

print('Nobody wins!')

您可能會說，目前為止並沒有什麼與眾不同的地方：甚本上和想像中沒有太大區別。現在，我們來看 Python 處理列表的方式，您會發現兩種語言之間的不同之處。

列表

一種常用的列表類型是 tuple，它是不可變的。在 tuple 中載入一系列值之後，您不會更改它。Tuple 可以包含數字、字元串、變數，甚至其他 tuples。Tuples 從 0 開始建立索引，這很正常；您可以使用 -1 索引訪問最後一個項目。您還可以對 tuple 運行一些函數（請參見清單 9）。

清單 9. Tuples

items = (1, mutt, 'Honda', (1,2,3))

print items[1] #prints Kafka

print items[-1] #prints (1,2,3)

items2 = items[0:2] #items2 now contains (1, 'Kafka') thanks to slice operation

'Honda' in items #returns TRUE

len(items) #returns 4

items.index('Kafka') #returns 1, because second item matches this index location

列表與 tuple 類似，只不過它們是可變的。創建列表之後，您可以添加、刪除和更新列表中的值。列表使用方括弧，而不是圓括弧（()），如清單 10 所示。

清單 10. 列表

groceries = ['ham','spam','eggs']

len(groceries) #returns 3

print groceries[1] #prints spam

for x in groceries:

print x.upper() #prints HAM SPAM EGGS

groceries[2] = 'bacon'

groceries #list is now ['ham','spam','bacon']

groceries.append('eggs')

groceries #list is now ['ham', 'spam', 'bacon', 'eggs']

groceries.sort()

groceries #list is now ['bacon', 'eggs', 'ham', 'spam']

字典類似於關聯數組或散列；它使用鍵值對來存儲和限制信息。但它不使用方括弧和圓括弧，而是使用尖括弧。與列表類似，字典是可變的，這意味著您可以添加、刪除和更新其中的值（請參見清單 11）。

清單 11. 字典

colorvalues = {'red' : 1, 'blue' : 2, 'green' : 3, 'yellow' : 4, 'orange' : 5}

colorvalues #prints {'blue': 2, 'orange': 5, 'green': 3, 'yellow': 4, 'red': 1}

colorvalues['blue'] #prints 2

colorvalues.keys() #retrieves all keys as a list:

#['blue', 'orange', 'green', 'yellow', 'red']

colorvalues.pop('blue') #prints 2 and removes the blue key/value pair

colorvalues #after pop, we have:

#{'orange': 5, 'green': 3, 'yellow': 4, 'red': 1}

在 Python 中創建一個簡單的腳本

現在，您已經對 Python 有了一定的了解。接下來，我們將創建一個簡單的 Python 腳本。該腳本將讀取位於您的伺服器 /tmp 目錄下的 PHP 會話文件的數量，並在日誌文件中寫入摘要報告。在該腳本中，您將學習如何導入特定函數的模塊，如何使用文件，以及如何寫入日誌文件。您還將設置一系列變數來跟蹤所收集的信息。

清單 12 展示了整個腳本。打開一個編輯器，並將代碼粘貼到其中，然後在系統中將該文件保存為 tmp.py。然後，對該文件運行 chmod + x，使它成為可執行文件（假定您使用 UNIX? 系統）。

清單 12. tmp.py

#!/usr/bin/python

import os

from time import strftime

stamp = strftime("%Y-%m-%d %H:%M:%S")

logfile = '/path/to/your/logfile.log'

path = '/path/to/tmp/directory/'

files = os.listdir(path)

bytes = 0

numfiles = 0

for f in files:

if f.startswith('sess_'):

info = os.stat(path + f)

numfiles += 1

bytes += info[6]

if numfiles > 1:

title = 'files'

else:

title = 'file'

string = stamp + " -- " + str(numfiles) + " session "

+ title +", " + str(bytes) + " bytes "

file = open(logfile,"a")

file.writelines(string)

file.close()

在第一行中，您可以看到一個 hash-bang 行：它用於標識 Python 解釋器的位置。在我的系統中，它位於 /usr/bin/python。請根據系統需求調整這一行。

接下來的兩行用於導入特定的模塊，這些模塊將幫助您執行作業。考慮到腳本需要處理文件夾和文件，因此您需要導入 os 模塊，因為其中包含各種函數和方法，可幫助您列出文件、讀取文件和操作文件夾。您還需要寫入一個日誌文件，因此可以為條目添加一個時間戳 — 這就需要使用時間函數。您不需要所有時間函數，只需要導入 strftime函數即可。

在接下來的六行中，您設置了一些變數。第一個變數是 stamp，其中包含一個日期字元串。然後，您使用 strftime 函數創建了一個特定格式的時間戳 — 在本例中，時間戳的格式為 2010-01-03 12:43:03。

接下來，創建一個 logfile 變數，並在文件中添加一個實際存儲日誌文件消息的路徑（該文件不需要實際存在）。為簡單起見，我在 /logs 文件夾中放置了一個日誌文件，但您也可以將它放置在別處。同樣，path 變數包含到 /tmp 目錄的路徑。您可以使用任何路徑，只要使用斜杠作為結束即可 (/)。

接下來的三個變數也非常簡單：files 列表包含指定路徑中的所有文件和文件夾，另外還包含 bytes 和 numfiles 兩個變數。這兩個變數都設置為 0；腳本會在處理文件時遞增這些值。

完成所有這些定義之後，接下來就是腳本的核心了：一個簡單的 for 循環，用於處理文件列表中的各文件。每次運行循環時，腳本都會計算文件名；如果它以 sess_ 開頭，則腳本會對該文件運行 os.stat()，提取文件數據（比如創建時間、修改時間和位元組大小），遞增 numfiles 計數器並將該文件的位元組大小累計到總數中。

當循環完成運行後，腳本會檢查 numfiles 變數中的值是否大於 1。如果大於 1，則會將一個新的 title 變數設置為 files；否則，title 將被設置為單數形式的 file。

腳本的最後部分也非常簡單：您創建了一個 string 變數，並在該變數中添加了一行以時間戳開始的數據，並且其後還包含 numfiles（已轉換為字元串）和位元組（也已轉換為字元串）。請注意繼續字元（）；該字元可允許代碼運行到下一行。它是一個提高可讀性的小技巧。

然後，您使用 open() 函數以附加模式打開日誌文件（畢竟始終需要在該文件中添加內容），writelines() 函數會將字元串添加到日誌文件中，而 close() 函數用於關閉該文件。

現在，您已經創建了一個簡單的 Python 腳本。該腳本可用於完成許多任務，舉例來說，您可以設置一個 cron作業來每小時運行一次這個腳本，以幫助您跟蹤 24 小時內所使用的 PHP 會話的數量。您還可以使用 jQuery 或其他一些 JavaScript 框架通過 Ajax 連接這個腳本，用於為您提供日誌文件提要（如果採用這種方式，則需要使用 print命令來返回數據）。

⑷ python 怎麼定時每天在凌晨2點 輸出hello word 也就是到時間執行print he

定時執行一般需要符合以下條件

使用cron之類的計劃任務程序來調用

程序在後台循環執行

後台循環一般代碼：

importtime

whileTrue:
current_time=time.localtime(time.time())
if((current_time.tm_hour==2)and(current_time.tmin==0)and(current_time.tsec==0)):
print"HelloWorld"
time.sleep(1)

⑸ 如何使用Python讓某段程序固定在每天早上八點鍾開始運行

你在windows下根本不用這么麻煩:

首先,比如你的程序名字是 test.py
如果你想調用某個具體函數，就自己寫一個的文件，比如
import spider
spider.go()

然後，用系統at命令指定幾點幾分或者每個星期幾或者每個月的第幾個星期幾等執行某個程序。在執行程序的地方寫到：
c:\python25\python.exe myfile.py
這樣就可以了。

===================================

如果你覺得簡單的方法不好或者你要在其它系統下也可以用，那就這樣：

首先，寫一串代碼：大致意思如下，把_換成空格
import os,time,spider
while True:
__time.sleep(1)
__if time.ctime()[12:19]=="8:00:00" or time.ctime()[12:19]=="20:00:00" :
____spider.go() #舉個例子

然後，開機就執行這個文件。windows下可以把文件存為pyw然後開機啟動這樣沒有黑框。其它系統你愛怎麼樣都可以了（mac沒用過不知道）

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