抱歉，您的浏览器无法访问本站
本页面需要浏览器支持（启用）JavaScript
了解详情 >

python进阶

知识

发布于：2022年10月30日

次浏览

python入门后我开始学习进阶知识

这些是我写的小项目，里面涉及一些知识点，算是实践练习了

仅作为参考笔记阅读。

python进阶学习

序列应用—猜单词游戏

随机抽选：random轮子使用

猜单词游戏： 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import random                        #------------random，随机选择模块
def guess():                         #-------------定义猜单词函数，便于执行
    words=("python","juice","easy","difficult","answer","continue","phone","hello","pose","game")     #------录入单词
    newword=""                  #-----空字符
    word=random.choice(words)   #---------随机挑一个单词
    recordword=word             #—--------保存单词，猜的时候对比
    while word:
        s=random.randrange(len(word))         #-----根据word长度，产生word随机位置
        newword+=word[s]                      #-----s位置的字母组合到乱序后的单词
        word=word[:s]+word[(s+1):]            #-----原位置字母用切片删除。
    print("乱序后的单词：",newword)
    x=str(input("让你猜："))
    if x==recordword:
        print("真棒，你猜对了")
    else:
        print("可惜，猜错了")
guess()                         #--------首次执行
while True:                     #--------------进入循环
    y=input("是否继续？(T/N):")
    if y=="T" or y=="y":
        guess()
    else:
        print("下次再见~")
        break


面向对象设计应用————发牌游戏

类定义

 简单来说就是去定义变量归属。
 就好比
 高二：
     Xraytf
     阿灯
 ------------
 调用的话就可以在高二这个类里面找
 ---
 （学过c的可以简单的看为结构体）
基本样式代码 
1
2
3
4
class Person
    num=1                    #成员变量（属性）
    def sayHello(self):      #成员函数
        print("hello")

构造函数，实例属性，类属性。

基本样式代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Person:
    num=1                                         #类属性
    def __init__(self,str,n):                     #构造函数
        self.name=str                             #实例属性
        self.age=n
    def SayHello(self):                           #成员函数
        print("Hello")
    def PrintName(self):                          #成员函数
        print("姓名:",self.name,"年龄:",self.age)
    def PrintNum(self):                           #成员函数
        print(Person.num)                         #由于是类属性，所以不写self.num
#主程序
P1=Person("夏敏",42)
P2=Person("王琳",36)
P1.PrintName()
P2.PrintName()
Person.num=2                                      #修改类属性
P1.PrintNum()
P2.PrintNum()

公有方法、私有方法、静态方法的定义和调用示例

基本样式代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Person:
    num=0                                   #类属性
    def __init__(self,str,n,w):             #构造函数
        self.name=str                       #对象实例属性（成员）
        self.age=n
        self.__weight=w                     #定义私有属性__weight
        Person.num+=1
    def __outputWeight(self):               #定义私有方法__outputWeight
        print("体重:",self.__weight)        #访问私有属性
    def PrintName(self):                    #定义公有方法（成员函数）
        print("姓名:",self.name,"年龄:",self.age,end=" ")
        self.__outputWeight( )              #调用私有方法
    def PrintNum(self):                     #定义公有方法（成员函数）
        print(Person.num)                   #由于是类属性，所以不写self.num
    @ staticmethod
    def getNum():                           #定义静态方法getNum
        return Person.num
p1=Person("夏敏",42,120)
p2=Person("张海",39,80)
#P1.outputWeight()
#错误'Person'object has no attribute 'outputWeight'
p1.PrintName()
p2.PrintName()
Person.PrintName(p2)
print("人数:",Person.getNum())
print("人数:",p1.getNum())

类的继承

—-#定义基类：Person类

基本样式代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import types
class Person:
    def __init__(self,name=" ",age=20,sex="man"):
        self.setName(name)
        self.setAge(age)
        self.setSex(sex)
    def setName(self,name):
        if type(name)!=str:                        #内置函数type（）返回被测对象的数据类型
            print("姓名必须是字符串.")
            return
        self.__name=name
    def setAge(self,age):
        if type(age)!=int:
            print("年龄必须是整形.")
            return
        self.__age=age
    def setSex(self,sex):
        if sex!='男'and sex!="女":
            print("性别输入错误")
            return
        self.__sex=sex
    def show(self):
        print("姓名:",self.__name,"年龄:",self.__age,"性别：",self.__sex)
