Adblock Detected

Read

Python: Utilisation de Lambda

Read

Introduction

Les fonctions anonymes sont des fonctions n'ayant pas de nom.
Parce que ces fonctions n'ont pas de nom, à l'endroit où l'on voudrait mettre leur nom, on trouve directement les instructions définissant la fonction introduites par une syntaxe particulière.

Dans les langages de programmation fonctionnelle, les fonctions anonymes sont souvent appelées fonctions lambda, en référence au lambda-calcul, outil théorique dans lequel on programme tout sous forme d'appel de fonction, alors même qu'aucune fonction de base n'est définie. [Wikipédia]

Lambda en Python

Lambda peut être utilisée comme:

Une méthode. Elle peut stocker/retourner des variables (chaîne, entier, etc ..).
Un mot-clé dans une programmation de haut niveau (tel est le cas de Python). Cependant en Python, on droit prendre en considération que Lambda ne peut retourner qu'une seule expression.

Exemple basé en Python3:

def faire(f, n):

    print(f(n))


# Création de deux lambdas 
carre = lambda x: x * x
cube = lambda x: x * x * x


# Passer lambda à faire
faire(carre, 4)
faire(cube, 3)




######################

Output/Affichage

######################

16
27

Usage de Lambda

- Lambda sans argument:

Dans l'exemple qui va suivre, on va utiliser lambda sans arguments et l’assigner à une variable pour calculer la somme de 1=

x = lambda n:  sum(range(1,4))

print(x()) # Noter qu'on a invoquer x(), ceci dit, la variable x est une méthode



#########################

Output/Résultat

#########################

6

- Lambda sans variable de retour:

Dans l'exemple qui va suivre, on va utiliser lambda, par exemple, comme print(). À noter que print() renvoi None comme type de retour.

p = lambda x: print(x)

p("Salut!")

p("Ça va?")



##################

Output/Résultat

##################

Salut!

Ça va?

un autre exemple:



import sys

info = lambda : sys.version_info



info()

##########################

Output/Résultat

##########################

sys.version_info(major=3, minor=4, micro=3, releaselevel='final', serial=0)

- Lambda récursive:

Ça veut dire qu'on peut utiliser une fonction lambda qui invoque une autre lambda, et ainsi de suite.
L'exemple qui va suivre expliquera mieux ce que je viens de dire.

Ps: L'utilisation excessive de cette faculté de lambda peut mener à une erreur de type:
In a RuntimeError: maximum recursion depth exceeded error

ajouter = lambda x: x+2

multiplier = lambda n: ajouter(n*2) # Appeler lambda dans une autre lambda!



print(mutiplier(3))

print(mutiplier(5))



#########################

Output/Résultat

#########################

8

12

- Lambda comme macro:

Lambda peut être utilisé pour réduire la répétition dans la syntaxe du code.
Voici un exemple:

ligne1 = "chat, chien"

ligne2 = "mouton, loup"



x = lambda s: s.strip().upper()



ligne1b = x(ligne1)

ligne2b = x(ligne2)



########################

Output/Résultat

########################



CHAT, CHIEN

MOUTON, LOUP

NB:

Lambda a plusieurs limites d'utilisation et elle ne pourra jamais remplacer la déclaration usuelle des méthodes en Python, ceci dit utiliser:

def methode(variable):

     //code

[Tutoriel] Glade3 et PyGi

Read

Dans cet article on va comprendre les bases de la création d'une interface utilisateur à l'aide de Glade3 (User interface Designer) et PyGi (PyGObject).
Ce tutoriel traitera un exemple simple et basique et se sera centré sur l'appel des méthodes de PyGi et la manière de lier un fichier XML généré par Glade3 et notre code en PyGi.
Assez parler! Débutons ... !

Création d'une fenêtre de type Top Level nommée (son id) Window1:

Modifier l'affichage de la fenêtre et la forcer à apparaître au centre de l'écran:

Modifier le titre de la fenêtre:

Modifier les dimensions de la fenêtre par défaut:

Utiliser Grid comme Container (La liste des container est regroupée sur Glade, mais dans cet exemple on va utiliser uniquement Grid avec une dimension 3x3 nommé Grid1):

