2020. szeptember 13., vasárnap

Python példaprogramok

>>> 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 ())) 
>>> b1 = Button( root , text ='Fetch ' , command = fetch ) 
>>> b1.pack( side = LEFT ) 
>>> b2 = Button( root , text ='Quit ' , command = root.destroy ) 
>>> b2.pack( side = RIGHT ) 
>>> root.mainloop()







>>> 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