#定义子类（Student类），其中增加一个入学年份私有属性（数据成员）
class Student(Person):
    def __init__(self, name=" ", age=20, sex="man",schoolyear=2016):
       ########调用基类构造方法初始化基类的私有数据成员
        super(Student,self).__init__(name,age,sex)
        #######------Person.__init__(self,name,age,sex)
        #######------也可以这样初始化基类私有数据成员
        self.setSchoolyear(schoolyear)      #初始化派生类的数据成员
    def setSchoolyear(self,schoolyear):
        self.__schoolyear=schoolyear
    def show(self):
        Person.show(self)                   #调用基类show（）方法
        #######------super(Student,self).show()     #也可以这样调用基类show()方法
        print("入学年份:",self.__schoolyear)
#主程序
if __name__=="__main__":
    zhangsan=Person("张三",19,"男")
    zhangsan.show()
    lisi=Student("李四",18,"男",2015)
    lisi.show()
    lisi.setAge(20)                                     #调用继承的方法修改年龄
    lisi.show()

发牌游戏—–程序设计步骤

—–设计类

基本样式代码 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#Card类
class Card():
    '''A play card'''
    RANKS=["A","2","3","4","5","6","7","8","9","10","J","Q","K"]
    SUITS=["梅","方","红","黑"]

    def __init__(self,rank,suit,face_up=True):
        self.rank=rank                              #指的是牌面1~3
        self.suit=suit                              #suit指的是花色
        self.is_face_up=face_up

    def __str__(self):                              #重写print（）方法，打印一张牌的信息
        if self.is_face_up:
            rep=self.suit+self.rank
        else:
            rep="XX"
        return rep

    def pic_order(self):                            #牌的顺序号
        if self.rank=="A":
            FaceNum=1
        elif self.rank=="J":
            FaceNum=11
        elif self.rank=="Q":
            FaceNum=12
        elif self.rank=="K":
            FaceNum=13
        else:
            FaceNum=int(self.rnak)
        if self.suit=="梅":
            Suit=1
        elif self.suit=="方":
            Suit=2
        elif self.suit=="红":
            Suit=3
        else:
            Suit=4
        return(Suit-1)*13+FaceNum
    def flip(self):                           #翻牌方法
        self.is_face_up=not self.is_face_up

#Hand类
class Hand( ):
    """A hand of playing cards"""
    def __init__(self):
        self.cards=[]                       #cards列表变量存储牌手的牌
    def __str__(self):                      #重写print()方法，打印出牌手的所有牌
        if self.cards:
            rep=""
            for card in self.cards:
                rep+=str(card)+"\t"
        else:
            rep="无牌"
        return rep
    def clear(self):                        #清空拍手的牌
        self.cards=[]
    def add(self,card):                     #增加牌
        self.cards.append(card)
    def qive(self,card,other_hand):         #把一张牌给别的牌手
        self.cards.remove(card)
        other_hand.add(card)
#Poke类
class Poke(Hand):
    """A deck of playing cards"""
    def populate(self):                     #生成一副牌
        for suit in Card.SUITS:
            for rank in Card.RANKS:
                self.add(Card(rank,suit))

    def shuffle(self):                      #洗牌
        import random
        random.shuffle(self.cards)          #打乱牌的顺序

    def deal(self,hands,per_hand=13):       #发牌，默认发给每个牌手13张牌
        for rounds in range(per_hand):
            for hand in hands:
                if self.cards:
                    top_card=self.cards[0]
                    self.cards.remove(top_card)
                    hand.add(top_card)
                else:
                    print("不能再发牌了，牌已经发完")
调用类发牌的主程序
主程序 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#主程序
if __name__=="__main__":
    print("This is a module with classes for playing cards")
    players=[Hand(),Hand(),Hand(),Hand()]
    poke1=Poke()
    poke1.populate()                    #生成一副牌
    poke1.shuffle()                     #洗牌
    poke1.deal(players,13)              #发给每个牌手13张牌
    n=1
    for hand in players:
        print("牌手",n,end=":")
        print(hand)
        n=n+1
    input("\npress the enter key to exit")

python图形界面设计————猜数字游戏

就是创建窗口，走出终端，在窗口内实现各种功能

