模塊

時間  2019-12-14
標籤 模塊 简体版
原文   原文鏈接

目錄html

模塊導入

語法 做用 注意
improt 文件名,文件名 導入單個或多個模塊。
from 文件名 import 函數名,函數名 導入單個模塊的單個函數或多個函數。
from 文件名 import * 導入模塊內全部函數和變量。
import 頂層包.子包.文件名 導入包中的單個模塊，用包全稱調用。 包中必須有 __init__.py 文件
from 頂層包.子包 import 文件名,文件名 導入包中的單個或多個模塊，用文件名調用。 包中必須有 __init__.py 文件
from 頂層包.子包.文件名 import 函數名,函數名 導入包中的單個或多個函數，用函數調用。 包中必須有 __init__.py 文件

import time

四種類型前端

類型 類型 做用
時間戳 浮點型 時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。
結構化 元組 共有9個元素組。
格式化時間 字符串 已格式化的結構使時間更具可讀性。包括自定義格式和固定格式。
延時 無 延時。

時間戳

語法 做用
time.time() 本地時間
time.clock() 計算CPU運行時間
time.mktime() 本地結構化時間

結構化時間

語法 做用
time.gmtime() UTC結構化時間
time.localtime() 本地結構化時間

結構化屬性python

索引 屬性 值
0 tm_year（年） 2017
1 tm_mon（月） 1-12
2 tm_mday（日） 1-31
3 tm_hour（時） 0-23
4 tm_min（分） 0-59
5 tm_sec（秒） 0-61(60或61是潤秒)
6 tm_wday（一週中的第幾天） 0-6（0表示週一）
7 tm_yday（一年中的第幾天） 1-366
8 tm_isdst（是不是夏令時） 默認爲0

結構化取單個值的兩種方法程序員

方法 做用
1 變量.屬性
2 變量[索引]

格式化時間

語法 做用
time.strftime('%Y-%m-%d') 本地格式化時間
time.ctime(秒) 本地固定格式時間，添加參數從1970年計時
time.asctime(結構化時間) 本地固定格式時間

格式化符號web

符號 做用
%Y 四位數的年份表示（000-9999）
%m 月份（01-12）
%d 日（0-31）
%H 24小時制小時數（0-23）
%M 分鐘數（00=59）
%S 秒（00-59）
%c 簡化格式化時間
%x 本地相應的日期表示，用/分割
%X 本地相應的時間表示，用:分割
%B 本地完整的月份名稱
%b 本地簡化的月份名稱
%A 本地完整星期名稱
%a 本地簡化星期名稱
%j 年內的第幾天（001-366）
%p 本地AM或PM的等價符，12或24小時制
%U 一年中的星期數（00-53）星期天爲星期的開始
%w 星期（0-6），星期天爲星期的開始
%W 一年中的星期數（00-53）星期一爲星期的開始
%Z 當前時區的名稱
%% %號自己
%y 兩位數的年份表示（00-99）
%I 12小時制小時數（01-12）

種類轉換

語法 做用
time.strptime('2018-12-17','%Y-%m-%d') 格式化時間轉換結構化時間
time.strftime('%Y-%m-%d',結構化時間) 結構化時間轉換格式化時間
time.localtime(秒) 時間戳轉換結構化時間
time.ctime(秒) 時間戳轉換固定格式格式化時間
time.asctime(結構化時間) 結構化時間轉換固定格式格式化時間
time.mktime(格式化時間) 結構化轉時間戳

import datetime

datetime.datetime.now

# 本地格式化時間
>>> datetime.datetime.now() # 2018-12-16 16:45:20.194687

import random

random

# 0至1浮點型隨機數
>>> random.random() # 0.3137125524227292

randint

# 1至8整數型隨機數
>>> random.randint(1,8) # 2

chonice

# 隨機打印單個
>>> random.choices('hello') # ['e']

sample

# 隨機打印幾個元素可調節
>>> random.sample(['a','b','c'],1) # ['c']

randrange

# 1至2隨機數可調節
>>> random.randrange(1,3) # 2

import os

切換當前工做路徑

語法 做用
os.chdir(r"C:\Users") 切換當前工做路徑

查看當前路徑及路徑下的文件

語法 返回值 做用
os.getcwd() str 查看當前目錄
os.listdir('.') list 查看當前目錄全部文件

