1- Définissez une fonction max() qui prend deux nombres comme arguments et renvoie le plus grand

d'entre eux. (Il est vrai que python a une fonction max() intégrée, mais le faire nous-mêmes est un
très bon exercice.

2- Définir une fonction max_de_tres(), qui prend trois nombres en arguments et renvoie le plus grand
d'entre eux.

3- Définir une fonction qui calcule la longueur d'une liste ou d'une chaîne donnée. (Il est vrai que
Python intègre la fonction len(), mais l’écrire nous-mêmes est un très bon exercice.

4- Écrivez une fonction qui prend un caractère et renvoie True si c'est une voyelle, sinon elle renvoie
False.

5- Écrire une fonction sum() et une fonction multip() qui additionnent et multiplient respectivement
tous les nombres d'une liste. Par exemple : sum([1,2,3,4]) doit renvoyer 10 et multip([1,2,3,4]) doit
renvoyer 24.

6- Définir une fonction inverse() qui calcule l'inversion d'une chaîne. Par exemple, la chaîne "Je teste"
doit renvoyer la chaîne "odnaborp yotse"

7 - Définir une fonction es_palindromo() qui reconnaît les palindromes (c'est-à-dire les mots qui se
ressemblent écrits à l'envers), exemple : es_palindromo ("radar") devrait retourner True.

8- Définissez une fonction superposition() qui prend deux listes et renvoie True si elles ont au moins 1
membre en commun ou renvoie False sinon. Écrivez la fonction en utilisant la boucle for imbriquée.

9- Définissez une fonction generate_n_characters() qui prend un entier n et renvoie le caractère

multiplié par n. Par exemple : generate_n_chars(5, "x") doit renvoyer "xxxxx".

10- Définissez une procédure histogram() qui prend une liste d'entiers et imprime un histogramme à
l'écran. Exemple : procédure([4, 9, 7]) doit afficher ce qui suit :
Exercice 1

#! /usr/bin/env python
# -*- codage : utf-8 -*-

déf max (n1, n2) :

si n1 < n2 :
imprimer n2
elif n2 < n1 :
imprimer n1
autre :
imprimer "Ce sont les mêmes"

Je précise que j'utilise print pour appeler la fonction de la manière max(8, 5) .

Vous pouvez également utiliser le retour.

Exercice 2

#! /usr/bin/env python
# -*- codage : utf-8 -*-
def max_of_trois (n1, n2, n3) :
si n1 > n2 et n1 > n3 :
imprimer n1
elif n2 > n1 et n2 > n3 :
imprimer n2
elif n3 > n1 et n3 > n2 :
imprimer n3
autre :
imprimer "Ce sont les mêmes"

Encore une fois, j'utilise print au lieu de return. Selon nos besoins, l'un ou l'autre est utilisé. Dans ce cas, je
souhaite uniquement afficher à l'écran quel est le plus grand des 3 nombres.

Exercice 3

#! /usr/bin/env python
# -*- codage : utf-8 -*-

def string_length (liste) :

suite = 0
pour moi dans la liste :
suite += 1
retour suite

Dans cet exercice, j'utilise return au lieu d'imprimer. Pour voir le résultat, il faudrait appeler la fonction comme
ceci : print string_length ([1,2,3,4]) ou
print string_length("bonjour")

Exercice 4

#! /usr/bin/env python
# -*- codage : utf-8 -*-

def is_voyelle (x):

si x == "a" ou x == "e" ou x == "i" ou x == "o" ou x == "u" :
retourner vrai
elif x == "A" ou x == "E" ou x == "I" ou x == "O" ou x == "U" :
retourner vrai
autre:
retourner Faux

Exercice 5

#! /usr/bin/env python
# -*- codage : utf-8 -*-

somme déf (liste):

somme = 0
pour moi dans la liste :
somme += je
somme de retour

def multip (liste):

multiplication = 1
pour moi dans la liste :
multiplication *= je
retourner la multiplication

Exercice 6

#! /usr/bin/env python
# -*- codage : utf-8 -*-

définition inverse (chaîne):

inversé = ""
cont = len (chaîne)
indice = -1
tandis que cont >= 1 :
inversé += chaîne[index]
indice = indice + (- 1 )
suite -= 1
retour inversé

Eh bien, j'avoue que j'ai réfléchi beaucoup pour résoudre le mot inversé. Peut-être avez-vous une solution plus
simple pour ceux qui débutent. Quoi qu'il en soit, laissez un commentaire et je vous expliquerai comment ça
marche.

Exercice 7

#! /usr/bin/env python
# -*- codage : utf-8 -*-

définition inverse (chaîne):

inversé = ""
cont = len (chaîne)
indice = -1
tandis que cont >= 1 :
inversé += chaîne[index]
indice = indice + (- 1 )
suite -= 1
retour inversé

def is_palindrome (chaîne) :

reverse_word = inverse (chaîne)
indice = 0
suite = 0
pour i dans la plage ( len (chaîne)):
si mot_inverti[index] == chaîne[index] :
indice += 1
suite += 1
autre :
imprimer "Ce n'est pas un palindrome"
casser

if cont == len (string): #If counter = le nombre de lettres dans la chaîne

print "C'est un palindrome" # c'est parce qu'il a parcouru toute la boucle for et tous les
# lettres sont identiques

Comme je l'ai dit dans l'exercice précédent, j'y ai pensé de cette façon, mais il doit y avoir des moyens plus simples
de le résoudre. J'utilise les connaissances que j'ai à ce jour sur Python.
Ce que je fais dans cet exercice, c'est utiliser la fonction de l'exercice précédent (mot inversé) pour la comparer
avec la chaîne que nous voulons.

Exercice 8

#! /usr/bin/env python
# -*- codage : utf-8 -*-

superposition def (list1, list2):

pour moi dans la liste1 :
pour x dans la liste2 :
si je == x :
retourner vrai
retourner Faux

Dans cette fonction, nous comparons deux listes .

Exercice 9

#! /usr/bin/env python
# -*- codage : utf-8 -*-

def generate_n_chars (n, caractère) :

imprimer n * caractère

Exercice 10

#! /usr/bin/env python
# -*- codage : utf-8 -*-

procédure def (liste):

pour moi dans la liste :
imprimer i * "x"

Ce serait bien si vous laissiez vos solutions à comparer ici, ou dans l'entrée où les exercices sont proposés.

Partie 2
Exercice 1
La fonction max() de l'exercice 1 (première partie) et la fonction max_of_trois() de l'exercice 2 (première partie) ne
fonctionneront que pour 2 ou 3 nombres. Supposons que nous ayons plus de 3 nombres ou que nous ne sachions
pas combien il y a de nombres. Écrivez une fonction max_in_list() qui prend une liste de nombres et renvoie le plus
grand.

Exercice 2
Écrivez une fonction longer_function() qui prend une liste de mots et renvoie le plus long.

Exercice 3
Écrivez une fonction filter_words() qui prend une liste de mots et un entier n, et renvoie des mots comportant plus
de n caractères.

Exercice 4
Écrivez un programme qui demande à l'utilisateur de saisir une chaîne. Le programme doit évaluer la chaîne et
indiquer combien de lettres majuscules elle contient.

Exercice 5
Créez un petit programme qui convertit les nombres binaires en nombres entiers.

Exercice 6
Écrivez un petit programme où :
- L'année en cours est saisie.
- Le nom et l'année de naissance de trois personnes sont inscrits.
- On calcule leur âge au cours de l'année en cours.
- Imprime à l'écran.

Exercice 7
Définissez un tuple avec 10 âges de personnes. Imprimez le nombre de personnes âgées de plus de 20 ans.
Vous pouvez varier l'exercice pour que ce soit l'utilisateur qui rentre les âges.

Exercice 8
Définissez une liste avec un ensemble de noms, imprimez le nombre de noms commençant par la lettre a.
Vous pouvez également demander à l'utilisateur de choisir la lettre à rechercher. (Un peu plus excitant)

Exercice 9
Créez une fonction count_vowels(), qui reçoit un mot et compte combien de lettres "a" il possède, combien de
lettres "e" il possède et ainsi de suite jusqu'à ce que toutes les voyelles soient complétées.
Vous pouvez demander à l'utilisateur de choisir le mot.

Exercice 10
Écrivez une fonction is_leap() qui détermine si une année donnée est une année bissextile. Une année bissextile
est divisible par 4, mais pas par 100. Il est également divisible par 400
Exercice 1

Je n'ai pas bien clarifié l'exercice, il se peut donc qu'ils le résolvent de cette façon :

#! /usr/bin/env python
# -*- codage : utf-8 -*-

def max_in_list (liste) :

return max (list) #La fonction max() est déjà intégrée à python

Mais l’idée est de résoudre la fonction par nous-mêmes pour savoir comment elle fonctionne. Voici la
solution :

#! /usr/bin/env python
# -*- codage : utf-8 -*-
def max_in_list (liste) :
début = 0
pour moi dans la liste :
si je > démarre :
début = je
rentrer à la maison

Exercice 2

#! /usr/bin/env python
# -*- codage : utf-8 -*-
def longest_ (liste) :
le plus long_= ""
pour moi dans la liste :
si len (i) > len (le plus long) :
le plus long_=je
revenir le plus longtemps

Exercice 3
#! /usr/bin/env python
# - * - Encodage : utf-8 - *
def filter_words (liste, n) :
pour moi dans la liste :
si len (i) > n :
imprimer je

Exercice 4

#! /usr/bin/env python
# - * - Encodage : utf-8 - *

def c_uppercase (chaîne) :

suite = 0
pour moi dans la chaîne :
si je != je. lower() : #Rappelez-vous que lower() convertit une chaîne en minuscules
suite += 1
print "La chaîne a" , suite, "lettre(s) majuscule(s)"

Exercice 5

#! /usr/bin/env python
# -*- codage : utf-8 -*-
def aDecimal (binnum):
numérobin = str (numérobin)
décimal = 0
exp = len (binnum) - 1
pour moi dans binNumber :
décimal += ( int (i) * 2 **(exp))
exp = exp - 1
retour décimal

Exercice 6

#! /usr/bin/env python
# -*- codage : utf-8 -*-
def principal ():
a_course = input ( "Entrez l'année en cours : " )
pour i dans la plage ( 3 ):
name = raw_input ( "Nom de la personne : " )
naissance = entrée ( "Année de naissance : ")
imprimer le nom, "anniversaire" , (a_course - naissance), "années dans" , a_course

Exercice 7

#! /usr/bin/env python
# -*- codage : utf-8 -*-
def majorité20 (tup) :
suite = 0
pour moi en tup :
si je > 20 :
suite += 1
print "Il y a" , suite, "des nombres supérieurs à 20"

Exercice 8

#! /usr/bin/env python
# -*- codage : utf-8 -*-
def principal ():
x = input ( "Combien de noms souhaitez-vous saisir ?: " )
liste = []
pour je dans la plage (x):
a = raw_input ( "Entrez le nom : " )
liste. ajouter (a)

imprimer ""
start = raw_input ( "Par quelle lettre commence le nom ? : " )
suite = 0
pour moi dans la liste :
si je[ 0 ] == démarrer. lower () ou i[ 0 ] == start. supérieur ():
suite += 1
retour suite
Comme vous pouvez le voir, je fais l'exercice en interagissant avec l'utilisateur. Dites également que j'utilise
la fonction append() qui est utilisée pour ajouter des éléments à une liste, j'utilise la fonction lower() pour
convertir les chaînes en minuscules et j'utilise la fonction upper() pour convertir des caractères ou des chaînes
en majuscules.

Exercice 9

#! /usr/bin/env python
# -*- codage : utf-8 -*-
def count_voyels (chaîne):
chaîne = chaîne. inférieur()
voyelles = "aeiou"

pour x dans les voyelles :

compteur = 0
pour moi dans la chaîne :
si je == x :
compteur += 1
print "Il y a %d %s." %(compteur,x)

Exercice 10

#! /usr/bin/env python
# -*- codage : utf-8 -*-
def is_leap ():
imprimer "Vérifier les années bissextiles"
a = input ( "Écrivez une année et je vous dirai si c'est une année bissextile : " )
si un % 4 == 0 et (pas( un % 100 == 0 )) :
print "L'année" , a , "est une année bissextile car elle est un multiple de 4"
elif a % 400 == 0 :
print "L'année" , a , "est une année bissextile car elle est un multiple de 400"
autre:
imprimer "L'année" , a , "n'est pas une année bissextile"
J'espère que ces solutions vous guideront si vous êtes bloqué dans un exercice.
J'attends vos commentaires pour pouvoir comparer les solutions ou pour tout type de doute. Salutations

partie 3

Bonjour, aujourd'hui je vais laisser quelques exercices supplémentaires pour python et ainsi nous
divertir un moment pendant le week-end.

Exercice 1
Concevoir un système de points pour le jeu Dragon Kingdom :
Je laisse le lien au cas où quelqu'un ne l'aurait pas vu.
L’idée est la suivante : tant que le joueur gagne, il accumule des points.
Exemple : Si le joueur entre dans la première grotte et gagne le trésor, il est crédité de 100 points, s'il
entre dans la deuxième grotte et gagne le trésor, il est crédité de 100 points supplémentaires. Si le joueur
perd, le total des points marqués et la possibilité de recommencer apparaîtront à l'écran.

Exercice 2
Écrivez un programme qui vous permet de jouer à une version simplifiée du jeu Master Mind . Le jeu
consistera à deviner une chaîne de nombres différents. Dans un premier temps, le programme doit
demander la longueur de la chaîne (2 à 9 chiffres). Ensuite, le programme devrait vous demander
d'essayer de deviner la chaîne de nombres. A chaque tentative, le programme signalera combien de
nombres ont été devinés (le programme considérera qu'un nombre a été deviné correctement si la valeur
et la position correspondent).

Dis-moi la longueur de la chaîne : 4

Essayez de deviner la chaîne : 1234
Avec 1234 vous avez deviné 1 valeurs. Essayez de deviner la chaîne : 1243
Avec 1243, vous avez deviné 0 valeur. Essayez de deviner la chaîne : 1432
Avec 1432 vous avez deviné 2 valeurs. Essayez de deviner la chaîne : 2431
Avec 2431 vous avez deviné 4 valeurs. Toutes nos félicitations

Exercice 3
Écrivez un programme qui demande deux mots et indique s'ils riment ou non. Si les trois dernières
lettres correspondent, cela veut dire qu’elles riment. Si seulement les deux derniers correspondent, il
faut dire qu'ils riment un peu et sinon, qu'ils ne riment pas.

Exercice 4
Créez un programme qui demande à l'utilisateur un montant en dollars, un taux d'intérêt et un nombre
d'années. Il indique à l'écran combien le capital initial aura été converti après ces années si le taux
d'intérêt saisi est appliqué chaque année.
N'oubliez pas qu'un capital C en dollars à un taux d'intérêt de x pour cent pendant n années devient C *
(1 + x/100) élevé à an (années). Testez le programme en sachant qu'un montant de 10 000 dollars à 4,5%
d'intérêt annuel devient 24 117,14 dollars après 20 ans.

Dès que j'aurai les solutions, je publierai l'entrée et mettrai à jour celle-ci avec le lien vers celles-ci.

Exercice 1

J'ai vraiment aimé la façon dont Ramón a donné le système de points pour le jeu Dragon Kingdom.

#Royaume des Dragons....

importer au hasard
heure d'importation

introduction def ():

print ( "Nous sommes dans un pays plein de dragons. Devant nous," )
print ( "vous pouvez voir deux grottes. Dans une grotte, le dragon est sympathique" )
print ( "et partagera le trésor avec vous. L'autre dragon "
print ( "il est gourmand et affamé, et il te mangera dès qu'il te verra." )
imprimer ( "" )

par défaut ChangeCave ():

grotte = ""
while cave != "1" et cave != "2" :
imprimer "Dans quelle grotte veux-tu entrer ? 1 ou 2?"
grotte = raw_input()

grotte de retour

nouveau jeu = ( "s" )

or = 0

while newgame == ( "s" ):

NuméroCave = ChangeCave()

print ( "Vous approchez de la Grotte..." )

[Link]( 2 )
print ( "Il fait sombre et lugubre..." )
[Link]( 2 )
print ( "Un grand dragon saute devant vous, ouvre la gueule et..." )
imprimer ( "" )
[Link]( 2 )
FriendlyCave = [Link] ( 1 , 2 )
imprimer "la cueba est" , FriendlyCueva

si CaveNumber == str (FriendlyCave) :

print ( "Il vous donne le trésor..." )
coffre = [Link]( 50 , 200 )
imprimer "Vous avez gagné" , poitrine, "en or"
or += coffre
autre :
print ( "Le dragon te mange d'un seul coup...." )
print "Vous avez perdu !!\nOr accumulé :" , or
newgame = raw_input ( "Voulez-vous rejouer ? (s/n)" )

or = 0

Exercice 2

#!/usr/bin/envpython
# -*- codage : utf-8 -*-

importer au hasard

def principal ():

string = input ( "Dites-moi la longueur de la chaîne : " )

choix = raw_input ( "Essayez de deviner la chaîne : " )
imprimer ""

aléatoire = random_num (chaîne)

tot = évaluer (chaîne, aléatoire, choix)
imprimer au hasard
imprimer ""

while choix != aléatoire :

print "Avec le numéro" , choix, "as-tu eu" , tot, "correct"
imprimer ""
choix = raw_input ( "Essayez de deviner la chaîne : " )
tot = évaluer (chaîne, aléatoire, choix)

imprimer ""
imprimer "Félicitations, vous avez gagné...."
entrée brute ()

def num_alat (carré):

nombre_aléatoire = ""
pour i dans la plage (cad):
x = alé[Link]( 0 , 9 )
x = chaîne (x)
nombre_aléatoire += x
renvoyer un nombre_aléatoire
def évalue (cad, aleat, electc) :
suite = 0
une = 0
b=0
pour i dans la plage (cad):
si aleat[a] == electc[b] :
suite += 1
une += 1
b+=1
autre:
une += 1
b+=1
retour suite

principal()

Exercice 3

#!/usr/bin/envpython
# -*- codage : utf-8 -*-

one = raw_input ( "Dites-moi le premier mot : " )

imprimer ""
two = raw_input ( "Dites-moi le deuxième mot : " )
imprimer ""

si len (un) < 3 ou len (deux) < 3 :

imprimer "Les mots ont moins de 3 lettres"
imprimer ""
elif un[- 3 :] == deux[- 3 :]:
imprimer "Rhyman"
imprimer ""
elif un[- 2 :] == deux[- 2 :]:
imprimer "Ils riment un peu"
imprimer ""
autre :
imprimer "Ils ne riment pas"
imprimer ""

Exercice 4

#!/usr/bin/envpython
# -*- codage : utf-8 -*-
def principal ():
dollars = entrée ( "Combien de dollars : " )
intérêt = entrée ( "Combien d'intérêt : " )
intérêt = float (intérêt)
années = entrée ( "Nombre d'années : " )
imprimer ""

résultat = calcul (dollars, intérêts, années)

print "Quand" , les années, u"les années passent, avec un" , intérêt, u"d'intérêt, vous aurez généré" ,
résultat, "des dollars."

calcul def (argent, intérêts, montants) :

x =argent * (( 1 + inte/ 100 ) **nombre_années)
retourner x

principal()

N'oubliez pas de laisser vos commentaires pour des questions ou des suggestions. Salutations

partie 4

Exercices en python

1) Ce programme demande d'abord le montant total des achats d'une personne. Si le montant est inférieur à
100,00 $, le programme dira que le client ne postule pas à la promotion. Mais si la personne saisit un montant
d'achats égal ou supérieur à 100,00 $, le programme génère aléatoirement un nombre entier de zéro à cinq.
Chaque numéro correspondra à une couleur différente parmi cinq couleurs de boules disponibles pour
déterminer la réduction que le client recevra en récompense. Si la boule aléatoire est blanche, il n'y a pas de
réduction, mais si c'est l'une des quatre autres couleurs, une certaine réduction sera appliquée selon le tableau
qui apparaît, et cette réduction sera appliquée au total d'achat que l'utilisateur a initialement saisi, afin que le
programme affiche un nouveau montant à payer après avoir appliqué la réduction.
 Exemple d'exercice 1

2) Depuis la galerie de produits, l'utilisateur saisira le code et le nombre d'unités du produit qu'il souhaite
acheter. Le programme déterminera le total à payer, comme une facture.
Une variante de cet exercice qui le rendrait un peu plus complexe serait de donner la possibilité de continuer
à saisir différents codes produits avec leurs quantités respectives, et lorsque l'utilisateur souhaite terminer le
calcul de la facture complète avec tous ses achats. Vous osez??

Exemple d'exercice 2

3) Ce programme affiche d'abord la liste des catégories de films et demande à l'utilisateur d'entrer le code de
la catégorie de film, puis demande à l'utilisateur d'entrer le nombre de jours de retard, et ainsi le total est
affiché à la fin pour s'éteindre.
 Exemple d'exercice 3