创建windows窗口

基本样式代码 
1
2
3
4
5
6
from tkinter import *
win=Tk()                 #创建windows窗口对象
win.title("我的第一个GUI程序")    #设置窗口标题
win.geometry("800x600")          #设置初始大小
win.configure(bg="#0050b3")       #设置背景颜色 
win.mainloop()                   #进入消息循环，也就是显示窗口

几何布局管理器

pack几何布局管理器 
1
2
3
4
5
6
7
8
9
10
11
from cProfile import label
import tkinter
root=tkinter.Tk()
label=tkinter.Label(root,text="hello world")
root.geometry("800x600")
label.pack()
button1=tkinter.Button(root,text="BUTTON1")   #创建文本是BUTTON1的button组件
button1.pack(side=tkinter.LEFT)               #将BUTTON1组件添加到窗口显示，左靠停
button2=tkinter.Button(root,text="BUTTON2")   #创建文本是BUTTON2的button组件
button2.pack(side=tkinter.RIGHT)              #将BUTTON2组件添加到窗口显示，右靠停
root.mainloop()
grid几何布局管理器 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
from tkinter import *
root=Tk()
root.geometry("400x400+280+280")       #200x200是初始化大小，280,280是初始化时位置
root.title("计算器示例")

#网格布局
L1=Button(root,text='1',width=5,bg="yellow")  #数字，大小，背景色
L2=Button(root,text="2",width=5)
L3=Button(root,text="3",width=5)
L4=Button(root,text="4",width=5)
L5=Button(root,text="5",width=5,bg="#0050b3")
L6=Button(root,text="6",width=5)
L7=Button(root,text="7",width=5)
L8=Button(root,text="8",width=5)
L9=Button(root,text="9",width=5,bg="yellow")
L0=Button(root,text="0",width=5)
Lp=Button(root,text=".",width=5)
L1.grid(row=0,column=0)   #放置位置----第0行0列
L2.grid(row=0,column=1)
L3.grid(row=0,column=2)
L4.grid(row=1,column=0)
L5.grid(row=1,column=1)
L6.grid(row=1,column=2)
L7.grid(row=2,column=0)
L8.grid(row=2,column=1)
L9.grid(row=2,column=2)
L0.grid(row=3,column=0,columnspan=2,sticky=E+W)  #跨两列，左右紧贴
Lp.grid(row=3,column=2,sticky=E+W)        #左右紧贴
root.mainloop()

place几何布局管理器 
1
2
3
4
5
6
7
8
9
10
11
12

from tkinter import *
root=Tk()
root.title("登录页面")
root["width"]=200;root["height"]=80
Label(root,text="用户名",width=6).place(x=1,y=1)
Entry(root,width=20).place(x=45,y=1)
Label(root,text="密码",width=6).place(x=1,y=20)
Entry(root,width=20,show='*').place(x=45,y=20)
Button(root,text='登录',width=8).place(x=40,y=40)
Button(root,text='取消',width=8).place(x=110,y=40)
root.mainloop()

tkinter组件

  • 列表点击
列表读取，添加，使用 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from tkinter import *
root=Tk()
def callbutton1():
    for i in listb.curselection():              #遍历选中项
        listb2.insert(0,listb.get(i))           #添加到右侧列表栏

def callbutton2():
    for i in listb2.curselection():             #遍历选中项
        listb2.delete(i)                        #从列表栏删除

li=['C','python','php','html','SQL','java']
listb=Listbox(root)                             #创建两个列表框组件
listb2=Listbox(root)                            
for item in li:
    listb.insert(0,item)
listb.grid(row=0,column=0,rowspan=2)            #将列表框放左边窗口对象中
b1=Button(root,text="添加>>",command=callbutton1,width=20)      #创建按钮，读取函数实现添加和删除，设置大小
b2=Button(root,text="删除<<",command=callbutton2,width=20)
b1.grid(row=0,column=1,rowspan=1)               #显示
b2.grid(row=1,column=1,rowspan=2)
listb2.grid(row=0,column=2,rowspan=2)
root.mainloop()
  • 复选框
