【Tkinter 入门教程】

#导入Tkinter模块，并用别名tk引用它。
import tkinter as tk
#定义一个函数say_hello，当按钮被点击时，这个函数会被调用。 这个函数会更新标签（label）的文本为"Hello World!"。
def say_hello():
    label.config(text="Hello World!")
#创建一个顶级窗口（root window），这是整个GUI程序的基础。
root = tk.Tk()
#创建一个标签（Label），设置其初始文本为"Click the button to say hello!"，并将其添加到根窗口中。
label = tk.Label(root, text="Click the button to say hello!")
label.pack()
#pack()方法用于将控件放置在父容器中，并自动调整它们的大小和位置。
#创建一个按钮（Button），设置其文本为"SAY Hello"，并将其命令属性设置为say_hello函数。这意味着当用户点击此按钮时，say_hello函数将被调用。
button = tk.Button(root, text="Say Hello", command=say_hello)
button.pack()
#最后，进入主循环。在此过程中，程序会持续监听用户的操作，如点击按钮等，并作出相应的响应。
root.mainloop()

import tkinter as tk
def say_hello():
    label.config(text="Hello World!")
root = tk.Tk()
# 创建一个自定义的字体对象，设置其大小
custom_font = ('Arial', 14, 'bold')
#设置背景填充颜色
label = tk.Label(root, text="Click the button to say hello!", font=custom_font, bg = 'red')
label.pack()
button = tk.Button(root, text="Say Hello", command=say_hello, font=custom_font, bg = 'red')
button.pack()
root.mainloop()

from tkinter import *
root = Tk()
root.wm_title("这是⼀个Tkinter程序窗⼝标题")
wl= Label(root, text = "欢迎来到tkinter")
wl.pack()
root.mainloop()

from tkinter import *
root = Tk()
root.wm_title("这是⼀个Tkinter程序窗⼝标题")
w1 = Label(root, text = "欢迎来到tkinter教程！", background = "white")
w2 = Label(root, text = "好好学习，天天向上！", background = "green")
w3 = Label(root, text = "轻松愉快，就选Python！", background = "red")
w1.pack()
w2.pack()
w3.pack()
root.mainloop()

from tkinter import *
def myLabel():
  global py, i
  s = Label(py, text = "轻松愉快，就选Python! 重要的事情说 %d 遍！" % i)
  s.pack()
  i+=1 # 每次点击后，i的值会⾃增1
py = Tk()
i = 1 # 全局变量i 初始化为 1
b = Button(py, text = "Python", command = myLabel)
b.pack()
py.mainloop()

from tkinter import *
# method 1
# def myLabel():
# method 2
def myLabel(event):
    global py, i
    s = Label(py, text = "轻松愉快，就选Python! 重要的事情说 %d 遍！" % i)
    s.pack()
    i+=1 # 每次点击后，i的值会⾃增1
py = Tk()
i = 1 # 全局变量i 初始化为 1
# method 1
# b = Button(py, text = "Python", command = myLabel)
# method 2
b = Button(py, text = "Python") # command = myLabel ⽊有了
b.bind("<Button-1>", myLabel) # 多了这⼀句
b.pack()
py.mainloop()

from tkinter import *
py = Tk()
b1 = Button(py, text = "tkinter教程")
b1["width"] = 20
b1["height"] = 6
b1.pack()
b2 = Button(py, text = "Python学院")
b2["width"] = 40
b2["background"] = "white"
b2.pack()
py.mainloop()

from tkinter import *
def reg():
    myAccount = a_entry.get() # 获取⽤户输⼊的⽤户名
    myPassword = p_entry.get() # 获取⽤户输⼊的密码
    a_len = len(myAccount) # 获取输⼊的⽤户名⻓度
    p_len = len(myPassword) # 获取输⼊的密码⻓度
    if myAccount == "qq_group" and myPassword == "945348278":
        msg_label["text"] = "登录成功" # ⽤户名和密码全部正确
    elif myAccount == "qq_group" and myPassword != "945348278":
        msg_label["text"] = "密码错误" # ⽤户名正确密码错误
        p_entry.delete(0, p_len)
    else:
        msg_label["text"] = "⽤户名错误" # ⽤户名错误
        a_entry.delete(0, a_len)
        p_entry.delete(0, p_len)
