devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

异常和日志_不断接收新用户的的输入(要求输入整数,不接受其他类型的输入)并做除法运算

作者：小蓝xlanll | 2024-06-13 04:18:04

赞

踩

不断接收新用户的的输入(要求输入整数,不接受其他类型的输入)并做除法运算

概念

 可向用户反馈报错信息。异常也是对象，可对他进行操作。所有的异常都是基类Exception的成员，异常是在exceptions模块中定义，Python自动将所有异常名称放在内建命名空间中，所以程序不必导入exceptions模块即可使用异常。

一旦引发而且没有捕捉SystemExit异常，程序执行就会终止。如果交互式会话遇到一个未被捕捉的SystemExit异常，会话就会终止。

异常是指程序运行时引发的错误，原因有除零、下标越界、文件不存在、网络异常、类型错误、名字错误、字典键错误、磁盘空间不足 、文件不存在、路径写错 缩进错误 将赋值运算符 = 和比较运算符==混淆

当Python解释 器遇到异常情况时，它会停止程序的运行，然后显示一个追踪(traceback) 信息。
 

SyntaxError;语法
IndentationError:缩进

TypeError: 数值不可修改 连接字符串和非字符串  忘记为类中第一个方法添加self

NameError : 变量没有定义

内置异常
定义在exceptions模块中，此模块在Python解释器启动时就会自动加载
 


 

 

异常处理结构

try……except……

编写程序接受用户输入，且要求用户必须输入整数，不接收其他类型的输入。

  1. >>>while True:
  2.    x = input('Please input:')
  3.    try:
  4.     x = int(x)
  5.     print('You have input {0}'.format(x))
  6.     break
  7.    except Exception as e:
  8.     print('Error.')

Please input:234c

Error.

Please input:5

You have input 5

try……except……else 

  1. >>>while True:
  2.    x = input('Please input:')
  3.    try:
  4.       x = int(x)
  5.    except Exception as e:
  6.       print('Error')
  7.    else:
  8.       print('You have input [0]'.format(x))
  9.    break

Please input:888c

Error.

Please input:888

You have input 888

try……except……finally

  1. filename = input('请输入一个文件名：')
  2. try:
  3.     fp = open(filename) #尝试打开文件
  4.     try: #尝试读取数据并计算和输出
  5.         print(int(fp.read())+5)
  6.     except: #读取文件或计算失败时执行的代码
  7.         print('文件内容格式不正确。')
  8.     finally: #确保文件能够关闭
  9.         fp.close()
  10. except: #打开文件失败时执行的代码
  11.      print('文件不存在')

异常类的实例和清除异常
每当有一一个异常被输出时，该异常类就会创建一个实例，此实例继承了异常类的所有属性。(最 重要的就是args属性)

  1. try:
  2.    x = [1,2,3]
  3.    print(x[4])
  4. except IndexError as err :
  5.    print(err.args[0])
  6.  
  7. list index out of range

IndexError: list index out of range
 

捕获多种异常处理结构

  1. >>>try:
  2.       x = float(input('请输入整数：'))
  3.       y = float(input('请输入除数：'))
  4.       z = x / y
  5.     except ZeroDivisionError:
  6.       print('除数不能为零')
  7.     except ValueError:
  8.       print('被除数和除数应为数值类型')
  9.     except NameError:
  10.       print('变量不存在')
  11.     else：
  12.       print(x,'/',y,'=',z)
  1. >>> a = 3
  2.  
  3. >>> b = 5
  4.  
  5. >>> assert a==b, 'a must be equal to b'
  6.  
  7.  
  8.  
  9. AssertionError: a must be equal to b

跟踪查看异常

发生异常时Python能够记住引发的异常以及程序的当前状态，Python还维护着traceback(跟踪)对象，其中含有异常发生时与函数调用堆栈有关的信息，异常可能在一系列嵌套较深的函数调用中引发，程序调用每个函数时，Python会在“函数调用堆栈”的起始处插入函数名，一旦异常被引发 ，Python会搜索一个相应的异常处理程序。

如果当前函数中没有异常处理程序，当前函数会终止执行，Python会搜索当前函数的调用函数，并以此类推，直到发现匹配的异常处理程序，或者Python抵达主程序为止，这一查找合适的异常处理程序的过程就称为“堆栈辗转开解”（Stack Unwinding）。解释器一方面维护着与放置堆栈中的函数有关的信息，另一方面也维护着与已从堆栈中“辗转开解”的函数有关的信息。
 

  1. try：
  2.    block
  3. except:
  4.    traceback.print_exc()

内置异常的协助模块

sys模块

sys模块中的exc_info()函数，可以取得目前正在处理的异常信息exc_info()函数会返回一个元组，这个元组包括三个元素。

  1. import sys
  2. try:
  3.    12/0
  4. except:
  5.    info = sys.exc_info()
  6.    exc_type = info[0]
  7.    exc_value = info[1]
  8.    exc_traceback = info[2]
  9.    print(ecx_type,':',exc_value)

 

  1. import sys
  2.   try:
  3.    12/0
  4. except :
  5.   info=sys.exc_ info( )
  6.   exc_ type=info[0]
  7.   exc_ value = info[1]
  8.   exc_ traceback = info[2]
  9.   print(exc_ type, " :" ,exc_ value )
  10. <class ' ZeroDivisionError'> : division by zero

 traceback对象