查看絕對路徑

語法 做用
os.path.abspath('.') 返回絕對路徑

查看路徑文件夾和文件名

語法 返回值 做用
os.path.split('F:\Easy Love\1.py') 元組 將路徑分解爲文件夾和文件名
os.path.join('F:\Easy Love','666') 拼接路徑
os.path.dirname('F:\Easy Love\1.py') 返回路徑中的文件夾部分結尾不包括 \
os.path.basename('F:\Easy Love\1.py') 返回路徑中的文件名

查看文件時間

語法 返回值 做用
os.path.getmtime('F:\Easy Love\1.py') 時間戳 文件或文件夾的最後修改時間
os.path.getatime('F:\Easy Love\1.py') 時間戳 文件或文件夾的最後訪問時間
os.path.getctime('F:\Easy Love\1.py') 時間戳 文件或文件夾的建立時間

查看文件大小

語法 做用
os.path.getsize('F:\Easy Love\1.py') 文件或文件夾的大小，如果文件夾返回0，字節類型。

查看文件是否存在

語法 返回值 做用
os.path.exists('F:\Easy Love\1.py') True | False 查看文件是否存在

一些表現形式參數

語法 做用
os.sep 表示 \\
os.extsep 表示 .
os.linesep 表示 \r\n

import sys

sys.argv

實現從程序外部向程序傳遞參數shell

sys.exit

退出程序，正常退出時exit(0)編程

sys.path

返回模塊的搜索路徑，初始化使用Python環境變量的值json

sys.modules

是一個全局字典，該字典是python啓動後就加載在內存中，每當程序員導入新的模塊，sys.modules將自動記錄該模塊，當第二次再導入該模塊時，python會直接到字典中查找,從而加快了程序運行的速度，它擁有字典所擁有的一切方法canvas

sys.platform

返回操做系統平臺名稱api

import hashlib

md5

# md5加密
m = hashlib.md5()
# b表明字符串就是bytes
m.update(b'hello')
# 等價於(b'helloworld')
b=m.update(b'world')
# 2進制格式hash
print(m.digest()) # b'\xfc^\x03\x8d8\xa5p2\x08TA\xe7\xfep\x10\xb0'
# 16進制格式hash
print(m.hexdigest()) # fc5e038d38a57032085441e7fe7010b0

sha1

# sha1加密
hash = hashlib.sha1()
hash.update(b'admin')
print(hash.hexdigest())

import logging

logging.getLogger

建立記錄器，參很多天志名稱

logging.StreamHandler

建立屏幕打印，參數爲空

logging.FileHandler

建立寫入文件，參數文件名稱

logging.Formatter

日誌格式 做用
%(name)s Logger的名字
%(levelno)s 數字形式的日誌級別
%(levelname)s 文本形式的日誌級別
%(pathname)s 調用日誌輸出函數的模塊的完整路徑名，可能沒有
%(filename)s 調用日誌輸出函數的模塊的文件名
%(module)s 調用日誌輸出函數的模塊名
%(funcName)s 調用日誌輸出函數的函數名
%(lineno)d 調用日誌輸出函數的語句所在的代碼行
%(created)f 當前時間，用UNIX標準的表示時間的浮點數表示
%(relativeCreated)d 輸出日誌信息時的，自Logger建立以來的毫秒數
%(asctime)s 字符串形式的當前時間，默認格式是'2003-07-08 16:49:45,896'逗號後面的是毫秒
%(thread)d 線程ID，可能沒有
%(threadName)s 線程名，可能沒有
%(process)d 進程ID，可能沒有
%(message)s 用戶輸出的消息

setFormatter

給屏幕打印和文件寫入添加日誌格式

addHandler

將屏幕打印和文件寫入添加到記錄器中

日誌等級

# 調試
debug('')
# 信息
info('')
# 警告
warn('')
# 錯誤
erroe('')
# 嚴重
critical('')

日誌記錄器