root = Tk()
# ⽤户名
a_label = Label(root, text = "⽤户名：")
a_label.grid(row = 0, column = 0, sticky = W)
a_entry = Entry(root)
a_entry.grid(row = 0, column = 1, sticky = E)
# 密码
p_label = Label(root, text = "密码：")
p_label.grid(row = 1, column = 0, sticky = W)
p_entry = Entry(root)
p_entry["show"] = "*" # 密码显示为 *
p_entry.grid(row = 1, column = 1, sticky = E)
# 登录按钮
btn = Button(root, text = "登录", command = reg)
btn.grid(row = 2, column = 1, sticky = E)
# 提示信息
msg_label = Label(root, text = "")
msg_label.grid(row = 3)
root.mainloop()

from tkinter import *
root = Tk()
menuBar = Menu(root)
for item in ["⽂件", "编辑", "视图", "关于"]:
    menuBar.add_command(label = item)
root["menu"] = menuBar
root.mainloop()

from tkinter import *
root = Tk()
menuBar = Menu(root)
fMenu = Menu(menuBar) # ⽂件
for item in ["新建", "打开", "保存", "另存为", "退出"]:
    fMenu.add_command(label = item)
eMenu = Menu(menuBar) # 编辑
for item in ["复制", "粘贴", "剪切", "撤销"]:
    eMenu.add_command(label = item)
vMenu = Menu(menuBar) # 视图
for item in ["默认视图", "全屏模式", "显示/隐藏菜单"]:
    vMenu.add_command(label = item)
aMenu = Menu(menuBar) # 关于
for item in ["版权信息", "帮助⽂档"]:
    aMenu.add_command(label = item)
menuBar.add_cascade(label = "⽂件", menu = fMenu)
menuBar.add_cascade(label = "编辑", menu = eMenu)
menuBar.add_cascade(label = "视图", menu = vMenu)
menuBar.add_cascade(label = "关于", menu = aMenu)
root["menu"] = menuBar
root.mainloop()

from tkinter import *
def myLabel():
    global root
    Label(root, text = "我的Python课程").pack() # 点击Python后添加这个标签
root = Tk()
menuBar = Menu(root)
for each in ["C/C++", "JavaEE", "Android", "PHP", "UI设计", "iOS", "前端与移动开发", "⽹络营销", "云计算"]:
    menuBar.add_command(label = each)
menuBar.add_command(label = "Python", command = myLabel)
def pop(event):
    menuBar.post(event.x_root, event.y_root)
root.bind("<Button-3>", pop) # ⿏标右击绑定
root.mainloop()

from tkinter import *
timeA = 0
timeB = 0
def funcA():
    global lab, btnA, timeA
    if timeA % 2 == 0:
        timeA += 1
        lab["text"] = "Python学科被选中"
    else:
        timeA += 1
        lab["text"] = "Python学科被取消"
def funcB():
    global lab, btnB, timeB
    if timeB % 2 == 0:
        timeB += 1
        lab["text"] = "C++学科被选中"
    else:
        timeB += 1
        lab["text"] = "C++学科被取消"
root = Tk()
btnA = Checkbutton(root, text = "Python学科", command = funcA)
btnA.pack()
btnB = Checkbutton(root, text = "C++学科", command = funcB)
btnB.pack()
lab = Label(root, text = " ")
lab.pack()
root.mainloop()

import tkinter as tk
root = tk.Tk()

text_widget = tk.Text(root, width=30, height=10)
text_widget.pack()

text_widget.insert('end', 'Hello, World!\n')

