Vote utilisateur: 5 / 5

Etoiles activesEtoiles activesEtoiles activesEtoiles activesEtoiles actives
 

Algorithme

Python 3 : trucs, astuces et bonnes pratiques


Sommaire

  1. Print() et Python
  2. Les listes sous Python
  3. Les fonctions
  4. Sauvegardes : module marshal
  5. Divers

 

1. Print() et Python

1.1.  Print et variables

Il est possible de changer une partie du texte en y incorporant des variables précédées de l'opérateur "%".

Les paramètres placés entre parenthèses à droite de la chaine à afficher seront insérés dans le texte dans l'ordre.
  • %s représente un paramètre de type "string" (texte).
  • %d un "digit" (nombre entier).
  • %f un "floating" (flottant : nombre réel).
Exemples :
variable1, variable2 = 1, 2

>>> print("A. le résultat de ",variable1,' + ',variable2," est : ",variable1+variable2)
A. le résultat de 1 + 2 est : 3 >>> print("B. le résultat de " + str(variable1) + ' + ' + str(variable2) + " est : "+ str(variable1 + variable2)) B. le résultat de 1 + 2 est : 3
>>> print("C. et le résultat de %s + %d est %d" % (variable1, variable2, variable1+variable2))
C. et le résultat de 1 + 2 est 3

1.2 Avec la fonction . format() ou print(f)

# .format() devant une chaine de charactères
>>> i=0.7
>>> j=1/3

>>>print("La valeur de i est {} est celle de j est {}".format(i,j))
La valeur de i est 0.7 est celle de j est 0.3333333333333333

# f devant une chaine de charactères
>>> print(f"La valeur de i est {i} est celle de j est {j}")
La valeur de i est 0.7 est celle de j est 0.3333333333333333

 

1.3 Pour avoir un nombre de décimales fixe

# le format avec des décimales 
# %f ou %0.nf avec n le nombre de décimales
>>> x=0.3
>>> print('x = %f'%(x))
x = 0.300000

>>> print('x = %0.2f avec 2 decimales'%(x))
x = 0.30 avec 2 decimales

>>> print('x = %0.9f avec 9 decimales'%(x))
x = 0.300000000 avec 9 decimales

>>> print('x = %0.20f avec 20 decimales'%(x))
x = 0.29999999999999998890 avec 20 decimales

>>> print('x = %0.30f avec 30 decimales'%(x))
x = 0.299999999999999988897769753748 avec 30 decimales

  top

2. Les listes sous Python

2.1. Copier une liste

  •  Lorsque l'on copie deux listes de cette manière on obtient :
#Lorsque l'on copie une liste de cette manière

x = [1,2,3]
y = x

>>x
[1,2,3]
>>y
[1,2,3]


#Or si vous changez une valeur de la liste y , la liste x sera elle aussi affectée par cette modification:

y[0] = 4
>>x
[4,2,3]
>>y
[4,2,3]

 

  • Il faut donc procéder différemment.
     
#Alors comment copier une liste qui sera indépendante?

z= [1,2,3]
t = z[:]
t[0] = 9

>>z
[1, 2, 3]
>>t
[9, 2, 3]

 

  • Pour les listes plus complexes.
     
#Pour des données plus complexes, vous pouvez utiliser la fonction deepcopy du module copy

import copy
u = [[1,2], 3]
v = copy.deepcopy(u)
v[1] = [4,5,6]
>>u
[[1, 2], 3]
>>v
[[1, 2], [4, 5, 6]]

 

2.2 Listes en compréhension

La liste en compréhension vous permet d'écrire des boucles for plus concises. Très utiles dès lors que vous créez de nouvelles listes basées sur des listes pré-existantes. Par exemples :

nombres = [1,2,3,4,5,6,7]
pairs = [x for x in nombres if x % 2 is 0]
# x%2 donne le reste de la division euclidienne de x par 2

>>>pairs
[2, 4, 6]

impairs = [y for y in nombres if y not in pairs]
>>>impairs
[1, 3, 5, 7]

