>>> import Tkinter
>>> def hello():
print 'hello world !'
>>> win = Tkinter.Frame()
>>> win.pack ()
>>> Tkinter.Label( win , text ='hello world !').pack( side = Tkinter.TOP)
>>> b1 = Tkinter.Button( win , text ='hello ' , command = hello )
>>> b1. pack( side = Tkinter.LEFT )
>>> b2 = Tkinter.Button( win , text ='quit ' , command =win.quit )
>>> b2.pack( side = Tkinter.RIGHT )
>>> win.mainloop ()
>>> def fetch ():
print 'Texte : <%s>' % ent.get()
>>> root = Tk()
>>> ent = Entry( root )
>>> ent.insert(0 , 'Szoveg beirasa ')
>>> ent.pack( side =TOP , fill =X)
>>> ent.bind( '' , ( lambda event : fetch ()))
>>> root = Tk()
>>> r = 0
>>> for item in [ 'foo ' , 'bar ' , 'stuff ']:
l = Label( root , text =item , width =10)
e = Entry( root , width =10)
l. grid( row=r , column =0)
e. grid( row=r , column =1)
r += 1
>>> root.mainloop()
>>> def fetch():
print txt.get( '1.0 ' , END+' -1c')
>>> root = Tk ()
>>> txt = Text( root , height =5 , width =20 , wrap = WORD )
>>> txt.insert( '1.0 ' , 'Szoveg beirasa ')
>>> txt.pack( side =TOP )
>>> Button( root , text ='fetch ' , command = fetch ).pack()
>>> root.mainloop()
>>> def fetch():
print list.get( ACTIVE )
>>> root = Tk()
>>> list = Listbox( root )
>>> list.pack( side =TOP )
>>> Button( root , text ='fetch ' , command = fetch ) . pack ()
>>> idx = 0
>>> for i in range (10):
list.insert( idx , 'ligne -' + str (i))
idx += 1
>>> root.mainloop()
>>> vars = []
>>> root = Tk()
>>> for item in [ ’foo ’ , ’bar ’ , ’stuff ’]:
var = IntVar()
Checkbutton( root , text =item ,
variable =var ).pack( side = LEFT )
vars.append( var)
>>> def state():
for v in vars :
print v.get() ,
>>> b = Button( root , text =’State ’ , command = state )
>>> b.pack( side = LEFT )
>>> root.mainloop()
# -*- Fibonacci -*-
# Elso Python script
# Fibonacci sort kiirato program,
# Ez egy olyan számsor, melynek minden tagja az előző két tag szorzata.
print "Fibonacci sor :"
a,b,c = 1,1,1 # a & b az egymast koveto tagok szamolasara kell
# c egy szamlalo
print 1 # az elso tag kiiratasa
while c<15: # osszesen 15 tagot iratunk ki
a,b,c = b,a+b,c+1
print b
--------------
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
# Lista és felteteles elagaztatas alkalmazasa et de branchements conditionnels
print "Ez a script megkeresi harom szam kozul a legnagyobbat"
print 'Irjon be vesszovel elvalasztva harom szamot : '
# Megjegyzes : a list() fuggveny listava alakitja at az adatsort, amit
# argumentumnak agtunk meg. Az alabbi utasitas tehat
# az nn listava alakitja at a felhasznalo altal megadott adatokat :
nn = list(input())
max, index = nn[0], 'elso'
if nn[1] > max: # ne hagyjuk le a kettospontot !
max = nn[1]
index = 'masodik'
if nn[2] > max:
max = nn[2]
index = 'harmadik'
print "A legnagyobb szam", max
print "Ez a listaban", index, "szam."
-----
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
# Osszetett utasitasok <while> - <if> - <elif> - <else>
print 'Valasszon egy szamot 1-tol 3-ig (vagy nullat befejezeskent) ',
a = input()
while a != 0: # a != operátor jelentese: kulonbozik
if a == 1:
print "Egyet valasztott :"
print "elso, egyedi, egyseg..."
elif a == 2:
print "Kettot valasztott :"
print "egy par, le couple, le duo ..."
elif a == 3:
print "Kettot valasztott :"
print "le trio, la trinité le triplet ..."
else :
print "Kerek egy szamot EGY es HAROM kozott"
print 'Valasszon egy szamot 1-tol 3-ig (vagy nullat befejezeskent) ',
a = input()
print "Nullat irt be :"
print "A gyakorlatnak vege van"
--------------
#! /usr/bin/env python
# -*- coding: Utf-8 -*-
# Tkinter grafikus konyvtarat hasznalo alkalmazas
from Tkinter import *
# esmenykezelok definicioja :
def move():
"labda elmozditasa"
global x1, y1, dx, dy, flag
x1, y1 = x1 +dx, y1 + dy
if x1 >210:
x1, dx, dy = 210, 0, 15
if y1 >210:
y1, dx, dy = 210, -15, 0
if x1 <10:
x1, dx, dy = 10, 0, -15
if y1 <10:
y1, dx, dy = 10, 15, 0
can1.coords(oval1,x1,y1,x1+30,y1+30)
if flag >0:
abl1.after(50,move) # 50 msec mulva ujra hivja onmagat
def stop_it():
"leallitja az animaciot"
global flag
flag =0
def start_it():
"inditja az animaciot"
global flag
if flag ==0: # hogy ne lehessen több ciklust inditani
flag =1
move()
#========== Foprogram =============
# A kovetkezo valtozokat globalis valtozokkent hasznaljuk :
x1, y1 = 10, 10 # kiindulasi koordinatak
dx, dy = 15, 0 # elmozdulas merteke
flag =0 # iranyvalto
# a fowidget letrehozasal ("szülo") :
abl1 = Tk()
abl1.title("Animációs gyakorlat Tkinter-rel")
# a "gyermek" widgetek letrehozasa :
can1 = Canvas(abl1,bg='dark grey',height=250, width=250)
can1.pack(side=LEFT, padx =5, pady =5)
oval1 = can1.create_oval(x1, y1, x1+30, y1+30, width=2, fill='red')
button1 = Button(abl1,text='Kilép', width =8, command=abl1.quit)
button1.pack(side=BOTTOM)
button2 = Button(abl1, text='Indít', width =8, command=start_it)
button2.pack()
button3 = Button(abl1, text='Leállít', width =8, command=stop_it)
button3.pack()
# esemenykezelo inditasa (fohurok) :
abl1.mainloop()
#bou -> button
---------------
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
# Petit exercice utilisant la librairie graphique Tkinter
from Tkinter import *
# définition des gestionnaires d'événements :
def move():
"déplacement de la balle"
global x1, y1, dx, dy, flag
x1, y1 = x1 +dx, y1 + dy
if x1 >210:
x1, dx, dy = 210, 0, 15
if y1 >210:
y1, dx, dy = 210, -15, 0
if x1 <10:
x1, dx, dy = 10, 0, -15
if y1 <10:
y1, dx, dy = 10, 15, 0
can1.coords(oval1,x1,y1,x1+30,y1+30)
if flag >0:
fen1.after(50,move) # boucler aprčs 50 millisecondes
def stop_it():
"arret de l'animation"
global flag
flag =0
def start_it():
"démarrage de l'animation"
global flag
if flag ==0: # pour éviter que le bouton ne puisse lancer plusieurs boucles
flag =1
move()
#========== Programme principal =============
# les variables suivantes seront utilisées de maničre globale :
x1, y1 = 10, 10 # coordonnées initiales
dx, dy = 15, 0 # 'pas' du déplacement
flag =0 # commutateur
# Création du widget principal ("parent") :
fen1 = Tk()
fen1.title("Exercice d'animation avec Tkinter")
# création des widgets "enfants" :
can1 = Canvas(fen1,bg='dark grey',height=250, width=250)
can1.pack(side=LEFT, padx =5, pady =5)
oval1 = can1.create_oval(x1, y1, x1+30, y1+30, width=2, fill='red')
bou1 = Button(fen1,text='Quitter', width =8, command=fen1.quit)
bou1.pack(side=BOTTOM)
bou2 = Button(fen1, text='Démarrer', width =8, command=start_it)
bou2.pack()
bou3 = Button(fen1, text='Arręter', width =8, command=stop_it)
bou3.pack()
# démarrage de l'observateur d'évčnements (boucle principale) :
fen1.mainloop()
--------------
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
# Tkinter grafikus konyvtarat hasznalo alkalmazas
from Tkinter import *
# altalanos mozgato eljaras :
def mozog(gd, hb):
global x1, y1
x1, y1 = x1 +gd, y1 +hb
can1.coords(oval1, x1, y1, x1+30, y1+30)
# esmenykezelok definiciojas :
def mozdit_balra():
mozog(-10, 0)
def mozdit_jobbra():
mozog(10, 0)
def mozdit_fel():
mozog(0, -10)
def mozdit_le():
mozog(0, 10)
#------ Foprogram -------
# A kovetkezo valtozokat globalis valtozokkent hasznaljuk :
x1, y1 = 10, 10 # kiindulasi koordinatak
# a fowidget letrehozasal ("szülo") :
abl1 = Tk()
abl1.title("Animaciós gyakorlat Tkinter-rel")
# a "gyermek" widgetek letrehozasa :
can1 = Canvas(abl1,bg='dark grey',height=200,width=200)
oval1 = can1.create_oval(x1,y1,x1+30,y1+30,width=2,fill='red')
can1.pack(side=LEFT)
Button(abl1,text='Kilép',command=abl1.quit).pack(side=BOTTOM)
Button(abl1,text='Balra',command=mozdit_balra).pack()
Button(abl1,text='Jobbra',command=mozdit_jobbra).pack()
Button(abl1,text='Föl',command=mozdit_fel).pack()
Button(abl1,text='Le',command=mozdit_le).pack()
# esemenykezelo inditasa (fohurok) :
abl1.mainloop()
#avance -> mozog
#depl_gauche -> mozdit_balra
#depl_droite -> mozdit_jobbra
#depl_haut -> mozdit_fel
#depl_bas -> mozdit_le
#fen1 -> abl1
------------
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
from Tkinter import *
from math import *
# azt az akciot definialjuk, amit az adatbeviteli mezo szerkesztesekor
# az "enter" billentyu megnyomasara kell vegrehajtani :
def evaluate(event):
chain.configure(text = "Eredmény = " + str(eval(mezo.get())))
# ----- Foprogram : -----
ablak = Tk()
mezo = Entry(ablak, bd=2, relief =GROOVE)
mezo.bind("<Return>",evaluate)
mezo.pack(padx =10, pady =5)
chain = Label(ablak)
chain.pack(padx =10, pady =5)
ablak.mainloop()
#chaine - chain
#entry -> mezo
#window -> ablak
-----------
# -*- coding:Latin-1 -*-
# Tkinter grafikus konyvtarat alkalmazo gyakorlat
from Tkinter import *
def circle(x, y, r, color ='black'):
"(x,y) kozeppontu es r sugaru kor rajzolasa"
can.create_oval(x-r, y-r, x+r, y+r, outline=color)
def figure_1():
"celtablat rajzol"
# Eloszor valamennyi mar meglevo rajzot toroljuk :
can.delete(ALL)
# ket egyenes rajzolasa (fuggoleges es vizszintes) :
can.create_line(100, 0, 100, 200, fill ='blue')
can.create_line(0, 100, 200, 100, fill ='blue')
# több koncentrikus kor rajzolasa :
radius = 15
while radius < 100:
circle(100, 100, radius)
radius += 15
def figure_2():
"egyszerusitett arc rajzolasa"
# Eloszor valamennyi mar meglevo rajzot toroljuk :
can.delete(ALL)
# Mindegyik kör jellemzoit
# egy listaba agyazott listaba tesszuk :
cc =[[100, 100, 80, 'red'], # fej
[70, 70, 15, 'blue'], # szemek
[130, 70, 15, 'blue'],
[70, 70, 5, 'black'],
[130, 70, 5, 'black'],
[44, 115, 20, 'red'], # arc
[156, 115, 20, 'red'],
[100, 95, 15, 'purple'], # orr
[100, 145, 30, 'purple']] # szaj
# az osszes kort egy ciklus segitsegevel rajzoljuk meg :
i =0
while i < len(cc): # lista bejarasa
el = cc[i] # mindegyik elem maga is egy lista
circle(el[0], el[1], el[2], el[3])
i += 1
##### Foprogram : ############
window = Tk()
can = Canvas(window, width =200, height =200, bg ='ivory')
can.pack(side =TOP, padx =5, pady =5)
b1 = Button(window, text ='1. ábra', command =figure_1)
b1.pack(side =LEFT, padx =3, pady =3)
b2 = Button(window, text ='2. ábra', command =figure_2)
b2.pack(side =RIGHT, padx =3, pady =3)
window.mainloop()
#cercle -> circle
#dessin -> drawing
#fen -> window
#rayon -> radius
#coul -> color
-------------
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
from Tkinter import *
abl1 = Tk()
# a 'Label' és 'Entry' widgetek létrehozása :
txt1 = Label(abl1, text = 'Elsö :')
txt2 = Label(abl1, text = 'Második :')
txt3 = Label(abl1, text = 'Harmadik :')
mezo1 = Entry(abl1)
mezo2 = Entry(abl1)
mezo3 = Entry(abl1)
# egy bitmap képet tartalmazó 'Canvas' widget létrehozása :
can1 = Canvas(abl1, width =160, height =160, bg ='white')
photo = PhotoImage(file ='Martin_p.gif')
item = can1.create_image(80, 80, image =photo)
# Mlaptördelés a'grid' metódus segítségével :
txt1.grid(row =1,sticky =E)
txt2.grid(row =2,sticky =E)
txt3.grid(row =3,sticky =E)
mezo1.grid(row =1, column =2)
mezo2.grid(row =2, column =2)
mezo3.grid(row =3, column =2)
can1.grid(row =1, column =3, rowspan =3, padx =10, pady =5)
# indítás :
abl1.mainloop()
---------------
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
from Tkinter import *
abl1 = Tk()
# a 'Label', 'Entry' és Checkbutton widgetek létrehozása :
Label(abl1, text = 'Elsö :').grid(sticky =E)
Label(abl1, text = 'Második :').grid(sticky =E)
Label(abl1, text = 'Harmadik :').grid(sticky =E)
mezo1 = Entry(abl1)
mezo2 = Entry(abl1) # ezekre a widgetek
mezo3 = Entry(abl1) # kés?bb biztosan hivatkozni kell :
mezo1.grid(row =0, column =1) # ezért mindegyiket
mezo2.grid(row =1, column =1) # külön változóhoz kell rendelni
mezo3.grid(row =2, column =1)
chek1 = Checkbutton(abl1, text ='Checkbox')
chek1.grid(columnspan =2)
# egy bitmap képet tartalmazó 'Canvas' widget létrehozása :
can1 = Canvas(abl1, width =160, height =160, bg ='white')
photo = PhotoImage(file ='Martin_p.gif')
can1.create_image(80,80, image =photo)
can1.grid(row =0, column =2, rowspan =4, padx =10, pady =5)
# indítás :
abl1.mainloop()
-----------
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
# Détection et positionnement d'un clic de souris dans une fenętre :
from Tkinter import *
def mutato(event):
chain.configure(text = "Kattintást detektált X =" + str(event.x) +\
", Y =" + str(event.y))
ablak = Tk()
keret = Frame(ablak, width =200, height =150, bg="light yellow")
keret.bind("<Button-1>", mutato)
keret.pack()
chain = Label(ablak)
chain.pack()
ablak.mainloop()
------------
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
# Tkinter grafikus könyvtárat használó gyakorlat
# az eseménykezel? függvények definíciója :
def drawline():
"Vonal rajzolása a can1 canvasra (vászonra)"
global x1, y1, x2, y2, color
can1.create_line(x1,y1,x2,y2,width=2,fill=color)
# a koordináták módosítása a következ? egyenes számára :
y2, y1 = y2+10, y1-10
def changecolor():
"a rajz színének véletlenszer? megváltoztatása"
global color
pal=['purple','cyan','maroon','green','red','blue','orange','yellow']
c = randrange(8) # => véletlenszám generálása 0 és 7 között
color = pal[c]
#------ F?program -------
from Tkinter import *
from random import randrange
# a következ? változókat globális változókként használjuk :
x1, y1, x2, y2 = 10, 190, 190, 10 # az egyenes koordinátái
color = 'dark green' # az egyenes színe
# A f?-widget létrehozása ("master") :
abl1 = Tk()
# a "slave" widget-ek létrehozása :
can1 = Canvas(abl1,bg='dark grey',height=200,width=200)
can1.pack(side=LEFT)
gomb1 = Button(abl1,text='Kilép',command=abl1.quit)
gomb1.pack(side=BOTTOM)
gomb2 = Button(abl1,text='Vonalat rajzol',command=drawline)
gomb2.pack()
gomb3 = Button(abl1,text='Más szín',command=changecolor)
gomb3.pack()
# esemenyfigyelo inditasa (fohurok) :
abl1.mainloop()
abl1.destroy()
-----------
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
class Atom:
"""egyszer?sített atomok, a Per.Rendszer els? 10 eleme közül választva"""
table =[None, ('hidrogen',0), ('helium',2), ('litium',4),
('berilium',5), ('bor',6), ('szen',6), ('nitrogen',7),
('oxigen',8), ('fluor',10), ('neon',10)]
def __init__(self, nat):
"a rendszám meghatározza a protonok, elektronok és neutronok számát"
self.np, self.ne = nat, nat # nat = rendszám
self.nn = Atom.table[nat][1] #neutronszám a táblázatból
def kiir(self):
print
print "Az elem neve :", Atom.table[self.np][0]
print "%s proton, %s elektron, %s neutron" % \
(self.np, self.ne, self.nn)
class Ion(Atom):
"""az ionok atomok, amik elektronokat vettek fel vagy vesztettek"""
def __init__(self, nat, toltes):
"a rendszám és a töltés határozzák meg az iont"
Atom.__init__(self, nat)
self.ne = self.ne - toltes
self.toltes = toltes
def kiir(self):
"ez a metódus a szül?osztálytól örökölt metódust helyettesíti"
Atom.kiir(self)
print "Toltott reszecske. Toltes=", self.toltes
### F?program : ###
a1 = Atom(5)
a2 = Ion(3, 1)
a3 = Ion(8, -2)
a1.kiir()
a2.kiir()
a3.kiir()
--------------
# -*- coding:Utf-8 -*-
class Teglalap:
"téglalap-osztály"
def __init__(self, hossz =30, szelesseg =15):
self.L = hossz
self.l = szelesseg
self.nev ="teglalap"
def kerulet(self):
return "(%s + %s) * 2 = %s" % (self.L, self.l,
(self.L + self.l)*2)
def terulet(self):
return "%s * %s = %s" % (self.L, self.l, self.L*self.l)
def meretek(self):
print "Egy %s x %s -as %s" % (self.L, self.l, self.nev)
print "területe %s" % (self.terulet(),)
print "kerülete %s\n" % (self.kerulet(),)
class Negyzet(Teglalap):
"Négyzet-osztály"
def __init__(self, oldal =10):
Teglalap.__init__(self, oldal, oldal)
self.nev ="négyzet"
if __name__ == "__main__":
r1 = Teglalap(15, 30)
r1.meretek()
c1 = Negyzet(13)
c1.meretek()
-----------
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
####################################
# Programme Python type #
# auteur : G.Swinnen, Ličge, 2003 #
# licence : GPL #
####################################
class Point:
"""point mathématique"""
def __init__(self, x, y):
self.x = x
self.y = y
class Rectangle:
"""rectangle"""
def __init__(self, ang, lar, hau):
self.ang = ang
self.lar = lar
self.hau = hau
def trouveCentre(self):
xc = self.ang.x + self.lar /2
yc = self.ang.y + self.hau /2
return Point(xc, yc)
class Carre(Rectangle):
"""carré = rectangle particulier"""
def __init__(self, coin, cote):
Rectangle.__init__(self,
coin, cote, cote)
self.cote = cote
def surface(self):
return self.cote**2
###########################
## Programme principal : ##
# coord. de 2 coins sup. gauches :
csgR = Point(40,30)
csgC = Point(10,25)
# "boîtes" rectangulaire et carrée :
boiteR = Rectangle(csgR, 100, 50)
boiteC = Carre(csgC, 40)
# Coordonnées du centre pour chacune :
cR = boiteR.trouveCentre()
cC = boiteC.trouveCentre()
print "centre du rect. :", cR.x, cR.y
print "centre du carré :", cC.x, cC.y
print "surf. du carré :",
print boiteC.surface()
--------------
#! /usr/bin/env python
# -*- coding: Utf-8 -*-
# Python programozasvizsga - 6TSIb - Juin 2004
from Tkinter import *
class FaceDom:
def __init__(self, can, val, pos, size =70):
self.can =can
# ***
x, y, c = pos[0], pos[1], size/2
can.create_rectangle(x -c, y-c, x+c, y+c, fill ='ivory', width =2)
d = size/3
# ***
self.pList =[]
# ***
pDispo = [((0,0),), ((-d,d),(d,-d)), ((-d,-d), (0,0), (d,d))]
disp = pDispo[val -1]
# ***
for p in disp:
self.circle(x +p[0], y +p[1], 5, 'red')
def circle(self, x, y, r, colo):
# ***
self.pList.append(self.can.create_oval(x-r, y-r, x+r, y+r, fill=colo))
def erase(self):
# ***
for p in self.pList:
self.can.delete(p)
class Project(Frame):
def __init__(self, width_, height_):
Frame.__init__(self)
self.width_, self.height_ = width_, height_
self.can = Canvas(self, bg='dark green', width =width_, height =height_)
self.can.pack(padx =5, pady =5)
# ***
bList = [("A", self.buttonA), ("B", self.buttonB),
("C", self.buttonC), ("D", self.buttonD),
("Quit", self.buttonQuit)]
for b in bList:
Button(self, text =b[0], command =b[1]).pack(side =LEFT)
self.pack()
def buttonA(self):
self.d3 = FaceDom(self.can, 3, (100,100), 50)
def buttonB(self):
self.d2 = FaceDom(self.can, 2, (200,100), 80)
def buttonC(self):
self.d1 = FaceDom(self.can, 1, (350,100), 110)
def buttonD(self):
# ***
self.d3.erase()
def buttonQuit(self):
self.master.destroy()
Project(500, 300).mainloop()
#taille -> size
#cercle -> circle
#colour -> colo
#effacer -> erase
#larg -> width_
#haut -> height_
#bout -> button
-------------------
#! /usr/bin/env python
# -*- coding: Utf-8 -*-
class Application:
def __init__(self):
"""A foablak constructora"""
self.root =Tk()
self.root.title('Szinkódok')
self.drawResistor()
Label(self.root,
text ="Írja be az ellenállásértéket ohm-ban :").grid(row =2)
Button(self.root, text ='Mutat',
command =self.changeColours).grid(row =3, sticky = W)
Button(self.root, text ='Kilép',
command =self.root.quit).grid(row =3, sticky = E)
self.entry = Entry(self.root, width =14)
self.entry.grid(row =3)
# a 0-9 ertekek szinkodjai :
self.cc = ['black','brown','red','orange','yellow',
'green','blue','purple','grey','white']
self.root.mainloop()
def drawResistor(self):
"""Vaszon ellenallas modellel, amin harom szines csik van"""
self.can = Canvas(self.root, width=250, height =100, bg ='light blue')
self.can.grid(row =1, pady =5, padx =5)
self.can.create_line(10, 50, 240, 50, width =5) # fils
self.can.create_rectangle(65, 30, 185, 70, fill ='beige', width =2)
# Harom szines csik (indulaskor feketek) :
self.line =[] # egy listaban fogjuk tarolni a harom csikot
for x in range(85,150,24):
self.line.append(self.can.create_rectangle(x,30,x+12,70,
fill='black',width=0))
def changeColours(self):
"""A beirt erteknek megfelelo harom szin kiiratasa"""
self.v1ch = self.entry.get() # get() metodus egy stringet ad vissza
try:
v = float(self.v1ch) # atalakitas szamertekke
except:
err =1 # error : nem numerikus adat
else:
err =0
if err ==1 or v < 10 or v > 1e11 :
self.reportError() # inkorrekt vagy tartomanyon kivuli ertek
else:
li =[0]*3 # a 3 kiirando kod listaja
logv = int(log10(v)) # logaritmus egesz resze
ordgr = 10**logv # nagysagrend
# az elso szignifikans szamjegy eloallitasa :
li[0] = int(v/ordgr) # egesz resz
decim = v/ordgr - li[0] # tizedes resz
# a masodik szignifikans szamjegy eloallitasa :
li[1] = int(decim*10 +.5) # +.5 a korrekt kerekiteshez
# a 2 szignifikans szamjegyhez hozzateendo nullak szama :
li[2] = logv -1
# A 3 szakasz szinezese :
for n in range(3):
self.can.itemconfigure(self.line[n], fill =self.cc[li[n]])
def reportError(self):
self.entry.configure(bg ='red') # mezo hatterenek szinezese
self.root.after(1000, self.emptyEntry) # 1 sec utan torolni
def emptyEntry(self):
self.entry.configure(bg ='white') # feher hetter visszaallitasa
self.entry.delete(0, len(self.v1ch)) # karakterek torlese
# Foprogram :
if __name__ == '__main__':
from Tkinter import *
from math import log10 # 10 alapu logaritmus
f = Application() # alkalmazas objektum letrehozas
#dessineResistance -> drawResistor
#changeCouleurs -> changeColours
#entree-> entry
#ligne -> line
#videEntree -> emptyEntry
#signaleErreur -> reportError
----------------
#! /usr/bin/env python
# -*- coding: Utf-8 -*-
##################################################
# Curseurs.py
# A f,phi,a parameterek szabalyozasara szolgalo #
# kurzorokat tartalmazo widget. #
# A parameterek minden modositasakor egy speci. #
# esemeny generalodik, ami a master widget #
# ertesitesere valo, ami aztan reagalni tud
# #
# Szerzo : G.Swinnen (Liège, Belgium) #
# 2002/03/16 - Licence GPL #
##################################################
from Tkinter import *
from math import pi
class ChoiceVibra(Frame):
"""kurzorok egy rezges frekvenciajanak, fazisanak es amplitudojanak kivalasztasahoz"""
def __init__(self, maitre=None, colo='red'):
Frame.__init__(self) # a szuloosztaly constructora
# nehany peldany-attributum inicializalasa :
self.freq, self.phase, self.ampl, self.colo = 0, 0, 0, colo
# A checkbox allapotvaltozoja :
self.chk = IntVar() # Tkinter 'objektum-valtozo
Checkbutton(self, text='Rajzol', variable=self.chk,
fg = self.colo, command=self.setCurve).pack(side=LEFT)
# A 3 cursor-widget definicioja :
Scale(self, length=150, orient=HORIZONTAL, sliderlength =25,
label ='Frekvencia (Hz) :', from_=1., to=9., tickinterval =2,
resolution =0.25,
showvalue =0, command = self.setFrequency).pack(side=LEFT, pady =5)
Scale(self, length=150, orient=HORIZONTAL, sliderlength =15,
label ='Fázis (fok) :', from_=-180, to=180, tickinterval =90,
showvalue =0, command = self.setPhase).pack(side=LEFT, pady =5)
Scale(self, length=150, orient=HORIZONTAL, sliderlength =25,
label ='Amplitúdó :', from_=2, to=10, tickinterval =2,
showvalue =0, command = self.setAmplitude).pack(side=LEFT, pady =5)
def setCurve(self):
self.event_generate('<Control-Z>')
def setFrequency(self, f):
self.freq = float(f)
self.event_generate('<Control-Z>')
def setPhase(self, p):
pp =float(p)
self.phase = pp*2*pi/360 # fok -> radian atalakitas
self.event_generate('<Control-Z>')
def setAmplitude(self, a):
self.ampl = float(a)
self.event_generate('<Control-Z>')
#### Kod az osztaly tesztelesehez : ###
if __name__ == '__main__':
def showAll(event=None):
lab.configure(text = '%s - %s - %s - %s' %
(fra.chk.get(), fra.freq, fra.phase, fra.ampl))
root = Tk()
fra = ChoiceVibra(root,'navy')
fra.pack(side =TOP)
lab = Label(root, text ='test')
lab.pack()
root.bind('<Control-Z>', showAll)
root.mainloop()
--------------------
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
##################################################
# Oscillo2.py #
# <Canvas> -bol szarmaztatott specializalt widget#
# kiteres/ido gorbe rajzolasara szolgal #
# #
# Szerzo : G.Swinnen (Liege, Belgium) #
# 16/03/2002 - Licence GPL #
##################################################
from Tkinter import *
from math import sin, pi
class OscilloGraphe(Canvas):
"kiteres/ido gorbe rajzolasara szolgalo specializalt vaszon"
def __init__(self, master=None, width_=200, height_=150):
"A grafika constructora : tengelyek es vizszintes skala."
# a szulo widget elkeszitese :
Canvas.__init__(self) # a szuloosztaly
self.configure(width=width_, height=height_) # constructoranak hivasa
self.width_, self.height_ = width_, height_ # tarolas
# vizszintes skala rajzolasa 8 beosztassal :
step = (width_-25)/8. # vizszintes skala intervallumai
for t in range(1, 9):
stx = 10 + t*step # +10, hogy az origotol eltavolodjunk
self.create_line(stx, height_/10, stx, height_*9/10, fill='grey')
# fuggoleges skala rajzolasa 8 beosztassal :
step = height_*2/25. # vizszintes skala intervallumai
for t in range(-5, 6):
sty = height_/2 -t*step # height_/2 hogy az origotol eltavolodjunk
self.create_line(10, sty, width_-15, sty, fill='grey')
# referencia tengelyek rajzolasa :
self.create_line(10, height_/2, width_, height_/2, arrow=LAST) # X-tengely
self.create_line(10, height_-5, 10, 5, arrow=LAST) # Y-tengely
# a tengelyek vegen megadjuk a fizikai mennyisegek nevet :
self.create_text(20, 10, anchor =CENTER, text = "e")
self.create_text(width_-10, height_/2-12, anchor =CENTER, text = "t")
def drawCurve(self, freq=1, phase=0, ampl=10, colo='red'):
"1 sec idotartamra eso kiteres/ido gorbe rajzolasa"
curve =[] # koordinatak listaja
step = (self.width_-25)/1000. # az X-skalaa 1 sec-nak felel meg
for t in range(0,1001,5): # amit 1000 ms-ra osztunk fel
e = ampl*sin(2*pi*freq*t/1000 - phase)
x = 10 + t*step
y = self.height_/2 - e*self.height_/25
curve.append((x,y))
n = self.create_line(curve, fill=colo, smooth=1)
return n # n = a rajz sorszama
#### Kod az osztaly tesztelesehez : ####
if __name__ == '__main__':
root = Tk()
gra = OscilloGraphe(root, 250, 180)
gra.pack()
gra.configure(bg ='ivory', bd =2, relief=SUNKEN)
gra.drawCurve(2, 1.2, 10, 'purple')
root.mainloop()
#traceCourbe -> drawCurve
#height -> height_
#width -> width_
#pas -> step
#coul -> colo
-----------------
#! /usr/bin/env python
# -*- coding: Utf-8 -*-
##################################################
# Oscillo.py #
# <Canvas> -bol szarmaztatott specializalt widget#
# kiteres/ido gorbe rajzolasara szolgal #
# #
# Szerzo : G.Swinnen (Liege, Belgium) #
# 16/03/2002 - Licence GPL #
##################################################
from Tkinter import *
from math import sin, pi
class OscilloGraphe(Canvas):
"kiteres/ido gorbe rajzolasara szolgalo specializalt vaszon"
def __init__(self, master=None, width_=200, height_=150):
"A grafika constructora : tengelyek es vizszintes skala."
# a szulo widget elkeszitese :
Canvas.__init__(self) # a szuloosztaly
self.configure(width=width_, height=height_) # constructoranak hivasa
self.width_, self.height_ = width_, height_ # tarolas
# referencia tengelyek rajzolása :
self.create_line(10, height_/2, width_, height_/2, arrow=LAST) # X-tengely
self.create_line(10, height_-5, 10, 5, arrow=LAST) # Y-tengely
# fuggoleges skala rajzolasa 8 beosztassal :
step = (width_-25)/8. # vizszintes skala intervallumai
for t in range(1, 9):
stx = 10 + t*step # +10 hogy az origotol eltavolodjunk
self.create_line(stx, height_/2-4, stx, height_/2+4)
def drawCurve(self, freq=1, phase=0, ampl=10, colo='red'):
"1 sec idotartamra eso kiteres/ido gorbe rajzolasa"
curve =[] # koordinatak listaja
step = (self.width_-25)/1000. # az X-skala 1 sec-nak felel meg
for t in range(0,1001,5): # amit 1000 ms-ra osztunk fel
e = ampl*sin(2*pi*freq*t/1000 - phase)
x = 10 + t*step
y = self.height_/2 - e*self.height_/25
curve.append((x,y))
n = self.create_line(curve, fill=colo, smooth=1)
return n # n = a rajz sorszama
#### Kod az osztaly tesztelesehez : ####
if __name__ == '__main__':
root = Tk()
gra = OscilloGraphe(root, 250, 180)
gra.pack()
gra.configure(bg ='ivory', bd =2, relief=SUNKEN)
gra.drawCurve(2, 1.2, 10, 'purple')
root.mainloop()
#larg -> width_
#haut -> height_
#pas -> step
#traceCourbe -> drawCurve
#coul -> colo
----------------------
#! /usr/bin/env python
# -*- coding: Utf-8 -*-
# Scale widget bemutatasa
from Tkinter import *
def updateLabel(x):
lab.configure(text='Aktuális érték = ' + str(x))
root = Tk()
Scale(root, length=250, orient=HORIZONTAL, label ='Beállítás :',
troughcolor ='dark grey', sliderlength =20,
showvalue =0, from_=-25, to=125, tickinterval =25,
command=updateLabel).pack()
lab = Label(root)
lab.pack()
root.mainloop()
---------------------------
#! /usr/bin/env python
# -*- coding: Utf-8 -*-
##################################################
# Vibrations.py #
# 3 harmonikus rezgomozgas #
# kiteres/ido grafikonjanak rajzolasa #
# #
# Szerzo : G.Swinnen (Liege, Belgium) #
# 02/03/2002 - Licence GPL #
##################################################
from oscillo import *
from curseurs import *
class ShowVibra(Frame):
"Harmónikus rezgőmozgások bemutatása"
def __init__(self, master =None):
Frame.__init__(self, master) # a szülő osztály constructora
self.colour=['dark green','red','purple']
self.trace=[0]*3 # kirajzolandó görbék listája�
self.control=[0]*3 # kontrolpanelek listája
# vászonpéldány létrehozása az x és y koordináta-tengelyekkel :
self.gra = OscilloGraphe(self, width_ =400, height_=300)
self.gra.configure(bg ='white', bd=4, relief=GROOVE)
self.gra.pack(side =TOP, pady=5)
# 3 vezérlő panel (cursorok) létrehozása :
for i in range(3):
self.control[i] = ChoiceVibra(self,self.colour[i])
self.control[i].pack()
# Az ábrák kirajzolását indító események definiálása� :
self.master.bind('<Control-Z>', self.showCurve)
# pozicionalas :
self.master.title('Harmónikus rezgőmozgások')
self.pack()
def showCurve(self,event):
"A 3 kiteres/ido grafikon kirajzolasa"
for i in range(3):
# Eloszor toroljuk az (esetleges) ekozo abrakat :
self.gra.delete(self.trace[i])
# Utana uj gorbeket rajzolunk�:
if self.control[i].chk.get():
self.trace[i] = self.gra.drawCurve(
colo=self.colour[i],
freq=self.control[i].freq,
phase=self.control[i].phase,
ampl=self.control[i].ampl)
#### Kod az osztaly tesztelesehez : ###
if __name__ == '__main__':
ShowVibra().mainloop()
#couleur -> colour
#controle -> control
#coul -> colo
------------------
#! /usr/bin/env python
# -*- coding: Utf-8 -*-
from Tkinter import *
def circle(can, x, y, r):
"<r> sugaru kor rajzolasa a vaszon <can> <x,y> pontjaba"
can.create_oval(x-r, y-r, x+r, y+r)
class Application(Tk):
def __init__(self):
Tk.__init__(self) # a szuloosztaly constructora
self.can =Canvas(self, width =475, height =130, bg ="white")
self.can.pack(side =TOP, padx =5, pady =5)
Button(self, text ="Vonat", command =self.drawing).pack(side =LEFT)
Button(self, text ="Hello", command =self.kukucs).pack(side =LEFT)
def drawing(self):
"4 vagon letrehozasa a vasznon"
self.w1 = Wagon(self.can, 10, 30)
self.w2 = Wagon(self.can, 130, 30)
self.w3 = Wagon(self.can, 250, 30)
self.w4 = Wagon(self.can, 370, 30)
def kukucs(self):
"emberek jelennek meg bizonyos ablakokban"
self.w1.perso(3) # 1. vagon, 3. ablak
self.w3.perso(1) # 3. vagon, 1. ablak
self.w3.perso(2) # 3. vagon, 2. ablak
self.w4.perso(1) # 4. vagon, 1. ablak
class Wagon:
def __init__(self, canvas_, x, y):
"egy kis vagon rajza a <canvas_> vásznon <x,y> -ban"
# paraméterek tárolása példány-változókban :
self.canvas_, self.x, self.y = canvas_, x, y
# alap téglalap : 95x60 pixel :
canvas_.create_rectangle(x, y, x+95, y+60)
# 3 ablak 25x40 pixeles, 5 pixel távolságra :
for xf in range(x +5, x +90, 30):
canvas_.create_rectangle(xf, y+5, xf+25, y+40)
# két 12 pixel sugarú kerék :
circle(canvas_, x+18, y+73, 12)
circle(canvas_, x+77, y+73, 12)
def perso(self, fen):
"egy ember jelenik meg a <wind> ablakban"
# az ablakok koordinatainak kiszamolasa :
xf = self.x + fen*30 -12
yf = self.y + 25
circle(self.canvas_, xf, yf, 10) # arc
circle(self.canvas_, xf-5, yf-3, 2) # balszem
circle(self.canvas_, xf+5, yf-3, 2) # jobbszem
circle(self.canvas_, xf, yf+5, 3) # szaj
app = Application()
app.mainloop()
-------------------------
#! /usr/bin/env python
# -*- coding:Latin-1 -*-
from Tkinter import *
def circle(can, x, y, r, colour ='white'):
"<r> sugaru kor rajzolasa a vaszon <can> <x,y> pontjaba"
can.create_oval(x-r, y-r, x+r, y+r, fill =colour)
class Application(Tk):
def __init__(self):
Tk.__init__(self) # a szuloosztaly constructora
self.can =Canvas(self, width =475, height =130, bg ="white")
self.can.pack(side =TOP, padx =5, pady =5)
Button(self, text ="Vonat", command =self.drawing ).pack(side =LEFT)
Button(self, text ="Hello", command =self.kukucs).pack(side =LEFT)
Button(self, text ="Vilagitas34", command =self.light34).pack(side =LEFT)
def drawing (self):
"4 vagon letrehozasa a vasznon"
self.w1 = Wagon(self.can, 10, 30)
self.w2 = Wagon(self.can, 130, 30, 'dark green')
self.w3 = Wagon(self.can, 250, 30, 'maroon')
self.w4 = Wagon(self.can, 370, 30, 'purple')
def kukucs(self):
"emberek jelennek meg bizonyos ablakokban"
self.w1.perso(3) # 1. vagon, 3. ablak
self.w3.perso(1) # 3. vagon, 1. ablak
self.w3.perso(2) # 3. vagon, 2. ablak
self.w4.perso(1) # 4. vagon, 1. ablak
def light34(self):
"a vilagitas bekapcsolasa a 3 & 4 vagonban"
self.w3.light()
self.w4.light()
class Wagon:
def __init__(self, canvas_, x, y, colour ='navy'):
"egy kis vagon rajza a <canvas_> vásznon <x,y> -ban"
# paraméterek tárolása példány-változókban :
self.canvas_, self.x, self.y = canvas_, x, y
# alap téglalap : 95x60 pixel :
canvas_.create_rectangle(x, y, x+95, y+60, fill =colour)
# 3 ablak 25x40 pixeles, 5 pixel távolságra :
self.wind =[] # az ablakok hivatkozasainak tarolasara
for xf in range(x +5, x +90, 30):
self.wind.append(canvas_.create_rectangle(xf, y+5,
xf+25, y+40, fill ='black'))
# két 12 pixel sugarú kerék :
circle(canvas_, x+18, y+73, 12, 'gray')
circle(canvas_, x+77, y+73, 12, 'gray')
def perso(self, wind):
"egy ember jelenik meg a <wind> ablakban"
# az ablakok koordinatainak kiszamolasa :
xf = self.x + wind*30 -12
yf = self.y + 25
circle(self.canvas_, xf, yf, 10, "pink") # arc
circle(self.canvas_, xf-5, yf-3, 2) # balszem
circle(self.canvas_, xf+5, yf-3, 2) # jobbszem
circle(self.canvas_, xf, yf+5, 3) # szaj
def light(self):
"felkapcsolja a vagon belso vilagitasat"
for f in self.wind:
self.canvas_.itemconfigure(f, fill ='yellow')
app = Application()
app.mainloop()
#cercle -> circle
#dessine -> drawing
#coucou -> kukucs
#fen -> wind
#allumer -> light
#eclai34 -> light34
------------------
>>> import Tkinter
>>> root = Tkinter.Tk()
>>> msg = Tkinter.Label( root , text ='hello world ')
>>> msg.config( font =( 'courier ' , 20 , 'bold '))
>>> msg.config( bg='deepskyblue ' , fg='yellow ')
>>> msg.config( height =3 , width =20)
>>> msg.pack( expand = Tkinter.YES , fill = Tkinter.BOTH )
>>> root.mainloop()
>>> import Tkinter
>>> import sys
>>> widget = Tkinter.Button( None )
>>> widget.config( text ='press to quit ' , command =sys.exit )
>>> widget.pack( expand = Tkinter.YES , fill = Tkinter.X)
>>> widget.mainloop()
Nincsenek megjegyzések:
Megjegyzés küldése