# 获取所有文本
all_text = text_widget.get('1.0', 'end')
# 删除第一行
text_widget.delete('1.0', '1.end')

root.mainloop()

import tkinter as tk
def copy_text():
    source_text = text_source.get('1.0', 'end')
    text_destination.insert('end', source_text)
root = tk.Tk()
text_source = tk.Text(root, width=30, height=10)
text_source.pack()
text_destination = tk.Text(root, width=30, height=10)
text_destination.pack()
button_copy = tk.Button(root, text="Copy Text", command=copy_text)
button_copy.pack()
root.mainloop()

import sys
import tkinter
import time
from tkinter import scrolledtext
class myStdout(): # 重定向类
    def __init__(self):
      # 将其备份
        self.stdoutbak = sys.stdout
        self.stderrbak = sys.stderr
        # 重定向
        sys.stdout = self
        sys.stderr = self
    def write(self, info):
        # info信息即标准输出sys.stdout和sys.stderr接收到的输出信息
        t.insert('end', info) # 在多行文本控件最后一行插入print信息
        t.update()  # 更新显示的文本，不加这句插入的信息无法显示
        t.see(tkinter.END)  # 始终显示最后一行，不加这句，当文本溢出控件最后一行时，不会自动显示最后一行
    def restoreStd(self):
        # 恢复标准输出
        sys.stdout = self.stdoutbak
        sys.stderr = self.stderrbak
def btn_func():
    for i in range(5):
        print(i)
        # t.insert('end', i)
        time.sleep(1)
"""按键的触发事件"""
mystd = myStdout()  # 实例化重定向类
window = tkinter.Tk() # 实例化tk对象
t = scrolledtext.ScrolledText(window) # 创建多行文本控件
t.pack()  # 布局在窗体上
b = tkinter.Button(window, text='start', command=btn_func)  # 创建按钮控件，并绑定触发事件
b.pack()  # 布局在窗体上
window.mainloop() # 显示窗体
mystd.restoreStd()  # 恢复标准输出

import tkinter as tk
# 创建一个顶级窗口
root = tk.Tk()
# 加载图片
image_path = 'path_to_your_image.png'  # 替换为实际的图片路径
image = tk.PhotoImage(file=image_path)
# 创建一个标签来显示图片
label = tk.Label(root, image=image)
label.pack()
# 开始主循环
root.mainloop()

from tkinter import *
root = Tk()
Button(root, text = "A").pack(side = LEFT, expand =YES, fill = Y)
Button(root, text = "B").pack(side = TOP, expand = YES, fill = BOTH)
Button(root, text = "C").pack(side = RIGHT, expand = YES, fill = NONE, anchor = NE)
Button(root, text = "D").pack(side = LEFT, expand = NO, fill = Y)
Button(root, text = "E").pack(side = TOP, expand = NO, fill = Y)
Button(root, text = "F").pack(side = BOTTOM, expand = YES)
Button(root, text = "G").pack(anchor = SE)
root.mainloop()

from tkinter import *
py = Tk()
Label(py, text = "账号：").grid(row = 0, sticky = W)
Entry(py).grid(row = 0, column = 1, sticky = E)
Label(py, text = "密码：").grid(row = 1, sticky = W)
Entry(py).grid(row = 1, column = 1, sticky = E)
Button(py, text = "登录").grid(row = 2, column = 1, sticky = E)
py.mainloop()

from tkinter import *
root = Tk()
root.title("开心就好")
canv = Canvas(root, width = 400, height = 300, bg = "pink")
canv.create_line((0,0), (200,200), width = 8)
canv.create_line((400,0), (200,200), width = 8)
canv.create_text(300, 30, text = "Python教程")
canv.pack()
root.mainloop()