#日誌記錄器
import logging
# 建立記錄器,參數寫日誌名
logger = logging.getLogger('TEST-LOG')
# 日誌等級
logger.setLevel(logging.DEBUG)
# 屏幕打印
ch = logging.StreamHandler()
# 日誌等級
ch.setLevel(logging.DEBUG)
# 文件寫入,參數寫文件名
fh = logging.FileHandler("access.log")
# 日誌等級
fh.setLevel(logging.DEBUG)
)# 建立日誌格式
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'
# 將日誌格式添加到ch
ch.setFormatter(formatter)
# 將日誌格式添加到fh
fh.setFormatter(formatter)
# 將ch屏幕打印添加到記錄器
logger.addHandler(ch)
# 將fh文件寫入添加到記錄器
logger.addHandler(fh)
# 日誌記錄
logger.debug('debug message')
# 日誌記錄
logger.info('info message')
# 日誌記錄
logger.warn('warn message')
# 日誌記錄
logger.error('error message')
# 日誌記錄
logger.critical('critical message')

import re

根據條件匹配，條件匹配結束後內容沒有匹配完，反覆使用條件匹配直到全部內容匹配完爲止。

元字符

元字符 做用
. 除\n表明任意字符
^ 只能從頭開始匹配
$ 只能從結尾開始匹配
+ 前的一個字符1至n次匹配
* 字符串前端能匹配幾個是幾個，全匹上前一個字符0至n次匹配
{1,2} 前的一個字符匹配1個或2個字符串，直到匹配結束
? 只能匹配0次或1次
[^] 取反
| 匹配到其中一個就能夠
() 只顯示分組內的匹配
(?:) 分組有權限用?:去除就能夠所有顯示了
\d 匹配任意數字，同[0-9]
\D 匹配非數字，同[^0-9]
\s 匹配任何空白字符，同[ \t\n\r\f\v]
\S 匹配非空白字符，同[^\s]
\w 匹配包括下劃線在內的任何字母數字，同[a-zA-Z0-9_]
\W 匹配特殊字符，同[^a-zA-Z0-9_]
\b 匹配一個有特殊字符邊界的字符,好比空格，&，#
\B 匹配一個沒有特殊字符邊界的字符，好比空格，&，#
\A 僅匹配字符串開頭，同^
\Z 僅匹配字符串的結尾，同$

findall

# 元字符，全部結果都返回一個列表內

# .除\n表明任意字符
>>> re.findall('h..lo','hello world') # ['hello']
# ^只能從頭開始匹配
>>> re.findall('^hello','hello world') # ['hello']
# $只能從結尾開始匹配
>>> re.findall('hello$','hello world') # []
# +前的一個字符1至∞次匹配
>>> re.findall('hello+','hellooo world') # ['hellooo']
# *字符串前端能匹配幾個是幾個，全匹上前一個字符0至∞次匹配
>>> re.findall('helo*','hellooo world') # ['hel']
# {1,2}前的一個字符匹配2次，可調節
>>> re.findall('hello{1,2}','hellooo world') # ['helloo']
# ?只能匹配0次或1次
>>> re.findall('a?b?c', 'aac') # ['ac']
# [^]取反
>>> re.findall('a[^\d]d','acd') # ['acd']
# |匹配到其中一個就能夠
>>> re.findall('a|b','aabb') # ['a', 'a', 'b', 'b']
# ()只顯示分組內的匹配
>>> re.findall('123(ab)','123abc') # ['ab']
# (?:)分組有權限用?:去除就能夠所有顯示了
>>> re.findall('123(?:ab)','123abc') # ['123ab']

返回匹配到的一個對象，能夠調用如下方法返回結果

語法 返回類型 做用
group() str 返回被 re 匹配到的字符串。
start() int 返回匹配開始的位置。
end() int 返回匹配結束的位置。
span() tuple 返回一個元組，包含匹配開始結束的位置。 
# (?p<>)是分組命名格式，|是或的意識
>>> a=re.search('(?P<id>\d{2})|(?P<name>\w{3})','2/com')
# 調用search中匹配到的字符
>>> a.group() # 'com'
# 調用名字爲id分組匹配結果
>>> a.group('id')
# 調用名字爲name分組匹配的結果
>>> a.group('name') # 'com'

match

只在字符串開始匹配,返回一個對象，對象能夠調用group，返回結果

# 建立規則對象
obj = re.compile(r'www.*.com')
# 如今b就是一個對象
b = a.match('www.baidu.com')
print(b) # <_sre.SRE_Match object; span=(1, 14), match='www.baidu.com'>

split

分割字符串