Pour l’instant je laisse ces 3 exercices réfléchir un peu. J'attends vos solutions.

Comme je le dis toujours : c'était ma façon de résoudre les exercices, vous pouvez avoir une manière différente de
les résoudre.
Dites également que les espaces marqués de ---- sont des indentations dont les fonctions ont besoin pour que tout
fonctionne correctement (puisque l'éditeur Blogger ne me permet pas d'utiliser des indentations, j'utilise cette
nomenclature). Salutations

Exercices 1

# -*- codage : utf-8 -*-

#!/usr/bin/envpython

importer au hasard

def promotion (): #Informations sur la réduction

---- imprimer ""
---- imprimez "VOS DÉPENSES ÉGALES OU DÉPASSENT 100,00 $ ET PAR CONSÉQUENT VOUS PARTICIPEZ À LA
PROMOTION."
---- imprimer ""
---- imprimer "COULEUR RÉDUIT"
---- imprimer ""
---- imprimer "LA BALLE BLANCHE N'A PAS"
---- imprimer "BALLE ROUGE 10 POUR CENT"
---- imprimer "BALLE BLEUE 20 POUR CENT"
---- imprimer "BALLE VERTE 25 POUR CENT"
---- imprimer "BALLE JAUNE 50 POUR CENT"
---- imprimer ""