from tkinter import *
root = Tk()
root.title("中国象棋棋盘⼿绘")
canv = Canvas(root, width = 400, height = 450)
canv.create_line((0,2), (400,2), width = 2)
for i in range(10):
canv.create_line((0, i * 50), (400, i * 50), width = 2)
canv.create_line((3,0), (3,450), width = 2)
for i in range(8):
canv.create_line((i * 50,0), (i * 50,200), width = 2)
for i in range(8):
canv.create_line((i * 50,250), (i * 50,450), width = 2)
canv.create_line((397,0), (397,450), width = 2)
canv.create_line((150,0), (250,100), width = 2)
canv.create_line((150,100), (250,0), width = 2)
canv.create_line((150,450), (250,350), width = 2)
canv.create_line((150,350), (250,450), width = 2)
canv.create_text(110, 220, text = "汉界")
canv.create_text(290, 220, text = "楚河")
canv.pack()
root.mainloop()

#!/usr/bin/env python3
"""
ZetCode Tkinter tutorial
This is a simple Snake game
clone.
Author: Jan Bodnar
Website: zetcode.com
Last edited: April 2019
"""
import sys
import random
from PIL import Image, ImageTk
from tkinter import Tk, Frame, Canvas, ALL, NW
class Cons:
    BOARD_WIDTH = 300
    BOARD_HEIGHT = 300
    DELAY = 100
    DOT_SIZE = 10
    MAX_RAND_POS = 27