使用sys模块的exc_ info() 函数返回值的第三个元素，会返回一个traceback对象。
traceback对象的接口函数可以捕捉、格式化，或是输出Python程序的堆栈追踪(traceback) 信息。

  1. import traceback
  2.   try:
  3.      12/0
  4.   except :
  5.      traceback.print exc()
  6.  
  7.  
  8. Traceback (most recent call last) ;
  9. File "<ipython- input- 19- 71f6b5a77e1e>", line 4, in <module>
  10. 12/0
  11. ZeroDivisionError: division by zero

抛出异常

raise NameError ('抛出了一个异常')

  1. raise NameError( '这里是raise抛出的-个异常' )
  2.  
  3.  
  4. NameError
  5. Traceback (most recent cal1 last )
  6. <ipython- input- 20-e274246dfc1f> in <module>
  7. ----> 1 raise NameError( '这里是raise抛出的一个异常')
  8. NameError:这里是raise抛出的一 个异常

结束解释器的运行

用户可以利用输出SystemExit异常，来强迫结束解释器的运行

使用sys.exit()函数会输出一个SystemExit异常，sys.exit()会结束线程

  1. import sys
  2.  
  3. try:
  4.     sys.exit()
  5. except SystemExit:
  6.     print('目前还不能结束解释器运行')
  7.  
  8. #如果想正常结束解释器运行，最好利用OS模块的_exit()函数

 离开嵌套循环

使用raise语句离开嵌套循环

  1. class ExitLoop(Exception):
  2.       pass
  3.  
  4. try:
  5.     i = 1
  6.     while i < 10:
  7.         for j in range(1, 10):
  8.             print(i, j)
  9.             if (i == 2) and (j == 2):
  10.                 raise(ExitLoop)
  11.             i += 1
  12. except ExitLoop:
  13.     print('当i = 2, j = 2时离开嵌套循环')

1 1
2 2
当i=2，j=2时离开循环嵌套
 

 用户自定义异常类

  1. class URLError(Exception):
  2.         pass
  3.  
  4. try:
  5.     raise URLError(“URL ERROR”)
  6. except URLError as err:
  7.     print(err.args[0])

 URL ERROR

 assert语句

原理：检查表达式的代码当表达式求值为真，一切正常；但若表达式求值为假，则暂停程序，打印消息，并在可行的情况下启动调试器。

  1. assert <测试码>[, 参数]
  2. #原理
  3.  
  4. a = 10
  5. assert (a != 0),"Error happened, a = 0"
  6. print(a)

 如果a = 0会抛出 Error happened a = 0

__debug__内置变量

  1. if __debug__:
  2.     if not (<测试码>)：
  3.        raise AssertionError [, 参数]
  4.  
  1. import types
  2. def checkType(arg):
  3.     if__debug__:
  4.         if not (type(arg) == str):
  5.             raise AssertionError("参数类型不是字符串")
  6.  
  7. checkType(1)

Asser t ionError
Traceback (most recent ca11 last)
<ipython- input- 30-c6dc6612ea27> in <module>
5
raise AssertionError("参 数类型不是字符串")
6
----> 7 checkType(1)
<ipython- input-30-c6dc6612ea27> in checkType (arg)
3
debug__
4
if not (type(arg) == str):
----> 5
raise AssertionError("参 数类型不是字符串")
6
7 checkType(1)
AssertionError:参数类型不是字符串
 

断言与上下管理语句

  • 上下文管理（context manager）语句with可以自动管理资源，不论因为什么原因（哪怕是代码引发了异常）跳出with块，总能保证文件被正确关闭，并且可以在代码块执行完毕后自动还原进入该代码块时的现场，常用于文件操作、数据库连接、网络通信连接和多线程、多进程同步等场合。
  • with语句用于文件操作时的用法如下：

with open(filename, mode, encoding) as fp:

      # 通过文件对象fp操作文件的代码

tkinter简介

tkinter是Python标准库，不需要额外安装就可以直接使用，比较方便，得到了很多人的青睐，成为现在做GUI开发的主流模块。除了在tkinter库的主模块中提供了大量组件，还通过其中的模块tkinter.ttk提供了Combobox、Progressbar和Treeview等组件，tkinter.scrolledtext提供了带滚动条的文本框，messagebox、commondialog、dialog、colorchooser、simpledialog、filedialog等模块提供了各种形式的对话框。

常用组件

组件名称说明
Button按钮
Canvas画布，用于绘制直线、椭圆、多边形等各种图形
Checkbutton复选框形式的按钮
Entry单行文本框
Frame框架
Label标签，常用来显示文本
Listbox列表框
Menu菜单
Message多行文本框
Radiobutton单选框
Scrollbar滚动条
Toplevel创建新窗口

Tkinter开发基本步骤：

编写通用代码，例如数据库操作

搭建界面，放置组件，设置组件属性，可以借助PAGE

编写组件的事件处理代码

启动应用程序，启动消息主循环