# 用cd分割
>>> re.split('cd','abcdef') # ['ab', 'ef']
# 先用c分割再用d分割
>>> re.split('[cd]','abcdef') # ['ab', '', 'ef']

sub

修改字符串

# 3是個數參數，默認爲所有修改
>>> re.sub('a','b','aaaaa'1,3) # 'bbbaa'
# 10是個數參數，默認爲所有修改
>>> re.subn('a','b','aaaaa',10)

compole

建立的compole規則對象能夠用re其餘方法調用

# 建立規則對象
>>> object=re.compile(r'www.*.com')
# 用規則對象進行匹配
>>> object.findall('aaawww.bbb.comccc') # ['www.bbb.com']

findtier

返回的是一個迭代器

import re
b=re.finditer('\d','1a2b3c')
a=0
while True:
    if a<3:
        print(next(b).group()) # 1 2 3
        a+=1
    else:
        break

import json

咱們把對象(變量)從內存中變成可儲存或傳輸的過程稱之爲序列化，在Python中叫pickling，在其餘語言中也稱之爲serialization、marshalling、flattening等等，都是一個意識。

序列化以後就能夠把序列化後的內容寫入磁盤，或者經過網絡傳輸到其餘機器上反之，把變量內容從序列化的對象從新讀到內存裏稱之爲反序列化，即unpickling

若是咱們要在不一樣的編程語言之間傳遞對象，就必須把對象序列化爲標準格式，好比XML，但更好的辦法是序列化爲JSON，由於JSON表示出來就是一個字符串，能夠被全部語言讀取，也能夠方便存儲到磁盤或者經過網絡傳輸JSON不只是標註格式，而且比XML更快，並且能夠直接在Web頁面中讀取，很是方便

序列化

import json
dic={'name':'tangle','age':23,'sex':'male'}
print(type(dic)) # <class 'dict'>
j=json.dumps(dic)
print(type(j)) # <class 'str'>
f=open('序列化對象','w')
# 等價於 json.dump(dic,f)
f.write(j)
f.close()

反序列化

import json
f = open('序列化對象')
# 等價於 data=json.load(f)
data = json.loads(f.read())
print(data)
f.close

import pickle

序列化

import pickle
dic = {'name': 'tangle', 'age': 23, 'sex': 'male'}
print(type(dic)) # <class 'dict'>
j = pickle.dumps(dic)
print(type(j)) # <class 'bytes'>
# w是寫入str，wb是寫入bytes，j是bytes類型
f = open('序列化對象', 'wb')
# 等價於 pickle.dump(dic,f)
f.write(j)
f.close()

反序列化

import pickle
f = open('序列化對象', 'rb')
# 等價於 data=pickle.load(f)
data = pickle.loads(f.read())
print(data['age'])

import shelve

shelve模塊比pickle模塊簡單，只有一個open函數，返回相似字典的對象，可讀可寫，key必須爲字符串，而值能夠是Python全部支持的數據類型。

序列化

import shelve
# 打開文件
f= shelve.open(r'shelve.txt')
# 寫入文件
f['info_1']={'name':'tangle','age':'18'}
f['info_1']={'name':'python','age':'27'}
f.close()

反序列化

import shelve
# 打開文件
f = shelve.open(r'shelve.txt')
print(f.get('stu1_info')['age'] )# 18
data=f.get('school_info')
print(data)# {'website': 'oldboyedu.com', 'city': 'beijing'}

import win32

窗口

語法 輸出 做用
win32api.GetSystemMetrics(win32con.SM_CXSCREEN) 寬度分辨率 獲取寬度分辨率。
win32api.GetSystemMetrics(win32con.SM_CYSCREEN) 高度分辨率 獲取高度分辨率。
left,top,right,bottom = win32gui.GetWindowRect(句柄) (左,上,右,下) 獲取窗口左上角和右下角座標。
win32gui.PostMessage(hwnd, win32con.WM_CLOSE,0,0) 關閉窗口
win32gui.SetForegroundWindow(hwnd) 設置爲前臺
win32gui.SetForegroundWindow(句柄) 窗口置頂
語法 參數 作用
win32gui.ShowWindow(句柄, win32con. SW_HIDE) SW_HIDE 隱藏窗口，大小不變，激活狀態不變。
SW_MAXIMIZE 最大化窗口，顯示狀態不變，激活狀態不變。
SW_MINIMIZE 最小化窗口，顯示狀態不變，激活狀態不變。
SW_RESTORE 從最大化或最小化恢復正常大小，顯示狀態不變，激活狀態不變。
SW_SHOW 顯示並激活窗口，大小狀態不變。
SW_SHOWMAXIMIZED 顯示並激活窗口，以最大化顯示。
SW_SHOWMINIMIZED 顯示並激活窗口，以最小化顯示。
SW_SHOWMINNOACTIVE 顯示窗口並最小化，激活狀態不變。
SW_SHOWNA 顯示窗口，大小狀態不變，激活狀態不變。
SW_SHOWNOACTIVATE 顯示並從最大化或最小化恢復正常大小，激活狀態不變。
SW_SHOWNORMAL 顯示並激活窗口，恢復正常大小。

