Python pour les impatients

Plongez votre nez dans Python avec la pratique et sans passer par la case lecture interminable de longs tutoriaux !
Ici, pas de blabla, juste ce qu'il faut pour apprendre mais aussi pour réutiliser comme fiche de référence par la suite.

Des remarques, retours, commentaires, éléments à ajouter ou corriger, ou des erreurs ? Utilisez les commentaires en fin de page. Merci !

Environnement

• Les fichiers terminent par ".py"
• Il est possible de lancer un interpréteur avec la commande "python"
• C'est un langage interprété. Qu'est-ce que c'est ?
  
  
  "C" est un langage compilé. Un compilateur lit le code, fait des vérifications, ajoute des bibliothèques et le transforme en un exécutable.
  Python, tout comme Perl ou PHP, est un langage interprété. Il n'y a pas de compilateur. Lorsque l'on lance un programme, l?exécuteur va lire la source au fur et à mesure de l?exécution et effectuer les vérifications pendant l?exécution.
  L'avantage des langages interprétés sont :

  • Les fichiers font office à la fois de source et d?exécutable
  • C'est plus portable

  Les inconvénients :

  • C'est plus lent puisque le fichier doit être parsé avant de pouvoir être exécuté
  • Il n'y a aucune pré-vérification, donc c'est important de tester chaque morceau du code et de passer dans chaque "if" au moins une fois pour s'assurer qu'il est correct
• C'est un langage faiblement typé. Qu'est-ce que c'est ?

  Les langages à typage faible permettent de donner n'importe quel type à n'importe quelle variable. Ils utilisent beaucoup de "casts" implicites. Python, PHP et Perl sont faiblement typés.

  Les langages à typage forts sont très stricts. Une variable se voit attribuer un type très précis. Utiliser une fonction qui prend en paramètre une string en lui donnant un int ne fonctionnera pas et produira une erreur. Il faut donc utiliser des "casts" explicites.

  C et C++ sont des entre-deux : il faut spécifier des types, mais certains casts sont implicites.

• C'est un langage à multiples paradigmes : impératif, objet, fonctionnel, procédural et reflexion
• Il est possible de séparer le code en "modules". Chaque fichier correspond à un module. Un seul fichier doit contenir le main (voir "Bonnes pratiques")
• Les opérateurs habituels peuvent avoir un comportement différent selon les types qui les utilisent.
• Les règles de "scoping" habituelles sont valables en python : une variable défini dans une fonction n'existera que dans celle-ci. Ce n'est pas le cas pour tous les scopes.

Syntaxe et Sémantique

• Les noms de variables et de fonctions sont sensibles à la casse. "a" est différent de "A".
• Il n'y a pas de ";" en fin de lignes. On marque la fin d'une ligne... par un retour à la ligne.
• Les blocs sémantiques (ou "scopes") sont définis par l'indentation avec des espaces ou des tabulations (en C, ils le sont grâce aux accolades { }).
• L'indentation doit être logique d'une ligne à l'autre. Si une ligne est indenté avec 3 espaces et la suivante avec 4 sans sous bloc (if statement: par exemple), c'est une erreur de syntaxe.
• Un langage basé sur l'indentation, ça peut paraître étrange, mais c'est logique, bien fait, bien géré par la plupart des IDE et on s'y fait très vite.
• Les commentaires commencent par des "#"
• Opérateurs : + - / // * += -= ++ -- Qu'est-ce que c'est ?
  • + : addition
  • - : soustraction
  • / : division avec nombres flottants
  • // : division sur int
  • * : multiplication
  • += : a += b revient a: a = a + b
  • -= : même chose mais avec une soustraction
  • ++ : ajoute 1
  • -- : soustrait 1
• Comparaisons : ==, !=, <, <=, >, >=, or (= || en C), and (= && en C), Qu'est-ce que c'est ?
• Définir une variable :

a = 5

• Définir une fonction :

def addition(a, b, print):
    result = a + b
    if print:
        print 'The result is:', str(result)
    return result

• Appeler une fonction :

addition(2, 3, true)

• "Si"

if a == '*':
  doeverything()
elif a == '-':
  donothing()
else:
  dosomething(a)

• While :

while i < len(a):
    print a[i]
    i += 3

• For :

words = ['cat', 'window', 'defenestrate']
for w in words:
    print w, len(w)

• Inclure un module :

import sys