class Board(Canvas):
    def __init__(self):
        super().__init__(width=Cons.BOARD_WIDTH, height=Cons.BOARD_HEIGHT,
            background="black", highlightthickness=0)
        self.initGame()
        self.pack()
    def initGame(self):
        '''initializes game'''
        self.inGame = True
        self.dots = 3
        self.score = 0
        # variables used to move snake object
        self.moveX = Cons.DOT_SIZE
        self.moveY = 0
        # starting apple coordinates
        self.appleX = 100
        self.appleY = 190
        self.loadImages()
        self.createObjects()
        self.locateApple()
        self.bind_all("<Key>", self.onKeyPressed)
        self.after(Cons.DELAY, self.onTimer)
    def loadImages(self):
        '''loads images from the disk'''
        try:
            self.idot = Image.open("dot.png")
            self.dot = ImageTk.PhotoImage(self.idot)
            self.ihead = Image.open("head.png")
            self.head = ImageTk.PhotoImage(self.ihead)
            self.iapple = Image.open("apple.png")
            self.apple = ImageTk.PhotoImage(self.iapple)
        except IOError as e:
            print(e)
            sys.exit(1)
    def createObjects(self):
        '''creates objects on Canvas'''
        self.create_text(30, 10, text="Score: {0}".format(self.score),
                         tag="score", fill="white")
        self.create_image(self.appleX, self.appleY, image=self.apple,
            anchor=NW, tag="apple")
        self.create_image(50, 50, image=self.head, anchor=NW,  tag="head")
        self.create_image(30, 50, image=self.dot, anchor=NW, tag="dot")
        self.create_image(40, 50, image=self.dot, anchor=NW, tag="dot")
    def checkAppleCollision(self):
        '''checks if the head of snake collides with apple'''
        apple = self.find_withtag("apple")
        head = self.find_withtag("head")
        x1, y1, x2, y2 = self.bbox(head)
        overlap = self.find_overlapping(x1, y1, x2, y2)
        for ovr in overlap:
            if apple[0] == ovr:
                self.score += 1
                x, y = self.coords(apple)
                self.create_image(x, y, image=self.dot, anchor=NW, tag="dot")
                self.locateApple()
    def moveSnake(self):
        '''moves the Snake object'''
        dots = self.find_withtag("dot")
        head = self.find_withtag("head")
        items = dots + head
        z = 0
        while z < len(items)-1:
            c1 = self.coords(items[z])
            c2 = self.coords(items[z+1])
            self.move(items[z], c2[0]-c1[0], c2[1]-c1[1])
            z += 1
        self.move(head, self.moveX, self.moveY)
    def checkCollisions(self):
        '''checks for collisions'''
        dots = self.find_withtag("dot")
        head = self.find_withtag("head")
        x1, y1, x2, y2 = self.bbox(head)
        overlap = self.find_overlapping(x1, y1, x2, y2)
        for dot in dots:
            for over in overlap:
                if over == dot:
                  self.inGame = False
        if x1 < 0:
            self.inGame = False
        if x1 > Cons.BOARD_WIDTH - Cons.DOT_SIZE:
            self.inGame = False
        if y1 < 0:
            self.inGame = False
        if y1 > Cons.BOARD_HEIGHT - Cons.DOT_SIZE:
            self.inGame = False
    def locateApple(self):
        '''places the apple object on Canvas'''
        apple = self.find_withtag("apple")
        self.delete(apple[0])
        r = random.randint(0, Cons.MAX_RAND_POS)
        self.appleX = r * Cons.DOT_SIZE
        r = random.randint(0, Cons.MAX_RAND_POS)
        self.appleY = r * Cons.DOT_SIZE
        self.create_image(self.appleX, self.appleY, anchor=NW,
            image=self.apple, tag="apple")
    def onKeyPressed(self, e):
        '''controls direction variables with cursor keys'''
        key = e.keysym
        LEFT_CURSOR_KEY = "Left"
        if key == LEFT_CURSOR_KEY and self.moveX <= 0:
            self.moveX = -Cons.DOT_SIZE
            self.moveY = 0
        RIGHT_CURSOR_KEY = "Right"
        if key == RIGHT_CURSOR_KEY and self.moveX >= 0:
            self.moveX = Cons.DOT_SIZE
            self.moveY = 0
        RIGHT_CURSOR_KEY = "Up"
        if key == RIGHT_CURSOR_KEY and self.moveY <= 0:
            self.moveX = 0
            self.moveY = -Cons.DOT_SIZE
        DOWN_CURSOR_KEY = "Down"
        if key == DOWN_CURSOR_KEY and self.moveY >= 0:
            self.moveX = 0
            self.moveY = Cons.DOT_SIZE
    def onTimer(self):
        '''creates a game cycle each timer event'''
        self.drawScore()
        self.checkCollisions()
        if self.inGame:
            self.checkAppleCollision()
            self.moveSnake()
            self.after(Cons.DELAY, self.onTimer)
        else:
            self.gameOver()
    def drawScore(self):
        '''draws score'''
        score = self.find_withtag("score")
        self.itemconfigure(score, text="Score: {0}".format(self.score))
    def gameOver(self):
        '''deletes all objects and draws game over message'''
        self.delete(ALL)
        self.create_text(self.winfo_width() /2, self.winfo_height()/2,
            text="Game Over with score {0}".format(self.score), fill="white")
class Snake(Frame):
    def __init__(self):
        super().__init__()
        self.master.title('Snake')
        self.board = Board()
        self.pack()
def main():
    root = Tk()
    nib = Snake()
    root.mainloop()
if __name__ == '__main__':
    main()

