精华内容
下载资源
问答
  • Tkinter项目-源码

    2021-02-25 02:30:42
    这是一个使用Tkinter库创建GUI的Python项目。 它具有登录系统和创建帐户系统,因此用户可以登录该程序。 仍在进行中的项目... :timer_clock: 正在使用的库(ATM): Tkinter SQLite3 重新-(正则表达式) 复制
  • 主要介绍了python tkinter控件布局项目实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 1,项目概况 项目名称: 小说在线阅读器 项目需求: 1,根据关键字检索,实现从互联网获取所需链接。 2,对获取的链接进行解析,获取二级链接,获取的链接以文件的形式保存。 3,实现小说在线阅读。 所需技术: ...

    1,项目概况
    项目名称:
    小说在线阅读器
    项目需求:
    1,根据关键字检索,实现从互联网获取所需链接。
    2,对获取的链接进行解析,获取二级链接,获取的链接以文件的形式保存。
    3,实现小说在线阅读。
    所需技术:
    Python基本爬虫,Python tkinter GUI设计
    2,项目代码:

    from fake_useragent import UserAgent
    from bs4 import BeautifulSoup as Bp
    import tkinter as tk
    import tkinter.messagebox
    import requests as req
    import re
    import os
    #弹出窗口提示,说明使用须知。
    tkl = tk.Tk()
    tkl.title('验证窗口')
    tkl.geometry('250x100')
    tkinter.messagebox.showinfo(title='使用须知',message='''1,本软件需要连接网络才能够正常使用,使用本软件时请先连接网络!\n2,本软件仅供学习交流使用,请勿私自传播!\n3,鉴于本人水平有限,本软件若有不足之处,望见谅。\n4,在软件获取链接或者解析时请勿操作软件,否则可能会导致软件无响应!''')
    tlable = tk.Label(tkl,text='阅读须知后请关闭此窗口!!!',font=('Arial',12))
    tlable.pack()
    tkl.mainloop()
    #创建主窗口
    app = tk.Tk()
    app.title('小说搜索解析阅读器v1.0')
    app.geometry('800x600')
    
    lable = tk.Label(app,text='请输入关键字',font=('Arial',12))
    lable.pack()
    #定义搜索框
    search_entry = tk.Entry(app,show=None,width=50)
    search_entry.pack()
    
    #定义功能函数
    def getdata():
        st.delete(1.0,tk.END)
        url = 'http://www.biquge.info/modules/article/search.php'
        #伪装头部
        ua = UserAgent()
        header = {'User-Agent':ua.random}
        key = search_entry.get()
        #爬取链接
        try:
            r = req.post(url,{'searchkey':key},headers=header)
        except Exception as e:
            tkinter.messagebox.showinfo(title='警告!',message='获取链接失败,请点击按钮重试!')
            return
        r.raise_for_status()
        r.encoding = r.apparent_encoding
        re_list = []
        soup = Bp(r.text,'html.parser')
        data = soup.find_all('a')
        for item in data:
            try:
                if re.findall(key,item.text):
                    re_list.append(item.text + ':' + 'http://www.biquge.info' + item['href'])
            except:
                continue
        if not re_list:
            st.insert('insert','没有发现!')
        dvar = '-*---------------------*-\n请在下面复制要解析的链接,注意:一次只能解析一条\n' + '\n'.join(re_list)
        st.insert('insert',dvar)
        return
    
    #定义按钮实现功能
    search_button = tk.Button(app,text='获取链接',width=12,
                              height=2,command=getdata)
    search_button.pack()
    
    lable1 = tk.Label(app,text='链接显示区域',font=('Arial',12))
    lable1.pack()
    
    st = tk.Text(app,width=80,height=5)
    st.pack()
    
    lable2 = tk.Label(app,text='请输入链接',font=('Arial',12))
    lable2.pack()
    
    read_entry = tk.Entry(app,show=None,width=80)
    read_entry.pack()
    #定以函数,用以实现相关按钮功能
    def readlink():
        url = read_entry.get()
        try:
            rd = req.get(url)
            rd.raise_for_status()
            rd.encoding = rd.apparent_encoding
            soup = Bp(rd.text,'html.parser')
            readdata = soup.find_all('a')
            read_re_data = []
            for item in readdata:
                try:
                    if 'html' in item['href'] and 'http' not in item['href']:
                        read_re_data.append(url + item['href'])
                    else:
                        continue
                except:
                    continue
            with open('read.txt','w') as wfile:
                wfile.write('\n'.join(read_re_data))
                wfile.close()
        except:
            tkinter.messagebox.showinfo(title='警告', message='发生错误,请重试!')
        return
    
    read_button = tk.Button(app,text='解析',width=12,
                              height=2,command=readlink)
    read_button.pack()
    #readapp用于设置阅读窗口
    def readapp():
        readapp = tk.Tk()
        readapp.title('阅读界面')
        readapp.geometry('1000x800')
    
        lable = tk.Label(readapp,text='阅读界面',font=('Arial',12))
        lable.pack()
        if not os.path.exists('read.txt'):
            tkinter.messagebox.showinfo(title='错误',message='未找到文件!')
            readapp.destroy()
            return
        with open('page.tmp','w') as file:
            file.write('1')
            file.close()
        def downd():
            if not os.path.exists('page.tmp'):
                tkinter.messagebox.showinfo(title='错误', message='请重试!')
            rf = open('page.tmp','r')
            page = int(eval(rf.read()))
            page += 1
            rf.close()
            page_str = str(page)
            rfs = open('page.tmp','w')
            rfs.write(page_str)
            rfs.close()
            readt.delete(1.0,tk.END)
            rfile = open('read.txt', 'r')
            url = rfile.readlines()
            rfile.close()
            readr = req.get(url[page][:-1:])
            readr.raise_for_status()
            readr.encoding = readr.apparent_encoding
            soup = Bp(readr.text, 'html.parser')
            data = soup.find_all('div', id='content')
            for item in data:
                readt.insert('insert', item.text)
            return
        def upd():
            if not os.path.exists('page.tmp'):
                tkinter.messagebox.showinfo(title='错误', message='请重试!')
            rf = open('page.tmp', 'r')
            page = int(eval(rf.read()))
            rf.close()
            if page <= 1:
                tkinter.messagebox.showinfo(title='错误', message='没有上一章了!')
                return
            page -= 1
            page_str = str(page)
            rfs = open('page.tmp', 'w')
            rfs.write(page_str)
            rfs.close()
            readt.delete(1.0, tk.END)
            rfile = open('read.txt', 'r')
            url = rfile.readlines()
            rfile.close()
            readr = req.get(url[page][:-1:])
            readr.raise_for_status()
            readr.encoding = readr.apparent_encoding
            soup = Bp(readr.text, 'html.parser')
            data = soup.find_all('div', id='content')
            for item in data:
                readt.insert('insert', item.text)
            return
    
        button1 = tk.Button(readapp,text='上一章',width=10,height=2,command=upd)
        button1.pack()
    
        button2 = tk.Button(readapp,text='下一章',width=10,height=2,command=downd)
        button2.pack()
    
        readt = tk.Text(readapp, width=120, height=50)
        rfile = open('read.txt','r')
        url = rfile.readlines()
        rfile.close()
        readr = req.get(url[1][:-1:])
        readr.raise_for_status()
        readr.encoding = readr.apparent_encoding
        soup = Bp(readr.text,'html.parser')
        data = soup.find_all('div',id='content')
        for item in data:
            readt.insert('insert',item.text)
        readt.pack()
    
        readapp.mainloop()
    
    read_button1 = tk.Button(app,text='阅读',width=12,
                             height=2,command=readapp)
    
    read_button1.pack()
    
    app.mainloop()
    

    3,项目效果:
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • ### 项目分析- 屏保可以自己启动,也可以手动启动- 一旦敲击键盘或者移动鼠标后,或者其他的引发时间,则停止- 如果屏保是一幅画的话,则没有画框- 图像的动作是随机的,具有随机性,可能包括颜色,大小,运动...

    ### 项目分析

    -  屏保可以自己启动,也可以手动启动

    -  一旦敲击键盘或者移动鼠标后,或者其他的引发时间,则停止

    -  如果屏保是一幅画的话,则没有画框

    -  图像的动作是随机的,具有随机性,可能包括颜色,大小,运动方向,变形等

    -  整个世界的构成是:

    -  ScreenSaver:

    - 需要一个canvas,大小与屏幕一致,没有边框

    -  Ball

    - 颜色,大小,多少, 运动方向,变形等随机

    - 球能动,可以被调用

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

    import random

    import tkinter

    #pythoncom.CoInitialize()

    # 定义关于球的类

    class RandomBall():

    # 自动初始化画布和屏幕尺寸

    def __init__(self, canvas, scrnwidth, scrnheight):

    self.canvas = canvas

    # 定义球的初始位置(x,y),此坐标为球的圆心,位置随机生成

    self.xpos = random.randint(60, int(scrnwidth) - 60)

    self.ypos = random.randint(60, int(scrnheight) - 60)

    # 定义球在x、y方向上的移动速度,速度随机给定

    self.xvelocity = random.randint(6, 12)

    self.yvelocity = random.randint(6, 12)

    # 将屏幕尺寸的形参赋给函数内部

    self.scrnwidth = scrnwidth

    self.scrnheight = scrnheight

    # 定义球的半径,半径大小随机给定

    self.radius = random.randint(40, 70)

    #定义球的颜色

    c = lambda:random.randint(0, 255)

    self.color = '#%02x%02x%02x' % (c(), c(), c())

    # 创建球的函数

    def creat_ball(self):

    # 通过圆心,获取一矩形左上角和右下角的坐标

    x1 = self.xpos - self.radius

    y1 = self.ypos - self.radius

    x2 = self.xpos + self.radius

    y2 = self.ypos + self.radius

    # tkinter没有创建圆的函数,通过创建椭圆的方式来生成圆

    self.item = self.canvas.create_oval(x1, y1, x2, y2, fill=self.color,outline=self.color)

    # 创建球移动的函数

    def move_ball(self):

    # 球的(x,y)坐标根据速度变化不断更新

    self.xpos += self.xvelocity

    self.ypos += self.yvelocity

    # 当球撞到屏幕边界后,反弹的算法判断

    if self.xpos + self.radius >= self.scrnwidth:

    self.xvelocity = -self.xvelocity

    if self.xpos - self.radius <= 0:

    self.xvelocity = -self.xvelocity

    if self.ypos + self.radius >= self.scrnheight:

    self.yvelocity = -self.yvelocity

    if self.ypos - self.radius <= 0:

    self.yvelocity = -self.yvelocity

    # 在画布上移动图画

    self.canvas.move(self.item, self.xvelocity, self.yvelocity)

    # 定义屏保的类

    class ScreenSaver():

    def __init__(self):

    self.balls = []

    # 每次启动程序,球的数量随机

    self.num_balls = random.randint(6, 20)

    # 生成root主窗口

    self.root = tkinter.Tk()

    #获取屏幕尺寸,作为主窗口尺寸

    self.width = self.root.winfo_screenwidth()

    self.height = self.root.winfo_screenheight()

    # 取消边框

    self.root.overrideredirect(1)

    # 调整背景透明度

    self.root.attributes('-alpha', 1)

    # 点击鼠标、移动鼠标、敲击键盘时退出程序

    self.root.bind('', self.myquit)

    self.root.bind('',self.myquit)

    self.root.bind('', self.myquit)

    # 创建画布,包括画布的归属、尺寸和背景颜色

    self.canvas = tkinter.Canvas(self.root,width=self.width,height=self.height,bg = "black")

    self.canvas.pack()

    # 根据num_balls随机生成的数值,在画布上生成球

    for i in range(self.num_balls):

    # 调用RandomBall函数,自动初始化出不同大小、位置和颜色的球

    ball = RandomBall(self.canvas,scrnwidth=self.width, scrnheight=self.height)

    # 调用生成球的函数

    ball.creat_ball()

    self.balls.append(ball)

    self.run_screen_saver()

    self.root.mainloop()

    # 调动球运动的函数

    def run_screen_saver(self):

    for ball in self.balls:

    ball.move_ball()

    # after函数是每200毫秒后启动一个函数,第二个参数为需启动的函数,类似于递归

    self.canvas.after(50, self.run_screen_saver)

    # 定义一个停止运行的函数

    def myquit(self, event):

    self.root.destroy()

    # 调用函数

    if __name__ == '__main__':

    ScreenSaver()

    # 球在边框上蹦跶主要是出生点太靠线球就不会反弹了

    # 解决的方法是将出生点设置的高点 设置以下位置

    # 定义球的初始位置(x,y),此坐标为球的圆心,位置随机生成

    #self.xpos = random.randint(60, int(scrnwidth) - 60)

    #self.ypos = random.randint(60, int(scrnheight) - 60)

    展开全文
  • TKinter项目-屏保

    2019-08-18 22:06:38
    TKinter项目实战-屏保 项目分析 屏保可以自己启动,也可以手动启动 一旦敲击键盘或者移动鼠标后,或者其他的引发时间,则停止 如果屏保是一幅画的话,则没有画框 图像的动作是随机的,具有随机性,可能包括颜色,...

    TKinter项目实战-屏保

    项目分析

    • 屏保可以自己启动,也可以手动启动
    • 一旦敲击键盘或者移动鼠标后,或者其他的引发时间,则停止
    • 如果屏保是一幅画的话,则没有画框
    • 图像的动作是随机的,具有随机性,可能包括颜色,大小,多少, 运动方向,变形等
    • 整个世界的构成是:
      • ScreenSaver:

        • 需要一个canvas, 大小与屏幕一致,没有边框
      • Ball

        • 颜色,大小,多少, 运动方向,变形等随机
        • 球能动,可以被调用
    import random
    import tkinter
    
    class RandomBall():
        '''
        定义运动的球的类
        '''
        def __init__(self, canvas, scrnwidth, scrnheight):
            '''
            canvas: 画布,所有的内容都应该在画布上呈现出来,此处通过此变量传入
            scrnwidth/scrnheigh:屏幕宽高
            '''
            self.canvas = canvas
            # 球出现的初始位置要随机,此处位置表示的球的圆心
            # xpos表示位置的x坐标
            self.xpos = random.randint(10, int(scrnwidth)-50)
            # ypos表示位置的y坐标
            self.ypos = random.randint(10, int(scrnheight)-50)
    
            # 定义球运动的速度
            # 模拟运动:不断的擦掉原来画,然后在一个新的地方再从新绘制
            # 此处xvelocity模拟x轴方向运动
            self.xvelocity = random.randint(4, 20)
            # 同理,yvelocity模拟的是y轴方向运动
            self.yvelocity = random.randint(4, 20)
    
            # 定义屏幕的大小
            self.scrnwidth = scrnwidth
            # 定义屏幕的高度
            self.scrnheight = scrnheight
    
            # 球的大小随机
            # 此处球的大小用半径表示
            self.radius = random.randint(20, 120)
    
            # 定义颜色
            # RGB表示法:三个数字,每个数字的值是0-255之间,表示红绿蓝三个颜色的大小
            # 在某些系统中,之间用英文单词表示也可以,比如red, green
            # 此处用lambda表达式
            c = lambda: random.randint(0,255)
            self.color ='#%02x%02x%02x'%(c(), c(), c()) 
    
            
        def create_ball(self):
            '''
            用构造函数定义的变量值,在canvas上画一个球
            '''
            #tkinter没有画圆形函数
            # 只有一个画椭圆函数,画椭圆需要定义两个坐标,
            # 在一个长方形内画椭圆,我们只需要定义长方形左上角和右下角就好
            # 求两个坐标的方法是,已知圆心的坐标,则圆心坐标减去半径能求出
            #左上角坐标,加上半径能求出右下角坐标
            x1 = self.xpos - self.radius
            y1 = self.ypos - self.radius
            x2 = self.xpos + self.radius
            y2 = self.ypos + self.radius
        
            # 再有两个对角坐标的前提下,可以进行画圆
            # fill表示填充颜色
            # outline是外围边框颜色
            self.item = self.canvas.create_oval(x1, y1, x2, y2, \
                                               fill=self.color, \
                                               outline=self.color)
              
        def move_ball(self):
            # 移动球的时候,需要控制球的方向            
            # 每次移动后,球都有一个新的坐标
            self.xpos += self.xvelocity
            # 同理计算ypos
            self.ypos += self.yvelocity
            # 以下判断是会否撞墙
            # 撞了南墙就要回头
            # 注意撞墙的算法判断
            if self.xpos + self.radius >= self.scrnwidth or self.xpos <= self.radius:
                # 装到了左边或者右边墙
                self.xvelocity = -self.xvelocity
                # 或者以下代码
                # self.xvelocity *= -1
            # 同理可以判断撞别的墙的算法
            if self.ypos + self.radius >= self.scrnheight or self.ypos <= self.radius:        
                # 撞到了上边或者下边墙
                self.yvelocity = -self.yvelocity
            # 在画布上挪动图画
            self.canvas.move(self.item, self.xvelocity, self.yvelocity)
                        
                        
                        
    class ScreenSaver():
        '''
        定义屏保的类
        可以被启动
        '''
        # 如何装随机产生的球?
        balls = list()
                        
        def __init__(self):
            # 每次启动球的数量随机
            self.num_balls = random.randint(6, 20)
    
            self.root = tkinter.Tk()
            # 取消边框
            self.root.overrideredirect(1)
            
            # 任何鼠标移动都需要取消
            self.root.bind('<Motion>', self.myquit)
            # 同理,按动任何键盘都需要退出屏保
    
            #得到屏幕大小规格
            w,h = self.root.winfo_screenwidth(), self.root.winfo_screenheight()
               
            #创建画布,包括画布的归属,规格
            self.canvas = tkinter.Canvas(self.root, width=w, height=h)
            self.canvas.pack()
                        
            # 在画布上画球
            for i in range(self.num_balls):
                ball = RandomBall(self.canvas, scrnwidth=w, scrnheight=h)
                ball.create_ball()
                self.balls.append(ball)
                            
            self.run_screen_saver()
            self.root.mainloop()
      
        def run_screen_saver(self):
            for ball in self.balls:
                ball.move_ball()
                        
            # after是200毫秒后启动一个函数,需要启动的函数是第二个参数
            self.canvas.after(200, self.run_screen_saver)
                        
        def myquit(self, e):
            # 此处只是利用了事件处理机制
            # 实际上并不关心事件的类型 
            self.root.destroy()
                        
    if __name__ == "__main__":
        # 启动屏保
        ScreenSaver()
        
    
    import tkinter
    
    help(tkinter.Tk.overrideredirect)
    
    Help on function wm_overrideredirect in module tkinter:
    
    wm_overrideredirect(self, boolean=None)
        Instruct the window manager to ignore this widget
        if BOOLEAN is given with 1. Return the current value if None
        is given.
    
    展开全文
  • Tkinter-Calculator-first:这是我的第一个tkinter项目
  • Tkinter项目:Python Tkinter PNote记事本开发 一、整体功能规划 整体的功能是模仿记事本的一些基本简单设计,但是增加了工具栏的快捷方式。名字为PNote,“P”是指单词“penguin”(企鹅),简而言之,该记事本叫...

    Tkinter项目:Python Tkinter PNote记事本开发学习记录

    原项目:[Tkinter项目]Python Tkinter NotePad记事本项目实战
    https://www.bilibili.com/video/BV1qk4y1k7N2/?p=4

    一、整体功能规划

    整体的功能是模仿记事本的一些基本简单设计,但是增加了工具栏的快捷方式。名字为PNote,“P”是指单词“penguin”(企鹅),简而言之,该记事本叫“企鹅记事本”,其icon就是使用一张小企鹅的表情包制成的,增添界面的趣味性。界面功能思维导图如下

    提前找好工具栏的图片,图片的格式都为gif,大小一般为32x32或16x16。icon图片来源网站:https://www.iconfont.cn/

    ,下载的时候把图片后缀改成gif就可以了。

    先建一个py文件,随意起一个记事本的名字,py文件和图片文件分开放,图片放在同目录下的img文件中。ico图片转化网站:https://www.uupoop.com/ico/。将小企鹅表情包.jpg图片转换成尺寸大小32x32的icon图

    记录工具:CSDN官网上的Markdown编辑器

    二、代码实现

    根据想法中的思维导图整个应用程序的图形化界面分为四个part:菜单栏、工具栏、文本输入区域、右键弹出菜单,将组件代码分别写在这个四个方法中,其他的功能实现方法则另外处理

    PS:此处的代码展示和源码文件的排版并不一致

    1.菜单栏

    导入类库

    #导入tkinter类库
    from tkinter import *  
    from tkinter import filedialog, messagebox
    from tkinter.ttk import Scrollbar, Checkbutton,Label,Button  #tkk里面的组件会有所优化
    import os
    import sys
    

    类PNote:

    class PNote(Tk):
        #工具栏所用图片的名称
        icons = ["new_file","open_file","save","cut","copy","paste",
                 "undo","redo","find_text"]
        icon_res = []
        # 默认主题使用字典(背景色为白色,字体为黑色)、主题一(背景为企鹅灰,字体为深蓝色)、主题二(背景色为深蓝色、字体为白色)
        theme_color = {"Default":"#000000.#FFFFFF",
                       "Penguin Gray":"#222b34.#e7e4e3",
                       "Night Mode":"#FFFFFF.#222b34"}
    		# 初始化操作
        def __init__(self):       
            super().__init__() #继承父类的构造  
            #调用方法
            self.set_window()  #调用界面窗口方法
            self.create_menu_bar() #菜单栏
            self.create_tool_bar()  #工具栏
            self.create_body()  #文本输入区域
            self.create_pop_menu()  #弹出菜单
    

    设置窗口界面

        # 设置窗口界面
        def set_window(self):
            self.title("PNote")  #标题
            max_width,max_height = self.maxsize()  #宽高
            # 居中对齐,像素
            align_center = "800x600+%d+%d" % ((max_width-800)/2,(max_height-600)/2)       
            self.geometry(align_center)
            self.iconbitmap("./img/penguin.ico")
       
    
        #创建菜单栏
        def create_menu_bar(self):
            menu_bar = Menu(self)
            self['menu']=menu_bar
                    #添加菜单栏项目
    
            #文件
            file_menu = Menu(menu_bar,tearoff=0)
            file_menu.add_command(label='新建',accelerator='Ctrl+N',command=self.new_file)
            file_menu.add_command(label='打开',accelerator='Ctrl+O',command=self.open_file)
            file_menu.add_command(label='保存',accelerator='Ctrl+S',command=self.save_file)
            file_menu.add_command(label='另存为',accelerator='Ctrl+Shift+S',command=self.save_as)
            file_menu.add_separator()  #分割符
            file_menu.add_command(label='退出',accelerator='Alt+F4',command=self.exit_notepad)
            menu_bar.add_cascade(label='文件',menu=file_menu)
            
    #文件菜单功能实现
        # 打开文件功能
        def open_file(self,event=None):
            #打开文件并进行类型设置
            input_file = filedialog.askopenfilename(filetypes=[("所有文件","*.*"),("文本文档","*.text")])
            if input_file:
                self.title("{}***NotePad".format(os.path.basename(input_file)))
                self.file_name = input_file
                self.context_text.delete(1.0,END)
                with open(input_file,'r') as _file:
                    self.context_text.insert(1.0,_file.read())
    
        #文件的保存,是保存(替代)原有文本文件的内容,先读写文件
        def write_to_file(self,file_name):
            try:
                content = self.context_text.get(1.0,END)
                with open(file_name,'w') as _file:
                    _file.write(content)
                self.title("{}---NotePad".format(os.path.basename(file_name)))
            except IOError:
                messagebox.showerror("错误","文件保存失败!")
    
        def save_file(self,event=None):
            if not self.file_name:
                self.save_as() #避免保存出来的新建的问题
            else:
                self.write_to_file(self.file_name)
    
        #新建
        def new_file(self,event=None):
            self.title("新建---PNote")
            self.context_text.delete(1.0,END)
            self.file_name = None
    
        #另存为
        def  save_as(self):
            input_file = filedialog.askopenfilename(filetypes=[("所有文件","*.*"),("文本文档","*.text")])
            if input_file:
                self.file_name= input_file
                self.write_to_file(self.file_name)
    
        #退出
        def exit_notepad(self):
            if messagebox.askokcancel("退出","确定退出吗?"):
                self.destroy()
    
            
    if __name__ == '__main__':
        app = PNote()
        app.mainloop()
    

    编辑菜单

    由于编辑的功能和工具栏差不多,所以会其方法放在body部分,但是“查找”功能在此单独说明

    #在方法create_menu_bar(self)加入以下代码
    
            #编辑
            editor_menu = Menu(menu_bar,tearoff=0)
            """撤销,恢复,剪切,复制,粘贴,查找,全选"""
            menu_bar.add_cascade(label='编辑',menu=editor_menu)
            editor_menu.add_command(label='撤销',accelerator='Ctrl+Z',command=lambda:self.handle_menu_action('撤销'))
            editor_menu.add_command(label='恢复',accelerator='Ctrl+Y',command=lambda:self.handle_menu_action('恢复'))
            editor_menu.add_separator()
            editor_menu.add_command(label='剪切',accelerator='Ctrl+X',command=lambda:self.handle_menu_action('剪切'))
            editor_menu.add_command(label='复制',accelerator='Ctrl+C',command=lambda:self.handle_menu_action('复制'))
            editor_menu.add_command(label='粘贴',accelerator='Ctrl+V',command=lambda:self.handle_menu_action('粘贴'))
            editor_menu.add_separator()
            editor_menu.add_command(label='查找',accelerator='Ctrl+F',command=self.find_text_dialog)
            editor_menu.add_command(label='全选',accelerator='Ctrl+A',command=self.select_all)
    
    

    查找文本功能

        #设置查找对话框
        def find_text_dialog(self):
            search_dialog = Toplevel(self)
            search_dialog.title('查找文本')
            #居中
            max_width,max_height = self.maxsize()  #宽高
            align_center = "300x80+%d+%d" % ((max_width-300)/2,(max_height-80)/2)       
            search_dialog.geometry(align_center)
            search_dialog.resizable(False,False)
            Label(search_dialog,text='查找全部').grid(row=0,column=0,sticky='e')
            search_text = Entry(search_dialog,width=25)
            search_text.grid(row=0,column=1,padx=2,pady=2,sticky="we")
            search_text.focus_set()
            #忽略大小写
            ignore_case_value = IntVar()
            Checkbutton(search_dialog,text="忽略大小写",variable=ignore_case_value).grid(
                row=1,column=1,sticky='e',padx=2,pady=2
                )
            Button(search_dialog,text='查找',command=lambda:self.search_result(search_text.get(),
                                                                             ignore_case_value.get(),
                                                                             search_dialog,
                                                                             search_text
                                                                             )).grid(row=0,column=2,
                                                                                     sticky="w"+"e",padx=1,
                                                                                     pady=1)
            # 关闭查找文本对话框
            def close_search_dialog():
                self.context_text.tag_remove('match',1.0,END)
                search_dialog.destroy()
    
            search_dialog.protocol("WM_DELETE_WINDOW",close_search_dialog)
            return "break"
        # 查找的方法
        def search_result(self,key,ignore_case,search_dialog,search_box):
            self.context_text.tag_remove('match',1.0,END)
            matches_found = 0
            if key:
                start_pos = 1.0
                while True:
                    start_pos = self.context_text.search(key,start_pos,
                                                         nocase=ignore_case,
                                                         stopindex=END)
                    if not start_pos:
                        break
                    end_pos = "{}+{}c".format(start_pos,len(key))
                    self.context_text.tag_add('match',start_pos,end_pos)
                    matches_found +=1
                    start_pos = end_pos
                self.context_text.tag_config('match',foreground='white',
                                             background='green')
            search_box.focus_set()
            search_dialog.title("发现了%d个匹配项" % matches_found)
        # 全选
        def select_all(self):
            self.context_text.tag_add('sel',1.0,END)
            return "break"        
    

    视图、关于菜单

    视图的下拉列表包括显示行号和显示高亮当前行、主题选择,前两者用checkbutton组件实现图形化界面,后者使用radiobutton组件实现图形化界面

    
    # 在方法create_menu_bar(self)加入以下代码
            #视图菜单
            view_menu = Menu(menu_bar,tearoff=0)
            menu_bar.add_cascade(label='视图',menu=view_menu)
            
            """显示行号"""
            self.is_show_line_num = IntVar()
            self.is_show_line_num.set(1)
            view_menu.add_checkbutton(label="显示行号",
                                      onvalue=0,offvalue=1,
                                      variable=self.is_show_line_num,
                                      command=self.update_line_num
                                      )
    
            """显示高亮当前行"""
            self.is_heighlight_line = IntVar()
            view_menu.add_checkbutton(label="高亮当前行",
                                      variable=self.is_heighlight_line,
                                      command=self.toggle_highlight)
    
            """主题"""
            
            themes_menu = Menu(menu_bar,tearoff=0)
            view_menu.add_separator()
            view_menu.add_cascade(label="主题",menu=themes_menu)
            #主题选择
            #默认主题
            self.theme_choice = StringVar()
            self.theme_choice.set("Default")
            for k in sorted(self.theme_color):
                themes_menu.add_radiobutton(label=k,
                                            variable=self.theme_choice,
                                            command=self.change_theme)
        
            #关于菜单
            about_menu = Menu(menu_bar,tearoff=0)
            about_menu.add_command(label="关于",command=lambda:self.show_messagebox("关于"))
            about_menu.add_command(label="帮助",command=lambda:self.show_messagebox("帮助"))
            menu_bar.add_cascade(label='关于',menu=about_menu)
    

    “关于”菜单的下拉列表都是使用messagebox弄两个对话框,简单化,如图所示

    在这里插入图片描述

    视图和菜单的功能实现

        # 主题的切换
        def change_theme(self):
            selected_theme = self.theme_choice.get()
            fg_bg = self.theme_color.get(selected_theme)
            fg_color,bg_color = fg_bg.split('.')
            self.context_text.config(bg=bg_color,fg=fg_color)
    
        # 关于菜单
        def show_messagebox(self,type):
            if type == "帮助":
                messagebox.showinfo("帮助","这是帮助文档",icon="question")
            else:
                messagebox.showinfo("关于","这是一个简单的记事本程序")
    

    2.工具栏

    工具栏界面的实现

    工具栏的,设计上是新建、打开、保存、剪切、复制、粘贴、撤销、重做、查找文本的icon逐一排列,和弹出菜单、菜单栏的功能是有些重复,是常用的功能快捷方式

        def create_tool_bar(self):
            tool_bar = Frame(self,height=25,background="#ffffff") # 容器Frame,白色
            # 填充x轴
            tool_bar.pack(fill="x")
            # 生成图片文件放到对应的位置
            for icon in self.icons:
                tool_icon = PhotoImage(file="./img/%s.gif" % (icon,)) # 因为是元组所以有个逗号
                tool_btn = Button(tool_bar,image=tool_icon,command=self.tool_bar_action(icon))
                tool_btn.pack(side="left")  # 图片左对齐
                # 将tool_icon添加到icon_res里
                self.icon_res.append(tool_icon)
    
    
    工具栏的命令处理
       def tool_bar_action(self,action_type):        
            def handle():
                if action_type == 'open_file':
                    self.open_file()
                elif action_type == "save":
                    self.save_file()
                elif action_type == "new_file":
                    self.new_file()
                elif action_type == "cut":
                    self.handle_menu_action("剪切")
                elif action_type == "copy":
                    self.handle_menu_action("复制")
                elif action_type == "paste":
                    self.handle_menu_action("粘贴")
                elif action_type == "undo":
                    self.handle_menu_action("撤销")
                elif action_type == "redo":
                    self.handle_menu_action("恢复")
                elif action_type == "find_text":
                    self.find_text_dialog()
            
            # handle返回处理
            return handle
    

    3. 主体body部分(文本输入、行号、高亮、滚动条)

        def create_body(self):
            # 左:行号;右:滚动条;中:文本编辑区
            # 行号区域
            self.line_number_bar = Text(self,width=3, padx=3,takefocus=0,border=0,
                                        background="#f0f0f0",state="disable"
                                        ) #state="disable"不能编辑状态
            #左边填充整个y轴
            self.line_number_bar.pack(side='left',fill='y')
            # 文本编辑区
            # undo=True是否具备文本取消功能,wrap:如何换行,word:按照单词自动换行,expand:可以拉伸
            self.context_text = Text(self,wrap="word",undo=True)
            # 热键绑定
            self.context_text.bind("<Control-o>",self.open_file)
            self.context_text.bind("<Control-O>",self.open_file)
            self.context_text.bind("<Control-s>",self.save_file)
            self.context_text.bind("<Control-S>",self.save_file)
            self.context_text.bind("<Control-n>",self.new_file)
            self.context_text.bind("<Control-N>",self.new_file)
            self.context_text.bind('<Any-KeyPress>',lambda e:self.update_line_num())
            self.context_text.pack(fill='both',expand="yes")
            
            # 设置文本输入区
            self.context_text.tag_config("active_line",background="#ffffff")
            
            # 滚动条
            scroll_bar = Scrollbar(self.context_text)
            scroll_bar['command'] = self.context_text.yview
            self.context_text["yscrollcommand"] = scroll_bar.set
            scroll_bar.pack(side="right",fill="y")
    
    

    增加行号

        # 行号处理
        def update_line_num(self):
            if self.is_show_line_num.get():
                # 获取所有行
                row,col = self.context_text.index(END).split('.')
                # 列举每行的行号
                line_num_content = "\n".join([str(i) for i in range(1,int(row))])
                self.line_number_bar.config(state="normal")
                self.line_number_bar.delete(1.0,END)
                self.line_number_bar.insert(1.0,line_num_content)
                self.line_number_bar.config(state='disable')
            else:
                self.line_number_bar.config(state='normal')
                self.line_number_bar.delete(1.0,END)
                self.line_number_bar.config(state='disable')
    

    高亮当前行

    高亮的颜色默认是白色的,所以在

        # 高亮当前行
        def toggle_highlight(self):
            if self.is_heighlight_line.get():
                self.context_text.tag_remove('active_line',1.0,END)
                # 设置高亮
                self.context_text.tag_add("active_line","insert linestart",
                                          "insert lineend+1c")
                # 通过递归的方式进行处理,会很耗资源,想想有没有别的办法
                self.context_text.after(200,self.toggle_highlight)
            else:
                self.context_text.tag_remove("active_line",1.0,END)
    

    4.弹出菜单

    弹出菜单的功能选项有:剪切、复制、粘贴、撤销、恢复、全选

        #弹出菜单(也叫右键菜单)
        def create_pop_menu(self):
            pop_menu = Menu(self.context_text,tearoff=0)
            for item1,item2 in zip(['剪切','复制','粘贴','撤销','恢复'],
                                   ['cut','copy','paste','undo','redo',]):
                
                pop_menu.add_command(label=item1,compound='left',command=self.tool_bar_action(item2))
            pop_menu.add_separator() #分割
            pop_menu.add_command(label="全选",command=self.select_all)
            #绑定
            self.context_text.bind("<Button-3>",lambda event:pop_menu.tk_popup(event.x_root,event.y_root))
            
        #右键菜单的处理
        def handle_menu_action(self,action_type):
            if action_type == "撤销":
                self.context_text.event_generate("<<Undo>>")
            elif action_type == "恢复":
                self.context_text.event_generate("<<Rndo>>")
            elif action_type == "剪切":
                self.context_text.event_generate("<<Cut>>")
            elif action_type == "复制":
                self.context_text.event_generate("<<Copy>>")
            elif action_type == "粘贴":
                self.context_text.event_generate("<<Paste>>")
    
        #防止事件传递
            return "break"
    

    三、展示效果

    版本如以下动图所示:

    在这里插入图片描述

    在这里插入图片描述

    四、打包程序

    网上找的教程python打包生成exe可执行文件
    打包使用的是auto -py-to-exe
    先安装pip install auto-py-to-exe,安装成功后输入auto-py-to-exe回车会弹出一个窗口
    在这里插入图片描述
    根据网上的教程为了便于打包,修改了图片的位置,所以修改了代码中图片的路径表达,

            self.iconbitmap("D:\\PNote\\img\\penguin.ico")
    
    		tool_icon = PhotoImage(file="D:\\PNote\\img\\%s.gif" % (icon,)) 
    

    最后上传文件和图片
    在这里插入图片描述
    最中得到PNote.exe,测试使用无误
    在这里插入图片描述

    展开全文
  • 这是在网上找的Tkinter知识框架图:tkinter内部的组件和方法很多,对于tkinter这个模块,个人不建议专门找一本书啃下来,最好的学习方式,就是在项目中边查边练,毕竟想一口气把所有内容记住也不太现实。下面是我...
  • MacOS下打包Python应用参照以下步骤将我们上一篇编写的main.py文件打包成一个MacOS标准软件:pip3 install py2app命令进行安装py2app工具从命令行用cd xxx进入到main.py文件所在的目录(可选)py2applet --make-setup ...
  • 今天小编就为大家分享一篇在python tkinter中Canvas实现进度条显示的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • from tkinter import ttk import tkinter as tk import tkinter.font as tkFont from tkinter import * # 图形界面库 import tkinter.messagebox as messagebox # 弹窗 from tkinter import * import tkinter....
  • Python Tkinter 绘图项目

    2021-07-01 03:57:05
    【课程介绍】本课程讲解Python Tkinter绘图项目的开发,该项目有修改画笔颜色、修改画笔大小、修改画布背景颜色、橡皮檫、清除画布、保存绘图等功能。【项目截图】 【Tkinter介绍】Tkinter 是 Python 标准 GUI 库。...
  • Tkinter编程实例+源码

    2016-09-03 15:26:38
    Tkinter编程实例(python3.2)(源码) Tkinter编程实例.pdf
  • Python-tkinter-pyinstaller项目之EXE打包器一、前言二、建立根窗口三、添加控件四、封装tkinterGUI的python代码展示五、封装kivyGUI的python代码展示总结 一、前言 有没有被pyinstaller打包折磨的死去活来?有没有...
  • tkinter学习练手小项目 因为网课查题脚本经常失效,提取了网上查题脚本的api, 自己写了基于python tkinter项目,适合新手练手. github地址:https://github.com/nerkeler/chaoxing_tool (search.ico,xuexitong....
  • 【实例简介】《Tkinter Programming Code By Examples》,非常棒的Tkinter实例教程,通过各种类型的示例,实现Tkinter的快速入门。就是这本书的章节先后顺序,建议从前至后进行阅读。问题与反馈:如果在练习中有疑问或...
  • Tkinter 项目-屏保

    2018-12-12 17:16:22
    关于tkinter的屏保涉及的知识点和思想 项目分析: 屏保启动方式:手动,自动 敲击键盘或者移动鼠标后,或者其他引发事件,则停止 如果屏保是一幅画的话,则没有边框 图像的动作是随机的,具有随机性,可能包括颜色,...
  • import tkinter from treeWindows import TreeWindows from infoWindows import InfoWindows win = tkinter.Tk() win.title("sunck") win.geometry("600x400+200+50") path = "D:\\黑客\\python绝技heike\...
  • 原博文2017-10-07 09:42 −一、项目说明: 本次通过实现一个小的功能模块对Python GUI进行实践学习。项目来源于软件制造工程的作业。记录在这里以复习下思路和总结编码过程。所有的源代码和文件放在这里: 链接: ...
  • ### 第1课 项目演示 ①演示项目 ②介绍项目功能### 第2课 主窗口[1] ①开发主窗口 ②设置窗口标题 ③设置窗口图标 ④固定窗口大小### 第3课 主窗口[2] ①设置窗口大小 ②实现窗口屏幕居中 ### 第4课 主窗口...
  • 一个项目学会python的tkinter模块---GUI设计

    万次阅读 多人点赞 2017-10-28 21:28:06
    项目基于tkinter模块,设计了一个简易调查问卷,问卷本身并无任何意义,其目的仅在于掌握如何使用和安排tkinter模块的各构件。
  • python tkinter项目

    千次阅读 2018-02-19 11:48:04
    import tkinter as tk import time import pandas as pd import random import tkinter.messagebox as mbox def fun5(): path1 ='D://用户数据.xls' path2 ='D://充值消费数据.xls' col=['会员号','电话','姓名',...
  • 本次 Python 小项目主要功能:调用电脑摄像头实现拍照,并使用百度 API 接口实现图像识别。上次完成了API的封装,这次完成GUI的布局。具体成品如下所示。拍照保存图片采用的是opencv中的imwrite方法,具体的示例查看...
  • 实验九 综合训练项目- tkinter编程案例 ** 1.使用tkinter实现计算器程序。实现效果如下 import re import tkinter import tkinter.messagebox root = tkinter.Tk() #设置窗口大小和位置 root.geometry(‘300x270+...
  • python学习了2个月有点想放弃了(本人英文基本为0,之前也根本没接触过IT行业) 不过贪吃蛇的程序做成,给了继续下去的理由和信心 下面是代码: import tkinter import random ''' 构成:运行窗口Win,需要展现的Snk...
  • 参考下下面的实例:测试开发实战:python GUI作业:tkinter控件改变背景色​zhuanlan.zhihu.com测试开发实战:python GUI作业:tkinter grid布局​zhuanlan.zhihu.com使用tkinter生成如下窗口:参考资料参考代码#!...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,524
精华内容 3,809
关键字:

tkinter项目