句柄

語法 輸出 做用
win32gui.FindWindow('類名', '窗口標題') 句柄 經過類名標題獲取窗口句柄，類名不知道能夠填寫 0。
win32gui.GetWindowRect(句柄) (x座標,y座標,寬度,高度) 返還窗口信息元祖類型
win32gui.FindWindowEx(句柄, None, 類名, 窗口標題) 句柄 經過父句柄獲取子句柄
hwndChildList = []
win32gui.EnumChildWindows(句柄, lambda hwnd, param: param.append(hwnd),hwndChildList)		 根據句柄列出子句柄，若是句柄爲 None 列出全部主句柄。

鼠標

語法 輸出 做用
win32api.GetCursorPos() (x座標, y座標) 獲取鼠標座標。
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN,0,0,0,0) 鼠標左鍵按下
win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP,0,0,0,0) 鼠標左鍵彈起
win32api.mouse_event(win32con.MOUSEEVENTF_RIGHTDOWN,0,0,0,0) 鼠標右鍵按下
win32api.mouse_event(win32con.MOUSEEVENTF_RIGHTUP,0,0,0,0) 鼠標右鍵彈起
win32api.SetCursorPos((x, y)) 設置鼠標位置
win32api.SendMessage(句柄,win32con.WM_LBUTTONDOWN,win32con.MK_LBUTTON,win32api.MAKELONG(x座標,y座標)) 後臺鼠標左鍵按下
win32api.SendMessage(句柄,win32con.WM_LBUTTONUP,win32con.MK_LBUTTON,win32api.MAKELONG(x座標,y座標)) 後臺鼠標左鍵彈起

鍵盤

語法 做用
win32gui.SetForegroundWindow(0) 綁定窗口
win32api.keybd_event(鍵代碼, 0, 0, 0) 按下
win32api.keybd_event(鍵代碼, 0, 0, 0) 彈起

根據句柄獲取句柄標題和類名

語法 輸出 做用
title = win32gui.GetWindowText(句柄) 標題 獲取標題
clsname = win32gui.GetClassName(句柄) 類名 獲取類名

菜單

語法 做用
menu = win32gui.GetMenu(句柄) 獲取第幾個主菜單
menu1 = win32gui.GetSubMenu(menu, 0) 獲取第幾個主菜單
cmd_ID = win32gui.GetMenuItemID(menu1, 2) 獲取第幾個子菜單 ID
win32gui.PostMessage(句柄, win32con.WM_COMMAND, cmd_ID, 0) 點擊菜單 
import win32con
import win32gui

hwnd = win32gui.FindWindow('SciCalc','計算器')
menu = win32gui.GetMenu(hwnd)
menu1 = win32gui.GetSubMenu(menu, 0)
cmd_ID = win32gui.GetMenuItemID(menu1, 1)
win32gui.PostMessage(hwnd, win32con.WM_COMMAND, cmd_ID, 0)

def get_menu_item_txt(menu,idx):
    import win32gui_struct
    # 新建一個win32gui的空的結構體mii
    mii, extra = win32gui_struct.EmptyMENUITEMINFO()
    # 將子菜單內容獲取到mii
    win32gui.GetMenuItemInfo(menu, idx, True, mii)
    # 解包mii
    ftype, fstate, wid, hsubmenu, hbmpchecked, hbmpunchecked,\
    dwitemdata, text, hbmpitem = win32gui_struct.UnpackMENUITEMINFO(mii)
    return text

for i in range(3):
    print(get_menu_item_txt(menu,i))

