Le blog de syeric

Bonjour !

Je continue mon palmarès des fonctions que tout le monde connait sauf moi :D.

Lire la suite

Salut !

Je voulais vous présenter une fonction plutôt sympa de string dans python.

Mise en situation : Je vous donne la phrase suivante :

egek guv wpg fgoq fg uvtkpi.ocmgvtcpu() swk guv wpg hqpevkqp rnwvqv uaorc

Puis je vous dit que pour la comprendre, il faut remplacer toutes les lettres par celle qui se situe deux rangs plus hauts, par exemple remplacer c par a, d par b... Il y a deux méthodes pour le faire. La bonne, qui consiste à faire un programme, et la mauvaise, qui consiste à le faire à la main.

Heureusement, python va nous sortir de cette situation !

Voyez plutôt :

[python]
#!/usr/bin/python
#-*- coding:utf-8 -*-
import string

#la fameuse phrase
c="egek guv wpg fgoq fg uvtkpi.ocmgvtcpu() swk guv wpg hqpevkqp rnwvqv uaorc"
#on défini un premier élément, qui sont les lettres de l'alphabet décalées de +2 rangs
first='cdefghijklmnopqrstuvwxyzab'
#on défini le second, plus facile
second='abcdefghijklmnopqrstuvwxyz'
#On crée une table qui va servir à la traduction avec string.maketrans()
table=string.maketrans(first, second)
#On traduit avec translate(table)
result=c.translate(table)
#on affiche le résultat
print result

A son exécution, vous aurez comme résultat :

Ceci est une demo de string.maketrans() qui est une fonction plutot sympa

Bon, cet exemple est nul, mais cette fonction prend tout son sens lorsque l'on travaille avec des éléments chiffrés que l'on veut traduire en mots, ou autre. Seule obligation, avoir le même nombre de caractères de part et d'autre de la table de traduction.

A+

Sylvain

Bonjour !

Haaa, pygtk c'est génial :) Et en ce moment je m'amuse ! Je me suis mis en tête de générer une série de pages, des tutoriels par exemple, où on navigue avec des boutons "Continuer" et "Précédent", mais le tout automatiquement et uniquement avec des fichiers texte. Ca présente l'intérêt que une fois que vous avez fait le programme, ben pour modifier le contenu et faire des ajouts, vous n'avez besoin de rien d'autre que des fichiers textes ;-)

Voyons ça de plus près ;-)

C'est des fonctions que l'on va appeler depuis un autre script.

On commence par la fonction widget_tuto qui génère le cadre dans lequel va se trouver le document et les boutons et même une image !

[python]
def widget_tuto(fichier):
	"Fonction qui génère la box qui va contenir la page du tuto et les boutons"
	#Un petit cadre
	cadre = gtk.Frame()
	#cération d'une boite horizontale
	box1=gtk.HBox(False, 5)
	#on l'ajoute au cadre
	cadre.add(box1)
	#Fenetre "scrollable"
	fd = gtk.ScrolledWindow()
	fd.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
	#On l'ajoute à la box1
	box1.pack_start(fd, True, True, 10)
	#on importe le texte
	text=chainaslist(fichier)
	#on crée une boite verticale
	box=gtk.VBox(False, 5)
	#on l'incorpore à la fenêtre scrollable
	fd.add_with_viewport(box)
	#On crée un label
	label1=gtk.Label()
	#On rempli le label avec text en tenant compte des balise
	label1.set_markup(text)
	#On ajoute le label à box
	box.pack_start(label1, False, False, 5)
	#On crée une image
	image = gtk.Image()
	#on l'importe à partir du nom donné dans le fichier du tuto
	image.set_from_file(getimage(fichier))
	#on la met dans la box
	box.pack_start(image, False, False, 5)
	#on crée le bouton suivant avec la fonction get_next
	next=get_next(fichier)
	#on crée le bouton précédent avet la foction get_previous
	previous=get_previous(fichier)
	#si c'est le premier
	if previous=="first":
		boutonnext=gtk.Button("Continuer")
		boutonnext.connect("clicked", nexttuto, next, cadre, box1)
		#On crée une boite horizontale
		box2=gtk.HBox(False, 5)
		#on y met le bouton
		box2.pack_start(boutonnext, False, False, 5)
	else:
		boutonprev=gtk.Button("Précédent")
		boutonprev.connect("clicked", nexttuto, previous, cadre, box1)
		boutonnext=gtk.Button("Continuer")
		boutonnext.connect("clicked", nexttuto, next, cadre, box1)
		#On crée une boite horizontale
		box2=gtk.HBox(False, 5)
		#on y met le bouton
		box2.pack_start(boutonnext, False, False, 5)
		box2.pack_start(boutonprev, False, False, 5)
	#on met la box2 dans box
	box.pack_start(box2, False, False, 5)
	#on montre tout ça
	cadre.show_all()
        return cadre