复选框Checkbutton演示 
1
2
3
4
5
6
7
8
9
10
11
12
import tkinter
root=tkinter.Tk()
c=tkinter.IntVar()
a=tkinter.IntVar()
root.geometry("400x400")
c.set(2)
a.set(2)
check=tkinter.Checkbutton(root,text="喜 欢",variable=c,onvalue=1,offvalue=2)
check.pack()
check=tkinter.Checkbutton(root,text="芜 湖",variable=a,onvalue=1,offvalue=2)
check.pack()
root.mainloop()
  • 单选按钮
单选按钮Radiobutton演示 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import tkinter
root=tkinter.Tk()
r=tkinter.StringVar()
root.geometry("400x400")
r.set("1")
radio=tkinter.Radiobutton(root,variable=r,value='1',text='中国')
radio.pack()
radio=tkinter.Radiobutton(root,variable=r,value='2',text='美国')
radio.pack()
radio=tkinter.Radiobutton(root,variable=r,value='3',text='日本')
radio.pack()
radio=tkinter.Radiobutton(root,variable=r,value='4',text='加拿大')
radio.pack()
radio=tkinter.Radiobutton(root,variable=r,value='5',text='韩国')
radio.pack()
root.mainloop()
print(r.get())

  • 菜单
菜单组件 
1
2
3
4
5
6
7
8
9
10
11

from tkinter import *
root=Tk()
def hello():
    print("请点击主菜单")
m=Menu(root)
for item in ['文件','编辑','视图']:
    m.add_command(label=item,command=hello)
root['menu']=m
root.mainloop()

  • 消息窗口
消息窗口 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


import tkinter as tk
from tkinter import messagebox as msgbox
def btn1_clicked():
    msgbox.showinfo("Info","Showinfo test.")
def btn2_clicked():
    msgbox.showwarning("warning","showwarining test")
def btn3_clicked():
    msgbox.showerror("Error","Showerror test.")
def btn4_clicked():
    msgbox.askquestion("question","Askquestion test.")
def btn5_clicked():
    msgbox.askokcancel("OkCancel","askokcancel test.")
def btn6_clicked():
    msgbox.askyesno("YesNo","askyesno test.")
def btn7_clicked():
    msgbox.askretrycancel("Retry","askretrycancel test.")
root=tk.Tk()
root.geometry("400x400")
root.title("MsgBox Test")
btn1=tk.Button(root,text="showinfo",command=btn1_clicked)
btn1.pack(fill=tk.X)
btn1=tk.Button(root,text="showwarning",command=btn2_clicked)
btn1.pack(fill=tk.X)
btn1=tk.Button(root,text="showerror",command=btn3_clicked)
btn1.pack(fill=tk.X)
btn1=tk.Button(root,text="askquestion",command=btn4_clicked)
btn1.pack(fill=tk.X)
btn1=tk.Button(root,text="askokcancel",command=btn5_clicked)
btn1.pack(fill=tk.X)
btn1=tk.Button(root,text="askyesno",command=btn6_clicked)
btn1.pack(fill=tk.X)
btn1=tk.Button(root,text="askretrycancel",command=btn7_clicked)
btn1.pack(fill=tk.X)
root.mainloop()


  • 框架，分区
框架（Frame）组件 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


from tkinter import *
root=Tk()
root.title("使用Frame组件的例子")
root.geometry("400x400")
f1=Frame(root)                  #创建第一个Frame组件
f1.pack()
f2=Frame(root)                  #创建第二个Frame组件
f2.pack()               
f3=LabelFrame(root,text='第三个Frame')
f3.pack(side=BOTTOM)            #社会在窗口底部
redbutton=Button(f1,text="Red",fg="red")
redbutton.pack(side=LEFT)
brownbutton=Button(f1,text="Brown",fg='brown')
brownbutton.pack(side=LEFT)
bluebutton=Button(f1,text="Blue",fg='blue')
bluebutton.pack(side=LEFT)
blackbutton=Button(f2,text='Black',fg='black')
blackbutton.pack()
greenbutton=Button(f3,text='Green',fg="Green")
greenbutton.pack()
root.mainloop()

  • 刷新Frame
制作GUI图形界面 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from tkinter import *
root=Tk()
colors=('red','orange','yellow','green','blue','purple')
root.geometry('400x400')
f=Frame(root,height=400,width=400)
f.color=0
f['bg']=colors[f.color]         #设置框架背景色
lab1=Label(f,text='0')
lab1.pack()