for i in range(2):
    print(get_menu_item_txt(menu1,i))

import threading

語法 做用
t = threading.Thread(target = 函數名,args = (參數)) 建立線程。
t.start() 執行線程調用建立線程中的函數。
t.setDaemon(True) 每一個線程設置此方法，主線程結束子線程也結束
threading.active_count() 查看當前運行多少個線程
t.join() 等待線程結束 
import threading

def demo():
    while True:
        if not ev1.wait(): break

ev1 = threading.Event()
ev1.set()

t = threading.Thread(target=demo)
t.start()

ev1.clear()

線程鎖

禁止 cpu 切換，鎖中的代碼串行運行

r = threading.Lock()
r.acquire()
print('demo')
r.release()

可重用鎖

r = threading.RLock()
r.acquire()
print('demo')
r.release()

信號量

semaphore=threading.BoundedSemaphore(5)
r.acquire()
print('demo')
r.release()

import tkinter

語法 做用
window = tk.TK() 建立窗口。
window.title('窗口名') 窗口標題名。
window.geometry('500x300+200+50') 設置窗口的長寬和位置。
window.wm_attributes('-topmost',1) 窗口置頂。
time = StringVar() 聲明字符串鉤子
time.set('1') 設置初始值
window.destroy() 關閉窗口。
window.mainloop() 主窗口循環更新。 
import tkinter as tk
from tkinter import messagebox
from tkinter import ttk

window = tk.Tk()
window.title('My Window')
window.geometry('500x300')

def demo():
    pass

b1 = tk.Button(window, text='文本', font=('Arial', 12), width=10, height=1, command=demo)
b1.pack()

window.mainloop()

窗口禁止關閉

def closeWindow():
    messagebox.showerror(title='警告',message='沒錯你關不掉')
    return
window.protocol('WM_DELETE_WINDOW', closeWindow)

Label 標籤

語法 做用
l = tk.label(window,text = '文本'，bg = '顏色',font = ('Arial',12),width = 30,height = 2) 建立標籤
l.pack() 顯示標籤

Button 按鈕

語法 做用
b = tk.Button(window, text='文本', font=('Arial', 12), width=10, height=1, command=函數名) 建立按鈕。
b.pack() 顯示按鈕。

Entry 輸入框