Bon ! Il y a une série de fonctions la dedans. Déjà, lorsqu'il s'agit des pages suivantes, il faut créer une deuxième fonction, quasi identique sauf qu'il n'y a pas le cadre...

[python]
def widget_tuto2(fichier, cadre):
	"fonction qui va générer les tutos suivants"
	#cération d'une boite horizontale
	box1=gtk.HBox(False, 5)
	#Fenetre "scrollable"
	fd = gtk.ScrolledWindow()
	fd.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
	#On l'ajoute à la box1
	box1.pack_start(fd, True, True, 10)
	#on importe le texte
	text=chainaslist(fichier)
	#on crée une boite verticale
	box=gtk.VBox(False, 5)
	#on l'incorpore à la fenêtre scrollable
	fd.add_with_viewport(box)
	#On crée un label
	label1=gtk.Label()
	#On rempli le label avec text en tenant compte des balise
	label1.set_markup(text)
	#On ajoute le label à box
	box.pack_start(label1, False, False, 5)
	#On crée une image
	image = gtk.Image()
	#on l'importe à partir du nom donné dans le fichier du tuto
	image.set_from_file(getimage(fichier))
	#on la met dans la box
	box.pack_start(image, False, False, 5)
	#on crée le bouton suivant avec la fonction get_next
	next=get_next(fichier)
	#on crée le bouton précédent avet la foction get_previous
	previous=get_previous(fichier)
	#si c'est le premier
	if previous=="first":
		boutonnext=gtk.Button("Continuer")
		boutonnext.connect("clicked", nexttuto, next, cadre, box1)
		#On crée une boite horizontale
		box2=gtk.HBox(False, 5)
		#on y met le bouton
		box2.pack_start(boutonnext, False, False, 5)
	else:
		boutonprev=gtk.Button("Précédent")
		boutonprev.connect("clicked", nexttuto, previous, cadre, box1)
		boutonnext=gtk.Button("Continuer")
		boutonnext.connect("clicked", nexttuto, next, cadre, box1)
		#On crée une boite horizontale
		box2=gtk.HBox(False, 5)
		#on y met le bouton
		box2.pack_start(boutonnext, False, False, 5)
		box2.pack_start(boutonprev, False, False, 5)
	#on met la box2 dans box
	box.pack_start(box2, False, False, 5)
	#on montre tout
	box1.show_all()
        return box1

Bien, ensuite, les fonctions get_next et get_previous.

[python]
def get_next(fichier):
	#on ouvre fichier grace à la fonction openfilelist de fileFunctions.py
	chaine=fileFunctions.openfilelist(fichier)
	#On évalue le nombre de lignes
	a=len(chaine)
	#chaine de caractère qui va être le nom du fichier
	name=chaine[a-3]
	#chaine de caractères qui est le nom du tuto
	name_tuto=chaine[a-1]
	#enfin, le chemin global du fichier (fonction suppr_char supprime le retour chariot en fin de ligne)
	finalchar=".""/Tutos/"+fileFunctions.suppr_char(name_tuto)+"/text/"+fileFunctions.suppr_char(name)
	return finalchar
	

def get_previous(fichier):
	#on ouvre fichier grace à la fonction openfilelist de fileFunctions.py
	chaine=fileFunctions.openfilelist(fichier)
	#On évalue le nombre de lignes
	a=len(chaine)
	#chaine de caractère qui va être le nom du fichier
	name=chaine[a-2]
	#chaine de caractères qui est le nom du tuto
	name_tuto=chaine[a-1]
	finalchar=""
	#enfin, le chemin global du fichier (fonction suppr_char supprime le retour chariot en fin de ligne)
	if name=="first\n":
		finalchar="first"
	else:
		finalchar=".""/Tutos/"+fileFunctions.suppr_char(name_tuto)+"/text/"+fileFunctions.suppr_char(name)
        return finalchar

fileFunctions.suppr_char() est une fonction de fileFunctions.py qui supprime le retour charriot en fin de ligne.

La fonction chainaslist()

[python]
def chainaslist(fichier):
	"fonction qui va ouvrir fichier et retourner la chaine de caratères entre le début et la balise [endtext]"
	#on ouvre le fichier
	chaine=fileFunctions.openfilelist(fichier)
	#variable de boucle
	i=0
	#on crée une chaine de caractère vide txt
	txt=''
	#Et c'est parti, tant que la ligne est différente de [endtext]\n, on rempli txt avec son contenu plus la ligne
	while chaine[i] != "[endtext]\n":
		txt=txt+chaine[i]
		i=i+1
	#on retourne txt
	return txt

Enfin, la fonction nexttuto() :

[python]
def nexttuto(widget, fichier, cadre, wid):
	cadre.remove(wid)
	box=widget_tuto2(fichier, cadre)
	cadre.add(box)
	cadre.show_all()