用户登录界面

  1. import tkinter
  2. import tkinter.messagebox
  3. import os
  4. import os.path
  5.  
  6. path = os.getenv('temp')
  7. filename = os.path.join(path, 'info.txt')
  8. #创建应用程序窗口
  9. root = tkinter.Tk()
  10. #定义窗口大小
  11. root['height'] = 140
  12. root['width'] = 200
  13.  
  14. #在窗口上创建标签组件
  15. labelName = tkinter.Label(root,
  16.                              text='User Name:',
  17.                              justify=tkinter.RIGHT,
  18.                              anchor = 'e',
  19.                              width=80)
  20. #把组件放置到窗口上指定区域
  21. labelName.place(x=10, y=5, width=80, height=20)
  22.  
  23. varName = tkinter.StringVar(root, value='')
  24. entryName = tkinter.Entry(root,
  25.                              width=80,
  26.                              textvariable=varName)
  27. entryName.place(x=100, y=5, width=80, height=20)
  28.  
  29. labelPwd = tkinter.Label(root,
  30.                             text='User Pwd:',
  31.                             justify=tkinter.RIGHT,
  32.                             anchor = 'e',
  33.                             width=80)
  34. labelPwd.place(x=10, y=30, width=80, height=20)
  35.  
  36. #创建密码文本框
  37. varPwd = tkinter.StringVar(root, value='')
  38. entryPwd = tkinter.Entry(root,
  39.                             show='*',    #不管输入什么，都显示星号
  40.                             width=80,
  41.                             textvariable=varPwd)
  42. entryPwd.place(x=100, y=30, width=80, height=20)
  43.  
  44. #尝试自动填写用户名和密码
  45. try:
  46.     with open(filename) as fp:
  47.         n, p = fp.read().strip().split(',')
  48.         varName.set(n)
  49.         varPwd.set(p)
  50. except:
  51. 	pass
  52. 	#记住我，复选框
  53. rememberMe = tkinter.IntVar(root, value=1)
  54. checkRemember = tkinter.Checkbutton(root,
  55.                                         text='Remember me?',
  56.                                         variable=rememberMe,
  57.                                         onvalue=1,
  58.                                         offvalue=0)
  59. checkRemember.place(x=30, y=70, width=120, height=20)
  60.  
  61. #登录按钮事件处理函数
  62. def login():
  63.     #获取用户名和密码
  64.     name = entryName.get()
  65.     pwd = entryPwd.get()
  66.     if name=='admin' and pwd=='123456':
  67.         tkinter.messagebox.showinfo(title='恭喜',
  68.                                        message='登录成功！')
  69.         if rememberMe.get() == 1:
  70.             #把登录成功的信息写入临时文件        
  71.             with open(filename, 'w') as fp:
  72.                 fp.write(','.join((name,pwd)))
  73.         else:
  74.             try:
  75.                 #删除用于记录用户名和密码的临时文件
  76.                 os.remove(filename)
  77.             except:
  78.                 pass
  79.     else:
  80.         tkinter.messagebox.showerror('警告',
  81.                                         message='用户名或密码错误')
  82. #创建按钮组件，同时设置按钮事件处理函数
  83. buttonOk = tkinter.Button(root,
  84.                             text='Login',  #设置按钮上显示的文本
  85.                             command=login) #设置按钮的单击事件处理函数
  86. buttonOk.place(x=30, y=100, width=50, height=20)
  87.  
  88. #取消按钮的事件处理函数
  89. def cancel():
  90.     #清空用户输入的用户名和密码
  91.     varName.set('')
  92.     varPwd.set('')
  93. buttonCancel = tkinter.Button(root,
  94.                                  text='Cancel',
  95.                                  command=cancel)
  96. buttonCancel.place(x=90, y=100, width=50, height=20)
  97. #启动消息循环
  98. root.mainloop()
  99. 例12-2  tkinter单选钮、复选框、组合框、列表框综合运用案例。
  100. import tkinter
  101. import tkinter.messagebox
  102. import tkinter.ttk
  103.  
  104. #创建tkinter应用程序
  105. root = tkinter.Tk()
  106. #设置窗口标题
  107. root.title('Selection widgets')
  108. #定义窗口大小
  109. root['height'] = 400
  110. root['width'] = 320
  111.  
  112. #与姓名关联的变量
  113. varName = tkinter.StringVar()
  114. varName.set('')
  115. #创建标签，然后放到窗口上
  116. labelName = tkinter.Label(root,
  117.                             text='Name:',
  118.                             justify=tkinter.RIGHT,
  119.                             width=50)
  120. labelName.place(x=10, y=5, width=50, height=20)
  121. #创建文本框，同时设置关联的变量
  122. entryName = tkinter.Entry(root,
  123.                              width=120,
  124.                              textvariable=varName)
  125. entryName.place(x=70, y=5, width=120, height=20)
  126.  
  127. labelGrade = tkinter.Label(root,
  128.                              text='Grade:',
  129.                              justify=tkinter.RIGHT, width=50)
  130. labelGrade.place(x=10, y=40, width=50, height=20)
  131. #模拟学生所在年级，字典键为年级，字典值为班级
  132. studentClasses = {'1':['1', '2', '3', '4'],
  133.                     '2':['1', '2'],
  134.                     '3':['1', '2', '3']}
  135.  #学生年级组合框
  136. comboGrade = tkinter.ttk.Combobox(root,width=50,
  137.                               values=tuple(studentClasses.keys()))
  138. comboGrade.place(x=70, y=40, width=50, height=20)
  139. #事件处理函数
  140. def comboChange(event):
  141.     grade = comboGrade.get()
  142.   if grade:
  143.         #动态改变组合框可选项
  144.         comboClass["values"] = studentClasses.get(grade)
  145.     else:
  146.         comboClass.set([])
  147. #绑定组合框事件处理函数
  148. comboGrade.bind('<<ComboboxSelected>>', comboChange)
  149.  
  150. labelClass = tkinter.Label(root,
  151.                               text='Class:',
  152.                               justify=tkinter.RIGHT, width=50)
  153. labelClass.place(x=130, y=40, width=50, height=20)
  154. #学生班级组合框
  155. comboClass = tkinter.ttk.Combobox(root, width=50)
  156. comboClass.place(x=190, y=40, width=50, height=20)
  157.  
  158. labelSex = tkinter.Label(root,
  159.                             text='Sex:',
  160.                             justify=tkinter.RIGHT, width=50)
  161. labelSex.place(x=10, y=70, width=50, height=20)
  162. #与性别关联的变量，1:男；0:女，默认为男
  163. sex = tkinter.IntVar()
  164. sex.set(1)
  165. #单选钮，男
  166. radioMan = tkinter.Radiobutton(root,
  167.                                   variable=sex,
  168.                                   value=1,
  169.                                   text='Man')
  170. radioMan.place(x=70, y=70, width=50, height=20)
  171. #单选钮，女
  172. radioWoman = tkinter.Radiobutton(root,
  173.                                     variable=sex,
  174.                                     value=0,
  175.                                     text='Woman')
  176. radioWoman.place(x=130, y=70, width=70, height=20)
  177.  
  178. #与是否班长关联的变量，默认当前学生不是班长
  179. monitor = tkinter.IntVar()
  180. monitor.set(0)
  181. #复选框，选中时变量值为1，未选中时变量值为0
  182. checkMonitor = tkinter.Checkbutton(root,
  183.                                       text='Is Monitor?', 
  184.                                       variable=monitor,
  185.                                       onvalue=1,
  186.                                       offvalue=0)
  187. checkMonitor.place(x=20, y=100, width=100, height=20)
  188. #添加按钮单击事件处理函数
  189. def addInformation():
  190.     result = 'Name:' + entryName.get()
  191.     result = result + ';Grade:' + comboGrade.get()
  192.     result = result + ';Class:' + comboClass.get()
  193.     result = result + ';Sex:'\
  194.               + ('Man' if sex.get() else 'Woman')
  195.     result = result + ';Monitor:'\
  196.               + ('Yes' if monitor.get() else 'No')
  197.     #把信息插入到列表框组件中
  198.     listboxStudents.insert(0, result)    
  199. buttonAdd = tkinter.Button(root,
  200.                              text='Add',
  201.                              width=40,
  202.                              command=addInformation)
  203. buttonAdd.place(x=130, y=100, width=40, height=20)
  204.  
  205. #删除按钮的事件处理函数
  206. def deleteSelection():
  207.     selection = listboxStudents.curselection()
  208.     if  not selection:
  209.         tkinter.messagebox.showinfo(title='Information',
  210.                                        message='No Selection')
  211.     else:
  212.         listboxStudents.delete(selection)
  213. buttonDelete = tkinter.Button(root,
  214.                                  text='DeleteSelection',
  215.                                  width=100,
  216.                                  command=deleteSelection)
  217. buttonDelete.place(x=180, y=100, width=100, height=20)
  218.  
  219. #创建列表框组件
  220. listboxStudents = tkinter.Listbox(root, width=300)
  221. listboxStudents.place(x=10, y=130, width=300, height=200)
  222.  
  223. #启动消息循环
  224. root.mainloop()
  225.  

  1. import os
  2. import tkinter
  3. import tkinter.simpledialog
  4. import tkinter.colorchooser
  5. import tkinter.filedialog
  6. #需要执行pip install pillow安装扩展库
  7. from PIL import ImageGrab
  8.  
  9. root = tkinter.Tk()
  10. root.title('My Paint----by Dong Fuguo')
  11. root['width'] = 800
  12. root['height'] = 600
  13.  
  14. #控制是否允许画图的变量，1：允许，0：不允许
  15. canDraw = tkinter.IntVar(value=0)
  16.  
  17. what = tkinter.IntVar(value=1)
  18.  
  19. #记录鼠标位置的变量
  20. X = tkinter.IntVar(value=0)
  21. Y = tkinter.IntVar(value=0)
  22.  
  23. #前景色、背景色
  24. foreColor = '#000000'
  25. backColor = '#FFFFFF'
  26.  
  27. #创建画布
  28. image = tkinter.PhotoImage()
  29. canvas = tkinter.Canvas(root,
  30.                           bg='white',
  31.                           width=800, height=600)
  32. canvas.create_image(800, 600, image=image)
  33.  
  34. #鼠标左键单击，允许画图，并记录当前鼠标位置
  35. def onLeftButtonDown(event):
  36.     canDraw.set(1)
  37.     X.set(event.x)
  38.     Y.set(event.y)
  39.     if what.get()==4:
  40.         canvas.create_text(event.x, event.y, text=text)
  41. canvas.bind('<Button-1>', onLeftButtonDown)
  42.  
  43. #记录最后绘制图形的id
  44. lastDraw = 0
  45. #按住鼠标左键移动，画图
  46. def onLeftButtonMove(event):
  47.     global lastDraw
  48.     if canDraw.get()==0:
  49.         return
  50.    if what.get()==1:
  51.         #使用当前选择的前景色绘制曲线
  52.         canvas.create_line(X.get(), Y.get(), event.x,
  53.                              event.y, fill=foreColor)
  54.         X.set(event.x)
  55.         Y.set(event.y)
  56.     elif what.get()==2:
  57.         #绘制直线，先删除刚刚画过的直线，再画一条新的直线
  58.         try:
  59.             canvas.delete(lastDraw)
  60.         except Exception as e:
  61.             pass
  62.         lastDraw = canvas.create_line(X.get(), Y.get(),
  63.                                          event.x, event.y,
  64.                                          fill=foreColor)
  65.     elif what.get()==3:
  66.         #绘制矩形，先删除刚刚画过的矩形，再画一个新的矩形        
  67.         try:
  68.             canvas.delete(lastDraw)
  69.         except Exception as e:
  70.             pass
  71.         lastDraw = canvas.create_rectangle(X.get(), Y.get(),
  72.                                               event.x, event.y,
  73.                                               fill=backColor,
  74.                                               outline=foreColor)
  75.     elif what.get()==5:
  76.         #橡皮，使用背景色填充10*10的矩形区域
  77.         canvas.create_rectangle(event.x-5, event.y-5,
  78.                                    event.x+5, event.y+5,
  79.                                    outline=backColor, fill=backColor)
  80. canvas.bind('<B1-Motion>', onLeftButtonMove)
  81.  
  82. #鼠标左键抬起，不允许再画图了
  83. def onLeftButtonUp(event):
  84.     if what.get()==2:
  85.         #绘制直线
  86.         canvas.create_line(X.get(),
  87.                              Y.get(),
  88.                              event.x,
  89.                              event.y,
  90.                              fill=foreColor)
  91.     elif what.get()==3:
  92.         #绘制矩形
  93.         canvas.create_rectangle(X.get(),
  94.                                   Y.get(),
  95.                                   event.x,
  96.                                 event.y,
  97.                                   fill=backColor,
  98.                                   outline=foreColor)
  99.     canDraw.set(0)
  100.     global lastDraw
  101.     #防止切换图形时误删上次绘制的图形
  102.     lastDraw = 0
  103. canvas.bind('<ButtonRelease-1>', onLeftButtonUp)
  104.  
  105. #创建菜单
  106. menu = tkinter.Menu(root, tearoff=0)
  107. #打开图像文件
  108. def Open():
  109.     filename = tkinter.filedialog.askopenfilename(title='Open Image',
  110.                             filetypes=[('image', '*.jpg *.png *.gif')])
  111.     if filename:
  112.         global image
  113.         image = tkinter.PhotoImage(file=filename)
  114.         canvas.create_image(80, 80, image=image)
  115. menu.add_command(label='Open', command=Open)
  116.  
  117. def Save():
  118.     #获取客户区域位置和尺寸，并截图保存
  119.     left = int(root.winfo_rootx())
  120.     top = int(root.winfo_rooty())
  121.     width = root.winfo_width()
  122.     height = root.winfo_height()
  123.     im = ImageGrab.grab((left,top,left+width,top+height))
  124.     
  125.     #保存绘制的图片
  126.     filename = tkinter.filedialog.asksaveasfilename(title='保存图片',
  127.                                        filetypes=[('图片文件','*.png')])
  128.     if not filename:
  129.         return
  130.     if not filename.endswith('.png'):
  131.         filename = filename+'.png'
  132.     
  133.     im.save(filename)
  134. menu.add_command(label='Save', command=Save)
  135.  
  136. #添加菜单，清除，遍历画布上的所有图像，逐个删除
  137. def Clear():
  138.     for item in canvas.find_all():
  139.         canvas.delete(item)
  140. menu.add_command(label='Clear', command=Clear)
  141. #添加分割线
  142. menu.add_separator()
  143.  
  144. #创建子菜单，用来选择绘图类型
  145. menuType = tkinter.Menu(menu, tearoff=0)
  146. def drawCurve():
  147.     what.set(1)
  148. menuType.add_command(label='Curve', command=drawCurve)
  149.  
  150. def drawLine():
  151.     what.set(2)
  152. menuType.add_command(label='Line', command=drawLine)
  153.  
  154. def drawRectangle():
  155.     what.set(3)
  156. menuType.add_command(label='Rectangle', command=drawRectangle)
  157.  
  158. def drawText():
  159.     global text
  160.     text = tkinter.simpledialog.askstring(title='Input what you want to draw', prompt='')
  161.     what.set(4)
  162. menuType.add_command(label='Text', command=drawText)
  163.  
  164. menuType.add_separator()
  165.  
  166. #选择前景色
  167. def chooseForeColor():
  168.     global foreColor
  169.     foreColor = tkinter.colorchooser.askcolor()[1]
  170. menuType.add_command(label='Choose Foreground Color',
  171.                        command=chooseForeColor)
  172.  
  173. #选择背景色
  174. def chooseBackColor():
  175.     global backColor
  176.     backColor = tkinter.colorchooser.askcolor()[1]
  177. menuType.add_command(label='Choose Background Color',
  178.                        command=chooseBackColor)
  179.  
  180. #橡皮
  181. def onErase():
  1. import tkinter
  2. import tkinter.messagebox
  3. import random
  4. import threading
  5. import itertools
  6. import time
  7.  
  8. root = tkinter.Tk()
  9. # 窗口标题
  10. root.title('随机提问')
  11. # 窗口初始大小和位置
  12. root.geometry('260x180+400+300')
  13. # 不允许改变窗口大小
  14. root.resizable(False, False)
  15.  
  16. # 关闭程序时执行的函数代码，停止滚动显示学生名单
  17. def closeWindow():
  18.     # 标记flat变量为False，停止滚动
  19.     root.flag = False
  20.     # 暂停0.1秒，等待用于滚动名单的子线程结束
  21.     time.sleep(0.1)
  22.     # 销毁窗口，关闭程序
  23.     root.destroy()
  24. # 绑定消息处理函数，当窗口关闭时会触发'WM_DELETE_WINDOW'消息
  25. root.protocol('WM_DELETE_WINDOW', closeWindow)
  26.  
  27. # 模拟学生名单，这些学生姓名在窗口上滚动
  28. students = ['张三', '李四', '王五', '赵六', '周七', '钱八']
  29. # 变量，用来控制是否滚动显示学生名单，默认启动时不滚动
  30. root.flag = False
  31.  
  32. # 用户滚动名单的线程函数
  33. def switch():
  34.     root.flag = True
  35.     # 随机打乱学生名单
  36.     t = students[:]
  37.     random.shuffle(t)
  38.     # 创建cycle对象，用于实现无限重复的滚动
  39.     t = itertools.cycle(t)
  40.  
  41.     # 一直滚动，直到flag的值为False
  42.     while root.flag:        
  43.         # 滚动显示
  44.         # 把第二个人名移动到第一个
  45.         # 把第三个人名移动到第二个
  46.         # 获取一个新的人名显示为第三个
  47.         lbFirst['text'] = lbSecond['text']        
  48.         lbSecond['text'] = lbThird['text']
  49.         lbThird['text'] = next(t)
  50.         
  51.         # 数字可以修改，控制滚动速度
  52.         time.sleep(0.1)
  53.         
  54. def btnStartClick():
  55.     # 每次单击“开始”按钮创建并启动新线程
  56.     t = threading.Thread(target=switch)
  57.     t.start()
  58.     # 把“开始”按钮禁用，避免重复响应单击操作
  59.     btnStart['state'] = 'disabled'
  60.     # 启用“停”按钮
  61.     btnStop['state'] = 'normal'
  62. btnStart = tkinter.Button(root,
  63.                           text='开始',
  64.                           command=btnStartClick)
  65. btnStart.place(x=30, y=10, width=80, height=20)
  66.  
  67. def btnStopClick():
  68.     # 单击“停”按钮结束滚动显示
  69.     root.flag = False
  70.     # 等待0.3秒，彻底停止滚动之后再获取中奖的人名
  71.     time.sleep(0.3)
  72.     tkinter.messagebox.showinfo('恭喜',
  73.                                 '本次中奖：'+lbSecond['text'])
  74.     # 启用“开始”按钮，禁用“停”按钮
  75.     btnStart['state'] = 'normal'
  76.     btnStop['state'] = 'disabled'
  77. btnStop = tkinter.Button(root,
  78.                          text='停',
  79.                          command=btnStopClick)
  80. # 程序启动时，“停”按钮初始设置为禁用
  81. btnStop['state'] = 'disabled'
  82. btnStop.place(x=150, y=10, width=80, height=20)
  83.  
  84. # 用来滚动显示学生名单的3个Label组件
  85. # 可以根据需要进行添加，但要修改上面的线程函数代码
  86. lbFirst = tkinter.Label(root, text='')
  87. lbFirst.place(x=80, y=60, width=100, height=20)
  88.  
  89. # 红色Label组件，表示中奖名单
  90. lbSecond = tkinter.Label(root, text='')
  91. lbSecond['fg'] = 'red'
  92. lbSecond.place(x=80, y=90, width=100, height=20)
  93.  
  94. lbThird = tkinter.Label(root, text='')
  95. lbThird.place(x=80, y=120, width=100, height=20)
  96.  
  97. # 启动消息主循环，启动应用程序
  98. root.mainloop()
  99. 例12-7 使用tkinter实现计算器程序
  100.  
  101. import re
  102. import tkinter
  103. import tkinter.messagebox
  104.  
  105. root = tkinter.Tk()
  106. # 设置窗口大小和位置
  107. root.geometry('300x270+400+100')
  108. # 不允许改变窗口大小
  109. root.resizable(False, False)
  110. # 设置窗口标题
  111. root.title('简易计算器-董付国')
  112.  
  113. # 字符串变量
  114. contentVar = tkinter.StringVar(root, '')
  115. # 用来显示表达式的文本框，设置关联变量
  116. contentEntry = tkinter.Entry(root, textvariable=contentVar)
  117. # 设置为只读，只能通过按钮来输入要计算的表达式
  118. contentEntry['state'] = 'readonly'
  119. contentEntry.place(x=10, y=10, width=280, height=20)
  120.  
  121. # 按钮通用代码，参数btn表示按钮的是哪个按钮
  122. def buttonClick(btn):    
  123.     content = contentVar.get()
  124.     # 如果已有内容是以小数点开头的，前面加0
  125.     if content.startswith('.'):
  126.         content = '0' + content
  127.  
  128.     # 根据不同按钮做出相应的处理
  129.     if btn in '0123456789':
  130.         # 普通数字按钮，直接连接到表达式最后
  131.         content += btn
  132.     elif btn == '.':
  133.         # 如果最后一个运算数中已经有小数点，就提示错误
  134.         lastPart = re.split(r'\+|-|\*|/]', content)[-1]
  135.         if '.' in lastPart:
  136.             tkinter.messagebox.showerror('错误', '小数点太多了')
  137.             return
  138.         else:
  139.             # 最后一个运算数中没有小数点，把小数点连接到最后
  140.             content += btn
  141.     elif btn == 'C':
  142.         # 清除整个表达式
  143.         content = ''
  144.     elif btn == '=':
  145.         # 按下等于号按钮，计算结果
  146.         try:
  147.             # 尝试对输入的表达式求值
  148.             content = str(eval(content))
  149.         except:
  150.             tkinter.messagebox.showerror('错误', '表达式错误')
  151.             return
  152.     elif btn in operators:
  153.         # 按下运算符按钮，表达式中不允许有连续的运算符
  154.         if content.endswith(operators):
  155.             tkinter.messagebox.showerror('错误',
  156.                                          '不允许存在连续运算符')
  157.             return
  158.         content += btn
  159.     elif btn == 'Sqrt':
  160.         # 求平方根
  161.         # 切分出整数部分和小数部分
  162.         n = content.split('.')
  163.         # 要求小数点前后都是数字，如果表达式中含有运算符，不符合要求
  164.         if all(map(lambda x: x.isdigit(), n)):
  165.             content = eval(content) ** 0.5
  166.         else:
  167.             tkinter.messagebox.showerror('错误', '表达式错误')
  168.             return
  169.     # 显示计算结果
  170.     contentVar.set(content)
  171.  
  172. # 放置清除按钮和等号按钮
  173. btnClear = tkinter.Button(root,
  174.                           text='Clear',
  175.                           command=lambda:buttonClick('C'))
  176. btnClear.place(x=40, y=40, width=80, height=20)
  177. btnCompute = tkinter.Button(root,
  178.                             text='=',
  179.                             command=lambda:buttonClick('='))
  180. btnCompute.place(x=170, y=40, width=80, height=20)
  181.  
  182. #放置10个数字、小数点和计算平方根的按钮
  183. digits = list('0123456789.') + ['Sqrt']
  184. index = 0
  185. for row in range(4):
  186.     for col in range(3):
  187.         d = digits[index]
  188.         index += 1
  189.         btnDigit = tkinter.Button(root,
  190.                                   # 按钮上显示的内容
  191.                                   text=d,
  192.                                   # 按下按钮时执行的函数
  193.                                   command=lambda x=d:buttonClick(x))
  194.         # 把按钮放置到窗口上
  195.         btnDigit.place(x=20+col*70,
  196.                        y=80+row*50,
  197.                        width=50,
  198.                        height=20)
  199.  
  200. # 放置运算符按钮
  201. operators = ('+', '-', '*', '/', '**', '//')
  202. for index, operator in enumerate(operators):
  203.     btnOperator = tkinter.Button(root,
  204.                                  text=operator,
  205.                                  command=lambda x=operator:buttonClick(x))
  206.     btnOperator.place(x=230, y=80+index*30, width=50, height=20)
  207.  
  208. # 启动消息主循环，启动应用程序
  209. root.mainloop()
  210. 例12-8 使用tkinter实现定时自动关闭的窗口
  211.  
  212. import time
  213. import tkinter
  214. import threading
  215.  
  216. # 创建应用程序窗口，设置标题和大小
  217. root = tkinter.Tk()
  218. root.title('倒计时自动关闭的窗口')
  219. root['width'] = 400
  220. root['height'] = 300
  221. # 不允许改变窗口大小
  222. root.resizable(False, False)
  223.  
  224. # 创建Text组件，放置一些文字
  225. richText = tkinter.Text(root, width=380)
  226. richText.place(x=10, y=10, width=380, height=230)
  227. # 连续插入5行内容
  228. # '0.0'表示插入位置，第0行第0列
  229. # 如果想让插入的内容占一行，需要在字符串最后有换行符
  230. for i in range(5):
  231.     # f字符串语法，会把{i}替换为i的当前实际值
  232.     richText.insert(f'{i}.0',
  233.                     '假设阅读这些文字需要10秒钟时间\n')
  234.  
  235. # 显示倒计时的Label
  236. lbTime = tkinter.Label(root, fg='red', anchor='w')
  237. lbTime.place(x=10, y=250, width=150)
  238.  
  239. def autoClose():
  240.     # 倒计时10秒钟
  241.     for i in range(10):
  242.         # f字符串语法，对{}中的表达式进行计算并替换
  243.         lbTime['text'] = f'距离窗口关闭还有{10-i}秒'
  244.         # 每秒钟修改一次提示信息
  245.         time.sleep(1)
  246.     root.destroy()
  247. # 创建并启动线程
  248. t = threading.Thread(target=autoClose)
  249. t.start()
  250.  
  251. # 启动消息主循环，启动应用程序
  252. root.mainloop()
  253.  
  254. import time
  255. import tkinter
  256. import threading
  257.  
  258. # 创建应用程序窗口，设置标题和大小
  259. root = tkinter.Tk()
  260. root.title('倒计时自动关闭的窗口')
  261. root['width'] = 400
  262. root['height'] = 300
  263. # 不允许改变窗口大小
  264. root.resizable(False, False)
  265.  
  266. # 创建Text组件，放置一些文字
  267. richText = tkinter.Text(root, width=380)
  268. richText.place(x=10, y=10, width=380, height=230)
  269. # 连续插入5行内容
  270. # '0.0'表示插入位置，第0行第0列
  271. # 如果想让插入的内容占一行，需要在字符串最后有换行符
  272. for i in range(5):
  273.     # f字符串语法，会把{i}替换为i的当前实际值
  274.     richText.insert(f'{i}.0',
  275.                     '假设阅读这些文字需要10秒钟时间\n')
  276.  
  277. # 显示倒计时的Label
  278. lbTime = tkinter.Label(root, fg='red', anchor='w')
  279. lbTime.place(x=10, y=250, width=150)
  280.  
  281. def autoClose():
  282.     # 倒计时10秒钟
  283.     for i in range(10):
  284.         # f字符串语法，对{}中的表达式进行计算并替换
  285.         lbTime['text'] = f'距离窗口关闭还有{10-i}秒'
  286.         # 每秒钟修改一次提示信息
  287.         time.sleep(1)
  288.     root.destroy()
  289. # 创建并启动线程
  290. t = threading.Thread(target=autoClose)
  291. t.start()
  292.  
  293. # 启动消息主循环，启动应用程序
  294. root.mainloop()