calcul def (valeur): #Calcul de la fonction

----réduction = 0

----x = [Link]([ 0 , 10 , 20 , 25 , 50 ])

----balles = { 0 : "BALLE BLANCHE" , 10 : "BALLE ROUGE" , 20 : "BALLE BLEUE" , 25 : "BALLE VERTE" , 50 : "BALLE
JAUNE" }

---- si x == 0 :
-------- imprimer " AU HASARD VOUS AVEZ UNE BOULE BLANCHE "
-------- imprimer ""
-------- imprimer "Malheureusement, SUR CETTE OPPORTUNITÉ, IL N'Y A PAS DE RÉDUCTION"

---- autre :
-------- imprimer "ALÉATOIRE VOUS EN AVEZ UN" , balles[x]
-------- imprimer ""
-------- imprimer "FÉLICITATIONS, VOUS AVEZ GAGNÉ A" , x, "PERCENT DE RÉDUCTION"
-------- imprimer ""
-------- print "VOTRE NOUVEAU TOTAL À PAYER EST : $" , float (value -( float (value * x)/ 100 ))
-------- imprimer ""

def achats (): #fonction principale

----purchase_value = raw_input ( "ENTREZ LE MONTANT TOTAL DE L'ACHAT : " )

----purchase_value = int (purchase_value)

---- si valeur_achat < 100 :

-------- imprimer ""
-------- imprimer "Le client n'applique pas la promotion !!!"
---- autre :
--------promotion()
---------calcul (valeur_achat)

achats()

Exercice 2
#!/usr/bin/envpython
# -*- codage : utf-8 -*-

def principal ():

---- imprimer "CHOISISSEZ LE PRODUIT SOUHAITÉ"

---- imprimer ""
---- imprimer "CODE PRODUIT"
---- imprimer ""
---- imprimer "CHEMISE.......................... 1"
---- imprimer "CEINTURE.......................... 2"
---- imprimer "CHAUSSURE.......................... 3"
---- imprimer "PANTALON............... 4"
---- imprimer "CHAUSSETTES........ 5"
---- imprimer "JUPES.................................. 6"
---- imprimer "MAJUSCULES.......................... 7"
---- imprimer "PULL.................................. 8"
---- imprimer "TIE.......................... 9"
---- imprimer "VESTE.................. dix"
---- imprimer ""

----rapport = { 1 : 35 , 2 : 10 , 3 : 50 , 4 : 40 , 5 : 5 , 6 : 20 , 7 : 7 , 8 : 15 , 9 : 10 , 10 : 35 }

----code = entrée ( "ENTRER LE CODE : " )

---- imprimer ""
---- print "LE PRIX EST : $" , relation[code]
----quantité = entrée ( "ENTRER LE NOMBRE D'UNITÉS : " )
---- imprimer ""

----price_t = float (ratio[code] * quantité)

---- print "LE TOTAL À PAYER EST : $" , price_t

principal()

Exercice 3

# -*- codage : utf-8 -*-

#!/usr/bin/envpython

t'importer
heure d'importation
 def principal ():
---- imprimer "CATÉGORIE PRIX SUPPLÉMENT CODE/JOUR DÉLAI"
---- imprimer ""
---- imprimer "FAVORIS 2,50 $ 1 0,50 $"
---- imprimer "NOUVEAU 3,00 $ 2 0,75 $"
---- imprimer "SORTIES 3,50 $ 3 1,00 $"
---- imprimer "SUPER PREMIÈRES 4,00 $ 4 1,50 $"
---- imprimer ""

----code = raw_input ( "INTER LE CODE DE LA CATÉGORIE DE FILM : " )

----n_days = raw_input ( "ENTREZ LE NOMBRE DE JOURS DE DÉLAI DANS LE RETOUR : " )
---- imprimer ""

----n_days = int (n_days)

----total = 0

---- si code == "1" :

--------- total = float ( 2,50 + ( 0,50 * n_days))
-------- imprimer "LE TOTAL À PAYER EST: $" , total, "dollars"
---- code elif == "2" :
--------- total = float ( 3,00 + ( 0,75 * n_days))
-------- imprimer "LE TOTAL À PAYER EST: $" , total, "dollars"
---- code elif == "3" :
--------- total = float ( 3,50 + ( 1,00 * n_days))
-------- imprimer "LE TOTAL À PAYER EST: $" , total, "dollars"
---- code elif == "4" :
--------- total = float ( 4,00 + ( 1,50 * n_days))
-------- imprimer "LE TOTAL À PAYER EST: $" , total, "dollars"
---- autre :
-------- imprimer "MAUVAISE OPTION, ESSAYER ENCORE..."
---------[Link]( 2 )
---------[Link]( "cls" )
--------principal()

principal()

Si vous avez des questions ou des suggestions, laissez des commentaires sous l'entrée, salutations : Diego.
partie 5

Aujourd'hui, je vous propose quelques exercices à pratiquer et à résoudre graphiquement . Depuis un

certain temps maintenant, nous tâtonnons avec des applications graphiques et quelle meilleure façon de
s'entraîner avec quelques exercices .

Vous pouvez faire les exercices avec la bibliothèque que vous aimez le plus ou préférez (Tkinter, wxPython,
Qt, etc.), l'idée est de partager le code et de préciser avec quelle bibliothèque le code a été créé (pour des
raisons d'ordre et non pour se confondre avec les différentes librairies).

Peut-être que ces articles pourront vous aider :

1 - Comment installer PyQt 4 en python

2 - Première application avec Qt Designer et python
3 - Applications graphiques avec Tkinter et python
4 - Dialogues et messages en Python avec Tkinter

Les meilleures solutions seront publiées dans une autre entrée faisant référence à l'auteur de la
solution.

Les codes de solution peuvent être laissés en commentaire et serviront de référence pour ceux qui débutent
avec les applications graphiques en Python . N'oubliez pas que lorsque vous laissez un commentaire avec
du code Python sur le blog, celui-ci perd l'indentation et peut prêter à confusion (dans ce cas, vous pouvez
faire l'indentation avec ---- 4 tirets par indentation).

Exemple:

def Salutation() :
----imprimer "Bonjour tout le monde"

Exercices sur les applications GUI en Python

Exercice 1.1 - Compteur de croissant

 Exercice 1.1

Écrivez une application GUI (appelée IncreasingCont) comme celle vue sur la figure. A chaque clic sur le
bouton "+", la valeur du compteur est incrémentée de 1.
Le programme comporte 3 volets :
1 – Un label « Comptable »
2 - Une ligne Edit non éditable, affichant la valeur du compteur
3 - Un bouton "+"

Exercice 1.2 - Compteur décroissant

Exercice 1.2

Écrivez une application GUI (appelée DecreasingCont) comme celle vue sur la figure. Chaque fois que vous
cliquez sur le bouton "-", 1 est soustrait de la valeur du compteur.
Le programme comporte 3 volets :
1 - Un tag "Comptable"
2 - Une ligne Edit non éditable, affichant la valeur du compteur et commençant par le chiffre 88
3 - Un bouton "-"

Exercice 1.3 - Factorielle

 Exercice 1.3

Écrivez une application GUI (appelée Factorial) comme celle vue sur la figure. A chaque fois que l'on clique
sur le bouton "Suivant", il doit calculer la factorielle de la première ligneEdit et l'afficher dans la seconde. En
donnant ensuite (n est augmenté de 1) n = 2 avec sa factorielle correspondante.
formule factorielle
Factorielle de 5 = 1 x 2 x 3 x 4 x 5 = 120
Factorielle de 3 = 1 x 2 x 3 = 6

La candidature comporte :
1 - Deux étiquettes : une pour n et une pour Factorielle (n)
2 - Deux lignes non modifiables
3 - Un bouton suivant

Exercice 1.4 Compteur

Exercice 1.4

Écrivez une application GUI (appelée Counter) comme celle vue sur la figure. Avec 3 boutons ( Count Up -
Pour augmenter, Count Down - Pour soustraire et Reset - Pour repartir de zéro).
La candidature porte :
1 - Un label « Comptable »
2 - Un lineEdit non éditable, qui affiche le compteur et commence à 0
3 à 3 boutons

Exercices graphiques un peu plus complexes

Exercice 2.1 Calculatrice

 Exercice 2.1

Écrivez une application GUI (appelée Calculatrice) qui fonctionne comme une simple calculatrice.
La candidature porte :
1 - Trois étiquettes (Premier numéro, Deuxième numéro et Résultat)
2 - 3 lineEdit (le résultat lineEdit ne peut pas être modifié)
3 à 6 boutons (+, -, *, /, % et RESET). Le bouton CLEAR devrait effacer les 3 lineEdit. Lorsque vous
appuyez sur (+, -, * ou %), le seul champ modifié est Résultat.

Exercice 2.2 Films

Exercice 2.2

Écrivez une application GUI (appelée Films). Sa fonction sera la suivante : lorsque vous appuyez sur le
bouton Ajouter , il ajoutera le contenu de lineEdit (Films) au listWidget.

La candidature porte :
1 - 2 Tags (Écrire le titre d'un film et de films)
2 - Une ligneEdit où sera écrit le nom du film
3 - Un listWidget qui enregistre les films ajoutés
4 - Un bouton "Ajouter"
Exercice 2.3 Générateur de nombres

Exercice 2.3

Écrivez une application GUI (appelée Number Generator). Sa fonction sera la suivante : lorsque vous
appuierez sur le bouton Générer , il générera un nombre aléatoire dans la plage des deux Spin Box .
La candidature porte :
1 à 3 balises (numéro 1, numéro 2 et numéro généré)
2 - 2 boîte à spin
3 - 1 lineEdit non modifiable
4 - 1 bouton "Générer"

Exercice 2.4 Calculatrice 2

Exercice 2.4

Écrivez une application GUI (appelée Calculatrice 2) comme celle de la figure qui fonctionne comme une
calculatrice.
La candidature porte :
1 à 4 étiquettes (valeur 1, valeur 2, résultat et opérations)
2 à 4 boutons radio (Ajouter, Soustraire, Multiplier et Diviser)
3 - 3 lineEdit (le résultat lineEdit ne peut pas être modifié)
4 - 1 Bouton Calculer qui, une fois enfoncé, effectue l'opération correspondante.

"Défi pour les plus courageux..."

Jeu de mathématiques

Jeu de mathématiques

Écrivez une application GUI (appelée Mathematical Game) comme celle vue sur la figure.
La candidature porte :
1 à 7 étiquettes (Jeux :, 2, Bon :, 1, Mauvais :, 1 et -) les étiquettes qui sont des nombres commencent vides.
Le label - (entre les deux lineEdit) commence par un point d'interrogation (?) et change en fonction de la
valeur du radioButton (Add = +, Subtract = -, Multiply = * et Divide = /).
2 - 3 lineEdit (Seul le résultat lineEdit peut être modifié)
3 à 2 boutons (nouveau numéro et résultat)
Comment ça marche:
Le lecteur commence avec radioButton et lineEdit vides. Lorsque le joueur appuie sur New Game , 2
nombres aléatoires apparaîtront (dans la ligne Edit ci-dessus) avec 1 radioButton. Le joueur doit saisir un
résultat en fonction de l'opération et appuyer sur le bouton Résultat . Si le joueur gagne, Jeu : somme 1 et
Bon : somme 1. Le joueur appuie sur New Game , deux nouveaux nombres aléatoires et une nouvelle
opération (tous aléatoires) apparaissent. Le joueur fait un mauvais calcul et perd ( Jeux : ajoute 1 et reste à 2,
Mauvais : ajoute 1). Il continue ainsi jusqu'à ce qu'il s'ennuie ou devienne un génie hehe...
Jusqu'à présent, ils sont pardonnés, mais...

Un peu plus de complexité, pourquoi pas ?

Vous pouvez ajouter 3 boutons radio supplémentaires pour que le joueur puisse choisir la difficulté. Si vous
choisissez Facile (les nombres aléatoires seront de 0 à 10), si vous choisissez Moyen (les nombres aléatoires
seront de 0 à 100) et si vous choisissez Difficile (les nombres aléatoires seront de 0 à 1000). A chaque fois
que vous choisissez une difficulté, tout revient à 0.

Difficulté

Et vous pouvez ajouter un compteur (numéro LCD) qui compte à rebours 60 secondes (si le joueur ne répond
pas avant le moment où il perd cette partie). Le temps en secondes peut également dépendre de la difficulté.

Ici je laisserai les solutions aux exercices graphiques de programmation Python (partie 1) . La
bibliothèque que j'ai utilisée pour résoudre les exercices était PyQt4 , mais n'oubliez pas que vous pouvez
résoudre les exercices avec la bibliothèque de votre choix.

Exercice 1.1 - Compteur croissant

Comme le demande la lettre de l'exercice, je crée une fenêtre similaire et à l'intérieur de celle-ci je place un
label "Counter", un lineEdit dont je désélectionne la propriété "enabled" pour qu'elle ne puisse pas être
modifiée et l'initialise à 0, et un " +"bouton".

Le graphique ressemble à ceci :

 Augmentation du compteur en Python

Et voici le code :

?
1
2
3 #Diego Caraballo
#[Link]
4 #Augmentation du compteur dans PyQt4
5 #!/usr/bin/envpython
6 # -*- codage : utf-8 -*-
7
8 système d'importation
9 depuis PyQt4 importer QtCore, QtGui, uic
10
# Chargez notre fichier .ui
11 form_class = [Link]("C:\Users\Admin\Desktop\[Link]")[0]
12
13 classe MyWindowClass([Link], form_class) :
14 def __init__(self, parent=Aucun) :
15 [Link].__init__(soi, parent)
16 [Link](soi)
[Link](self.btn_mas_clicked)
17
18 # + événement bouton
19 def btn_mas_clicked(soi) :
20 x = int([Link]())
21 résultat = x + 1
22 [Link](str(résultat))
23
24
app = [Link]([Link])
25 MaFenêtre = MaClasseFenêtre (Aucun)
26 MaFenê[Link]()
27 app.exec_()
28
29

Exercice 1.2 - Compteur décroissant

Comme le disent les paroles, je crée le graphique le plus proche et je commence à travailler dessus :

Voici le graphique :

Compteur décroissant en Python

Voici le code :

?
1 #[Link]
#Diego Caraballo
2
#Compteur décroissant dans PyQt4
3 #!/usr/bin/envpython
4 # -*- codage : utf-8 -*-
5
6 système d'importation
7 depuis PyQt4 importer QtCore, QtGui, uic
8
# Chargez notre fichier .ui
9 form_class = [Link]("C:\Users\Admin\Desktop\[Link]")[0]
10
11 classe MyWindowClass([Link], form_class) :
12 def __init__(self, parent=Aucun) :
13 [Link].__init__(soi, parent)
14 [Link](soi)
[Link](self.btn_menos_clicked)
15
16 # Événement de bouton -
17 def btn_less_clicked(soi) :
18 x = int([Link]())
19 résultat = x - 1
20 [Link](str(résultat))
21
22
app = [Link]([Link])
23 MaFenêtre = MaClasseFenêtre (Aucun)
24 MaFenê[Link]()
25 app.exec_()
 26
27
28
29

Exercice 1.3 - Factorielle

Suite de l'exercice à la lettre, voici le graphique :

Pour calculer la factorielle utilisez la solution de José, Merci !!!

Factorielle dans PyQt4

Voici le code :
?
1 #Diego Caraballo
#[Link]
2
#Calculer la factorielle dans PyQt
3 #!/usr/bin/envpython
4 # -*- codage : utf-8 -*-
5
6 système d'importation
7 depuis PyQt4 importer QtCore, QtGui, uic
8
# Chargez notre fichier .ui
9 form_class = [Link]("C:\Users\Admin\Desktop\[Link]")[0]
10
11
12 classe MyWindowClass([Link], form_class) :
13 def __init__(self, parent=Aucun) :
14 [Link].__init__(soi, parent)
15 [Link](soi)
[Link](self.btn_next_clicked)
16
17
18 # Événement du bouton suivant
19 def btn_next_clicked(soi) :
20 croissante_var = int([Link]()) + 1
21 [Link] (str(increasing_var))
22 #J'effectue la factorielle
facteur_var = 1
23 pour un dans la plage (1 , int([Link]())) :
24 var_factorial = var_factorial * (a+1)
25 [Link] (str(var_factorial))
 26
27
28
29
30
31 app = [Link]([Link])
32 MaFenêtre = MaClasseFenêtre (Aucun)
33 MaFenê[Link]()
34 app.exec_()
35
36

Exercice 1.4 - Comptable

Tout comme la description de l'exercice, je démarre le graphique puis le code :

Compteur en Python et PyQt4

Voici le code :

?
1 #Diego Caraballo
#[Link]
2
#Compteur dans PyQt
3 #!/usr/bin/envpython
4 # -*- codage : utf-8 -*-
5
6 système d'importation
7 depuis PyQt4 importer QtCore, QtGui, uic
8
# Chargez notre fichier .ui
9 form_class = [Link]("C:\Users\Admin\Desktop\[Link]")[0]
10
11 classe MyWindowClass([Link], form_class) :
12 def __init__(self, parent=Aucun) :
13 [Link].__init__(soi, parent)
14 [Link](soi)
[Link](self.btn_Up_clicked)
15 [Link](self.btn_Down_clicked)
16 [Link](self.btn_Reset_clicked)
17
18
 19
20
21
22 # Événement du bouton Compte à rebours
23 def btn_Up_clicked(soi) :
24 moreOne = int([Link]()) + 1
[Link](str (plusOne))
25
26 # Événement du bouton Compte à rebours
27 def btn_Down_clicked(soi) :
28 les moinsUn = int([Link]()) - 1
29 [Link](str (moinsUn))
30
31 # Événement du bouton de réinitialisation
def btn_Reset_clicked(soi) :
32 [Link](str (0))
33
34
35
36 app = [Link]([Link])
37 MaFenêtre = MaClasseFenêtre (Aucun)
38 MaFenê[Link]()
39 app.exec_()
40
41

Bon, je laisse ici toute la première partie des exercices graphiques en Python . J'espère que cela
vous aidera et comme je vous le dis toujours, n'hésitez pas à laisser tout type de commentaire, tout
s'additionne. Salutations, Diego...

Temps

-------------------------------------------------- -------------------------------------------------- -----------------------

Eh bien, j'espère que vous apprécierez cet article et tous les commentaires sont toujours les bienvenus.

Salutations, Diego.