Alors, qu'est ce que ça fait tout ça ? Ca va générer un cadre dans lequel il y a un texte qui est lu dans "fichier" jusqu'à la balise endtext en prenant en compte le balisage pango. Ensuite, ça prend une image avec getimage en lisant dans le fichier le nom de l'image dans fichier. Ensuite, ça défini les boutons. Si l'avant dernière ligne de fichier est égale à "first", alors on ne met pas de bouton précédent. Sinon, et bien on crée les deux boutons, on lit le nom des fichiers qui correspondent aux suivant et précédent dans fichier, et grace à la fonction nextuto, on détruit l'intérieur du cadre et on régénère le nouveau document avec les nouveaux noms.

Au final, si vous voulez ajouter des documents, en enlever etc, vous avez juste à modifier les noms dans les fichiers ;-)

A bientôt.

Sylvain

Salut !

Python est un langage que j'affectionne particulièrement. La syntaxe n'est pas très lourde, c'est orienté objet et ça s'avère très puissant. De plus, il est portable sous windows et mac. Associé à la bibliothèque graphique pygtk, on peut faire des trucs très sympa :)

J'ai galèré un bon moment avant d'arriver à faire un notebook (plusieurs onglets dans la même fenêtre) avec un bouton "fermer" dans l'onglet. Je donne donc la solution si il y en a que ça intéresse ;-)

[python]
#!/usr/bin/env python
# -*- coding:utf-8 -*-

#  notebook.py

import pygtk
pygtk.require('2.0')
import gtk

class NotebookExample:
    def add_icon_to_button(self,button):
	"Fonction pour ajouter un bouton fermer"
	#création d'une boite horizontale
        iconBox = gtk.HBox(False, 0)   
	#Création d'une image vide     
        image = gtk.Image()
	#On récupère l'icone du bouton "fermer"
        image.set_from_stock(gtk.STOCK_CLOSE,gtk.ICON_SIZE_MENU)
	#On enlève le relief au bouton (donné en attribut)
        gtk.Button.set_relief(button,gtk.RELIEF_NONE)
	#On récupère les propriétés du bouton
        settings = gtk.Widget.get_settings(button)
	#On affecte à w et h les dimensions
        (w,h) = gtk.icon_size_lookup_for_settings(settings,gtk.ICON_SIZE_MENU)
	#On modifie ces dimensions
        gtk.Widget.set_size_request(button, w + 4, h + 4)
        image.show()
	#On met l'image dans la boite
        iconBox.pack_start(image, True, False, 0)
	#On ajoute la boite dans le bouton
        button.add(iconBox)
        iconBox.show()
        return 

    def create_custom_tab(self,text, notebook, frame):
        "Crée une tab customisée avec un label et un bouton fermer"
	#On crée une eventbox
        eventBox = gtk.EventBox()
	#On crée une boite horizontale
        tabBox = gtk.HBox(False, 2)
	#On crée un label "text" (text donné en attribut)
        tabLabel = gtk.Label(text)
	#On crée un bouton
        tabButton=gtk.Button()
	#On lui affecte la méthode remove_book
        tabButton.connect('clicked',self.remove_book, notebook, frame)

        #On ajoute l'image au bouton en utilisant la méthode add_icon_to_button
        self.add_icon_to_button(tabButton)
                
        eventBox.show()
        tabButton.show()
        tabLabel.show()
	#On attache label et bouton à la boite
        tabBox.pack_start(tabLabel, False)       
        tabBox.pack_start(tabButton, False)

        tabBox.show_all()
	#On ajoute la boite à l'eventbox
        eventBox.add(tabBox)
        return eventBox
    
    
    def remove_book(self, button, notebook, frame):
	"Fonction de suppression de page"
	#On supprime la page. Le secret, c'est de donner comme argument le widget enfant de la page, ici un cadre frame.
        notebook.remove(frame)
        # On actualise le widget
        notebook.queue_draw_area(0,0,-1,-1)

    def delete(self, widget, event=None):
        gtk.main_quit()
        return False

    def __init__(self):
        window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        window.connect("delete_event", self.delete)
        window.set_border_width(10)

        #On crée un nouveau notebook
        notebook = gtk.Notebook()
        window.add(notebook)
        notebook.show()

        # On ajoute quelques pages
        for i in range(5):
            page_number = i + 1
            frame = gtk.Frame("Frame %d" % page_number)
            frame.set_border_width(10)
            frame.set_size_request(100, 75)
            frame.show()
            label = gtk.Label("Dans la Frame %d" % page_number)
            frame.add(label)
            label.show()
            
            eventBox = self.create_custom_tab("Tab %d" % page_number, notebook, frame)
            notebook.append_page(frame, eventBox)
        # Page que nous verrons à l'ouverture (page 4)
        notebook.set_current_page(3)
        window.show()

def main():
    gtk.main()
    return 0

if __name__ == "__main__":

    NotebookExample()

    main()

Et voilà ! A l'exécution de ce script, vous obtiendrez ça :



A bientôt !

Sylvain