日志

 logging库日志级别
 

级别                级别数值                使用时机
DEBUG               10                      详细信息,常用于调试。
INFO                    20                      程序正常运行过程中产“生的一些信息。
WARNING            30                      警告用户，虽然程序还在正常工作，但有可能发生错误。
ERROR                 40                     由于更严重的问题，程序已不能执行一些功能了。
CRITICAL               50                    严重错误，程序已不能继续运行。

  1. import logging 
  2.  
  3. #print("This is a 10g. text")
  4.  
  5. logging. debug("This is debug log")
  6. logging.info("This is info Log")
  7. logging.warning("This is warning log") 
  8. logging.error("This is error Log")
  9. logging.critical("This is critical log")
  1. WARNING: root:This is wa rning log
  2. ERROR: root:This is error Log
  3. CRITICAL : root:This is critical Log
  4.  
  5. Process finished with exit code 0
  1. import logging
  2. #使用baseConfig( )来指定日志输出级别
  3. logging.basicConfig( leve1= logging. DEBUG)
  4. print("This is a log text")
  5. logging.debug("This is debug log" )
  6. logging.info("This is info log")
  7. logging.warning("This is warning log")
  8. logging.error("This is error log")
  9. logging.critical(This is critical log")

输出代码： 

  1. DEBUG: root:This is debug log
  2. INFO: root:This is info log
  3. WARNING: root:This is warning log
  4. ERROR: root:This is error log
  5. CRITICAL: root:This is critical log
  6. This is a log text

logging . basicConfig( filename='demo，Log', fi lemode= 'w's leve (= Logging . DEBUG

新生成一个叫demo.log的文件 每次记录日志都会重新写入 不依次追加 默认是追加

  1. loggingbasicConfig(format="%(message)s", level=logging.DEBUG)
  2. name = “张三"
  3. age = 18
  4. logging.debug("姓名%s， 年龄%d", name, age )

 可以只输出信息 

  1. logging.basicConfig(format="%(asctime)s|%(LeveLnames|%(filename)s:% (lineno)s|% (message)s
  2. ", leve L= logging. DEBUG)
  3.

 2021-09-16 11:07:52, 161 DEBUG|2.2py:10|姓名张三，年龄18

日志logging


高级应用，四个组件:


Loggers:记录器
Handlers:处理器
Filters:过滤器
Formatters:格式化器

  1. import logging 
  2. import logging.config
  3.  
  4. #配置文件的方式来处理日志
  5. logging.config.fileConfig('logging.config')
  6.  
  7. logger = logging.getLogger('applog')
  8.  
  9. #打印日志
  10. logger.debug("This is a debug log")
  11. logger.info("This is a info log")
  12. logger.warning("This is a warning log")
  13. logger.error("This is a error log")
  14. logger.critical("This is a critical log")

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/710845
推荐阅读