carres=[x**2 for x in nombres]
>>> carres
[1, 4, 9, 16, 25, 36, 49] 

liste_de_villes = ['Paris', 'Dublin', 'Copenhage']

def visite(liste):
    for i in liste: 
        print("Welcome in  "+i)
    

>>> visite(liste_de_villes) 
Welcome in  Paris
Welcome in  Dublin
Welcome in  Copenhage

 

2.3. enumerate

# Enumerate est une fonction intégrée de Python. 
# Elle nous permet de boucler sur une liste et d’avoir un compteur automatique. 
>>> for i, elem in enumerate('azerty'): print (i, elem) 0 a 1 z 2 e 3 r 4 t 5 y # On peut changer l'index de départ >>> for i, elem in enumerate('azerty',10): print (i, elem) 10 a 11 z 12 e 13 r 14 t 15 y # avec une liste L=['a','b','c','dd','eee'] >>>for i, elem in enumerate(L): print (i, elem) 0 a 1 b 2 c 3 dd 4 eee # la fonction list() : transforme un itérable (tuple, string, set, dictionary) en une liste. >>> compteur_list = list(enumerate(L, 1)) >>> print(compteur_list) [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'dd'), (5, 'eee')]

 

 2.4 . Travailler sur des éléments d'une liste

 

# Listes
# Quelques astuces pour travailler sur certains éléments d'une liste


a =[i for i in range(100,111)]
>>> print(a)
[100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110]

# a[-4:] : Affiche les 4 dernières occurrences : 
>>> print(a[-4:] )
[107, 108, 109, 110]

# a[5:8] : Tous les éléments de a[5] à a[7]
>>> print(a[5:8] ) 
[105, 106, 107]       

# a[:3] : les 3 premiers caractères
>>> print(a[:3])  
[100, 101, 102]     

#  a[3:] : Tout sauf les 3 premiers caractères
>>> print(a[3:]) 
[103, 104, 105, 106, 107, 108, 109, 110]     

# On remplace les 5 premiers éléments de la liste par X
>>> a[:3] = ["X"]
>>> print(a)
['X', 103, 104, 105, 106, 107, 108, 109, 110]

# On remplace les 2 premiers éléments de la liste par [0,1,2,3,4]
>>> a[:2] = range(5)
>>> print(a)
[0, 1, 2, 3, 4, 104, 105, 106, 107, 108, 109, 110]

 

# On inverse la liste
>>> b =[i for i in range(100,111)]
>>> print("b = ",b)
b =  [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110]

>>> b= b[::-1]
>>> print("b = ",b)
b =  [110, 109, 108, 107, 106, 105, 104, 103, 102, 101, 100]