• Utiliser une variable ou une fonction provenant d'un autre module :
  • Fichier hello.py

    def say(name):
        print 'Hello', name

  • Fichier main.py

    import hello
    hello.say('Alice');

• Il peut y avoir plusieurs fonctions portant le même noms mais dans des modules (fichiers) différents.
• Utiliser une fonction ou une variable provenant d'un autre module sans avoir à spécifier le nom du module (cette pratique est peu recommandé) :

from hello import say
say('Kim');

• Voir le module str pour les informations sur la syntaxe des strings
• En python, on utilise et manipule des listes et non des tableaux. Voir le module list pour plus d'informations
• Le type "tuple" existe également : Qu'est-ce que c'est ?
  
  

  C'est un regroupement de variables en une seule. Contrairement aux listes, un tuple a une taille fixe. On peut le comparer aux structures en C, mais sans nommage des éléments.

  user = ('cindy', 12)

  Les tuples ne sont pas modifiables, mais certains utilitaires marchent comme len, [ ].

  On peut déconstruire un tuple :

  (name, age) = cindy

Modules

Sys

• sys.arg contient le nom du script et les arguments passés en ligne de commande
• sys.exit est une fonction pour quitter qui prend en paramètre le code de retour du programme. Qu'est-ce que c'est ?
  
  

  Chaque programme retourne un nombre qui correspond à son statut. Le standard est 0 si tout s'est bien passé et > 0 s'il y a eu une erreur.

  On peut afficher le retour d'un programme dans un shell :

  $> echo $?
• sys.stdin, sys.stdout, ...
• Documentation complète : lien

Strings