import tkinter as tk
from tkinter import ttk
import pyrealsense2 as rs
import numpy as np
from PIL import Image, ImageTk
import os
def camera_aligned():
    # 创建GUI界面
    # global camera_static
    root = tk.Tk()
    style = ttk.Style()
    style.configure('Custom.TButton', font=('Helvetica', 16))
    root.title("Realsense D435i Camera")
    root.geometry('380x400')
    # 创建图像显示区域
    color_label = tk.Label(root)
    color_label.grid(row=2, column=0,columnspan=3)
    depth_label = tk.Label(root)
    depth_label.grid(row=2, column=4,columnspan=3)
    # 创建保存图像函数
    def save_image(color_image, depth_image):
        # 创建data文件夹（如果不存在）
        if not os.path.exists("data"):
            os.makedirs("data")
        # 获取data文件夹下已保存图像的数量
        # num_files = len(os.listdir("data"))
            # 获取data文件夹下最大的序号
        num_files = 0
        for file_name in os.listdir("./data"):
            if file_name.endswith(".png"):
                index = int(file_name.split(".")[0])
                num_files = max(num_files, index)
        # 保存彩色图为PNG格式
        color_image_path = "data/{:04d}.png".format(num_files + 1)
        color_image.save(color_image_path)
        print(f"Color image saved as {color_image_path}")
        # 保存深度图为对齐TIFF格式
        depth_image_path = "data/{:04d}.tiff".format(num_files + 1)
        depth_image.save(depth_image_path, "TIFF")
        print(f"Depth image saved as {depth_image_path}")
    # 创建打开相机按钮的回调函数
    def open_camera():
        # 创建Realsense管道
        global pipeline
        pipeline = rs.pipeline()
        # 配置相机参数
        config = rs.config()
        config.enable_stream(rs.stream.color, 640, 480, rs.format.rgb8, 30)
        config.enable_stream(rs.stream.depth, 640, 480, rs.format.z16, 30)
        # 启动相机
        pipeline.start(config)
        try:
            while True:
                # 等待相机数据
                frames = pipeline.wait_for_frames()
                color_frame = frames.get_color_frame()
                depth_frame = frames.get_depth_frame()
                # 将相机数据转换为可显示的图像
                color_image = np.asanyarray(color_frame.get_data())
                pil_color_image = Image.fromarray(color_image)
                tk_color_image = ImageTk.PhotoImage(pil_color_image.resize((160, 120)))
                depth_image = np.asanyarray(depth_frame.get_data())
                pil_depth_image = Image.fromarray(depth_image)
                tk_depth_image = ImageTk.PhotoImage(pil_depth_image.resize((160, 120)))
                # 更新图像显示
                color_label.config(image=tk_color_image)
                depth_label.config(image=tk_depth_image)
                # 保持图像显示的引用，防止被垃圾回收
                color_label.image = pil_color_image
                depth_label.image = pil_depth_image
                # 更新GUI界面
                root.update()
        finally:
            pipeline.stop()
            root.destroy()
    # 创建保存图像按钮的回调函数
    def save_button_callback():
        # 获取当前显示的彩色图和深度图
        color_image = color_label.image
        depth_image = depth_label.image
        # 检查图像是否存在
        if color_image is not None and depth_image is not None:
            # 保存图像
            save_image(color_image, depth_image)
        else:
            print("No image to save")
    def close_camera():
        # camera_static = 1
        pipeline.stop()
    # 创建退出按键的回调函数
    def image_button_callback():
        # 停止相机并关闭窗口
        # pipeline.stop()
        root.destroy()
    la1=ttk.Label(root,text='Realsense D435相机图形采集', style='Custom.TButton')
    la1.grid(row=0,column=0, ipady=6, pady=6, columnspan=7) # 0行0列
    # 创建打开相机按钮
    open_button = tk.Button(root, text="打开相机", command=open_camera, bg='green',fg='yellow')
    open_button.grid(row=1, column=0)
# 创建打开相机按钮
    close_button = tk.Button(root, text="关闭相机", command=close_camera, bg='red',fg='yellow')
    close_button.grid(row=1, column=2)
    # 创建保存图像按钮
    save_button = tk.Button(root, text="保存图像", command=save_button_callback, bg='blue',fg='yellow')
    save_button.grid(row=1, column=4)
    # 创建退出图像按钮
    image_Exit_button = tk.Button(root, text="退出采集", command=image_button_callback, bg='red',fg='yellow')
    image_Exit_button.grid(row=1, column=6)
    la2=ttk.Label(root,text='彩色图像')
    la2.grid(row=3,column=1) # 0行0列
    la2=ttk.Label(root,text='深度图像')
    la2.grid(row=3,column=5) # 0行0列
    # 运行GUI界面
    root.mainloop()
if __name__ == '__main__':
    camera_aligned()