精华内容
下载资源
问答
  • 15.1. 交互模式

    2021-01-14 03:25:22
    在交互模式下,它返回主提示符;当输入来自文件的时候,打印堆栈跟踪后以非零退出状态退出。(try声明中被except子句捕捉到的异常这种情况不是错误。)有些错误是非常致命的会导致一个非零状态的退出;这也...

    15.1.1. 错误处理

    当错误发生时,解释器打印一个错误信息和堆栈跟踪。在交互模式下,它返回主提示符;当输入来自文件的时候,在打印堆栈跟踪后以非零退出状态退出。(在 try 声明中被 except 子句捕捉到的异常在这种情况下不是错误。)有些错误是非常致命的会导致一个非零状态的退出;这也适用于内部错误以及某些情况的内存耗尽。所有的错误信息都写入到标准错误流;来自执行的命令的普通输出写入到标准输出。

    输入中断符(通常是 Control-C 或者 DEL)到主或者从提示符中慧取消输入并且返回到主提示。[1]当命令执行中输入中断符会引起 KeyboardInterrupt 异常,这个异常能够被一个 try 声明处理。

    15.1.2. 可执行 Python 脚本

    在 BSD’ish Unix 系统上,Python 脚本可直接执行,像 shell 脚本一样,只需要把下面内容加入到

    #!/usr/bin/env python3.4

    (假设 python 解释器在用户的 PATH 中)脚本的开头,并给予该文件的可执行模式。#! 必须是文件的头两个字符。在一些系统上,第一行必须以 Unix-style 的行结束符("

    ")结束,不能以 Windows 的行结束符("

    ")。 注意 "#" 在 Python 中是用于注释的。

    使用 chmod 命令能够给予脚本执行模式或者权限。

    $ chmod +x myscript.py

    在 Windows 系统上,没有一个 “可执行模式” 的概念。Python 安装器会自动地把 .py 文件和python.exe 关联起来,因此双击 Python 分拣将会把它当成一个脚本运行。文件扩展名也可以是.pyw,在这种情况下,运行时不会出现控制台窗口。

    15.1.3. 交互式启动文件

    当你使用交互式 Python 的时候,它常常很方便地执行一些命令在每次解释器启动时。你可以这样做:设置一个名为 PYTHONSTARTUP 的环境变量为包含你的启动命令的文件名。这跟 Unix shells 的.profile 特点有些类似。

    这个文件在交互式会话中是只读的,在当 Python 从脚本中读取命令,以及在当 /dev/tty 被作为明确的命令源的时候不只是可读的。该文件在交互式命令被执行的时候在相同的命名空间中能够被执行,因此在交互式会话中定义或者导入的对象能够无需授权就能使用。你也能在文件中更改提示sys.ps1 和 sys.ps2。

    如果你想要从当前目录中读取一个附加的启动文件,你可以在全局启动文件中编写代码像这样:if os.path.isfile(".pythonrc.py"): exec(open(".pythonrc.py").read())。如果你想要在脚本中使用启动文件的话,你必须在脚本中明确要这么做:

    import os

    filename = os.environ.get("PYTHONSTARTUP")

    if filename and os.path.isfile(filename):

    with open(filename) as fobj:

    startup_file = fobj.read()

    exec(startup_file)

    15.1.4. 定制模块

    Python 提供两个钩子为了让你们定制 sitecustomize 和 usercustomize。为了看看它的工作机制的话,你必须首先找到你的用户 site-packages 目录的位置。启动 Python 并且运行这段代码:

    >>> import site

    >>> site.getusersitepackages()

    "/home/user/.local/lib/python3.4/site-packages"

    现在你可以创建一个名为 usercustomize.py 的文件在你的用户 site-packages 目录,并且在里面放置你想要的任何内容。它会影响 Python 的每一次调用,除非它以 -s (禁用自动导入)选项启动。

    sitecustomize 以同样地方式工作,但是通常由是机器的管理员创建在全局的 site-packages 目录中,并且是在 usercustomize 之前导入。请参阅 site 模块获取更多信息。

    Footnotes

    | [1] | GNU 的 Readline 包的问题可能会阻止这种做法。 |

    展开全文
  • 关于GUI图形界面化交互模式

    千次阅读 2021-01-03 16:31:23
    self.master = master self.pack() # 将生成的效果排布框架(窗口对象)---挂主窗口上。 self.pack() # 调用createWidet方法 self.createWidet() # 创建(添加)组件 def createWidet(self): self.btn01 = Button...

    GUI图形界面化编程

    我们前面实现的都是基于控制台的程序,程序和用户的交互通过控制台来完成。而GUI图形界面化编程则是我们快速的实现图形界面和用户的交互。GUI编程类似于“搭积木”,将一个个组建(Widget)放在窗口中。在这里插入图片描述
    上面的各种按钮、菜单、编辑区等都是一个个组建,他们都放置到窗口中,并通过增加“对事件的处理”成为一个完整的程序。

    常用的GUI库

    1、Tkinter

    • tkinter(Tk interface)是Python的标准GUI库,支持跨平台的GUI程序开发。tkinter 适合小型的 GUI 程序编写,也特别是个初学者学习的编程。

    2、wxPython

    • wxPython是比较流行的GUI库,适合大型应用程序开发,功能强于 tkinter,整体设计框架类似于 MFC(Microsoft Foundation Classes 微软基础类库)。

    3、PyQT

    • Qt 是一种开源的 GUI 库,适合大型 GUI 程序开发,PyQT是 Qt 工具包标准的 Python 实现。我们也可以使用 Qt Desginer 界面设计器快速开发 GUI 应用程序。

    tkinter 模块

    GUI 编程的核心步骤和第一个 GUI 程序

    • 基于 tkinter 模块创建 GUI 程序包含如下 4 个核心步骤:
      1、创建应用程序主窗口对象(也称:根窗口)
      通过类 Tk 的无参构造函数
    from tkinter import *
    root = Tk()
    

    2、在主窗口中,添加各种可视化组件,比如:按钮(Button)、文本框(Label)等。

    btn01 = Button(root)
    btn01["text"] = "点我就送花" 
    btn01.pack()
    

    3、通过几何布局管理器,管理组件的大小和位置

    btn01.pack()
    

    4、事件处理
    (1) 通过绑定事件处理程序,响应用户操作所触发的事件(比如:单击、双击等)

    def songhua(e):
        messagebox.showinfo("Message","送你一朵玫瑰花,请你爱上我")
        print("送你 99 朵玫瑰花")
    btn01.bind("<Button-1>",songhua)
    
    • 组合起来实例演示:
    from tkinter import *
    from tkinter import messagebox
    # 1、创建窗口对象---创建一个窗口(主窗口)
    root = Tk()
    
    # 定义一个事件---Button按钮的意思
    # 传入root的意思是绑定主窗口
    btn01 = Button(root)
    btn01['text'] = '点我就送一朵鲜花'
    # 排列按钮(就是将btn01挂在主窗口root上)
    btn01.pack()
    
    
    def resign(event):
        messagebox.showinfo('message', '送你一朵玫瑰花,今晚你就属于我吧!')
        print('送了一朵花!')
    
    
    # 绑定一个事件,调用方法
    btn01.bind('<Button-1>', resign)
    
    # 设置一个主窗口标题
    root.title('第一个GUI')
    # 设定长宽高
    root.geometry('300x300+200+300')
    # 运行组件---显示出一个窗口(类似与一个死循环)
    # 调用组件---root.mainloop()
    root.mainloop()
    

    在这里插入图片描述

    • Tkinter–GUI库排布基本模板
    from tkinter import *
    from tkinter import messagebox
    
    
    class Application(Frame):
    
        def __init__(self, master=None):
            # 调用父类(Frame)中的init方法
            super().__init__(master)
            # 继承了Frame类之后,在现有类中重写了init方法,就需要重新调用原有父类的init方法。使用super方法。
            self.master = master
            self.pack()
            # 将生成的效果排布在框架(窗口对象)---挂在主窗口上。
            self.pack()
            # 调用createWidet方法
            self.createWidet()
    
        # 创建(添加)组件
        def createWidet(self):
            self.btn01 = Button(self)
            self.btn01['text'] = '点击送花'
            # pack就是布局的作用,将配件布局到窗口中
            self.btn01.pack()
            # 做出声明,调用resign方法
            self.btn01['command'] = self.resign
    
            # 加上退出按钮
            self.btn02 = Button(self, text='推出', command=root.destroy)
            self.btn02.pack()
    
        def resign(self):
            messagebox.showinfo('message', '送你一朵玫瑰花,今晚你就属于我吧!')
    
    
    if __name__ == '__main__':
        # 创建一个主窗口
        root = Tk()
        # 设定主窗口的参数(长宽高)
        root.geometry('300x300+400+300')
        # 创建主窗口的标题
        root.title('GUI的经典类的写法!')
    
        # 绑定(root)框架
        app = Application(master=root)
        # 调用组件---root.mainloop()
        root.mainloop()
    

    注:创建(添加)组建是可以更改的,其他的基本上不需要更改。

    tkinter主窗口

    主窗口位置和大小

    • 通过geometry((‘wxh±x±y’)进行设置。w为宽度,h为高度。+x表示句屏幕左边的距离;-x表示距离屏幕右边的距离;+y表示距离屏幕上边的距离;-y表示距离屏幕下边的距离。
    • 示例:测试tkinter主窗口位置和大小的设置。
    from tkinter import * 
    root = Tk() 
    root.title("测试主窗口的位置和大小") 
    root.geometry("500x400+100+200") #宽度 500,高度 400;距 屏幕左边 100,距屏幕上边 200 
    root.mainloop()
    

    打印输出结果:

    在这里插入图片描述

    GUI编程整体描述

    • 图形用户界面是由一个个组件组成,就像小孩“搭积木”一样最终组成了整个界面。有 的组件还能在里面再放置其他组件,我们称为“容器”。Tkinter 的 GUI 组件关系图如下:在这里插入图片描述
      Wm、Tk:是用来创建主窗口。进行交互
      Toplevel:顶级窗口。
      Misc、BaseWidget、Widget:创建组件的一些类。
      Pack、Place、Grid:布局管理器。

    Misc 和 Wm:

    • Tkinter 的 GUI 组件有两个根父类,它们都直接继承了 object 类:
    • Misc:它是所有组件的根父类。
    • Wm:它主要提供了一些与窗口管理器通信的功能函数。

    Tk

    • Misc 和 Wm 派生出子类 Tk,它代表应用程序的主窗口。一般应用程序都需要直接或间 接使用 Tk。

    Pack、Place、Grid布局管理器

    • Pack、Place、Grid 是布局管理器。布局管理器管理组件的:大小、位置。通过布局管 理器可以将容器中的组件实现合理的排布。

    BaseWidget

    • BaseWidget 是所有组件的父类

    Widget

    • Widget 是所有组件类的父类。Widget 一共有四个父类:BaseWidget、Pack、Grid、 Place。意味着,所有 GUI 组件同时具备这四个父类的属性和方法。
      在这里插入图片描述

    常用组件汇总列表

    在这里插入图片描述

    GUI 应用程序类的经典写法

    • 通过类 Application 组织整个 GUI 程序,类 Application 继承了 Frame 及通过继承拥有了父类的特性。通过构造函数 init()初始化窗口中的对象,通过 createWidgets()方法创 建窗口中的对象。
      Frame 框架是一个 tkinter 组件,表示一个矩形的区域。 Frame 一般作为容器使用,可以放置其他组件,从而实现复 杂的布局。
    • 示例:标准的GUI程序类的写法
    """测试一个经典的 GUI 程序的写法,使用面向对象的方式"""
    from tkinter import *
    from tkinter import messagebox
    
    
    class Application(Frame):
        """一个经典的 GUI 程序的类的写法"""
        def __init__(self, master=None):
            super().__init__(master) # super()代表的是父类的定义,而不是父类对象
            self.master = master
            self.pack()
            self.createWidget()
            
        def createWidget(self):
            """创建组件"""
            self.btn01 = Button(self)
            self.btn01["text"] = "点击送花"
            self.btn01.pack()
            self.btn01["command"] = self.songhua
            # 创建一个退出按钮
            self.btnQuit = Button(self, text="退出",command=root.destroy)
            self.btnQuit.pack()
            
        def songhua(self):
            messagebox.showinfo("送花","送你 99 朵玫瑰花")
            
                
    if __name__ == '__main__':
        root = Tk()
        root.geometry("400x100+200+300")
        root.title("一个经典的 GUI 程序类的测试")
        app = Application(master=root)
        root.mainloop()
    

    打印输出结果:
    在这里插入图片描述

    简单标签

    Label标签

    • Label(标签)主要用于显示文本信息,也可以显示图像。
    • Label(标签)有这样一些常见属性:
      • 1、width,height:
        用于指定区域大小,如果显示是文本,则以单个英文字符大小为单位(一个汉字宽度占 2 个字符位置,高度和英文字符一样);如果显示是图像,则以像素为单位。默认值是根据具体显示的内容动态调整。
      • 2、font
        指定字体和字体大小,如:font = (font_name,size)
      • 3、image:
        显示在 Label 上的图像,目前 tkinter 只支持 gif 格式。
      • 4、fg 和 bg
        fg(foreground):前景色、bg(background):背景色
      • 5、justify
        针对多行文字的对齐,可设置 justify 属性,可选值"left", “center” or “right”
        示例:Label(标签)的用法
    from tkinter import *
    from tkinter import messagebox
    
    
    class Application(Frame):
    
        def __init__(self, master=None):
            # 调用父类(Frame)中的init方法
            super().__init__(master)
            # 继承了Frame类之后,在现有类中重写了init方法,就需要重新调用原有父类的init方法。使用super方法。
            self.master = master
            self.pack()
            # 将生成的效果排布在框架(窗口对象)---挂在主窗口上。
            self.pack()
            # 调用createWidet方法
            self.createWidet()
    
        # 创建(添加)组件
        def createWidet(self):
            """创建组件"""
            # width=10, height=2---文本框的长宽
            self.lable01 = Label(self, text='逻辑教育', width=10, height=2, bg='black', fg='white')
            # self.lable01['text'] = 'logic'
            # self.lable01.config(bg='black',fg='white')
            # pack()布局排布
            self.lable01.pack()
    		
    		# bg='black', fg='white'---文本的前景颜色与背景颜色
    		# font=('宋体', 20)--- 设定文本标签的字体和字号大小
            self.lable02 = Label(self, text='王佳欣', width=10, height=2,bg='black', fg='white', font=('宋体', 20))
            self.lable02.pack()
    		
    		# 添加图片
            # 声明全局变量
            global image
            image = PhotoImage(file='imges/logic.gif')
            # 将图片作为标签,排布在主窗口
            self.lable03 = Label(self, image=image)
            self.lable03.pack()
            
            # borderwidth---边框的意思
            # relief---边框属于实现
            self.lable04 = Label(self, text='王佳欣\n干饭王\n帅哥一枚', borderwidth=1, relief='solid', justify='right')
            self.lable04.pack()
    
    
    if __name__ == '__main__':
        # 创建一个主窗口
        root = Tk()
        # 设定主窗口的参数(长宽高)
        root.geometry('300x300+400+300')
        # 创建主窗口的标题
        root.title('GUI的经典类的写法!')
    
        # 绑定(root)框架
        app = Application(master=root)
        # 调用组件---root.mainloop()
        root.mainloop()
    

    在这里插入图片描述

    Options选项详解

    • 通过Label组件,我们发现可以通过Options设置组件的属性,从而控制组件的各种状态。比如:宽度、高度、颜色、位置等。
    • 我们可以通过三种方式设置Options选项,这在各种GUI组件中用法都一致。
      1、创建对象时,使用可变参数。
    fred = Button(self, fg="red", bg="blue")
    

    2、创建对象后,使用字典索引方式

    fred["fg"] = "red"
    fred["bg"] = "blue"
    

    3、创建对象后,使用config()方法

    red.config(fg="red", bg="blue")
    
    • 如何查看组件的Option选项:
      1、可以通过打印config()方法的返回值,查看Options选项。
    print(fred.config())
    

    2、通过在IDE中,点击组件对象的构造方法,进入到方法内观察:
    我们可以看到如下的代码:

    class Button(Widget):
        """Button widget."""
        def __init__(self, master=None, cnf={}, **kw):
            """Construct a button widget with the parent MASTER.
    
            STANDARD OPTIONS
    
                activebackground, activeforeground, anchor,
                background, bitmap, borderwidth, cursor,
                disabledforeground, font, foreground
                highlightbackground, highlightcolor,
                highlightthickness, image, justify,
                padx, pady, relief, repeatdelay,
                repeatinterval, takefocus, text,
                textvariable, underline, wraplength
    
            WIDGET-SPECIFIC OPTIONS
    
                command, compound, default, height,
                overrelief, state, width
            """
            Widget.__init__(self, master, 'button', cnf, kw)
    

    上面代码中有:“standard options 标准选项”和“widget-specific options 组件特定选项”。我们常见的选项汇总如下:
    在这里插入图片描述

    Button按钮组件

    • Button(按钮)用来执行用户的单击操作。
    • Button可以包含文本,也可以包含图像。按钮被单击后回自动调用对应事件绑定的方法。
      示例:Button按钮使用用法(文字、图片、事件)
    """测试 Button 组件的基本用法,使用面向对象的方式"""
    
    from tkinter import *
    from tkinter import messagebox
    
    class Application(Frame):
        def __init__(self, master=None):
            super().__init__(master)  # super()代表的是父类的定义,而不是父类对象
            self.master = master
            self.pack()
            self.createWidget()
    
        def createWidget(self):
            """创建组件"""
            self.btn01 = Button(self, text='登陆', width=6, height=3, anchor=N, command=self.login)
            # anchor---是加载文字的方向
            self.btn01.pack()
    
            global image
            image = PhotoImage(file='imges/start.gif')
            self.btn02 = Button(self, image=image, command=self.login)
            self.btn02.pack()
            # 设置按钮为禁用状态
            self.btn02.config(state='disabled')
    
        def login(self):
            messagebox.showinfo('逻辑教育大课堂', '登陆成功,欢迎学习!')
    
    
    
    
    if __name__ == '__main__':
        root = Tk()
        root.geometry("400x130+200+300")
        app = Application(master=root)
        root.mainloop()
    

    在这里插入图片描述

    Entry单行文本框空间

    • 单行文本框Entry用力来接受一行字符串的控件。如果用户输入的文字,长度长于Entry控件的宽度时,文字会自动向后滚动,如果想输入多行文本,需要使用Text多行文本框控件。
    """测试 Button 组件的基本用法,使用面向对象的方式"""
    
    from tkinter import *
    from tkinter import messagebox
    
    
    class Application(Frame):
        def __init__(self, master=None):
            super().__init__(master)  # super()代表的是父类的定义,而不是父类对象
            self.master = master
            self.pack()
            self.createWidget()
    
        def createWidget(self):
            """创建登陆界面的组件"""
            # 创建用户名
            self.lable01 = Label(self, text='用户名')
            self.lable01.pack()
            # 需要创建一个双向的变量
            # 创建输入对象--输入用户名
            v1 = StringVar()
            self.entry01 = Entry(self, textvariable=v1)
            self.entry01.pack()
            # v1.set('wangjiaxinailirui')
            # print(v1.get())
            # print(self.entry01.get())
    
            # 创建密码
            self.lable02 = Label(self, text='密码')
            self.lable02.pack()
            # 需要创建一个双向的变量
            # 创建输入对象--输入密码
            v2 = StringVar()
            self.entry02 = Entry(self, textvariable=v2, show='*')
            self.entry02.pack()
    
            # 创建登录按钮
            self.btn01 = Button(self, text='登录', command=self.login)
            self.btn01.pack()
    
        # 创建登录之后的方法
        def login(self):
            username = self.entry01.get()
            password = self.entry02.get()
            print('用户名:' + self.entry01.get())
            print('密码:' + self.entry02.get())
            if username == 'wangjiaxin' and password  == 'wangjiaxinailirui':
                messagebox.showinfo('逻辑教育大课堂','登录成功,欢迎学习!')
            else:
                messagebox.showinfo('逻辑教育大课堂', '登录失败,用户名或密码错误,请重新输入!')
    
    
    if __name__ == '__main__':
        root = Tk()
        root.geometry("240x260+200+300")
        app = Application(master=root)
        root.mainloop()
    

    在这里插入图片描述

    Text多行文本框

    • Text(多行文本框)的主要用于显示多行文本,函可以显示网页链接,图片,HTML页面,甚至CSS样式表,添加组件等。因此,也常被当作简单的文本处理器、文本编辑器或者网页浏览器来使用。比如IDLE就是Text组件构成的。
      示例:Text多行文本框基本用法(文本输入、组件和图像显示)
    """测试 Text 多行文本框组件的基本用法,使用面向对象的方式"""
    
    from tkinter import *
    import webbrowser
    
    
    class Application(Frame):
        def __init__(self, master=None):
            super().__init__(master)  # super()代表的是父类的定义,而不是父类对象
            self.master = master
            self.pack()
            self.createWidget()
    
        def createWidget(self):
            self.w1 = Text(root, width=40, height=12, bg="gray")
            # 宽度 20 个字母(10 个汉字),高度一个行高
            self.w1.pack()
            self.w1.insert(1.0, "0123456789\nabcdefg")
            self.w1.insert(2.3, "锄禾日当午,汗滴禾下土。谁知盘中餐,粒粒皆辛苦\n")
            Button(self, text="重复插入文本", command=self.insertText).pack(side="left")
            Button(self, text="返回文本", command=self.returnText).pack(side="left")
            Button(self, text="添加图片", command=self.addImage).pack(side="left")
            Button(self, text="添加组件", command=self.addWidget).pack(side="left")
            Button(self, text="通过 tag 精确控制文本", command=self.testTag).pack(side="left")
    
        # 插入文本
        def insertText(self):
            # INSERT 索引表示在光标处插入
            self.w1.insert(INSERT, ' Cheney ')
            # END 索引号表示在最后插入
            self.w1.insert(END, 'logic')
            self.w1.insert(1.8, "Cheney")
    
        # 返回文本
        def returnText(self):
            # Indexes(索引)是用来指向 Text 组件中文本的位置,Text 的组件索引也是对应实际字符之间的位置。
            # 核心:行号以 1 开始 列号以 0 开始
            print(self.w1.get(1.2, 1.6))
            print("所有文本内容:\n" + self.w1.get(1.0, END))
    
        # 添加图片
        def addImage(self):
            # global photo
            self.photo = PhotoImage(file="imges/logic.gif")
            self.w1.image_create(END, image=self.photo)
    
        # 添加组件
        def addWidget(self):
            b1 = Button(self.w1, text='逻辑教育')
            # 在 text 创建组件的命令
            self.w1.window_create(INSERT, window=b1)
    
        # 通过TGA精确控制文本
        def testTag(self):
            self.w1.delete(1.0, END)
            self.w1.insert(INSERT, "good good study,day day up!\n腾讯课堂\n逻辑教育\n百度,搜一下就知道")
            self.w1.tag_add("good", 1.0, 1.9)
            self.w1.tag_config("good", background="yellow", foreground="red")
            self.w1.tag_add("百度", 4.0, 4.2)
            # underline---下划线的意思
            self.w1.tag_config("百度", underline=True)
            # tag_bind---绑定
            self.w1.tag_bind("百度", "<Button-1>", self.webshow)
    
        def webshow(self, event):
            webbrowser.open("http://www.baidu.com")
    
    
    if __name__ == '__main__':
        root = Tk()
        root.geometry("450x300+200+300")
        app = Application(master=root)
        root.mainloop()
    

    在这里插入图片描述

    利用Tags实现更加强大的文本显示和控制

    • Tags通常用于改变Text组件中内容的样式和功能。可以修改文本的字体、尺寸和颜色。另外,Tags还允许将文本、嵌入的组件和图片与鼠标和键盘等事件相关联。
      示例:利用Tag属性实现更复杂的文本控制
    #coding=utf-8
    from tkinter import *
    import webbrowser
    
    
    root = Tk()
    root.geometry("300x300+400+400")
    w1 = Text(root,width=40,height=20) #宽度 20 个字母(10 个汉字),高度一个行高
    w1.pack()
    w1.insert(INSERT,"good good study,day day up!\n 腾讯课堂\n逻辑教育\n 百度,搜一下就知道")
    w1.tag_add("good",1.0,1.9)
    w1.tag_config("good",background="yellow",foreground="red")
    w1.tag_add("baidu",4.0,4.2)
    w1.tag_config("baidu",underline=True)
    
    
    def webshow(event):
        webbrowser.open("http://www.baidu.com")
    
        
    w1.tag_bind("baidu","<Button-1>",webshow)
    root.mainloop()
    

    000

    Radiobutton单选按钮控件

    • 单选按钮Radinbutton控件用于选择同一组单选按钮中的一个。Radiobutton可以显示文本,也可以显示图像。
      示例:Radiobutton基础用法
    from tkinter import *
    from tkinter import messagebox
    
    
    class Application(Frame):
        def __init__(self, master=None):
            super().__init__(master)  # super()代表的是父类的定义,而不是父类对象
            self.master = master
            self.pack()
            self.createWidget()
    
        def createWidget(self):
            # 创建双向的变量
            self.v1 = StringVar()
            self.v1.set('F')
    
            # 创建两个按钮
            self.r1 = Radiobutton(self, text='男性', value='M', variable=self.v1)
            self.r2 = Radiobutton(self, text='女性', value='F', variable=self.v1)
            # side='left'使单选按钮排布为横向
            self.r1.pack(side='left')
            self.r2.pack(side='left')
    
            Button(self, text='确定', command=self.confirm).pack(side='left')
    
    
        def confirm(self):
            messagebox.showinfo('测试', '选择的性别:' + self.v1.get())
    
    if __name__ == '__main__':
        root = Tk()
        root.geometry("450x300+200+300")
        app = Application(master=root)
        root.mainloop()
    

    在这里插入图片描述

    Checkbutton

    • 复选按钮 Checkbutton 控件用于选择多个按钮的情况。Checkbutton 可以显示文本,也可以显示图像。
      示例:Checkbutton复选按钮用法
    """测试 Checkbutton 组件的基本用法,使用面向对象的方式"""
    
    from tkinter import *
    from tkinter import messagebox
    
    
    class Application(Frame):
        def __init__(self, master=None):
            super().__init__(master) # super()代表的是父类的定义,而不是父类对象
            self.master = master
            self.pack()
            self.createWidget()
            
        def createWidget(self):
            self.codeHobby = IntVar();
            self.videoHobby = IntVar()
            print(self.codeHobby.get()) # 默认值是 0
            self.c1 = Checkbutton(self, text="敲代码",variable=self.codeHobby,onvalue=1, offvalue=0)
            self.c2 = Checkbutton(self, text="看视频",variable=self.videoHobby,onvalue=1, offvalue=0)
            self.c1.pack(side="left");self.c2.pack(side="left")
            Button(self, text="确定",
            command=self.confirm).pack(side="left")
            
        def confirm(self):
            if self.videoHobby.get() == 1:
                messagebox.showinfo("测试","看视频,都是正常人有的爱好!你喜欢看什么类型?")
            if self.codeHobby.get() == 1:
                messagebox.showinfo("测试","抓获野生程序猿一只,赶紧送给他逻辑教育的视频充饥")
                
                
    if __name__ == '__main__':
        root = Tk()
        root.geometry("400x50+200+300")
        app = Application(master=root)
        root.mainloop() 
    

    在这里插入图片描述

    布局管理器

    grid布局管理器

    • grid表格布局,采用表格组织组件。子组件的位置右行和列的单元格来确定,并且可以跨行和跨列,从而实现复杂的布局。
      在这里插入图片描述
      示例:grid布局用法-登陆界面设计
    """测试 Grid 布局管理器的基本用法,使用面向对象的方式"""
    
    from tkinter import *
    from tkinter import messagebox
    import random
    
    
    class Application(Frame):
    
        def __init__(self, master=None):
            super().__init__(master)  # super()代表的是父类的定义,而不是父类对象
            self.master = master
            self.pack()
            self.createWidget()
    
        def createWidget(self):
            """通过 grid 布局实现登录界面"""
            # 创建用户名标签
            self.label01 = Label(self, text="用户名")
            # row=0, column=0---代表第0行,第0列
            self.label01.grid(row=0, column=0)
            # 创建输入文本框
            self.entry01 = Entry(self)
            # 判断输入文本框的位置
            self.entry01.grid(row=0, column=1)
            # 创建"用户名为手机号"标签,并选择排布位置
            Label(self, text="用户名为手机号").grid(row=0, column=2)
            # 创建"密码"标签,并选择排布位置
            Label(self, text="密码").grid(row=1, column=0)
            # 创建输入文本框
            Entry(self, show="*").grid(row=1, column=1)
            # 创建登陆按钮
            # sticky---为填充效果-(EW代表东西填充,也就是填充出文本框的距离!)
            Button(self, text="登录").grid(row=2, column=1, sticky=EW)
            # 创建取消按钮
            Button(self, text="取消").grid(row=2, column=2, sticky=E)
    
    
    if __name__ == '__main__':
        root = Tk()
        root.geometry("400x90+200+300")
        app = Application(master=root)
        root.mainloop()
    

    在这里插入图片描述

    示例:通过grid布局实现计算器软件界面
    代码如下:

    from tkinter import *
    from tkinter import messagebox
    import random
    
    
    class Application(Frame):
        def __init__(self, master=None):
            super().__init__(master)
            self.master = master
            self.pack()
            self.createWidget()
    
        def createWidget(self):
            """通过grid布局实现计算器的洁面"""
            # 参数--放在元组中,元组嵌套元组
            btnText = (
                ("MC", "M+", "M-", "MR"),
                ("C", "±", "/", "✖ "),
                (7, 8, 9, "-"),
                (4, 5, 6, "+"),
                (1, 2, 3, "="),
                (0, ".")
                      )
    
            # 输入框
            Entry(self).grid(row=0, column=0, columnspan=4, pady=10)
            # 遍历嵌套(enumerate()函数是为了遍历出元组中每一行的元素整体。)
            for rindex, r in enumerate(btnText):
                # 遍历出每一行元素中的元素(元组嵌套元组)
                for cindex, c in enumerate(r):
                    if c == '=':
                        Button(self, text=c).grid(row=rindex+1, column=cindex, rowspan=2, sticky=NSEW)
                    elif c == 0:
                        Button(self, text=c).grid(row=rindex+1, column=cindex, columnspan=2, sticky=NSEW)
                    elif c == '.':
                        Button(self, text=c).grid(row=rindex+1, column=cindex+1, sticky=NSEW)
                    else:
                        Button(self, text=c).grid(row=rindex+1, column=cindex, sticky=NSEW)
    
    
    if __name__ == '__main__':
        root = Tk()
        root.geometry("200x200+200+300")
        app = Application(master=root)
        root.mainloop()
    

    在这里插入图片描述

    pack布局管理器

    • pack布局管理器是按照组件的创建顺序将子组件添加在父组件中,按垂直或水平的方向自然排布。如果不指定任何选项,默认在父组件中自上而下的直接添加组件。
    • pack布局管理器代码量最少,最简单的一种,可以用于生成界面。
      在这里插入图片描述
      注:上述列出pack布局管理器的所有属性,单数不需要太熟悉,理解就好。pack只适用于垂直或水平排布,如需复杂排布,则需要使用grid布局管理器或place布局管理器。

    示例:pack布局管理器,制作钢琴案件布局

    # coding = utf-8
    # 测试 pack 布局管理
    """制作钢琴键"""
    
    from tkinter import *
    
    
    root = Tk()
    root.geometry("700x220")
    # Frame 是一个矩形区域,就是用来放置其他子组件
    f1 = Frame(root)
    f1.pack()
    f2 = Frame(root)
    f2.pack()
    btnText = ("流行风", "中国风", "日本风", "重金属", "轻音乐")
    for txt in btnText:
        # side="left"---向左排布,padx='10'---间隙水平为10
        Button(f1, text=txt).pack(side="left", padx="10")
    for i in range(1, 20):
        # width=5, height=10--按键的宽度和高度
        Button(f2, width=5, height=10, bg="black" if i % 2 == 0 else"white").pack(side="left")
    root.mainloop()
    

    在这里插入图片描述

    plcae布局管理器

    • plcae布局管理器可以通过坐标精确控制组件的位置,适用于一些布局更加灵活的场景。
    • place布局管理器的属性如下:在这里插入图片描述

    示例:place布局管理器用法

    #coding=utf-8
    
    from tkinter import *
    
    
    root = Tk()
    root.geometry("500x300")
    root.title("布局管理 place")
    root["bg"]="white"
    # Frame---就是一个窗口
    f1 = Frame(root, width=200, height=200, bg="green")
    f1.place(x=30, y=30)
    # relx=0.5, rely=0---相对位置; x=100, y=200---绝对位置; relwidth=0.2, relheight=0.2---宽度和高度
    Button(root, text="腾讯课堂").place(relx=0.5, rely=0, x=100, y=200, relwidth=0.2, relheight=0.2)
    Button(f1, text="逻辑教育").place(relx=0.6, rely=0.7)
    Button(f1, text="Cheney老师").place(relx=0.2, rely=0.2)
    root.mainloop()
    

    在这里插入图片描述

    示例:place布局管理器排布扑克牌

    """扑克牌游戏的界面设计"""
    
    from tkinter import *
    
    
    class Application(Frame):
        def __init__(self, master=None):
            super().__init__(master)  # super()代表的是父类的定义,而不是父类对象
            self.master = master
            self.pack()
            self.createWidget()
    
        def createWidget(self):
            """通过 place 布局管理器实现扑克牌位置控制"""
            # 测试
            # self.photo = PhotoImage(file='puke/puke1.gif')
            # self.puke1 = Label(self.master, image=self.photo)
            # self.puke1.place(x=10, y=10)
    
            # 列表推导式
            self.photos = [PhotoImage(file='puke/puke' + str(i) + '.gif') for i in range(1, 11)]
            self.pukes = [Label(self.master, image=self.photos[i]) for i in range(10)]
            for i in range(10):
                self.pukes[i].place(x=10+i*40, y=40)
                # 第一种绑定方法
                # bind---绑定一个事件(单个绑定)
                self.pukes[i].bind('<Button-1>', self.chupai)
            # 第二种绑定方法
            # bind_class根据指定的类型把所有这一类全部一起绑定
            # self.pukes[0].bind_class(Label, '<Button-1>', self.chupai)
    
        def chupai(self, event):
            # widget---是一个类
            print(event.widget.winfo_geometry())
            print(event.widget.winfo_y())
            if event.widget.winfo_y() == 40:
                event.widget.place(y=30)
            else:
                event.widget.place(y=40)
    
    if __name__ == '__main__':
        root = Tk()
        root.geometry("600x270+200+300")
        app = Application(master=root)
        root.mainloop()
    

    在这里插入图片描述

    事件处理

    • 一个GUI应用整个生命周期都处于一个消息循环(event loop)中。它等待事件的发生,并作出相应处理。Tkinter提供了用于处理相关事件的机制,处理函数可被绑定给各个控件的各种事件。
    widget.bind(event, handler)
    
    • 如果相关事件发生,handler函数会被触发,事件对象event会传递给handler函数。

    1、鼠标和键盘事件

    在这里插入图片描述

    鼠标事件分析

    * <Button-1>------鼠标左键单击
    * <Button-2>------鼠标中键单击
    * <Button-3>------鼠标右键单击
    	* <1> = <Button-1> = <ButtonPress-1>------鼠标左键单击
    	* <2> = <Button-2> = <ButtonPress-2>------鼠标中键单击
    	* <3> = <Button-3> = <ButtonPress-3>------鼠标右键单击
    
    * <B1-Motion>------鼠标左键拖动
    * <B2-Motion>------鼠标中键拖动
    * <B3-Motion>------鼠标右键拖动
    
    * <ButtonRelease-1>------鼠标左键释放
    * <ButtonRelease-2>------鼠标中键释放
    * <ButtonRelease-3>------鼠标右键释放
    
    * <Double-Button-1>------鼠标左键双击
    * <Double-Button-2>------鼠标中键双击
    * <Double-Button-3>------鼠标右键双击
    
    * <Enter>------鼠标指针进入控件
    * <Leave>------鼠标指针离开控件
    

    键盘事件分析

    • 键盘功能按键:
    <Return>------回车
    <Cancel>------Break键
    <BackSpace>------BackSpace键
    <Tab>------Tab键
    <Shift_L>------Shift键
    <Alt_L>------Alt键
    <Control_L>------Control键
    <Pause>------Pause键
    <Caps_Lock>------Caps_Lock键
    <Escape>------Escapel键
    <Prior>------PageUp键
    <Next>------PageDown键
    <End>------End键
    <Home>------Home键
    <Left>------左箭头
    <Up>------上箭头
    <Right>------右箭头
    <Down>------下箭头
    <Print>------Print Screen键
    <Insert>------Insert键
    <Delete>------Delete键
    <F1>------F1键
    <F12>------F12键
    <Num_Lock>------Num_Lock键
    <Scroll_Lock>------Scroll_Lock键
    <key>------任意键
    
    • 键盘字符按键:
    <KeyPress-a>------按下a键
    <KeyRelease-a>-----释放a键
    
    • 键盘组合键:
    <Shift-Up>------Shift+Up
    <Alt-Up>------Alt+Up
    <Control-Up>------ Ctrl+Up
    <Control-A>------Ctrl+shift+a
    

    2、event事件对象常用属性

    在这里插入图片描述

    • event事件对象属性分析:
    widget------事件被触发的控件
    
    x, y------鼠标距离窗体左上角的位置(坐标)
    
    x_root, x_y------鼠标距离屏幕左上角的位置(坐标)
    
    char------键盘事件对应的字符代码
    
    keysym------键盘事件对应的字符串
    
    keycode-------键盘事件对应的按键码
    
    num------鼠标事件对应的按键码
    
    width, height------控件的新大小
    
    type------事件类型
    

    示例:鼠标事件和键盘事件用法测试

    # coding=utf-8
    # 测试键盘和鼠标事件
    
    from tkinter import *
    
    root = Tk()
    root.geometry("530x300")
    # 创建画布的对象
    c1 = Canvas(root, width=200, height=200, bg="green")
    c1.pack()
    
    
    def mouseTest(event):
        print("鼠标左键单击位置(相对于父容器):{0},{1}".format(event.x, event.y))
        print("鼠标左键单击位置(相对于屏幕):{0},{1}".format(event.x_root, event.y_root))
        print("事件绑定的组件:{0}".format(event.widget))
    
    
    def testDrag(event):
        c1.create_oval(event.x, event.y, event.x + 1, event.y + 1)
    
    
    def keyboardTest(event):
        print("键的 keycode:{0},键的 char:{1},键的 keysym:{2}".format(event.keycode, event.char, event.keysym))
    
    
    def press_a_test(event):
        print("press a")
    
    
    def release_a_test(event):
        print("release a")
    
    
    # c1绑定鼠标左键
    c1.bind("<Button-1>", mouseTest)
    # c1绑定鼠标左键拖动
    c1.bind("<B1-Motion>", testDrag)
    #
    root.bind("<KeyPress>", keyboardTest)
    # 按下a键
    root.bind("<KeyPress-a>", press_a_test)
    # 只针对小写的a,大写的 A 不管用;释放事件a
    root.bind("<KeyRelease-a>", release_a_test)
    root.mainloop()
    

    在这里插入图片描述
    代码变更:

    from tkinter import *
    from tkinter import messagebox
    
    
    class Application(Frame):
        def __init__(self, master=None):
            super().__init__(master)
            self.master = master
            self.pack()
            self.createWight()
    
        # 添加组件
        def createWight(self):
            # Cancas设置画布
            c1 = Canvas(root, width=200, height=200, bg="green")
            c1.pack()
    
            # c1绑定鼠标左键
            c1.bind("<Button-1>", mouseTest)
            # c1 = Button("<Button-1>", bind=mouseTest)
            # c1绑定鼠标左键拖动
            c1.bind("<B1-Motion>", testDrag)
            # 绑定在主窗口进行键盘按键处理
            root.bind("<KeyPress>", keyboardTest)
            # 按下a键
            root.bind("<KeyPress-a>", press_a_test)
            # 只针对小写的a,大写的 A 不管用;释放事件a
            root.bind("<KeyRelease-a>", release_a_test)
    
    def mouseTest(event):
        print("鼠标左键单击位置(相对于父容器):{0},{1}".format(event.x, event.y))
        print("鼠标左键单击位置(相对于屏幕):{0},{1}".format(event.x_root, event.y_root))
        print("事件绑定的组件:{0}".format(event.widget))
    
    def testDrag(event):
        print('一条线!')
        print("事件绑定的组件:{0}".format(event.widget))
    
    def keyboardTest(event):
        print("键的 keycode:{0},键的 char:{1},键的 keysym:{2}".format(event.keycode, event.char, event.keysym))
    
    def press_a_test(event):
        print("press a")
    
    def release_a_test(event):
            print("release a")
    
    
    if __name__ == '__main__':
        # 创建主窗口
        root = Tk()
        # 设置操作框的大小
        root.geometry("530x300")
        # 设置主窗口标题
        root.title('王佳欣的鼠标键盘时间练习!')
        # 绑定root主窗口(框架)
        app = Application(master=root)
        # 调用mainloop组件
        root.mainloop()
    

    在这里插入图片描述

    3、lambda表达式详解

    • lambda表达式定义的是一个匿名函数,只适合简单输入参数,简单计算返回结果,不适合功能复杂情况。lambda定义的匿名函数有输入也有输出,只是没有名字。
    • 语法格式如下:
      • lambda参数值列表:表达式
      • 参数值列表即为输入
      • 表达式计算的结果即为输出
        我们写一个最简单的案例:
    add3args = lambda x, y, z:x+y+z
    print(add3args(10, 20. 30))
    

    上述lambda表达式相当于如下函数:

    def add3args(x, y, z):
    	return x+y+z
    
    

    lambda表达式的参数值列表伟如下内容:
    在这里插入图片描述

    我们在平时使用时,注意 lambda 只是一个匿名函数(没有名字的函数),功能不强,不要过度使用。

    4、使用lambda表达式实现传参

    示例:使用lambda帮助command属性绑定传参

    from tkinter import *
    
    
    class Application(Frame):
        def __init__(self, master=None):
            super().__init__(master)
            self.master = master
            self.pack()
            self.createWight()
    
    
        def createWight(self):
            self.btn01 = Button(root, text='测试 command1', command=mouseTest1).pack(side='left')
            self.btn02 = Button(root, text='测试 command2', command=lambda : mouseTest2('cheney', 'good man')).pack(side='left')
    
    
        def mouseTest1():
            print("command 方式,简单情况:不涉及获取 event 对象,可以使用")
    
    
        def mouseTest2(a, b):
            print("a={0},b={1}".format(a, b))
    
    
    if __name__ == '__main__':
        # 设置主窗口
        root = Tk()
        # 设置主窗口大小
        root.geometry('400x400')
        # 设置主窗口标题
        root.title('王佳欣的lambda窗口!')
        # 绑定主窗口
        app = Application(master=root)
        # 主窗口调用mainloop组件
        root.mainloop()
    
    

    在这里插入图片描述

    5、多种事件绑定方式汇总

    • 组件对象的绑定
      • 通过 command 属性绑定(只适合简单不获取event对象)
        • 示例:Button(root,text=”登录”,command=login)
      • 通过 bind() 方法绑定(适合获取event对象)
        • 示例:c1 = Canvas(); c1.bind(“”,drawLine)
    • 组件类的绑定
      • 调用对象的。bind_class函数,将该组件类所有的组件绑定事件: w.bind_class(‘Widget’, ‘event’, eventhanler)
      • 示例:btn01.bind_class('Button', func)
        示例:多种事件绑定方式总结
    # coding=utf-8
    # 多种事件绑定方式汇总
    
    from tkinter import *
    
    root = Tk()
    root.geometry("270x30")
    
    
    def mouseTest1(event):
        print("bind()方式绑定,可以获取 event 对象")
        print(event.widget)
    
    
    def mouseTest2(a, b):
        print("a={0},b={1}".format(a, b))
        print("command 方式绑定,不能直接获取 event 对象")
    
    
    def mouseTest3(event):
        print("右键单击事件,绑定给所有按钮啦!!")
        print(event.widget)
    
    b1 = Button(root, text="测试 bind()绑定")
    b1.pack(side="left")
    # bind 方式绑定事件
    b1.bind("<Button-1>", mouseTest1)
    # command 属性直接绑定事件
    b2 = Button(root, text="测试 command2", command=lambda: mouseTest2("cheney", "good man"))
    b2.pack(side="left")
    # 给所有 Button 按钮都绑定右键单击事件<Button-3>
    b1.bind_class("Button", "<Button-3>", mouseTest3)
    root.mainloop()
    

    在这里插入图片描述

    6、其他组件

    OptionMenu选择项

    • OptionMenu选择项被用来做多选一,选中的项会在顶部显示。

    示例:OptionMenu选择项的基本用法

    # coding = utf-8
    # optionmenu 的使用测试
    
    from tkinter import *
    
    
    root = Tk()
    root.geometry("200x100")
    v = StringVar(root)
    # v.set("逻辑教育!")---设置选项的初始值
    v.set("逻辑教育!")
    # v--->variable---->就是我需要选择的项
    # om--->就是多项选择组件的变量名
    om = OptionMenu(root, v, '腾讯课堂''逻辑教育', '全栈班[保底12万]' )
    # 设置组件宽度
    om['width'] = 10
    # 以并列组件之间的Y方向的间隔
    om.pack(pady=10)
    
    
    def test1():
    	print('最喜欢的机构:', v.get())
    
    
    # v.set('逻辑教育') #  直接修改了optionmenu中选选中的值
    Button(root, text='确定', command=test1).pack()
    root.mainloop()
    

    在这里插入图片描述

    Scale移动滑块

    • Scale移动滑块用于指定数值区间,通过滑块的移动来选择值。
      示例:使用Scale移动滑块控制字体的大小
    # coding = utf-8
    # scale的使用测试
    
    from tkinter import *
    
    root = Tk()
    root.geometry("400x150")
    
    
    def test1(value):
    	print('滑块的值:'value)
    	newFont = ('宋体', value)
    	# newFont--->是一个参数
    	# font--->是字体
    	a.confih(font=newFont)
    
    
    # orient---显示水平
    # from_---从何处开始(起始位置)
    # to---滑块数字显示间隔
    # length---滑块的长度 
    s1 = Scale(root, fron_=10, to=50, length=200, tickinterval=5, orient=HORIZONTAL, command=test1)
    s1.pack()
    a = Label(root, text="逻辑教育", width=10, height=1, bg="black", fg="white")
    a.pack()
    root.mainloop()
    

    在这里插入图片描述

    展开全文
  • Node.js全局对象、模块

    2021-08-18 19:14:16
    1.全局对象 (1)Globl 检测一个变量或者函数是否为全局的 交互模式属于全局作用域,变量和函数都是全局的,可以通过global访问. 脚本文件中不属于全局作用域,变量和函数都是局部的. 练习:编写脚本文件03_...

    1.全局对象

    (1)Globl

      检测一个变量或者函数是否为全局的

    交互模式属于全局作用域,变量和函数都是全局的,可以通过global访问.

    脚本文件中不属于全局作用域,变量和函数都是局部的.

    练习:编写脚本文件03_global.js,声明变量和创建函数,通过global查看是否为全局的

    var a=1;
    function fn(){
    	return 2;
    }
    console.log(window.a);
    console.log(window.fn());

    交互模式:

     

    JS的全局global叫做window.

    练习:编写04_window.js和04.html,把js嵌入到 html中。在js中声明变量和创建函数,使用window检测是否为全局的

    window.a   window.fn.

    var a=1;
    function fn(){
        return 2;
    }
    console.log(window.a);
    console.log(window.fn());

    浏览器控制台:

     

    (2)console对象

     

    console.time(  );//开始计时

    console.timeEnd(  );//结束计时

    开始计时和结束计时的值要保持一致

    练习:使用while、do-while循环100000次的耗时.

    console.time( 'tao ' );
    var i=1;
    while (i<=100000){
        i++;
    }
    console.timeEnd( 'tao ' );
    console.time( 'do-while' );
    var j=1;
    do{
        j++
    }
    while (j<=100000);
    console.timeEnd( 'do-while' );

    (3)process 进程对象

    用来管理当前nodejs这个进程

    启动任何一个软件都是代表对应的进程

    process.arch查看当前CPU架构.

      

    Process.platform 查看操作系统

     

    Process.version 产看当前nodejs的版本号

      

    Process.pid 查看当前进程的编号

      

    Process.kill() 结束指定编号的进程

      

    (4)Buffer缓冲区

    内存中一块临时存储数据的区域

    //创建Buffer
    //分配空间大小5,单位字节,每个汉字占3个字节
    var buf=Buffer.alloc(5,'abcde');
    console.log(buf);
    //将buffer转为字符串
    console.log(buf.toString());

    3.模块

    每个文件代表一个模块,模块表示一个功能体

    require:是一个函数,用于引入其它的模块,得到对方导出的对象

    module:当前模块的对象.

    module.exports:当前模块导出的对象,默认是一个空对象,如果要导出哪些内容只需要 放入到这个对象

    练习:编写08_2.js文件创建函数add导出a+b,编写08_1.js文件引入08_2.js模块传参实现计算

    function add(a,b){
    	return a+b;
    }
    //导出
    module.exports={
    	myadd:add
    }
    //引入模块
    var obj=require('./08_2.js');
    console.log(obj.myadd(2,3));

     

    展开全文
  • 设计模式全局意识

    2021-11-11 16:55:02
    设计模式的本质是面向对象设计原则的实际运用,是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解。 设计模式运用的优点: 可以提高程序员的思维能力、编程能力和设计能力 是程序设计更加标准...

    设计模式

    百度百科:使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

    学习设计模式的意义

    • 设计模式的本质是面向对象设计原则的实际运用,是对类的封装性继承性多态性以及类的关联关系和组合关系的充分理解。

    • 设计模式运用的优点

      • 可以提高程序员的思维能力、编程能力和设计能力
      • 是程序设计更加标准化、代码编制更加工程化,使软件开发效率大大提高,从而缩短软件的开发周期
      • 使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。

    设计模式的基本要素

    • 模式名称
    • 问题
    • 解决方案
    • 效果

    GoF23设计模式概述

    It is a concept, an attitude, a corporate mindset. 一种思维,一种态度,一种进步。

    1、分类

    • 创建型模式
      • 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式
    • 结构型模式
      • 适配器模、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
    • 行为型模式
      • 模块方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式

    2、GoF的23种设计模式的功能

    1. 单例(Singleton)模式:某个类只能生成一个实例,该类提供了一个全局访问点供外部获取该实例,其拓展是有限多例模式。
    2. 原型(Prototype)模式:将一个对象作为原型,通过对其进行复制而克隆出多个和原型类似的新实例。
    3. 工厂方法(Factory Method)模式:定义一个用于创建产品的接口,由子类决定生产什么产品。
    4. 抽象工厂(AbstractFactory)模式:提供一个创建产品族的接口,其每个子类可以生产一系列相关的产品。
    5. 建造者(Builder)模式:将一个复杂对象分解成多个相对简单的部分,然后根据不同需要分别创建它们,最后构建成该复杂对象。
    6. 代理(Proxy)模式:为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象,从而限制、增强或修改该对象的一些特性。
    7. 适配器(Adapter)模式:将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
    8. 桥接(Bridge)模式:将抽象与实现分离,使它们可以独立变化。它是用组合关系代替继承关系来实现,从而降低了抽象和实现这两个可变维度的耦合度。
    9. 装饰(Decorator)模式:动态的给对象增加一些职责,即增加其额外的功能。
    10. 外观(Facade)模式:为多个复杂的子系统提供一个一致的接口,使这些子系统更加容易被访问。
    11. 享元(Flyweight)模式:运用共享技术来有效地支持大量细粒度对象的复用。
    12. 组合(Composite)模式:将对象组合成树状层次结构,使用户对单个对象和组合对象具有一致的访问性。
    13. 模板方法(TemplateMethod)模式:定义一个操作中的算法骨架,而将算法的一些步骤延迟到子类中,使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
    14. 策略(Strategy)模式:定义了一系列算法,并将每个算法封装起来,使它们可以相互替换,且算法的改变不会影响使用算法的客户。
    15. 命令(Command)模式:将一个请求封装为一个对象,使发出请求的责任和执行请求的责任分割开。
    16. 职责链(Chain of Responsibility)模式:把请求从链中的一个对象传到下一个对象,直到请求被响应为止。通过这种方式去除对象之间的耦合。
    17. 状态(State)模式:允许一个对象在其内部状态发生改变时改变其行为能力。
    18. 观察者(Observer)模式:多个对象间存在一对多关系,当一个对象发生改变时,把这种改变通知给其他多个对象,从而影响其他对象的行为。
    19. 中介者(Mediator)模式:定义一个中介对象来简化原有对象之间的交互关系,降低系统中对象间的耦合度,使原有对象之间不必相互了解。
    20. 迭代器(Iterator)模式:提供一种方法来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。
    21. 访问者(Visitor)模式:在不改变集合元素的前提下,为一个集合中的每个元素提供多种访问方式,即每个元素有多个访问者对象访问。
    22. 备忘录(Memento)模式:在不破坏封装性的前提下,获取并保存一个对象的内部状态,以便以后恢复它。
    23. 解释器(Interpreter)模式:提供如何定义语言的文法,以及对语言句子的解释方法,即解释器。

    上面加粗的设计模式,是我们未来几天需要攻克的设计模式!下面先看看我们所提到的OOP设计七大原则,后面会用到。

    OOP软件设计七大原则

    开闭原则对扩展开放,对修改关闭降低维护带来的新风险
    依赖倒置原则高层不应该依赖低层,要面向接口编程更利于代码结构的升级扩展
    单一职责原则一个类只干一件事,实现类要单一便于理解,提高代码的可读性
    接口隔离原则一个接口只干一件事,接口要精简单一功能解耦,高聚合、低耦合
    迪米特法则不该知道的不要知道,一个类应该保持对其它对象最少的了解,降低耦合度只和朋友交流,不和陌生人说话,减少代码臃肿
    里氏替换原则不要破坏继承体系,子类重写方法功能发生改变,不应该影响父类方法的含义防止继承泛滥
    合成复用原则尽量使用组合或者聚合关系实现代码复用,少使用继承降低代码耦合

    实际上,这些原则的目的只有一个:降低对象之间的耦合,增加程序的可复用性、可扩展性和可维护性。

    记忆口诀:访问加限制,函数要节俭,依赖不允许,动态加接口,父类要抽象,扩展不更改。

    在程序设计时,我们应该将程序功能最小化,每个类只干一件事。若有类似功能基础之上添加新功能,则要合理使用继承。对于多方法的调用,要会运用接口,同时合理设置接口功能与数量。最后类与类之间做到低耦合高内聚。

    展开全文
  • 对象池 (需要交互模式) 小整数池 Python为了优化速度, 使用了小整数对象池, 避免为整数频繁申请和销毁内存空间 Python 对小整数的定义是 [-5, 256] ,这些整数对象是提前建立好的, 不会被垃圾回收 一个 Python 的...
  • 文章目录(一)设计模式的要素(二)创建型设计模式1. 抽象工厂(Abstract Factory)2. 生成器(Builder)3. 工厂方法(Factory Method)4. 原型(Prototype)5. 单例(Singleton)(三)结构型设计模式1. 适配器...
  • 一、Node.js概述(1)对比JS(2)网址(3)使用Node.js(4)特点二、全局对象(1)global(2)console(3)process(4)Buffer三、全局函数(1)一次性定时器四、模块(1)引入和导出(2)局部变量 一、Node.js概述 Node.js是运行服务器...
  • 09年Android相对较新的时候就写了这个答案,并且Android开发中有许多尚未完善的领域。 我本文的底部添加了很长的附录,以解决一些批评,并详细说明了我对使用Singleton而不是将Application子类化的观点上...
  • C#面向对象设计模式纵横谈 面向对象设计模式与原则 针对接口编程,而不是针对实现编程 优先使用对象组合,而不是类继承 封装变化点 使用重构得到模式—设计模式的应用不宜先入为主 设计原则 单一职责原则(SRP) ...
  • 面向对象设计模式

    2021-02-02 09:42:40
    1.简单工厂模式 例:计算器 按加减乘除功能分类 2.策略模式 例:超市打折 先定义抽象类,抽象类的子类里写各功能类(打折,满减。。。)
  • 记录学习王铮的课程笔记:《设计模式之美》,感兴趣的可以购买下面链接课程。 https://time.geekbang.org/column/intro/250 面向对象有两个名称概念: (1)面向对象编程 (2)面向对象的编程语言 面向对象编程的...
  • 设计模式总结 创建型模式 核心作用:用来帮助我们创建对象。 1.单例模式 保证一个类只有一个实例,并且提供一个访问该实例的全局访问点 通俗易懂:就像你有件事每天都要做,你可以让你的秘书帮你做,你可以让...
  • Java实现的23种设计模式汇总,及面向对象原则解释(SOLID),及指责分配原则解释(GRASP),及面向对象整个实现过程总结(OOA、OOD、OOP)。
  • 日常项目开发中,单例模式可以说是最常用到的设计模式,项目也常常单例模式中需要使用 Service 逻辑层的方法来实现某些功能。通常可能会使用 @Resource 或者 @Autowired 来自动注入实例,然而这种方法单例模式...
  • 培训中既有理论(论一个仪表盘的正确创建模式和可视化仪表盘的错误设计方式),又有实践(图表参花样传值,自由交互);既有深度(助力仪表盘的各种功能如图表参传值、URL控件等),又有广度(演示完整创建一个...
  •  2、对象模式:用于处理对象之间的关系,这些关系可以通过组合或聚合来实现,运行时刻是可以变化的,更具动态性。除了以上 4 种,其他的都是对象模式。 二、根据模式是用来完成什么工作来划分,这种方式可分为...
  • 实际的开发工作中,很多同学对面向对象编程都有误解,总以为把所有代码都塞到类里,自然就是进行面向对象编程了。实际上,这样的认识是不正确的。有时候,从表面上看似是面向对象编程风格的代码,从本质上看却是...
  • 一:设计模式是最重要的课程之一,堪称软件界的九阳真经,设计模式是一大套被反复使用,多数人知晓的,经过分类编目的,代码总结,使用设计模式是为了可重用代码.... 确定通用术语-----设计模式在项...
  • 设计模式、面向对象等知识相关的整理,以供查阅!
  • 有没有想过要设计多大的企业规模系统?主要的软件开发开始之前,我们必须选择一个合适的体系结构,它将为我们提供所需的功能和质量属性。因此,将它们应用到我们的设计之前,我们应该了解不同的体系...
  • 深入理解设计模式

    2021-04-20 23:48:59
    《设计模式——可复用面向对象软件的基础》原文中指出:“本书中的设计模式是对被用来特定场景解决一般设计问题的类和相互通信的对象的描述。” “设计模式确定了所包含的类和示例,它们的角色、协作方式以及...
  • 目录Node.js补充事件循环EventEmitter 类Buffer(缓冲区)stream(流)全局对象util Node.js补充 Node.js的组成 NPM,是和Node.js一起安装的包管理工具 REPL,交互式解释器,就相当于窗口中直接进行编辑,感觉没什么...
  • 备忘录模式(Memento Pattern):备忘录模式是指不破坏封装性的前提,捕获一个对象的内部状态,并对象之外保存这个状态。这样以后就可以将该对象恢复到原先保存的状态。这里的备忘录其实和我们常见的用来提醒...
  • 一张图快速了解23种设计模式

    万次阅读 多人点赞 2021-09-10 16:07:41
    设计模式是对被用来特定场景解决一般设计问题的类和相互通信的对象的描述。 这是《设计模式:可复用面向对象软件的基础》(Design Patterns: Elements of Reusable Object-Oriented)中对设计模式的定义。看完...
  • 文章目录什么是面向对象编程和面向对象编程语言?什么是面向对象分析和面向对象设计?封装(Encapsulation)抽象(Abstraction)继承(Inheritance)多态(Polymorphism)什么是面向过程编程与面向过程编程语言?...
  • 6. 策略模式由于表数据的同步方式有三种,分别是增量同步、先Delete后Insert方式、临时表方式,因此可以定义一个同步策略接口...类图如图8所示:图8 策略模式实例类图图8中,Oracle表同步对象类OracleTableDBS...
  • 交互式优点:运行一句执行一句缺点:关闭即消失命令行式优点:一直保存缺点:全部写完才能调试bug简述python垃圾回收机制:每个对象都维护一个引用计数字段,记录这个对象被引用的次数,如果有新的引用指向对象对象...
  • js 前后端交互ajax(http)

    2021-06-22 20:41:33
    互联网产品的前后端数据交互是通过一个通讯协议完成。前后台交互的协议主要包括HTTP,FTP,SMTP,TELNET,POP3…本文仅总结HTTP协议。 一、基础知识 HTTP协议 HTTP协议是Hyper Text Transfer Protocol(超文本传输协议)...
  • 软考(软件设计师)考点总结 -- 面向对象设计基础

    千次阅读 多人点赞 2021-05-21 17:31:21
    软考软件设计师考点总结 -- 面向对象基础:面向对象基本概念、面向对象的特性、分析、设计原则、设计模式:创建型模式、结构型模式、行为型模式、UML基本概念、UML模型。
  • 前:设计模式主要做的事情就是解耦! 创建型模式 创建型模式:创建对象模式,抽象了实例化的过程。它帮助一个系统独立于如何创建、组合和表示它的那些对象。关注的是对象的创建,创建型模式将创建对象的过程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 115,944
精华内容 46,377
关键字:

在交互模式下的全局对象是