• Les strings peuvent s'écrire avec des guillemets simples ou doubles, mais les simples sont plus communément utilisés. Il est possible d'utiliser des simples dans des doubles, et inversement. Sinon, on peut utiliser un \ pour en utiliser à l'intérieur des strings.
• Il est possible de faire des string sur plusieurs lignes en les mettant entre triple guillemets (""" ou ''')
• Accéder à un caractère d'une string :

name = 'john'
print name[1] # affiche 'o'

• Pour ne pas interpréter les '\' d'une string, utiliser :

rawstring = r'this\nthat\t'

• Le module string existe mais n'est pas recommandé, utiliser le module str
• Les strings ne sont pas modifiables une fois créees.
• len renvoie la taille de la string
• Concaténer : 'hello' + ' ' + 'world' donne hello world
• Répéter : 'hello ' * 3 donne hello hello hello
• La fonction str convertit une valeur d'un autre type en string
• print affiche sur la sortie standard suivi d'un retour à la ligne. Pour éviter celui-ci, finir l'appel par une virgule
• Une string peut être utilisé comme un objet avec des méthodes. Dans les exemples ci-dessous, on considère une string qui porte le nom s.
  • s.lower(), s.upper() - une version de la string en majuscule ou minuscule
  • s.strip() - supprime les espaces et tabulations inutiles en début et fin de la string
  • s.isalpha()/s.isdigit()/s.isspace()/... - divers tests
  • s.startswith('other'), s.endswith('other') - test si la string commence ou finit par
  • s.find('other') - cherche une string dans la string et retourne la position ou -1
  • s.replace('old', 'new') - remplace des mots par d'autres dans une string
  • s.split('delim') - sépare les mots entre le délimiteur et retourne une liste
  • s.split sans argument utilise les espaces et tabulations comme délimiteur
  • s.join(list) - l'inverse de split, concatène les string d'une liste en utilisant la string (s) comme délimiteur
• Il est possible de récupérer une portion d'une string en utilisant : s[debut:fin], sachant que l'un, l'autre ou les deux peuvent être omis, et les deux peuvent être négatif. s[:] va simplement renvoyer une copie.
• Il est possible de générer des strings similaires au printf en C :

presentation = "my name is %s and I'm %d years old" % ('Rachel', 18)

• Pour utiliser des caractères unicode :

u'todo'

• print ne fonctionne pas avec des strings unicode. Il faut donc les convertir :
  • s.ustring.encode('utf-8') pour encoder
  • unicode(s, 'utf-8') pour décoder

Listes

• Créer :

people = ['erika', 'manuel', 'josh']

• Récupérer des éléments :

you = people[1] # = 'manuel'

• Contrairement aux strings, les listes sont modifiées directement et non copiées.
• Concaténer :

family = ["mom", "dad"] + ["sister", "brother"]

• Assigner friends = people ne va pas créer une copie mais utiliser la même liste
• Pour chaque éléments :

friends = ["julia", "martin"]
num = 1
for friendname in friends
    print 'my friend number ', str(num), ' is ', friendname
    num += 1
print 'and I love them all'

• Vérifier qu'un élément est dans une liste :

if 'maria' in friends:
    print 'she\'s my friend'

Note : 'in' marche aussi sur les string et itère sur les caractères de celle-ci. - Utiliser des rangées de nombre pour, entre autre, itérer un certain nombre de fois :

for i in range(10)
    print str(i) # va afficher les nombres de 0 à 99

• Ajouter des éléments au fur et à mesure :

list = []
list.append('carl')
list.append('jim')

• Plus de fonctions de liste - click
  
  

  • list.append(elem) -- adds a single element to the end of the list. Common error: does not return the new list, just modifies the original.
  • list.insert(index, elem) -- inserts the element at the given index, shifting elements to the right.
  • list.extend(list2) adds the elements in list2 to the end of the list. Using + or += on a list is similar to using extend().
  • list.index(elem) -- searches for the given element from the start of the list and returns its index. Throws a ValueError if the element does not appear (use "in" to check without a ValueError).
  • list.remove(elem) -- searches for the first instance of the given element and removes it (throws ValueError if not present)
  • list.sort() -- sorts the list in place (does not return it). (The sorted() function shown below is preferred.)
  • list.reverse() -- reverses the list in place (does not return it)
  • list.pop(index) -- removes and returns the element at the given index. Returns the rightmost element if index is omitted (roughly the opposite of append()).

  
  
• La syntaxe list[debut:fin] vue pour les strings fonctionnent de la même façon pour les listes.
• sorted permet de trier une liste. Contrairement aux autres, elle ne modifie pas la liste et en créer une nouvelle. Cette fonction marche aussi sur d'autres éléments et a de nombreuses options pour trier efficacement. Plus d'informations : todo doc
• Comprehensions, il est possible de créer une liste à partir d'une liste et d'une formule avec la syntaxe [ expr for var in list ], exemple :

nums = [1, 2, 3, 4]
squares = [ n * n for n in nums ]   ## [1, 4, 9, 16]

D'autres modules

• list : manipuler des listes
• re: "regular expressions"
• os: Système d'exploitation, système de fichiers
• Documentation des modules standards : http://docs.python.org/library

Bonnes pratiques et Coding style

• Utiliser des noms de variable et de fonctions les plus explicites possibles. Comme le typage est faible, certains coding style demandent d'expliciter le type des variables dans leurs noms. À vous de voir !
• Le code est vérifié que lorsqu'il est exécuté.
  Dans l'exemple ci-dessous, si le cas où phonenumber vaut 1 n'est jamais testé, python ne préviendra jamais qu'il y a une faute de frappe dans l'appel à la fonction, et que la fonction appelé n'existe donc pas. Il est donc très important de se relire et de faire des tests pour tous les cas. Tester au fur et à mesure permet d'éviter des oublis.

if phonenumber == 1
    makeaphnecall('111')
else
    makeaphonecall(phonenumber)

• Commencer par la fonction main :

def main():
    print 'Hello', sys.argv[1]

if __name__ == '__main__':
    main()

• Utiliser des espaces pour l'indentation et pas des "tab".
• La documentation officielle recommande d'utiliser 4 espaces pour indenter. Google en conseille 2.
• Ne pas utiliser des noms de fonctions communément utilisés par les modules standards, comme "len", pour éviter les conflits.
• Documenter chaque fonction avec une "docstring".

def helloworld():
    """It will print the famous: Hello World"""
    print 'Hello World'

Les "docstring" peuvent aussi être récupérées directement depuis le code :

help(len) # donne la docstring de la fonction len
help(sys) # donne la docstring du module sys
dir(sys) # donne une liste des fonctions et variables du module sys

• Besoin d'aide ?
  • Chercher sur Google en utilisant le mot clé "python" pour trouver toutes les solutions.
  • Il existe aussi une doc officielle : docs.python.org
  • Et de nombreuses mailing lists : lien
  • StackOverflow est aussi une bonne ressource.
  • Coding Style par Google : lien

Objets

class MyClass(OtherClassToHeritFrom):
    """A simple example class"""
    i = 12345
    def __init__(self, str):
        self.str = str
    def f(self):
        return 'hello world'

example = MyClass('abc')

En attendant : lien