Archives par étiquette : Python

Algorithme au cycle 4 : Une passion naissante pour certain !

Maxence est un élève de troisième intéressé par Python. (Yes! Il y en a au moins  1!!!)

Ce week end il m’envoie un petit code et me demande ce que j’en pense :


from random import randint

w=input("Entrer le nom d'un premier joueur : ")
u=input("Entrer le nom d'un second joueur : ")

print("C'est au tour de", w, "de jouer, lancez 10 fois le dé :")

a = randint(1, 6)
if a==1:
 print(a, "point")
else:
 print(a, "points")
b = randint(1, 6)
if b==1:
 print(b, "point")
else:
 print(b, "points")
c = randint(1, 6)
if c==1:
 print(c, "point")
else:
 print(c, "points")
d = randint(1, 6)
if d==1:
 print(d, "point")
else:
 print(d, "points")
e = randint(1, 6)
if e==1:
 print(e, "point")
else:
 print(e, "points")
f = randint(1, 6)
if f==1:
 print(f, "point")
else:
 print(f, "points")
g = randint(1, 6)
if g==1:
 print(g, "point")
else:
 print(g, "points")
h = randint(1, 6)
if h==1:
 print(h, "point")
else:
 print(h, "points")
i = randint(1, 6)
if i==1:
 print(i, "point")
else:
 print(i, "points")
j = randint(1, 6)
if j==1:
 print(j, "point")
else:
 print(j, "points")
print(w,"a totalisé", a+b+c+d+e+f+g+h+i+j, "points")

print(" ")

print("C'est au tour de", u, "de jouer, lancez 10 fois le dé :")

k = randint(1, 6)
if k==1:
 print(k, "point")
else:
 print(k, "points")
l = randint(1, 6)
if l==1:
 print(l, "point")
else:
 print(l, "points")
m = randint(1, 6)
if m==1:
 print(m, "point")
else:
 print(m, "points")
n = randint(1, 6)
if n==1:
 print(n, "point")
else:
 print(n, "points")
o = randint(1, 6)
if o==1:
 print(o, "point")
else:
 print(o, "points")
p = randint(1, 6)
if p==1:
 print(p, "point")
else:
 print(p, "points")
q = randint(1, 6)
if q==1:
 print(q, "point")
else:
 print(q, "points")
r = randint(1, 6)
if r==1:
 print(r, "point")
else:
 print(r, "points")
s = randint(1, 6)
if s==1:
 print(s, "point")
else:
 print(s, "points")
t = randint(1, 6)
if t==1:
 print(t, "point")
else:
 print(t, "points")
print(u, "a totalisé", k+l+m+n+o+p+q+r+s+t, "points")

x=k+l+m+n+o+p+q+r+s+t
z=a+b+c+d+e+f+g+h+i+j

if z<x:
 print(u, "a totalisé plus de points que", w, "il a gagné !")
elif z==x:
 print(u, "et", w, "ont fait le même nombre de points !")
else:
 print(w, "a totalisé plus de points que", u, "!")


J’essaye donc son code :
jeu1
Pas mal du tout sachant que c’est un travail non demandé et seulement motivé par la curiosité

!

Voici ma contribution :


from random import randint

nombre_joueurs=int(input("Nombre de joueurs(s) :"))
nombre_lances=int(input("Nombre de lancé(s) :"))
gagnant=""
meilleur_score=0

for joueur in range(nombre_joueurs):
 print("Joueur ", joueur+1)
 print()
 score_joueur=0

 for lance in range(nombre_lances):
 jeu=randint(1,6)
 score_joueur+=jeu
 print("lancé ",lance+1,":",jeu)
 print("total :",score_joueur)
 if score_joueur>meilleur_score:
 meilleur_score=score_joueur
 gagnant="Joueur "+str(joueur+1)
 print("__________________")

print ("Le gagnant est ",gagnant," avec ",meilleur_score, "points")

#On ne gère pas les ex-aequo !





Plus court ;-)

jeu2wouf

 

Il faut pour comprendre cette version savoir à quoi correspond la ligne :

for joueur in range(nombre_joueurs):

Une idée ?

Lire aussi:

Un logiciel libre d’entrainement au poker !