# On pouvait aussi utiliser liste.reverse()
>>> c =[i for i in range(1,10)]
>>> print("c = ",c)
c =  [1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> c.reverse()
>>> print("c = ",c)
c =  [9, 8, 7, 6, 5, 4, 3, 2, 1]

# On inverse la liste, et on garde  1 élément sur 2
>>> d =[i for i in range(100,111)]
>>> print("d =", d)
d = [100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110]

>>> d= b[::-2]
>>> print("d =", d)
d = [100, 102, 104, 106, 108, 110]

 

 top

3. Les fonctions

3.1 Les fonctions anonyme sous Python : fonctions lambda

Comme son nom l'indique, une fonction anonyme est une fonction n'ayant pas de nom.

Concrètement, ces fonctions dites "lambda" n'ont pas plus d'avantages que les autres. Il n’existe aucune opération qu’on fasse avec une fonction anonyme qu’on ne puisse faire avec une fonction normale. On utilise les fonctions anonymes par goût, pour des raisons de style. Les lambdas sont très pratiques pour créer des fonctions jetables.

 

from math import *

def f(x):
    return x*2  

>>> f(3)
6

#Voici une fonction lambda qui fait la même chose que la fonction ordinaire précédente. 
#La syntaxe est condensée : il n’y a pas de parenthèses pas de return. 

>>> g = lambda x: x*2  
>>> g(3)
6

>>> h = lambda x: sqrt(x)  
>>> h(3)
1.7320508075688772

#Remarquez aussi que la fonction n’a pas de nom, mais qu’elle peut être appelée à travers la variable à laquelle elle est assignée.

>>> (lambda x: x*2)(3) 
6

Les limites des lambdas

  • On ne peut les écrire que sur une ligne.
  • On ne peut pas avoir plus d’une instruction dans la fonction.

 top

4. Sauvegardes : module marshal

On peut facilement sauvegarder des listes à l'aide du module marshal.

Sous repl,

  1. tu vas créer un fichier sous ton main que tu peux nommer sauvegarde comme dans l'exemple qui suit ;
      
  2. Pour sauvegarder et lire un objet enregistré la structure est :
    1. dump(objet, file) : où objet est l'objet élémentaire à sauvegarder et file est un fichier ouvert en écriture.
      Remarque : to dump (déverser, vider en informatique)
    2. load(fileobj) permet de lire un fichier et retourne l'objet enregistré; fileobj étant un fichier ouvert en lecture.
        
  3. Pour initialiser le procédé, on peut faire une première sauvegarde puis on met l'affectation en commentaire. Il y a plus joli  mais cette méthode est plus simple :
    marshal.dump([0,1], open("sauvegarde", 'wb')) ## Sauvegarde de l'objet initial
Voici comment on peut générer les termes de la suite de Fibonacci à chaque run  https://repl.it/@fduffaud/Sauvegarde-Liste )
### sauvegarder une liste
import marshal
 
# La fonction dump(objet, file) où objet est l'objet élémentaire à sauvegarder et file est un fichier ouvert en écriture.*
# Pour faire simple, on lance une première sauvegarde pour initialiser la liste (il y a mieux mais bon ...)
#marshal.dump([0,1], open("sauvegarde", 'wb')) ## Sauvegarde du fichier


recup=marshal.load(open("sauvegarde", "rb"))
#La focntion load(fileobj) permet de lire un fichier et retourne l'objet enregistré; fileobj étant un fichier ouvert en lecture. 

print(recup)
L2=recup
ajout=L2[-1]+L2[-2] 
# L2[-1] est le dernier terme de la liste et =L2[-2]  l'avant dernier

L2=L2+[ajout]

marshal.dump(L2, open("sauvegarde", 'wb')) ## Sauvegarde du fichier
print(L2)

 

10. Divers

10.1 Geopy

En géographie (et géodésie) le module geopy nous permet d’obtenir l’adresse complète du lieu, sa latitude, sa longitude et même son altitude. Il existe également une classe de distance utile qui calcule la distance entre deux lieux dans votre unité de mesure préférée.

 

from geopy.geocoders import Nominatim
geolocator = Nominatim(user_agent="specify_your_app_name_here")
#
location1 = geolocator.geocode("Notre dame de Paris")
location2 = geolocator.geocode("Lyon, France")
location3 = geolocator.geocode("new york")
#
coord1=(location1.latitude, location1.longitude)
coord2=(location2.latitude, location2.longitude)
coord3=(location3.latitude, location3.longitude)
#
>> print(location1.address)
Notre-Dame, 6, Parvis Notre-Dame - Place Jean-Paul II, iles, 4e, Paris, Île-de-France, France métropolitaine, 75004, France
>> print(coord1)
(48.85293705, 2.3500501225)
#
>> print(location2.address)
Lyon, Métropole de Lyon, Circonscription départementale du Rhône, Auvergne-Rhône-Alpes, France métropolitaine, France
>> print(coord2) 45.7578137, 4.8320114) >> print(location3.address) NYC, New York, USA
print(coord3) (40.7308619, -73.9871558)
from geopy import distance # >> print(distance.distance(coord1, coord2).km) 391.9113209974709 >> print(distance.distance(coord1, coord3).km) 5850.47017420855

 

top

Articles Connexes