語法 做用
e1 = tk.Entry(window, show='*', font=('Arial', 14) 建立輸入框，密文顯示。
e1.pack() 放置輸入框
e2 = tk.Entry(window, show=None, font=('Arial', 14)) 建立輸入框，明文顯示。
e2.pack() 放置輸入框
e.get() 輸出輸入框中的內容，能夠做爲變量。

Text 文本框

語法 做用
text = tk.Text(window,height = 3) 建立文本框
text.pack() 放置文本框
text.insert('insert',文本) 在文本框鼠標標點處插入。
text.insert('end',文本) 在文本框末尾處插入。
text.mark_set('mark',1.0) 1.0 或 1.1 設置標記插入位置
text.insert('mark',文本) 在標記處插入
text.mark_gravity('mark',LEFT) 標記在右側插入

按鈕改變文本

foo = StringVar()
foo.set("開")
def demo():
    foo.set("關")
按鈕 = tk.Button(window,textvariable=foo,command=開始1)
按鈕.grid(row=5, column=0, padx=10, pady=5)

Listbox 窗口部件

列表框

Radiobutton 窗口部件

單選框

Checkbutton 窗口部件

複選框

Scale 窗口部件

刻度條

Canvas 窗口部件

畫布

語法 做用
菜單欄 = tk.Menu(window) 建立一個菜單欄
菜單項 = tk.Menu(菜單欄, tearoff=0) 建立一個菜單項，默認不下拉。
菜單欄.add_cascade(label='菜單名', menu=菜單項) 空菜單命名
菜單項.add_command(label='子菜單名', command=函數名) 在菜單項中加入子菜單
菜單項.add_separator() 在菜單項中加入一條分割線
菜單項2 = tk.Menu(菜單欄, tearoff=0) 建立第二個菜單項,默認不下拉
菜單欄.add_cascade(label='菜單名', menu=菜單項2) 空菜單命名
菜單項2.add_command(label='子菜單名', command=函數名) 在菜單項中加入子菜單
二級菜單 = tk.Menu(菜單項) 建立二級菜單，即菜單項裏面的菜單。
菜單項.add_cascade(label='菜單名', menu=二級菜單, underline=0) 在菜單項下面建立一個菜單項
二級菜單.add_command(label='菜單名', command=函數名) 建立第三級菜單命令
window.config(menu=菜單欄) 放置菜單欄

Combobox 下拉選擇

語法 做用
cv = tk.stringVar() 綁定變量
com = ttk.Combobox(window, textvariable=cv) 建立下拉框
com.pack() 放置下拉框
com["value"] = ('文本',''文本'') 設置下拉數據
com.current() 設置默認值
com.bind("< >", 函數名) 下拉數據點擊調用函數

Frame 窗口部件

messageBox 彈窗

語法 做用
tk.messagebox.showwarning(title='窗口名', message='警告信息') 警告信息彈窗
tk.messagebox.showinfo('窗口名','提示信息') 提示信息彈窗
tk.messagebox.showerror('窗口名','錯誤信息') 錯誤信息彈窗
語法 返回值 做用
tk.messagebox.askokcancel('提示','要執行此操做嗎') True | False (疑問)肯定取消對話框
tk.messagebox.askquestion('提示', '要執行此操做嗎') yes | no (疑問)是否對話框
tk.messagebox.askyesno('提示', '要執行此操做嗎') True | False (疑問)是否對話框
tk.messagebox.askretrycancel('提示', '要執行此操做嗎') True | False (警告)重試取消對話框
語法 返回值 做用
tk.filedialog.asksaveasfilename() 含後綴文件目錄 另存爲窗口彈窗。
tk.filedialog.asksaveasfile() 文件流對象 另存爲窗口彈窗，會建立文件。
tkinter.filedialog.askopenfilename() 含後綴文件目錄 打開文件彈窗。
tk.filedialog.askopenfile() 文件流對象 打開文件彈窗，
tk.filedialog.askdirectory() 目錄名 選擇文件彈窗
tk.filedialog.askopenfilenames() 元組 打開多個文件名
tk.filedialog.askopenfiles()# 列表 多個文件流對象

部件放置方式

放置方式 參數 做用
grid row = 0 行
colum = 0 列
padx = 0 單元格左右間距
pady = 0 單元格上下間距
ipadx = 0 單元格內部元素與單元格的左右間距
ipady = 0 單元格內部元素與單元格的上下間距 
.grid(row = 0,column = 0,padx = 0,pady = 0,ipadx = 0,ipady = 0)
放置方式 參數 做用
pack side = 'top' 上
side = 'bottom' 下
side = 'left' 左
side = 'right' 右 
.pack(side='top')
放置方式 參數 做用
place x = 0 座標 x
y = 0 座標 y
anchor = 'nw' 錨定點 
.place(x = 0,y = 0, anchor = 'nw')

import configparser

建立 config.ini

語法 做用
config = configparser.ConfigParser() 實例化
config['DATE'] = {'date': '2019-05-08'} 設置配置 
import configparser

config = configparser.ConfigParser() # 注意大小寫
config['DATE'] = {'date': '2019-05-08'}

with open('f:\config.ini', 'w') as configfile:
    config.write(configfile)

讀取 config.ini

語法 返回值 做用
config.sections() 列表 獲取全部項
config.items('DATE') 列表嵌套元組 獲取項的鍵和值
config.options('DATE') 列表 獲取項的鍵
config['DATE']['date'] 字符串 獲取項的值 
import configparser

config = configparser.ConfigParser()
config.read('f:\config.ini')
print(config.sections())
print(config.items('DATE'))
print(config.options('DATE'))
print(config['DATE']['date'])
print(type(config['DATE']['date']))

import schedule

任務計劃

語法 做用
schedule.every(10).minutes.do(函數,參數) 每隔十分鐘執行一次任務
schedule.every().hour.do(函數,參數) 每隔一小時執行一次任務
schedule.every().day.at("10:30:").do(函數,參數) 天天的 10:30 執行一次任務
schedule.every(5).to(10).days.do(函數,參數) 每隔 5 到 10 天執行一次任務
schedule.every().monday.do(函數,參數) 每週一的這個時候執行一次任務
schedule.every().wednesday.at("13:15").do(函數,參數) 每週三 13:15 執行一次任務
schedule.run_pending() 運行全部能夠運行的任務 
import schedule
import time
 
def fun():
    print('demo')
 
schedule.every(0.01).minutes.do(fun)
schedule.every().hour.do(fun)
schedule.every().day.at("22:43:50").do(fun)
schedule.every(5).to(10).days.do(fun)
schedule.every().monday.do(fun)
schedule.every().wednesday.at("13:15").do(fun)
 
while True:
    time.sleep(1)
    schedule.run_pending()

import socket

服務端套接字

參數 做用
socket.SOCK_STREAM TCP
socket.SOCK_DGRAM UDP
AF_INET 服務器之間的通信
AF_INET6 服務器之間的通信
AF_UNIX UNIX 不一樣進程間的通信
語法 做用
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 建立 socket 對象
host = socket.gethostname() 獲取本地主機名
port = 9999
serversocket.bind((host, port))		 綁定端口號
serversocket.listen(5) 設置最大鏈接數，超事後排隊
clientsocket, addr = serversocket.accept() 創建客戶端鏈接
clientsocket.send(msg.encode('utf-8')) 發送消息
clientsocket.send(bytes(msg,'utf-8')) 發送消息
clientsocket.close() 關閉套接字 
import socket

serversocket = socket.socket(
    socket.AF_INET, socket.SOCK_STREAM)

host = socket.gethostname()
port = 9999
serversocket.bind((host, port))

serversocket.listen(5)

while True:
    clientsocket, addr = serversocket.accept()
    msg = 'demo' + "\r\n"
    print(msg.encode('utf-8'))
    print(bytes(msg,'utf-8'))
    clientsocket.send(msg.encode('utf-8'))
    clientsocket.close()

客戶端套接字

語法 做用
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 建立 socket 對象
host = socket.gethostname() 獲取本地主機名
port = 9999 設置端口號
s.connect((host, port)) 鏈接服務，指定主機和端口
msg = s.recv(1024) 接收小於 1024 字節的數據
print(msg.decode('utf-8')) 打印接收消息
print(str(msg,'utf-8')) 接收消息
s.close 關閉套接字 
import socket

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

host = socket.gethostname()
port = 9999
s.connect((host, port))

msg = s.recv(1024)

s.close()

print (msg.decode('utf-8'))
print(str(msg,'utf-8'))

公告用途的套接字函數

語法 返回值 做用
s.recv() 接收 TCP 數據
s.send() 發送 TCP 數據
s.sendall() 完整發送 TCP 數據
s.recvfrom() (數據,地址) 接收 UDP 數據
s.close() 關閉套接字
s.getpeername() (ipaddr,port) 返回連接套接字的遠程地址
s.getsockname() (ipaddr,port) 返回套接字本身的地址

參考

https://www.runoob.com/python3/python3-socket.html

import subprocess

import subprocess
subprocess.Popen(args,bufsize=0,executable=None,stdin=None,stdout=None,stderr=None,preexec_fn=None,close_fds=False,shell=False,cwd=None,env=None,universal_newlines=False,startupinfo=None,creationflags=0)
語法 作用
args 字符串或者列表
subprocess.PIPE 初始化參數 
import subprocess
subprocess.call('demo.bat', shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

import pillow

語法 做用
imload = Image.open('1.jpg') 打開圖片
im = imload.convert("RGB") 轉換爲 RGB 模式
demo = open('rgb.txt','a') 追加方式寫入到文件
rgb = im.getpixel((x,y)) 獲取對應像素點的
demo.write(rgb[1:-1]+"\t") 把 RGB值寫入文件

圖像轉 excel

from PIL import Image
imload = Image.open('1.jpg')
im = imload.convert("RGB")
width,height = im.size
demo = open('rgb.txt','a')

for y in range(height):
    for x in range(width):
        rgb = im.getpixel((x,y))
        rgb = str(rgb)
        demo.write(rgb[1:-1]+"\t")
    demo.write("\n")
demo.close()

VBA 渲染 RBG 顏色

語法 做用
For Each r In Range("A:B") 渲染幾列單元格 
Sub code()
    Dim r As Range, arr
    For Each r In Range("A:A")
        arr = Split(r, ",")
        r.Interior.Color = RGB(CInt(arr(0)), CInt(arr(1)), CInt(arr(2)))
    Next
End Sub
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程