J’ai le plaisir de vous annoncer la naissance de Poker-training, une application libre de droit et gratuite qui permet de s’entraîner au poker :

 

poker-taining

La page dédiée :

 

Lire aussi:

Apprendre à coder gratuitement !

Apprendre   Codecademy

 

 

Une jolie initiative pédagogique que voici ! Sur http://www.codecademy.com/fr/ vous pouvez gratuitement vous initier aux joies du HTML, JQuery, javascript, PHP, Python, Ruby !

C’est facile, ludique , en français et gratuit !

Que demander de plus ?

 

Lire aussi:

Citation 39 : Les bugs augmentent avec le nombre de développeurs. Laurent Ploix

Citation 39

Les bugs augmentent avec le nombre de développeurs.

écrivait Laurent Ploix. Cette citation et le design ci-dessus vous plaisent ?

  • Un Tshirt est disponible sur la boutique !
  • D’autres citations ? C’est là !
  • Une citation à proposer ? c’est là !

 

Lire aussi:

Poker : courbe en cloche et attitude face à la malchance

chimie

La courbe en cloche ou courbe de Gauss est l’une des courbes mathématiques les plus célèbres. On la voit apparaître dans un grand nombre de situations concrètes — en statistiques et en probabilités — et on lui fait souvent dire tout et n’importe quoi.(1)

Pour en savoir plus sur cette courbe, je vous conseille cette petite vidéo :

Tous les joueurs de Poker sont confrontés à la variance. Pour certain c’est une justification, un genre d’excuse pour s’autoriser à jouer mal. Pour d’autres c’est l’ennemi, qui les effrayent et les conduit au tilt. Faut-il en tenir compte ou faut-il l’ignorer ?

Une vérité mathématique : c’est à long terme que la fréquence s’approche de la probabilité.

J’ai simulé sous Python le lancée d’une pièce 100 millions de fois :

import random

s=0
for i in range(1,100000001):
    r=random.randint(0,1)
    s=s+r
    if (i%10000000==0):
        print ("lancees :",i,"piles :",s,"frequence :",s/i)

Le résultat est classique :

>>> ================================ RESTART ================================
>>> 
lancees : 10000000 piles : 4998747 frequence : 0.4998747
lancees : 20000000 piles : 10001071 frequence : 0.50005355
lancees : 30000000 piles : 15000402 frequence : 0.5000134
lancees : 40000000 piles : 20001787 frequence : 0.500044675
lancees : 50000000 piles : 24998410 frequence : 0.4999682
lancees : 60000000 piles : 29996608 frequence : 0.49994346666666667
lancees : 70000000 piles : 34999458 frequence : 0.49999225714285717
lancees : 80000000 piles : 39997336 frequence : 0.4999667
lancees : 90000000 piles : 44998925 frequence : 0.49998805555555553
lancees : 100000000 piles : 50001889 frequence : 0.50001889

La fréquence de pile s’approche de la fréquence théorique de 0,5, qui est appelée probabilité de l’événement « La pièce tombe sur pile »

Mais abandonnons la pièce et revenons aux OESD , couleurs et autres Gutshot…

Un OESD est un tirage quinte bilatéral. Avant de fréquenter les sites de poker sur la toile (3) je disais « tirage par les deux bouts »…

Par exemple vous avez  JT  (Valet , dix) et le flop (arc-en-ciel) montre Q,2,9 (Dame, deux, neuf ). Les quatre 8 et les quatre  rois vous donnent  la quinte et probablement la meilleur main.

Les Reg vous diront que vous avez une côte de 5 contre 1 environ, c ‘est à dire que la probabilité de toucher un out est environ 16%. Vous aurez donc intérêt à suivre une mise si elle peut vous faire gagner plus de 5 fois son montant. (côte du pot supérieur à 5:1).

Prenons un cas limite en guise d’exemple :

Le pot fait 85€. Votre adversaire mise 15 euros, vous offrant une bonne  côte pour suivre de 100:15 soit 6,67:1.

Normalement sur 6 parties de ce type vous allez investir 6 fois 15 = 90 Euros

Vous allez perdre 5 fois mais gagner 1 fois 100€.

Sur 6 parties le gain théorique est de 10€ ( Soit 1,67€ par partie, qui est aussi la différence entre côte du pot de 6,67:1 et côte de 5:1)