La fenêtre sera divisée comme suit:

Notre Grid sera ajouté automatiquement à l'hiérarchie de Window1 :

Dans Grid1 on ajoute ces Widgets listés dans le champs Control and display de Glade3. On aura une interface similaire à cella:

La liste des éléments et leur types ajoutés à Window1 s'affichent comme suit:

On modifie les propriétés de button1 (bouton ajouté à Windows1). On modifie le nom qui s'affiche sur le bouton et on le renomme Sortir :

On ajoute un signal (événement) à button1 de type clicked et on lie le signal à la méthode on_button :

On ajoute un signal (événement) à comboboxtext1 de type changed et on lie le signal à la méthode on_comboboxtext :

On ajoute le signal (événement) à checkbutton1 de type toggled et on lie le signal à la méthode on_toggle :

On ajoute le signal (événement) à entry1 de type activate et on lie le signal à la méthode on_entry_activate:

On ajoute le signal (événement) au searchentry1 et de type activate et on lie le signal à la méthode on_entry_activate:

Le logiciel s'affichera comme suit:

Pour le widget checkbutton1 on va le faire manuellement en modifiant le fichier XML généré par Glade. On va ajouter le signal au child switch1 (qui signifie que switch1 est l'enfant de Window1) comme ceci:

Cette ligne se traduit avec PyGi en:

switch1.connect("notify::active", on_switch_activate)

Ceci dit lier switch1 à un signal de type notify::active (notification active)

Sans beaucoup étaler le tutoriel, voilà le fichier XML généré par Glade3 et le code source en PyGi avec des commentaires pour comprendre l'utilisation et le fonctionnement de chaque ligne.

Code source du fichier XML de Glade3:

Code source en PyGi de l'exemple:

#!/user/bin/python
# -*- coding: utf-8 -*-
###################################################################
# Exemple mis en ligne par: Chiheb NeXus
# Licence : Aucune licence!
# Langage de programmation: Python3 et PyGi (PyGtk Version 3)
###################################################################

from gi.repository import Gtk

class Handler():
 """
 - Mettre tous les signaux dans une seule classe
 - NB: Dans PyGi les argements des méthodes sont des widgets intermédiaires qui héritent toutes les caractéristiques 
   des widgets d'origine. Ceci dit, si on essaye de donner une action à un widget de type "button" nommé "button1"
   dans la partie du code on écrit: def action(self, intermerdiare):
   intermerdiare hérite toutes les caractéristiques de button1 et l'action sur intermerdiare est une action indirecte sur button1
   Ceci est peut être bien expliqué en C/GTK+ vu que PyGi est en quelques sorte un porjet réecrit depuis C/GTK+.
 - Ps: Lors d'une utilisation avancée de PyGi, les signaux jouent un rôle primordial dans la création de notre Gui.
      C'est pourquoi une maîtrise de l'utilisation des signaux est fortement récommendée et, aussi, la modification du ficher XML
      généré par Glade3 est, aussi, récommendée.

 - Dans cet exemple, notre programme principale n'est pas mis dans une classe à part, vu sa simplicité. Mais, dans un programme
      avancé, une bonne maîtrise de Python et de PyGi est nécessaire.
      Glade3 ne permet que réduire le temps de création de Gui et éviter la création de l'interface à la main.
      Cependant, ceci ne veut pas dire qu'on va oublier les manipulations manuelles pour parvenir aux résultas voulus.

 - Documentation sur Github:

     1- Toutes les méthodes Gtk.methodes (exemple: Gtk.main_quit())
      https://lazka.github.io/pgi-docs/#Gtk-3.0/functions.html

     2- Les méthodes supportées par Gtk.Button() {Comment interéagir avec les widgets de type Gtk.Button()}
      https://lazka.github.io/pgi-docs/#Gtk-3.0/classes/Button.html#Gtk.Button

     3- Les méthodes supportées par Gtk.Entry() {Comment interéagir avec les widgets de type Gtk.Entry()}
      https://lazka.github.io/pgi-docs/#Gtk-3.0/classes/Entry.html#Gtk.Entry

     4- Les méthodes supportées par Gtk.Switch() {Comment interéagir avec les widgets de type Gtk.Switch()}
      https://lazka.github.io/pgi-docs/#Gtk-3.0/classes/Switch.html#Gtk.Switch

     5- Les méthodes supportées par Gtk.ComboBoxText() {Comment interéagir avec les widgets de type Gtk.ComboBoxText()}
      https://lazka.github.io/pgi-docs/#Gtk-3.0/classes/ComboBoxText.html#Gtk.ComboBoxText

     6- Les méthodes supportées par Gtk.ToggleButton() {Comment interéagir avec les widgets de type Gtk.ToggleButton()}
      https://lazka.github.io/pgi-docs/#Gtk-3.0/classes/ToggleButton.html#Gtk.ToggleButton

     7- Les méthodes supportées par Gtk.SearchEntry() {Comment interéagir avec les widgets de type Gtk.SearchEntry()}
      https://lazka.github.io/pgi-docs/#RB-3.0/classes/SearchEntry.html#RB.SearchEntry 

  - Pour plus d'informations: https://lazka.github.io/pgi-docs/

 """

 def on_button(self, button):
  """
  - Gtk.main_quit(): Est une fonction par défaut de PyGi
            qui permet de sortir de la boucle infinie de l'interface en Gtk+ en utilisant Python 
  - La méthode utilise le mot "self" et "button" comme arguments
  - "button" joue le rôle d'un widget intermédiaire entre button1 et cette partie de code
  """
  Gtk.main_quit()

 def on_switch_activate(self, switch, args):
  """
  - "switch" est un widget intermédiaire entre "switch1" et cette partie de code
         et args est l'argument passé à la méthode lors de l'appel de widget "switch1"
  - switch.get_active() : Cette méthode retourne "True" ou "False" 
      => "True" = Le bouton (widget) est actif / "False" = Le bouton (widget) est inactif 

  """
  if switch.get_active():
   # Bouton actif
   print("Switch activé!")
  else:
   # L'inverse 
   print("Switch désactivé!")

 def on_comboboxtext(self, combobox):
  """
  - L'ajout des éléments à ComboBoxText est faite sous Glade3
  - Cette méthode affichera uniquement les noms stockés dans le fichier XML générée par Glade3
  - combobox.get_active_text() : Retourne le text activé de widget ComboBoxText lors de la saisie dans l'interface UI 
       Le type de retour est une chaine de caractaire (String) et l'affiche sera sous la terminale
  """
  # On vérifie si combobox est vide ou non.
  # S'il est vide, il n'y aura aucun affichage sinon on affiche le contenu

  if combobox.get_active_text() != None:
   print("L'élément saisi est: " + combobox.get_active_text())

 def on_toggle(self, toggle):
  """
  - Le bouton "toggle1" affiche sur la terminale "Toggle button est activé!" ou "Toggle button est désactivé"
  - toggle.get_active() : Retourne "True" ou "False" et qui permet de vérifier l'état de widget (activé ou non)
  - L'affiche est sous la terminale
  """
  if toggle.get_active():
   print("Toggle button est activé!")
  else: 
   print("Toggle button est désactivé")

 def on_entry_activate(self, entry):
  """
  - Affichage du text saisi dans "entry1" et "seachentry1"
  - entry est un widget intermédiaire entre "entry1" et "seachentry1" 
  - entry.get_text(): Retourne le text entré dans "entry1" et "seachentry1"
  - L'affiche sera sur la terminale
  """
  txt = entry.get_text()
  print(txt)


#builder est de type Gtk.Builder() : Notre constructeur du fichier XML de Glade
builder = Gtk.Builder()

# Ajouter le chemin de fichier d'interface générée par Glade
builder.add_from_file("test.glade")  

# Tous les signaus sont mis dans une classe nommée Handler()
builder.connect_signals(Handler()) 

# window est un objet qui hérite toutes les méthodes de window1
window = builder.get_object("window1") 

# Affichage de la fenêtre window = Affichage de la fenêtre window1
window.show_all()   

# Lier la fenêtre principale à un signal de destruction de la fenêtre
window.connect("delete-event",Gtk.main_quit)  

# Lancer la boucle infinie qui permettera de visualiser l'interface indéfiniment sauf s'il y aura une intervention
# de l'utilisateur ou du programme interne 
Gtk.main()

Code source: GladePyGi

PyGI Photo-Viewer : Une visionneuse d'image crée avec PyGI

Read

PyGObject : Modifier les widgets avec du CSS-like

Read

Dans ce billet on va explorer une manière de rendre nos applications crées avec Gtk (codées avec Python ou Toutes les langues de programmation supportant la bibliothèque Gtk+).

GtkCssProvider est un module de la bibliothèque Gtk qui permet de faire du CSS-like, c'est à dire un concept de feuille de style similaire au CSS utilisé dans les sites web et dans les navigateurs web.

Par exemple remarquant la différence entre ces deux versions de la même application :

Sans l'utilisation de CSS

Avec l'utilisation de CSS

Parlons du code maintenant.

Je vais présenter cet aspect de CSS-like avec PyGObject (Python + Gtk+) dans un court exemple.

Je vous laisse avec le code :

Code de la fenêtre principale :


#!/usr/bin/env python


# -*- coding: utf-8 -*-




from gi.repository import Gtk, Gdk




class Example(Gtk.Window):


 """


 Utilisation de CSS avec Python et Gtk


 """


 def __init__(self):


  Gtk.Window.__init__(self, title="PyGtk & CSS")


  self.set_default_size(400,400)


  # Nom de la fenêtre


  self.set_name("MyWindow")




  # CSS Thème


  #Création d'un Gtk.CssProvider


  style_provider = Gtk.CssProvider()


  # Ouvrir notre fichier de style 


# en mode rb = Read en binaire


  css = open('style.css', 'rb')


  # Lire les données du fichier


  css_data = css.read()


  # Fermeture du fichier


  css.close()


  # Extraire les données CSS du fichier lu


  style_provider.load_from_data(css_data)


  # Ajouter les données lus au style provider


# en précisant la priorité d'affichage


  Gtk.StyleContext.add_provider_for_screen(


   Gdk.Screen.get_default(),


   style_provider,


   Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)




  # Création d'un box


  box = Gtk.VBox()


  # Ajout du box à la fenêtre principale


  self.add(box)


  # Création d'un Label


  self.label = Gtk.Label("Je suis un LABEL")


  # Création d'un boutton


  button = Gtk.Button("I'm a Button")


  # Ajouter un signal au boutton qui fait 


# changer le texte du Label


  button.connect("clicked", self.changer)


  # Ajouter le Label et le boutton au box 


# qui fait partie de la fenêtre principale


  box.pack_start(self.label,True, True, 0)


  box.pack_start(button, True, True, 0)


  # Tout afficher dans la fenêtre


  self.show_all()


  




 def changer(self, widget):


  """


  Changer le Label 


  """


  txt = self.label.get_text()


  if txt == "Je suis un LABEL":


   self.label.set_text("Catch me if you can !")


  elif txt == "Catch me if you can !" :


   self.label.set_text("ha ha ha you don't?")


  else :


   self.label.set_text("Funny!!!")




if __name__ == '__main__':


 # Création d'une variable qui contient 


# la fenêtre principale


 win = Example()


 # Ajouter le signal de destruction de


# la fenêtre à la fenêtre principale


 win.connect("delete-event", Gtk.main_quit)


 # Boucle principale


 Gtk.main()

Code CSS :


#MyWindow{


     background-color: black;


     font-size: 20px;


     color: green;


  }


/* Tous les bouttons nommés button seront colorés de 


la même manière : .button


Les Widget de type GtkButton seront modifiés */  


GtkButton{


           color: blue;


           background: grey;


}

Et voilà la résultat :

Pour plus d'informations, veuillez : Cliquer ICI.

Powerline script pour révolutionner votre Bash terminal

Read

GenHash : Générer des hashs de vos fichiers

Read

17 Façons pour apprendre Python gratuitement

Read

[PDF] liste non exhaustive des livres de programmation

Read

[PyGObject] Calculatrice PyGtk

Read

[PyGObject] Youtube-dl Pygtk Gui

Read