def foo():
    f.color=(f.color+1)%(len(colors))
    lab1['bg']=colors[f.color]
    lab1['text']=str(int(lab1['text'])+1)
    f.after(500,foo)                            #每隔500毫秒就执行foo函数刷新屏幕

f.pack()
f.after(500,foo)

root.mainloop()

  • 用刷新Frame实现电子广告
after（）实现移动电子广告 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

from tkinter import *
root=Tk()
f=Frame(root,height=200,width=200)
lab1=Label(f,text="欢迎")
x=0
def foo():
    global x
    x=x+10
    if x>200:
        x=0
    lab1.place(x=x,y=0)
    f.after(500,foo)         #-------每隔500毫秒就执行foo函数刷新屏幕

f.pack()
f.after(500,foo)
root.mainloop()

  • tkinter字体
Font对象设置标签label的字体 
1
2
3
4
5
6
7
8
9

#Font创建字体
from tkinter import *
import tkinter.font
root=Tk()
#指定字体名称，大小，样式
ft=tkinter.font.Font(family='Fixdsy',size=20,weight='bold')
Label(root,text='hello sticky',font=ft).grid()
root.mainloop()
通过tkFont.families函数可以返回所有可用的字体 
1
2
3
4
5
6

from tkinter import *
import tkinter.font
root=Tk()
print(tkinter.font.families())

#事件类型

1
2
3
4
 <Button-1>          #按下鼠标左键
<KeyPrees-A>        #按下键盘A键
<Control-Shift=KeyPress-A>      #同时按下Control，Shift，A三个键

事件类型 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


from tkinter import *
root=Tk()
root.geometry('400x400')
def printRect(event):
    print('rectangle左键事件')
def printRect2(event):
    print('rectangle右键事件')
def printLine(event):
    print('Line事件')

cv=Canvas(root,bg='yellow')      #创建一个Canvas，设置其背景为白色
rt1=cv.create_rectangle(
    10,10,110,110,
    width=8,tags='r1'
)
cv.tag_bind('r1','<Button-1>',printRect)        #绑定item与鼠标左键事件
cv.tag_bind('r1','<Button-3>',printRect2)       #绑定item与鼠标右键事件
#创建一个line，并将其tags设置为'r2'
cv.create_line(180,70,280,70,width=10,tags='r2')
cv.tag_bind('r2','<Button-1>',printLine)
cv.pack()
root.mainloop()


  • 键盘事件
触发KeyPress键盘事件 
1
2
3
4
5
6
7
8
9
10
11
12

from tkinter import *               
root=Tk()                           #实例化Tkinter
def printkey(event):                #定义的函数监听键盘事件
    print('你按下了:' + event.char)
entry=Entry(root)                   #实例化一个单行输入框
#为输入框绑定按键监听事件<KeyPress>监听任何按键
#<KeyPress-x>监听某键x，如大写的A<KeyPress-A>、回车<KeyPress-Return>
entry.bind('<KeyPress>',printkey)
entry.pack()
root.mainloop()

  • 鼠标事件
获取鼠标单击标签Label时的鼠标事件示例 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

from tkinter import *
root=Tk()
root.geometry("400x400")
def leftClick(event):                       #定义的函数监听鼠标事件
    print("x轴坐标:",event.x)
    print("y轴坐标",event.y)
    print("相对于屏幕左上角x轴坐标:",event.x_root)
    print("相对于屏幕左上角y轴坐标:",event.y_root)
lab=Label(root,text="hello")                #实例化一个Label组件
lab.pack()
#为Label绑定鼠标监听事件
lab.bind("<Button-1>",leftClick)
root.mainloop()

猜数字游戏–程序设计步骤

  • 引入模块及设计函数
引入模块，设计函数 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

#导入相应模块
import tkinter as tk        #窗口
import sys                  #系统，提供接口
import random               #随机
import re                   #通过正则表达式对字符串进⾏匹配

number = random.randint(0,1024)     #随即在1~1024选数
running = True
num = 0                             #猜的次数
nmaxn = 1024                        #提示 猜测范围的最大数
nminn = 0                           #提示 猜测范围的最小数

def eBtnClose(event):               #关闭按钮事件函数
    root.destroy()