Là aussi une simulation sur Python est très enrichissante :

import random

bankroll=1000
for i in range(1,10001):
    r=random.randint(1,6)
    bankroll=bankroll-15
    if (r==6):
        bankroll=bankroll+100
        print (i,(bankroll-1000)/i,bankroll)

Notre joueur dispose d’une bankroll de 1000€, et répète l’expérience suivante :

5 fois sur 6 il perd 15€ et une fois sur 6 il gagne 100€.

A chaque fois qu’il gagne on affiche successivement le rang de l’expérience, le gain par partie, et la bankroll du joueur.

Quelques extraits du log des résultats :

Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> ================================ RESTART ================================
>>> 
33 -11.969696969696969 605
56 -11.428571428571429 360
57 -9.736842105263158 445
62 -8.548387096774194 470
73 -8.150684931506849 405
79 -7.405063291139241 415
89 -7.134831460674158 365
94 -6.48936170212766 390
99 -5.909090909090909 415
104 -5.384615384615385 440
113 -5.265486725663717 405
127 -5.551181102362205 295
129 -4.922480620155039 365
133 -4.473684210526316 405
137 -4.0510948905109485 445

Ainsi à la 137 ème main, notre bankroll a fondu de moitié, nous perdons environs 4€ par main…

Bad Run, tilt et dépression ? 

J’étais un peu dans cette situation quand je me suis décidé à rédiger cet article. Pourquoi,  ?

Simplement car je commençais à coucher mes tirages à bonne côte avec la certitude imbécile que… décidément ça ne rentrait plus !

Mon conseil après relaxation  et réflexion.

Continuer à jouer son A-game avec optimisme et un soupçon de fatalisme. Le véritable soucis est en amont, c’est la gestion de votre bankroll. Ce sera l’objet d’un futur billet.

Pour terminer un autre extrait du log des résultats :

9973 0.6322069587887296 7305
9981 0.6296964232040878 7285
9983 0.6365821897225283 7355
9995 0.6278139069534767 7275
9997 0.6346904071221366 7345

Après environ 1000 parties, le gain par expérience est encore bien loin du gain théorique mais, la bankroll a été multiplié par 7.

J’ai un peu modifié le programme pour afficher le résultats après 10 millions d’expérience :

Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> ================================ RESTART ================================
>>> 
10000000 1.67556 16756600
>>>

Nous l’avons notre gain théorique !

Conclusion :

Soyons zen !

Lire aussi:

Initiation à Python : procédures et premières boucles

Wikipedia dixit :

Python est apprécié par les pédagogues qui y trouvent un langage où la syntaxe, clairement séparée des mécanismes de bas niveau, permet une initiation plus aisée aux concepts de base de la programmation.

Dans le cadre d’une structure « soutien-excellence » j’ai la chance d’animer pour des élèves de troisième, un module d’initiation à la programmation d’algorithmes numériques.

Oh ! nous y allons doucement, et si nous nous sommes surtout amusé la première fois avec l’IDLE,  l’environnement intégré à Python, nous avons aujourd’hui pénétré un peu dans la magie de la programmation.

def table(x):
    "la table de x"
    i=0
    while (i<10):
        i=i+1
        print i,"*",x,"=",x*i

def tables(x):
    "les x premières tables"
    i=0
    while (i<x):
        i=i+1
        table(i)
        print 30*"_"

Pas grand chose en effet dans ce petit bout de code :
Deux procédures définies par le mot clef « def ». Elles contiennent chacune une boucle « while » (tant que…)
(Ne me reprochez pas de ne pas utiliser « for », je m’adresse à des débutants)

