Python pour les gens qui veulent l'apprendre
# -*- coding: encodage -*- ? déclaration d'encodage du script

# commentaire

"""pseudo-commentaire
multi-lignes"""

#I - types de base :
#-------------------
entier = 1
flottant = 1.0
chaine = "python rocks"
liste = [4.5, "une liste", 0, 1, 2, 3]
dico = {"Vim":10, "Python":3, "Windows":"saynul"}
tuple = ("presque","comme","une","liste", 44, 1)


#II - controle et itération :
#---------------
# y a pas de “switch”

if True:
        print "Inexorable"
elif 3==4:
        print "Impossible"

else:
        print "Impossible (bis)"

while True:
        print "boucle infinie"

for i in objet_iterable:
        # en général, objet_iterable est une liste, une chaine

        # ou un tuple
        print i

##exemple : 
        for i in range (7):
                print i
        Vu que range (10) retourne cette liste : [0,1,2,3,4,5,6],
        ça fera comme un for classique de QBasic


#II - définir une fonction :
#---------------------------

def fonction (argument1, argument2, argument_optionnel="par défaut"):
        # faire des choses
        return "Un ou des trucs"

# équivalent lambda / def :
l = lambda arg: arg + 1
def l (arg): return arg + 1

#III - Fonctions utiles :

#-----------------------
range (n) ? [0,1,2,...,n-1]

## découper et recoller des chaines
liste = "a,b,c,d,e,f".split (",")
# liste == ["a", "b", "c", "d", "e", "f"]

chaine = "--".join (liste)
# chaine == "a--b--c--d--e--f"

## utiliser les index pour récupérer des éléments de liste/chaine/etc.
a = "abcdef"[0]   # "a"
a = "abcdef"[0:1] # "a" aussi

bc = "abcdef"[1:3] # compris ? ok
a = ["b","a","c"][1] # pour les listes c'est pareil
# note au passage : une liste et un tuple, c'est quasi pareil
# sauf que la liste, on peut utiliser append (), pop () et consorts

# alors que le tuple est constant, comme les chaines de caractères

# au passage aussi : addition de listes (ou de tuples)
[1,2] + [3,4] # == [1,2,3,4]

# Jesus' secret :
pains = "pain " * 3 # ? "pain pain pain "

pains = ["pain"] * 3 # ? ["pain","pain","pain"]
pains = ("pain",) * 3 # ? ("pain","pain","pain")

## passer chaque élément d'une liste à une fonction
liste = range (5) # ? [0,1,2,3,4]
augmenter = lambda n: n+1
liste_augmentee = map (augmenter, liste) # ? [1,2,3,4,5]

##pour le shell :
>>> dir (objet) # donne la liste des champs de l'objet

>>> help (objet) # affiche l'aide de l'objet au format man

#IV - I/O :
#---------
"""
a : append
r : read
w : write
"""

fichier = open ("/home/moi/mon_fichier.txt", "w")
fichier.write ("le_contenu")
fichier.close ()
fichier = open ("/home/moi/mon_fichier.txt", "r")
contenu = fichier.read ()
fichier.close ()
print contenu

#V - créer une classe :
#------------------------

class QuelquUn:
        def __init__ (self, nom, prenom, age=17):
                """
                Initialise la fiche.
                """
                self.nom = nom.upper()
                self.prenom = prenom.lower().capitalize()
                self.age = age
        def is_majeur (self):
                """

                Retourne True si la personne est majeure en France
                """
                return self.age >= 18
        def __str__ (self):
                """
                La méthode qui est appelée par la builtin str()

                """
                # exemple de chaîne de format inclus !
                format = "%s %s : %d ans"
                my_tuple = (self.prenom, self.nom, self.age)
                return format % my_tuple

# exemple d'utilisation d'une liste et d'une classe
personnages = []

personnages.append (QuelquUn("pouce","tom",30))
personnages.append (QuelquUn("nEIgE","blAncHe",10))


for perso in personnages:
        if perso.is_majeur:
                print str (perso)
                # note : le str est pas nécessaire ici
                # car print l'appelle tout seul

#VI - Opérateurs et leur surcharge :
#-----------------------------------
# calcul : les traditionnels +, *, /, -
(3*5+1)/4 # == 4

# attention aux divisions entières :
17/3 # == 5
17/3.0 # == 5.6666(...)7

# modulo :
17%3 # == 2

# logique : les traditionnels & | ^

# puissance :
5**2 # == 25

25**0.5 # == 5

##Surchargeons ?
class NombreDeEiku:
        def __init__ (self, valeur = 0):
                self.val = valeur
        def __repr__ (self):
                return str(self.val)
        def __str__ (self):
                return str(self.val)
        def __add__ (self, other):
                return NombreDeEiku(self.val + 1 + other)
        def __mul__ (self, other):
                return NombreDeEiku ((self.val-4) * other)
        # pour les autres, taper dir (1)

# test loufoque :
>>> a = NombreDeEiku (1)
>>> a
1
>>> a + 1
3
>>> a * 3 + 1
-8
# fin du test !