def eBtnGuess(event):               #猜按钮事件函数
    global nmaxn                    #全局变量
    global nminn
    global num
    global running
    #修改缺陷：用户答对了，提示标签还提示信息 Edit by Hongten 2013-09-09
    #即用户在答对了以后，提示标签不应该再随着用户点击'猜'按钮而变化
    if running:
        val_a = int(entry_a.get())  #获取猜的数字并转换成数字
        if val_a == number:
            labelqval("恭喜答对了！")
            num+=1
            running = False
            numGuess()              #显示猜的次数
        elif val_a < number:        #猜小了
            if val_a > nminn:
                nminn = val_a       #修改猜测范围的最小数
                num+=1
                label_tip_min.config(label_tip_min,text=nminn)
            labelqval("小了哦")
        else:
            if val_a < nmaxn:
                nmaxn = val_a       #修改猜测范围的最大数
                num+=1
                label_tip_max.config(label_tip_max,text=nmaxn)
            labelqval("大了哦")
    else:
        labelqval('你已经答对啦...')

#修改提示标签文字来显示猜的次数
def numGuess():             
    if num == 1:
        labelqval('我靠！一次答对！')  
    elif num < 10:
        labelqval('= =十次以内就答对了，很棒。。。尝试次数：'+str(num))
    elif num < 50:
        labelqval('还行哦尝试次数：'+str(num))
    else:
        labelqval('好吧。。。。。您都试了超过50次了。。。。尝试次数：'+str(num))

def labelqval(vText):
    label_val_q.config(label_val_q,text=vText)      #修改提示标签文字

  • 主程序
主程序实现游戏的窗体界面 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#以下是主程序实现游戏的窗体界面
root = tk.Tk(className="比大小游戏")
root.geometry("400x90+200+200")

line_a_tip = tk.Frame(root)
label_tip_max = tk.Label(line_a_tip,text=nmaxn)
label_tip_min = tk.Label(line_a_tip,text=nminn)
label_tip_max.pack(side = "top",fill = "x")
label_tip_min.pack(side = "bottom",fill = "x")
line_a_tip.pack(side = "left",fill = "y")

line_question = tk.Frame(root)
label_val_q = tk.Label(line_question,width="80")        #提示标签
label_val_q.pack(side = "left")
line_question.pack(side = "top",fill = "x")

line_input = tk.Frame(root)
entry_a = tk.Entry(line_input,width="40")               #单行数字文本框
btnGuess = tk.Button(line_input,text="猜")              #猜按钮
entry_a.pack(side = "left")
entry_a.bind('<Return>',eBtnGuess)                      #绑定事件
btnGuess.bind('<Button-1>',eBtnGuess)                   #猜按钮
btnGuess.pack(side = "left")
line_input.pack(side = "top",fill = "x")


line_btn = tk.Frame(root)
btnClose = tk.Button(line_btn,text="关闭")              #关闭按钮
btnClose.bind('<Button-1>',eBtnClose)
btnClose.pack(side="left")
line_btn.pack(side = "top")

labelqval("请输入0到1024之间任意整数：")
entry_a.focus_set()

print(number)
root.mainloop()


Tkinter图形绘制——图形版发牌程序

终于到图像进度了——ohhh！

Canvas图形绘制技术

  • 画布组件
创建画布 
1
2
3
4
5
6
7
8
#创建一个背景为白色，宽度为300，高度为120的ecanvas画布
from tkinter import *
root=Tk()
cv=Canvas(root,bg='white',width=300,height=120)         #绘制直线
cv.create_line(10,10,100,80,width=2,dash=7)
cv.pack()                                               #显示画布
root.mainloop()

  • 图形对象
绘制图形对象 
1
2
3
4
5
6
7
8
9
10
11
#在canvas画布上可以绘制各种图形对象，常用绘制函数如下：
———— create_arc():绘制圆弧
———— create_line():绘制直线
———— create_bitmap():绘制位图
———— create_image():绘制位图图像
———— create_oval():绘制椭圆
———— create_polygon():绘制多边形
———— create_window():绘制子窗口
———— create_text():创建一个文字对象


示例/利用属性tags 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#使用属性tas设置图形对象标记的示例
from tkinter import *
root=Tk()
#创建一个canvas，设置其背景色为白色
cv=Canvas(root,bg='white',width=200,height=200)
#使用tags指定给第一个举行指定三个tag
rt=cv.create_rectangle(10,10,110,110,tags=('r1','r2','r3'))
cv.pack()
cv.create_rectangle(20,20,80,80,tags='r3')      #使用tags为第二个矩形指定一个tag
#将所有与tag('r3')绑定的item边框颜色设置为蓝色
for item in cv.find_withtag('r3'):
    cv.itemconfig(item,outline='blue')
root.mainloop()


  • 圆弧图像
绘制圆弧 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#创建圆弧
from tkinter import *
root=Tk()
#创建一个Canvas,设置其背景色为白色
cv=Canvas(root,bg='white')
cv.create_arc((19,10,110,110),)     # 使用默认参数创建一个圆弧，结果为90度的扇形
d={1:PIESLICE,2:CHORD,3:ARC}
for i in d:
    #使用三种样式，分别创建扇形，弓形和弧形
    cv.create_arc((10,10+60*i,110,110+60*i),style=d[i])
    print(i,d[i])
#使用start/extent指定圆弧起始角度与偏移角度
cv.create_arc(
    (150,150,250,250),
    start=10,                       #指定起始角度
    extent=120                      #指定角度偏移量（逆指针）
)
cv.pack()
root.mainloop()
  • 绘制线条
    line=canvas.create_line(x0,y0,x1,y1, …, xn,yn,选项)
    参数x0,y0.。。都是线段的端点
绘制线条 
1
2
3
4
5
6
7
8
9
10
11
12
#绘制线条
#使用create_line()方法绘制线条
from tkinter import *
root=Tk()
cv=Canvas(root,bg='white',width=200,height=100)
cv.create_line(10,10,100,10,arrow='none')       #绘制没箭头的线段
cv.create_line(10,20,100,20,arrow='first')      #绘制起点有箭头的线段
cv.create_line(10,30,100,30,arrow='last')       #绘制终点有箭头的线段
cv.create_line(10,40,100,40,arrow='both')       #绘制两端有箭头的线段
cv.create_line(10,50,100,100,width=3,dash=7)    #绘制虚线
cv.pack()
root.mainloop()
  • 绘制矩形
绘制矩形 
1
2
3
4
5
6
7
8
9
10
11
12
#绘制矩形
#使用creat_rectangle()方法创建举行对象的示例
from tkinter import *
root=Tk()
#创建一个Canvas,设置其背景色为白色
cv=Canvas(root,bg='white',width=200,height=100)
cv.create_rectangle(10,10,110,110,width=2,fill='red')
#指定矩形的填充色为红色，宽度为2
cv.create_rectangle(120,20,180,80,outline='green')
#指定矩形的边框颜色为绿色
cv.pack()
root.mainloop()
  • 绘制多边形
绘制多边形 
1
2
3
4
5
6
7
8
9
10
11
12
13
#绘制多边形
#创建三角形，正方形，对顶三角形对象的示例
from tkinter import *
root=Tk()
cv=Canvas(root,bg='white',width=300,height=100)
cv.create_polygon(35,10,10,60,60,60,outline='blue',fill='red',width=2)          #等腰三角形
cv.create_polygon(70,10,120,10,120,60,outline='blue',fill='white',width=2)      #直角三角形
cv.create_polygon(130,10,180,10,180,60,130,60,width=4)                          #黑色填充正方形
cv.create_polygon(190,10,240,10,190,60,240,60,width=1)                          #对顶三角形
cv.pack()
root.mainloop()


  • 绘制圆形
绘制圆形 
1
2
3
4
5
6
7
8
9
10
11
#绘制椭圆
#绘制椭圆和圆形的示例
from tkinter import *
root=Tk()
cv=Canvas(root,bg='white',width=200,height=100)
cv.create_oval(10,10,100,50,outline='blue',fill='red',width=2)     #椭圆
cv.create_oval(100,10,190,100,outline='blue',fill='red',width=2)    #圆形
cv.pack()
root.mainloop()


  • 绘制文字
绘制文字 
1
2
3
4
5
6
7
8
9
10
#绘制文字
#创建文本的示例
from tkinter import *
root=Tk()
cv=Canvas(root,bg='white',width=200,height=100)
cv.create_text((10,10),text='hello,python',fill='red',anchor='nw')      #依次是，坐标，文本内容，文本颜色，控制文字对象的位置，比如nw就是左上对齐。
cv.create_text((200,50),text='你好,python',fill='blue',anchor='se')
cv.pack()
root.mainloop()

  • 绘制位图和图像
绘制位图和图像 关于图像，有修改，移动，删除，缩放等程序设定，都放上去比较臃肿，就先不写了，也不算难，就是图像的扩展，去找一下资料吧，这里就先提供制作图像和位图的示例代码。 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#绘制位图和图像
#绘制图像示例
from tkinter import *
root=Tk()
cv=Canvas(root)
img1=PhotoImage(file='图形相对路径')
#比如  img1=PhotoImage(file='C:\\aa.png')  获取这个图片的图形
cv.create_image((100,100),Image=img1) #绘制这个图形
d={1:'error',2:'info',3:'question',4:'hourglass',5:'questhead',6:'warning',7:'gray12',8:'gray25',9:'gray50',10:'gray75'}#字典
#以下遍历字典会之python内置的位图
for i in d:
    cv.create_bitmap((20*i,20),bitmap=d[i])
cv.pack()
root.mainloop()

Tkinter图形绘制——图形发牌程序

  • 主程序
主程序代码和基本解释 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

#图形版发牌程序导入相关模块的代码如下
from tkinter import *
import random
#假设包含52张牌，不包括大小王
n=52

#gen_pocker(n)函数实现对n张牌进行洗牌。方法是随机产生两个下标，将此下标的列表元素交换，达到洗牌目的。列表元素存储的是某张牌（实际上是牌的编号）
def gen_pocker(n):
    x=100
    while(x>0):
        x=x-1
        p1=random.randint(0,n-1)
        p2=random.randint(0,n-1)
        t=pocker[p1]
        pocker[p1]=pocker[p2]
        pocker[p2]=t
    return pocker

#以下是主程序

#将要发的52张牌，按照梅花0~12，方块13~25，红桃26~38，黑桃39~51的顺序编号并存储在pocker列表（未洗牌之前）
pocker=[i for i in random(n)]

#调用gen_pocker（n）函数实现对n张牌的洗牌
pocker=gen_pocker(n)                                #实现对n张牌的洗牌
print(pocker)
(player1,player2,player3,player4)=([],[],[],[])     #四位牌手各自手中牌的图片列表
(p1,p2,p3,p4)=([],[],[],[])                         #四位牌手各自手中拍得编号列表
root=Tk()
#创建一个Canvas，设置其背景色为白色
cv=Canvas(root,bg='white',width=700,height=600)

#将要发的52张牌的图片，按梅花0~12，方块13~25,红桃26~38，黑桃39~51的顺序编号，存储到扑克牌的图片imgs列表中。也就是说，imgs[10]存储梅花A的图片“1-1.gif”，imgs[1]存储梅花2的图片”1-2gif“，imgs[14]存储方块2的图片”2-2.gif“，依次类推。目的是让程序可以根据牌的编号找到对应的图片。
imgs=[]
for i in range(1,5):
    for j in range(1,14):
        imgs.insert((i-1)*13+(j-1),PhotoImage(file=str(i)+'-'+str(j)+'. gif'))

#实现每轮发4张牌，每位牌手发一张，总计13轮发牌，每位牌手最终各有13张牌。
for x in range(13):                                 #13轮发牌
    m=x*4
    p1.append(pocker[m])
    p2.append(pocker[m+1])
    p3.append(pocker[m+2])
    p4.append(pocker[m+3])

#牌手对牌进行排序，就相当于理牌，使同花色牌连在一起
p1.sort()                                           #牌手对牌进行排序
p2.sort()
p3.sort()
p4.sort()

#根据每位牌手手中的编号绘制对应的图片进行显示
for x in range(0,13):
    img=imgs[p1[x]]
    player1.append(cv.create_image((200+20*x,80),image=img))
    img=imgs[p2[x]]
    player2.append(cv.create_image((100,150+20*x),image=img))
    img=imgs[p3[x]]
    player3.append(cv.create_image((200+20*x,500),image=img))
    img=imgs[p4[x]]
    player4.append(cv.create_image((560,150+20*x),image=img))
print("player1:",player1)
print("player2:",player2)
print("player3:",player3)
print("player4:",player4)
cv.pack()
root.mainloop()

更新于：2023年3月3日

学习

python

评论