Une procédure est une partie de programme indépendante des autres procédures.
La première procédure appelé « table » attend une valeur entière: La première ligne entre guillemets est une documentation de la procédure. Une fois le programme chargé et exécuté (Run Module F5), si l’on tape dans l’iIDLE « table(« …

im1

Python a la gentillesse de nous dire ce qu’il attend !

  • Que fait cette procédure ?

Elle crée une boite une variable i dans laquelle elle range qu’elle initialise avec la valeur 0. (i=0)

Et tant que la variable i est inférieure à 10 :

  1. Elle remplace le contenu de la boite la variable i par i+1.
  2. Elle affiche successivement i, le signe multiplié, le nombre de départ x, le signe « égal » est le produit de x par i.

On sortira donc du « tant que » quand i sera égal à 11 pour n’afficher que les tables de 1 à 10 :

im2

La deuxième procédure tables(x), elle affichera les tables de 1 à x :

im3

im4

Vous en savez assez pour étudier vous-même son fonctionnement !

  • Remarque

J’aurais aimé (mais ce ne fût pas le cas) devoir répondre à une question concernant la boite variable i présente dans les deux procédures, avec des valeurs différentes… et embrayer sur le caractère local des variables : les deux variables i sont différentes, chaque procédure à la sienne…

Lire aussi:

Combinaisons, coefficients binomiaux et triangle de Pascal

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
1 12 66 220 495 792 924 792 495 220 66 12 1

Les nombres ci-dessus, disposés géométriquement en triangle vous rappellent probablement quelques choses…

Ils s’agit des coefficients binomiaux que l’on obtient en développement des expressions du genre (a+b)2=1a2+2ab+1b2

Dans cet disposition géométrique chacun des nombres s’obtient en ajoutant le nombre du dessus et son voisin de gauche.

Ces nombres nous les avons déjà évoqués ici, il s’agit des C(n,p) qui servent à dénombrer le nombres de parties à p éléments d’un ensemble à n éléments.

(Par exemple on a vu dans ce billet que C(52,5)=2 598 960 nous donne le nombres de mains au poker)

cnp

On démontre aisément que C(n,p) = C (n-1,p-1) + C (n-1, p), et on peut utiliser cette formule pour se créer une fonction en Python pour calculer de façon récursive les C(n,p)

def cnp2 (n,p):
if p==0 or n==p:
return 1
exit
return cnp2(n-1,p-1)+cnp2(n-1,p)

Pour aller plus loin :
http://fr.wikipedia.org/wiki/Coefficient_binomial

Popularisons les mathématiques dans les réseaux sociaux :

Lire aussi:

Python, généalogie et SOSA

Je ne suis pas passionné de généalogie, mais je m’intéresse à la façon de numéroter ses ancêtres (Le côté mathématique de la chose).

Ainsi à la trentième génération vous avez plus de cinq cents millions d’aïeuls !

Les généalogistes utilisent pour leur associer un code différents à chacun, la méthode SOSA :

La personne dont on dresse l’ascendance porte le numéro 1.
Son père porte le numéro 2 et sa mère le numéro 3.
Ainsi on associe toujours au père le double du code de l’enfant, et à la mère le code du père augmenté de 1.

Diagramme1

Ainsi à part la première personne qui peut-être un homme ou une femme, chaque individu de code pair est un homme et chaque individu de code impair est une femme.

Le problème c’est qu’un nombre est peu parlant. Qui est l’ancêtre numéro 54 ?

J’ai développé une petite application en Python qui nous en dit plus :

sosa

Cette application vous permet de trouver également le code SOSA du père de la mère du grand-père d’un individu :

sosa2

Ce programme vous intéresse ? Voici le code :


# -*- coding: UTF-8 -*-
digit=('m','p','M','P')
nombre="0123456789"

def retourne (chaine):
 "retourne une chaine de caractère"
 envers=""
 for i in chaine:
 envers =i + envers
 return envers

def sosa(chaine):
 "Donne le sosa, d'une chaine (exemple PMP)"
 valeur=1
 generation=0
 for lettre in retourne(chaine):
 if lettre in ('p','P'):
 valeur=valeur*2
 generation +=1
 elif lettre in ('m','M'):
 generation +=1
 valeur=valeur*2+1
 return valeur, generation

def chaine(sosa):
 "Donne le chaine correspondant au code sosa"
 chaine=""
 generation=0
 while sosa<>1:
 if sosa%2 ==0 :
 chaine += "P"
 generation += 1
 else :
 chaine +=  "M"
 generation +=1
 sosa=sosa/2
 if chaine<>"":
 if chaine[0] in ('p','P'):
 francais=u" Le père "

 elif chaine[0] in ('m','M'):
 francais=u" La mère "

 for i in chaine[1:]:
 if i in ('p','P') : francais = francais + u"du père "
 elif i in ("m",'M') : francais = francais + u"de la mère "
 francais += u"de l'individu"
 else:
 francais=u"L'individu lui même"

 return francais, chaine, generation

a=""
while a<>"q" :
 print u" Entrez au clavier un code SOSA"
 print u" une chaîne de caractère de la forme PPM,"
 print u" pour le père du père de la mère par exemple... )"
 print u"(Q pour quitter)"
 a= raw_input("------------------------> ")
 if a not in ("q","Q",""):
 est_nombre=True
 est_digit=True
 for i in a:
 if i not in digit : est_digit=False
 if i not in nombre :est_nombre=False
 if est_digit :
 x,y=sosa(a)
 print "Code SOSA : " ,x
 print 20*"_"
 print u"Génération : ",y
 print 50*"_"
 if est_nombre and long(a)>0:
 x,y,z= chaine(long(a))
 print u"Décodage SOSA : "
 print x," (",y,")"
 print 20*"_"
 print
 print u"Génération :",z
 print 50*"_"
 print 3*"\n"

Lire aussi:

Python, exemple d’utilisation de yield

Les statistiques de fréquentation d’un blog peuvent être surprenantes. Ainsi vous êtes nombreux à arriver ici en faisant une recherche sur la fonction yield de Python.

Pour la comprendre, il faut d’abord savoir ce qu’est un générateur. Pour simplifier un générateur est une fonction qui retourne successivement plusieurs valeurs. Non pas en utilisant le mot réservé RETURN, mais en utilisant YIELD.

L’ambiguïté qu’il faut signaler est que dans le langage courant, on confond souvent la fonction et l’objet généré.

Dans l’exemple suivant, la fonction CouleurIterateur (), qui émule un feu tricolore, renvoie à chaque fois que l’on rencontre YIELD, successivement :
Vert, Orange et Rouge

# Exemple d’utilisation de yield

# Wouf 2008

def CouleurIterateur ():

    while 1: #Une boucle infinie

        for i in (‘Vert’,‘Orange’,‘Rouge’):

            yield i

            # A chaque instruction yield

            # rencontrée l’execution

            # s’arrête, la fonction

            # renvoie i.

            # L’execution reprendra

            # Au prochain next()

couleur=CouleurIterateur()

for i in range(10) :

    print couleur.next()

    

    

Dans le corps du programme l’instruction couleur=CouleurIterateur() crée un objet itérateur qui bénéficie, et c’est là l’intérêt de YIELD de la popriété next():

La première fois que le programme rencontre couleur.next(), il va exécuter la fonction CouleurIterateur () jusqu’à rencontrer YIELD, il va à ce moment là geler l’exécution de la fonction et retourner la valeur de i (Soit : Vert)

La seconde fois, et les fois suivante où le programme rencontrera couleur.next() (Il y a dix itérations dans cet exemple) , c’est pareil, il exécutera le code jusqu’à YIELD, gèlera l’exécution, et renverra la valeur de i.

yield

Lire aussi:

Python, inverser une chaîne de caractères

free music

Lire en musique ?


La qualité numéro 1 du langage de programmation Python est son accessibilité, même pour les débutants.
Le code est lisible, compréhensible rapidement. Python est LE langage par excellence pour apprendre à programmer.

Si vous ne l’avez pas encore installer sur votre système, je vous engage fortement à le faire à partir du site officiel.

L’exemple de script que nous allons étudier aujourd’hui est basé sur une fonction crée par l’utilisateur, qui inverse une chaîne de caractère. Elle renverra par exemple TOM si on lui envoie MOT.

def envers (mot):

    « inverse une chaine de caractères »

    resultat=«  »                 # La chaine résultat est vide

    for lettre in mot:          # Pour chaque lettre de la chaine

     resultat=lettre+resultat   # On l’insère en première position

    return resultat             # Et on retourne la chaine

    

# Pour tester dans L’IDLE

a=raw_input(« chaine : « )

print envers(a)

Le code ci-dessus est écrit en utilisant plusieurs couleurs :

Le rouge sert à afficher les commentaires, ceux-ci sont précédés du caractère #. Les commentaires ne sont pas des instructions exécutées par Python, mais sont destinés à la compréhension du code (Pour permettre de se replonger dans ses anciens scripts, sans risquer de maux de tête, par exemple)

En orange : les mots réservés du langage Python
ici nous avons def, for, in et return

En violet : les fonctions prédéfinies (non créées par l’utilisateur )
seule la fonction raw-input() est utilisée dans ce script.

En bleu : Les fonctions crées par l’utilisateur
Ici une seule fonction : envers()

En vert : Les chaînes de caractères.
On en dénombre 3, dans des contextes très différents.

Une remarque importante, les espaces dans le code ont une importance capitale (On parle d’indentation du code), ainsi le bloc de code qui constitue le corps de la fonction envers est décalé de deux espaces vers la droite. Ainsi Python reconnaît la fin des instructions de cette fonction à l’arrêt de cette indentation.

Le mot clef def sert à définir notre propre fonction, il est suivi du nom de cette fonction (Ne pas utiliser de mots réservés ou de nom de fonctions prédéfinies!) puis de parenthèses enserrant une « variable » est du caractère « : »

def envers (mot):

On peut voir une fonction comme une usine, elle reçoit une matière première (ici une chaîne de caractère), effectue un travail (dans le bloc indenté) et livre (avec le mot clef
return) un produit fini (ici, une autre chaîne de caractère)

« inverse une chaîne de caractères »

Cette ligne est étrange, c’est une chaîne de caractères, seule, sans mot clefs qui demanderait à Python de faire quelque chose, sans affectation (On y reviendra). Elle semble ne servir à rien… Et pourtant son rôle est très pratique !
Si cette fonction est chargée en mémoire, en tapant envers ( avec une parenthèse ouvrante, cette phrase apparaît dans une bulle d’aide :

bulle

resultat=«  »
On définit au départ la variable resultat comme une chaîne vide. A noter pour les vrais débutants en développement, le sens particulier du signe égal. Ce caractère est le symbole de l’affectation. On range la chaîne vide «  » dans une « boite » qu’on a appelé resultat. Le contenue de cette boite changera au cours du script, cette boite est une variable.

for lettre in mot:

littéralement :
Pour lettre dans mot

mot est la matière première livrée à la fonction envers, une chaîne de caractères. Une chaîne de caractères étant constituée de lettres, l’expression for lettre in mot signifie que l’on va successivement affecter à la variable lettre les lettres contenues dans la chaîne mot (celle envoyée à la fonction).

Les deux points qui suivent, ainsi que l’indentation du code indique à Python que ce bloc indenté devra être exécuter pour chacune de ces lettres.

resultat=lettre+resultat

On reconnaît à nouveau ce signe égal d’affectation.
On va placer dans le membre de gauche (la variable resultat) l’évaluation de l’expression lettre + resultat. Je comprends l’étonnement de certain !
lettre est un caractère et resultat une chaîne ! Que signifie donc le signe + ?
Python comprend simplement +, pour des chaîne de caractère comme un ordre de concaténation :

« abc »+ »def »= »abcdef »

Un exemple de ce qui se passe dans ce programme:
Supposons qu’on ait envoyé à la fonction envers, la chaîne « CHAT »

resultat est d’abord vide (resultat= » »)
puis la boucle FOR IN parcourt les lettres de CHAT
1. resultat= »C »+ » » soit « C »
2. resultat = »H »+ »C » soit « HC »
3. resultat = »A » + »HC » soit « AHC »
4. resultat = »T » + »AHC » soit « TAHC »

la variable resultat contient donc une fois toutes les itérations de la boucles terminées, la chaîne de départ inversée.

Et l’usine envers() peut donc livrer son produit fini:

return resultat

La dernière partie du script, sert à tester la fonction:

a=raw_input(« chaine : « )

raw_input() est une fonction prédéfinie, son utilisation est aisée.
On range dans la variable a, la chaîne de caractères saisie au clavier par l’utilisateur.
Notez entre parenthèses une phrase d’invite pour lui indiquer ce qu’il doit faire.

print envers(a)

Le mot réservé print

affiche à l'écran envers(a), le produit de la fonction envers quand on lui envoie la variable a.

On peut donc tester notre fonction:

testons

Elle fonctionne, c'est déjà ça !!!

Tags Python abordés dans cet article

def
for
in
return
print
raw_input

Apprendre à programmer avec Python
Apprendre à programmer avec Python

Lire aussi: