Sommaire

Installation ...................................................................................................................................... 3
Langage Python..................................................................................................................... 3
Premier programme.................................................................................................................... 5
Installation de l'IDE PyCharm ......................................................................................................... 6
Fundamentaux .............................................................................................................................. 11
11
Variables.................................................................................................................................. 11
Commandes d'entrée et de sortie................................................................................................. 12
Opérateurs.............................................................................................................................. 13
Liste des exercices A ................................................................................................................ 15
Structures conditionnelles ........................................................................................................... 18
Liste des exercices B ................................................................................................................ 20
Structures de répétition........................................................................................................... 22
Liste des exercices C ................................................................................................................ 23
Tableaux.......................................................................................................................................... 26
Principales fonctions du tableau ..................................................................................................... 27
Quelques exemples pratiques........................................................................................................ 30
Tableaux multidimensionnels........................................................................................................ 31
Liste des exercices D ................................................................................................................ 34
Fonctions ....................................................................................................................................... 36
Caractéristiques
Exemple 01.............................................................................................................................. 39
Exemple 02.............................................................................................................................. 39
Exemple 03.............................................................................................................................. 40
Exemple 04.............................................................................................................................. 41
Exemple 05.............................................................................................................................. 41
Liste des exercices E................................................................................................................. 42
Structure de Données...................................................................................................................... 44
Dictionnaire de données................................................................................................................. 45
Exemple : Lien entre les métadonnées et les données.................................................................... 49
Liste d'exercices F................................................................................................................. 50
Python et SQLite........................................................................................................................... 52
Manipulation de la base de données.............................................................................................. 53

1
 Commande INSERT..................................................................................................................... 53
Commande UPDATE................................................................................................................... 57
Commande DELETE .................................................................................................................... 58
Commande SELECT..................................................................................................................... 59
Commande WHERE.................................................................................................................... 60
Travaillant avec plus d'une table.................................................................................... 61
Liste des exercices G.................................................................................................................. 63
Traitement des exceptions............................................................................................................... 64
Hiérarchie des exceptions........................................................................................................... 65
Action de nettoyage ...................................................................................................................... 67
Commande raise ........................................................................................................................ 67
Liste d'exercices H.................................................................................................................. 68
Fichiers ...................................................................................................................................... 70
Python et Arduino ........................................................................................................................ 71
Référence Bibliographique .............................................................................................................. 72

2
Installation

Dans ce chapitre, nous apprendrons comment installer le langage Python et son IDE sur

Système d'exploitation Windows.

Langage Python

Le langage de programmation Python peut être acquis en accédant à son

demande via l'[Link].

Sélectionnez le menu Télécharger et téléchargez la version Python 3.7.2. Exécutez le fichier

téléchargé et commencez votre installation.

Sur le premier écran, cochez l'option Ajouter Python 3.7 au PATH, choisissez l'option

Installation personnalisée.

Ensuite, restez sélectionné sur toutes les options et cliquez sur Suivant.

3
 Chaque option cochée a la signification suivante :
Documentation : installe la documentation du langage ;
pip : installez pip qui est utilisé pour télécharger des bibliothèques développées en Python ;

tcl/tk et IDLE : installe la bibliothèque Python création d'interface graphique;

Suite de tests Python : installez la bibliothèque Python responsable du traitement de
test de logiciel;
py lanceur : installez le lanceur pour les applications avec l'extension py.

Ensuite, laissez marquer les options recommandées. En Installer personnalisé

emplacement crée le chemin d'installation suivant : c:\développement\python3. Cliquez sur

botãoInstalle suivez la fin de votre installation.

4
Premier programme

Nous allons maintenant tester si l'installation

cela s'est déroulé comme prévu, nous allons créer

notre première application. Ouvrez l'invite

de l'Invite de commandes Windows et tapez le

commande suivante :

python –V

Dans cette commande, la version sera affichée

installée sur votre machine. Pour entrer dans le

environnement de développement tapez le

commande

python

Utilisez la commande print pour afficher quelque chose à l'écran. Testez la ligne de commande suivante :

print("Bonjour le monde")

La commande présentée concerne une fonction. Par définition, toute fonction doit posséder
parenthèses. Dans le cas présenté, la fonction print a reçu un contenu de type texte. A
suivre entre avec les commandes suivantes :

print(“IF Goiano”, “Trindade”, 2019, sep=” “)

print(“IF Goiano”, “Trindade”, 2019, sep=”.“)

La fonction print permet l'impression de diverses valeurs. Remarquez que chaque valeur
doit être séparé par une virgule. Il est permis de présenter des valeurs d'autres types qui ne le sont pas

soit le texte. Le dernier terme : sep = " ", définit quel caractère sera utilisé comme
séparateur des valeurs présentées.

Ci-après est présentée la sortie attendue pour les commandes saisies.

5
 Maintenant, saisissez les commandes suivantes :

IF Goiano
type(institution)
ano = 2019
type(ano)
print(instituicao, "Trindade", ano, sep=" ")

Répare que le comandotype(institution)etype(année)imprime respectivement

les sorties<class ‘str’> et<class ‘int’>. Cette sortie fait référence aux types des

variablesinstitutionocean.

Installation de l'IDE PyCharm

Développer des programmes en utilisant l'Invite de Commande peut être une tâche
extrêmement difficile en fonction de la complexité de l'application. En raison de cela

problème les développeurs utilisent des applications propres pour le développement de

logiciels. Ces applications sont connues sous l'acronyme IDE, Environnement de Développement Intégré
Environnement ou Environnement de Développement Intégré.
Dans ce cours, nous travaillerons avec l'IDE PyCharm, développé par l'entreprise Jet.

Cerveaux. Pour télécharger cet outil, accédez à l'adresse :

[Link]/pycharm/download

et téléchargez la version Windows Community.

6
 Exécutez le fichier, dans l'écran qui définit le dossier de destination, installez l'application

à l'adresse suivante :

c:\développement\PyCharm Édition Communautaire 2018.3.2

Ensuite, dans Options d'installation, cochez les options suivantes :

lanceur 64 bits ;
Ajoutez le répertoire du lanceur au PATH ;

.py
et cliquez sur le bouton Suivant.

7
 Après avoir terminé son installation, ouvrez le programme. Choisissez l'option Créer
Nouveau projet.

Une écran sera mis à disposition pour définir le chemin du projet et quelle machine virtuelle
à utiliser par le projet.

8
EmLocationcrie o seguinte caminho :

c:\développement\espace_de_travail\python\cours\premier

Dans l'option Interpréteur de projet, laissez cochée la machine virtuelle recommandée. Cliquez sur le

boutonCréer.

Avec le projet créé, faites un clic droit sur le nom du projet et choisissez l'option
Nouveau Fichier Python. Nommez le fichier comme [Link].

9
Tapez le code suivant :

Pour exécuter, cliquez sur le menu Exécuter Appuyez sur les touches Alt + Shift + F10. Le
le résultat sera affiché dans le coin inférieur de l'écran de l'application.

10
Fondamentaux

Développée par Guido van Rossum, le langage Python est apparu en 1991. Cette
la langue possède les caractéristiques suivantes :
Interprété : n'utilise pas les ressources directement de la machine;
Haut niveau : basé sur d'autres langages ;
Script : prend en charge la création de scripts ;

Paradigme orienté objet : utilise les concepts de classe et d'objets ;

Typage dynamique : les variables n'ont pas de types définis.
La structure du langage de programmation détermine que tout code soit
dûment indenté. Les structures et blocs ne sont pas limités par un début et une fin.

Commentaires

Un commentaire permet au développeur d'écrire quelque chose dans le programme qui n'est pas

sera interprété par le langage. Ce commentaire peut être sur une seule ligne,
exemple :

Ceci n'est qu'un commentaire

Ou de multiples lignes :

´´´
Je suis allé au marché et j'ai tapé

les données des produits

que j'ai acquis

´´´

Le commentaire multi-lignes doit être entouré de trois apostrophes au début

et fermeture.

Variables

En Python, une variable doit avoir seulement un nom et une valeur. Le type de
la variable est définie par la valeur reçue, c'est-à-dire que le langage permet la création de
variables non typées, qui n'ont pas de type prédéfini.

11
 Ainsi, une variable peut être un nombre ou un texte. Si c'est un nombre,
cela pourra contenir des valeurs :

int stocke des valeurs entières;

flottant stocke des valeurs réelles;
complexe stocke des valeurs ayant une partie réelle et une partie imaginaire.
Normalement, ces types sont utilisés dans des domaines tels que l'ingénierie électrique.

e Statistique.

Un nombre peut également être généré à l'aide des fonctions : int(); float();
e complexe(). Exemple :

Les variables qui ont des valeurs de type texte doivent être entourées de guillemets simples.

ou duplés. Exemple :

Pour nommer une variable, il est permis d'utiliser n'importe quel caractère qui n'est pas

symbole clé du langage. Une variable peut avoir n'importe quel nom, à l'exception
les mots réservés du langage.

Commandes d'entrée et de sortie

12
 Le développeur pourra imprimer une sortie à l'aide de la commande print. Ce
la commande peut être utilisée de la manière suivante :

Imprimant uniquement le texte souhaité. Exemple :

Je suis en train d'imprimer ce texte !

Impression d'une séquence de données (variables et textes). Exemple :

print(“Bonjour”, nom)

Imprimant une séquence de données qui sont délimitées par un caractère ou

texte. Exemple:

print("Aujourd'hui", "nous aurons", sep = "$")

En Python, il faut utiliser la commande input pour capturer l'entrée de l'utilisateur.

Cette commande retournera toujours un texte. Exemple :

Entrez votre nom

Opérateurs

Le langage offre quatre catégories d'opérateurs : d'affectation ; arithmétiques ;

relationnels et logiques.

Opérateur d'attribution

Cet opérateur a pour objectif de définir le contenu et le type d'une variable. Il

est représenté par le symbole égal (=).

Opérateurs Aritmétiques

Correspondent aux opérateurs utilisés dans la réalisation de calculs

mathématiciens. Ce sont eux :

13
 Description Symbole
Addition +
Soustraction -
Division /
Multiplication *
Resto %

Opérateurs relationnels

Ils correspondent aux opérateurs utilisés dans la création de phrases relationnelles.

Ces opérateurs sont largement utilisés dans les structures conditionnelles et de répétition.
Ce sont eux :

Description Symbole
Plus grand >
Mineur <
Supérieur ou égal >=
Moins ou égal <=
Égalité ==
Différent !=

Opérateurs Logiques

Ils participent à la construction d'une phrase logique. Ils sont également utilisés dans les

structures conditionnelles et de répétition. Ce sont eux :

Description Symbole
C'est logique et
OU logique ou
NÃO logique pas

Chaque opérateur a la table de vérité suivante :

et
P Q P et Q
Vrai Vrai Vrai

14
 Vrai Faux Faux
Faux Vrai Faux
Faux Faux Faux

ou
P Q P et Q
Vrai Vrai Vrai
Vrai Faux Vrai
Faux Vrai Vrai
Faux Faux Faux

pas
P pas P
Vrai Faux
Faux Vrai

Liste d'exercices A

1) Développez un programme en Python dans lequel l'utilisateur devra saisir le catète adjacent et
côté opposé relatif à un triangle rectangle. Le programme doit calculer l'hypoténuse de celui-ci
triangle et ses raisons trigonométriques respectives (sinus, cosinus et tangente). Imprimez les
valeurs du sinus, du cosinus et de la tangente.

Calcul de l'hypoténuse :

h² = ca² + co²

Calcul du sinus, cosinus et tangente

co ca co
seno cosinus tangente
h h ça
, où :

hypoténuse
ca = catéto adjacent;
co = côté opposé.

15
2) Développez un programme en Python qui génère un nombre aléatoire de quatre chiffres (M
– Milhar, C – Centena, D – Dezena, U - Unidade) variant entre 1000 et 9999. Le programme devra
calculer et imprimer l'expression mathématique suivante :

U randi(M*10)
x
C 2 D

3) Développez un programme en Python dans lequel l'utilisateur saisira le rayon d'un cercle, la base et
la hauteur d'un triangle. Le programme devra calculer l'aire du cercle et du triangle et imprimer
la différence de l'aire du triangle par l'aire du cercle.

4) L'IF Goiano - Campus Trindade souhaite vérifier quel a été le score obtenu par un
candidat déterminé inscrit au processus électoral pour coordinateur de cours. L'équipe de
des développeurs ont décidé d'aider dans cette tâche en créant un programme Python. Dans ce
Il est nécessaire que l'utilisateur saisisse : le nombre de votes valides du segment
enseignant au candidat ; le total des votes valides des enseignants ; le nombre de votes valides de
segment de vote pour le candidat ; et le nombre de votes valides des étudiants. Le programme devra
effectuer le calcul suivant :

2VDo1VDi
Vt  , étant :
3Do3Di

Vt : Votes valides obtenus par le candidat ;

VDo : Votes valables du segment enseignant au candidat ;
Voter valables des enseignants;
VDi : Votes valides du segment étudiant au candidat ;
Votes valides des étudiants.

À la fin du calcul, la valeur devra être affichée à l'écran.

16
5) Développez un programme en Python dans lequel l'utilisateur saisira un angle. Le programme
vous devrez calculer et imprimer le sinus, le cosinus et la tangente de cet angle.

6) Développez un programme en Python qui génère un nombre aléatoire variant entre 0 et 100.
Imprimez la valeur générée.

7) Développez un programme en Python qui génère 3 nombres aléatoires variant

respectivement entre : 0 et 50 ; 10 et 40 ; 100 et 999. Imprimez les valeurs générées.

8) Développez un programme en Python dans lequel l'utilisateur saisira une valeur initiale et une valeur
final. Le programme devra générer un nombre aléatoire dans l'intervalle choisi par l'utilisateur.
Imprime le numéro généré.
9) Développez un programme en Python dans lequel l'utilisateur saisira deux nombres (n1 et n2).
le programme devra calculer et imprimer la formule suivante :

résultat  n1 n2  3

Conseils :
Calculer la puissance d'un nombre. Exemple :

2 ** 5 = 32

Calculer la racine carrée d'un nombre. Exemple :

4 ** (1/2) = 2

Générer des nombres aléatoires. Exemple :

importer aléatoire

[Link](1, 9)

Générer PI

importer math
[Link]

Obtenir le sinus, le cosinus et la tangente

importer math

17
x = [Link](85) #convertit l'angle de degrés en radians
[Link](x) #sine
[Link](x) #cosinus
z = [Link](x) #tangente
y = [Link](z) #convertit l'angle de radians en degrés.

Structures conditionnelles

Une structure conditionnelle vise à vérifier une phrase relationnelle et à partir de celle-ci
la vérification a lieu lors de la prise de décision. Cette action se produit lorsque la phrase relationnelle

pour vraie (True). Il est également possible d'effectuer des actions selon le résultat de la phrase

relational soit faux (False).

Le langage offre trois types de structures conditionnelles : IF, ELIF ; et ELSE.

La structure IF

Possède la syntaxe suivante :

si condition :
commandes

où
si correspond au nom de la structure de condition;
condition phrase relationnelle à tester;
commandes tous les commandes à exécuter par
structure.

La structure ELIF

Il existe un besoin de tester plusieurs phrases relationnelles. Pour chaque

teste conditionnel utilise un ELIF. Cette structure correspond au if en cascade.
Observez votre syntaxe :
si condicaoA :
comandoA
elif condicaoB:

18
 comandoB
elif condicaoC:
comandoC

où
si correspond au nom de la structure conditionnelle;
sinon si utilisé pour tester une autre condition en plus de la
principal
conditionA sentences liées à
seront testées;
commandeA tous les ordres à être
exécutés dans les différents blocs.

La structure ELSE

Utiliser lorsqu'une séquence de commandes sera exécutée, même

toutes les conditions étant fausses. Cette structure doit être accompagnée d'un
structure IF. Voici sa syntaxe :

si condition :
commandeA
sinon :
comandoB

où :
si correspond au nom de la structure conditionnelle;
sinon utilisé pour exécuter une commande lorsque la condition
contenue dans le faux if for;

condition phrase relationnelle à tester;

commandeA tous les ordres à exécuter
nos différents blocs.

Selon le problème proposé, il est possible d'intégrer toutes les structures conditionnelles.
dans une seule structure, l'ELSE étant toujours la dernière structure allouée.

19
Liste des exercices B

1) Développez un programme en Python dans lequel l'utilisateur saisira une lettre (A à E) relative
un concept de note. Le programme devra convertir la lettre saisie en une note correspondante
avec le tableau ci-dessous :

CONCEPT NOTE
A 95
B 85
C 75
D 65
E 30

Toute lettre saisie différente de ce qui a été proposé dans le tableau ci-dessus sera imprimée comme suit
Concept invalide. Imprime la note convertie.

2) Développez un programme en Python dans lequel l'utilisateur saisira une valeur concernant ax. Le
le programme devra calculer et imprimer la valeur def(x).

1 se x 1
2se1 x 2
f(x)
x²se2 x 3
x³se x 3

3) Développez un programme en Python dans lequel l'utilisateur saisira une valeur numérique variant
entre 1 à 7. Le programme doit convertir ce numéro en jour de la semaine selon le
tableau suivant.

VALEUR SORTIE
1 DIMANCHE
2 LUNDI
3 MARDI
4 MERCREDI
5 JEUDI
6 VENDREDI
7 SAMEDI

Développez un programme en Python qui lit un poids sur Terre et le numéro d'une planète et
imprimez la valeur de votre poids sur cette planète. La liste des planètes est donnée ci-dessous avec
avec la valeur des gravités relative à la Terre :

20
 # GRAVITÉ RELATIVE PLANÈTE
1 0,37 MERCURE
2 0,88 VÉNUS
3 0,38 MARS
4 2,64 JUPITER
5 1,15 SATURNE
6 1,17 Uranus

Pour le calcul du poids, considérez la formule suivante :

p m g, étant donné que :

peso
m: masse;
g: gravité.

Calculez et imprimez le poids sur Terre et sur la planète choisie.

5) L'école "APRENDER" paie ses enseignants à l'heure/heure de cours. Créez un programme

en Python qui calcule et affiche le salaire d'un professeur. On sait que le tarif de l'heure de cours est
la table ci-dessous :

Professeur Niveau 1 12,00 R$ par heure/lesson

Professeur Niveau 2 17,00 R$ par heure/cours
Professeur Niveau 3 25,00 R$ par heure/cours

6) Une entreprise accordera une augmentation de salaire à ses employés, variable selon
avec le poste, comme indiqué dans le tableau ci-dessous. Écrivez un programme en Python qui lit le salaire et le

cargo d'un employé et calculez le nouveau salaire. Si le poste de l'employé n'est pas dans le tableau,
il devra donc recevoir une augmentation de 40%. Montrez l'ancien salaire, le nouveau salaire et la différence.

salarial.

CODE CARGO PERCENTAGE

101 Responsable 10%
102 Ingénieur 20 %
103 Technicien 30 %

7) Construire euh programme em Python pour déterminer a situation

(APPRIS/EXAMEN/REJETÉ) d'un élève, donné sa fréquence (FRÉQUENCE) (pourcentage
de 0 à 100%) et votre note (NOTE) (note de 0,0 à 10,0), étant donné que :

21
 Condition Situation
Fréquence jusqu'à 75% REPROUVÉ
Fréquence entre 75% et 100% et Note jusqu'à 3.0 REPROUVÉ
Fréquence entre 75 % et 100 % et Note de 3.0 à 7.0 EXAMEN
Fréquence entre 75 % et 100 % et Note entre 7,0 et 10,0 APPRouvé

Structures de répétition

Les structures de répétition sont utilisées lorsqu'il est nécessaire d'exécuter le

le même bloc de commande un nombre fini de fois. En Python, nous pouvons utiliser deux
structures de répétition : WHILE ; et FOR.

La structure WHILE

O WHILE exécute un bloc de commandes N fois jusqu'à ce que sa condition soit satisfaite.
Cette structure a la syntaxe suivante :

tant que la condition :

commandes

où :
tandis que mot-clé qui définit la structure;
condition phrase relationnelle qui définit la quantité de
fois que les commandes seront répétées;
commandes ensemble d'instructions à exécuter.

Exemple :

lifeRock = 5000;
iron = 0;
batida = 200;
tant que lifeRock >= 0:
fer += 5
lifeRock -= batida
print('A pris {0} fer'.format(fer))

La structure FOR

Utilisé pour suivre une collection de données. Syntaxe :

22
pour variable dans liste :
commandes

où
pour mot-clé de la structure;
variable variable qui recevra chaque élément de la liste;
liste liste des éléments
commandes ensemble d'instructions.

Exemple :

compras = ['Cupim', 'Picanha', 'Carvão', 'Coração de galinha',

Pain à l'ail
print('Liste des produits pour le barbecue')
pour n dans achats :
imprimer(n)

Liste d'exercices C

01) Développez un programme en Python dans lequel l'utilisateur saisira deux valeurs entières (AeB).
Le programme devra générer 100 nombres aléatoires. Chaque valeur générée devra être comprise dans le
intervalle saisi par l'utilisateur (AeB). Imprimez la plus grande valeur générée par le programme.

02) Développez un programme en Python dans lequel l'utilisateur saisira le nom et les notes de 35

élèves. Chaque élève a cinq notes. Le programme devra imprimer la moyenne arithmétique de chaque
aluno est le nom de l'élève qui a la meilleure moyenne.

03) Développez un programme en Python dans lequel l'utilisateur saisira les données suivantes d'un

le nom d'un aliment; sa catégorie (P - Protéine; C - Carbohydrate; G - Graisse); et

son total calorique. L'utilisateur saisira autant d'aliments qu'il le souhaite. La saisie se terminera lorsque le

la valeur calorique saisie est égale à zéro. Imprimez la valeur calorique totale de chaque catégorie.

04) Développez un programme en Python dans lequel l'utilisateur saisira les données suivantes d'un

le nom d'un aliment ; sa catégorie (P - Protéine ; C - Glucide ; G - Graisse) ; et

sa valeur calorique. L'utilisateur saisira combien d'aliments il souhaite. La saisie se terminera lorsque le

valeur calorique saisie égale à zéro. Imprimez :

23
 Quelle catégorie a la plus grande valeur calorique ;

Quel est le nom de l'aliment le plus calorique.

05) Développez un programme en Python qui calcule la vitesse moyenne de 100 véhicules.
le programme devra calculer et imprimer le pourcentage de véhicules dont la vitesse moyenne

a dépassé 80 km/h. Voici la formule de la vitesse moyenne :

d
Vm , étant donné que :
t

Vm vitesse moyenne
d distance
t tempo.
06) Développez un programme en Python qui simule le lancer d'un dé à six côtés 2500
fois. Le programme devra calculer et imprimer les pourcentages de nombres : uns ; deux ; trois ;

quatres; cincos et six qui ont été tirés pendant les 2500 tirages.

07) Développez un programme en Python dans lequel l'utilisateur saisira la quantité de

Kilowatt-heure (kWh) consommé dans une maison pendant 12 mois. Le programme devra présenter le
bannière de chaque mois. Étant la bannière définie par :

kWh Drapeau
Jusqu'à 172 kWh Vert
Entre 173 et 280 kWh Amarela
Mais que 281 kWh Rouge

08) Un naufragé se trouve coincé sur une île. Il possède une quantité X de nourriture et Y de
boisson. On sait que par jour, il consomme 5% de la nourriture totale et 3% de la boisson totale. Développez

un programme en Python dans lequel l'utilisateur indiquera le nombre de nourriture (X) et de boisson (Y) que le

Le naufragé a initialement. Le programme doit indiquer combien de jours il a fallu pour

consommer toute la nourriture et la boisson.

24
09)Un cadenas possède 10 serrures. On souhaite créer un
programme qui vérifie combien de tentatives une personne aura
jusqu'à ce que le cadenas s'ouvre. Développez un programme en Python

gère aléatoirement la bonne serrure. L'utilisateur devra

choisissez la serrure que vous souhaitez ouvrir jusqu'à ce que vous ayez du succès.

Imprime combien de fois l'utilisateur a essayé d'ouvrir le verrou.

25
Tableaux

Um tableau correspond à une structure de données de type liste dont l'objectif est
stockage d'une collection de données. Le tableau peut stocker n'importe quel type de valeur :

caractères; entiers; réels. Elle peut également stocker même un autre tableau.

Pour définir une liste, déclarez une variable et faites-lui recevoir des crochets.
Exemple :

x = []

En ce moment, la variable x stocke un tableau sans éléments. Si nécessaire

initialiser la liste avec des éléments, ajoutez les valeurs séparées par une virgule. Exemple :

x = [5, 6, 7, 2, 4]

Le vecteur a maintenant cinq éléments.

5 6 7 2 4
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

Chaque élément a un indice (index) dans la liste, le premier indice étant

zéro (0).

Pour accéder à un élément de la liste, utilisez le nom de la variable et entrez entre crochets l'indice

souhaité.

x[3]
La valeur 2 sera obtenue

Dans ce cas, le valeur 2 sera obtenu à l'indice 3.

Pour remplacer une valeur, faites en sorte que la variable à l'indice souhaité reçoive la nouvelle

valeur.

x[2] = 35

26
 5 6 35 2 4
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

La valeur 35 sera attribuée à l'index 2.

S'il est nécessaire de découvrir combien d'éléments existent dans la liste, utilisez la fonction

len().

len(x)

Dans le cas cité, la valeur 5 sera renvoyée.

Principales fonctions du tableau

En plus des ressources présentées, la liste (tableau) contient un ensemble de fonctions qui
permet au développeur de manipuler ses éléments. Dans ce sujet, seront présentés les
principales fonctions d'un tableau.

Voici l'ensemble de fonctions :

[Link](el) Ajoutez un élément à la fin de la liste. Exemple :

[Link](69)

5 6 35 2 4 69
↑ ↑ ↑ ↑ ↑ ↑
0 1 2 3 4 5

[Link]érer(i, x) Ajoutez un élément à la position souhaitée. Les

Les autres éléments après l'indice choisi sont déplacés à droite de la liste.
Exemple :

[Link](2, 24)

27
 5 6 24 35 2 4 69
↑ ↑ ↑ ↑ ↑ ↑ ↑
0 1 2 3 4 5 6

[Link](x) Supprimez le premier élément de la liste dont la valeur est mentionnée

dans la fonction. Exemple :

[Link](4)

5 6 24 35 2 69
↑ ↑ ↑ ↑ ↑ ↑
0 1 2 3 4 5

[Link]([i]) Retirez l'élément de la liste selon la position spécifiée

et retourne la valeur supprimée. Si l'indice n'est pas spécifié, il sera supprimé
le dernier élément de la liste. Exemple :

[Link](1)
La valeur 6 sera retournée. Elle sera supprimée de la liste.

5 24 35 2 69
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

[Link](x[, start[, end]]) Renvoie l'indice de la valeur souhaitée.

Exemple :

[Link](35)
La valeur retournée sera 2

[Link](x) Retourne le nombre d'éléments égaux à la valeur de

entrée. Exemple :

[Link](69)
La valeur retournée sera 1

28
 [Link]() Inverse les valeurs de la liste. Exemple :

[Link]()

69 2 35 24 5
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

[Link](clef=None, inverse=False) Trie les éléments de la liste

en ordre croissant. Si le paramètre reverse reçoit True, la méthode de
l'ordonnancement se fait par ordre décroissant. Exemple :

[Link]()

2 5 24 35 69
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

[Link](reverse=True)

69 35 24 5 2
↑ ↑ ↑ ↑ ↑
0 1 2 3 4

[Link]() Supprimez tous les éléments de la liste. Exemple :

[Link]()

Si vous souhaitez découvrir et approfondir les fonctionnalités disponibles, consultez le site :

[Link]

29
Quelques exemples pratiques

Exemple 01) Faites un programme en Python qui charge une liste de 15 éléments
avec des valeurs aléatoires variant entre 100 et 1000. Le programme devra calculer et
montrer

a) Le plus grand élément de la liste;

b) Le plus petit élément de la liste.

importer aléatoire

x = []
i=0
tant que i <= 14 :

[Link]([Link](100, 1000))
i += 1
[Link]()
imprimer(x)
imprimer(x[0])
imprimer(x[14])

Exemple 02) Dans une course, il y a 10 coureurs. Développez un programme en Python

qui lisait les valeurs du numéro de couloir et son temps respectif dans la course. De plus
disso, le programme devra imprimer le classement et le temps de course, du premier au
décimo placé, en identifiant le numéro d'inscription du coureur correspondant à cela
placement.

corredor = []
i=0
tant que i <= 2 :
inscription = input('Entrez l'inscription : ')
entrez le temps de la course :
[inscription, temps]
[Link](données)
i += 1
[Link](key = lambda corredor:corredor[1])
count = 1
pour i dans corredor :

30
 imprimer(count, 'º lieu: ', i[0], ' -> Temps: ', i[1], sep='')
compter += 1

Exemple 03) Développez un programme en Python dans lequel l'utilisateur saisira une
mot. Imprimez le mot original et inversé. Comparez si le mot inversé est égal à
original.

Entrez un mot :
x = liste(mot)
[Link]()
''.join(x)
print('Mot: ', mot)
print('Mot inversé : ', motInverse)
si palavra == palavraInvertida :
print('MOTS IDENTIQUES')
sinon :
print('MOTS DISTINCTS')

Tableaux multidimensionnels

Les tableaux multidimensionnels, également connus sous le nom de matrices, correspondent à une liste qui

reçoit une collection de données. Cette collection de données est représentée par un autre tableau.

Exemple :

x = [[1, 4], [3, 6], [2, 4]]

Ligne
0 1 4
1 3 6
2 2 4
↑ ↑
0 1
Colonne

Pour accéder à une donnée de cette structure, utilisez deux crochets en ajoutant l'adresse de
ligne et colonne.

31
x[1][0]
'''
La valeur renvoyée sera 3 qui est présente à la ligne 1 et à la colonne 0
'''

Le développeur pourra également créer un tableau multidimensionnel avec des données de

divers types. Considérez l'image suivante :

Considérez que dans l'image affichée, la listatabeladeverá posséder quatre colonnes par
donné. Chaque colonne a une définition et un type de donnée :
identifiant vous recevrez un entier correspondant au code d'un utilisateur;
utilisateur vous recevrez un texte correspondant au nom du compte d'un utilisateur;
Mot de passe vous recevrez un texte correspondant au mot de passe du compte utilisateur ;

actif recevra un booléen correspondant si le compte de l'utilisateur est valide

se trouve active.
Pour le cas cité, on peut créer un tableau multidimensionnel de la manière suivante :

[
denecley@[Link]
pepy@[Link]
[Link]@[Link]
primopato@[Link]
[Link]@[Link]
]

32
 Ligne
0 69 denecley@[Link] ****** Vrai
1 124 pepy@[Link] pepylegal Vrai
2 548 [Link]@[Link] 123321 Faux
3 96 primopato@[Link] primim2018 Vrai
4 56 [Link]@[Link] élèves2019 Faux
↑ ↑ ↑ ↑
0 1 2 3
Colonne

Et si nous voulions lister tous les comptes désactivés ?

Pour la question ci-dessus, nous pouvons résoudre le problème de la manière suivante :

pour ligne dans tableau :

si pas ligne[3]:
imprimer(ligne)

ou

list(filter(lambda ligne: not ligne[3], tableau))

Le commando listconvertit une série de données en une liste, un tableau. Le commando filter retire

toutes les données d'une liste à partir d'un critère de filtre. Pour utiliser le filtre, utilisez le
syntaxe :

lambda valeur: condition

où
lambda mot-clé utilisé pour créer une variable de
filtre
valeur nom de la variable de filtre. Cette variable recevra
chaque valeur de la liste;

condition critère de sélection.

33
Alors, comment pouvons-nous capturer tous les comptes dogmail ?

liste(filter(lambda ligne: 'gmail' in ligne[1], tableau))

Liste des exercices D

1) Créez un programme en Python qui lit une liste de 40 positions. Comptez et écrivez combien
valeurs paires il possède.

2) Créez un programme en Python qui lit deux listes de 20 positions et calcule une autre liste
contenu, aux positions paires les valeurs du premier et aux positions impaires les valeurs du
deuxième.
3) Faites un programme en Python qui détermine combien de nombres supérieurs à 100 il y a dans un
liste d'entiers avec 20 éléments. Remplissez la liste avec des nombres aléatoires variant entre 1 et
200.

4) Crée un programme en Python qui lit le score de 10 épreuves d'un concours et les noms
des participants respectifs. Enregistrez les données dans une liste. Présentez un classement des
placés qui ont obtenu plus de 70 points.
5) Créez un programme en Python qui lit quinze nombres de l'utilisateur et les stocke dans une liste.
racine carrée de chaque nombre. Si la valeur saisie est inférieure à zéro, le nombre -1 doit être
attribué à l'élément de la liste. Après cela, le programme doit imprimer toutes les valeurs
stockés.

6) Créez un programme en Python qui reçoit la taille de 10 athlètes. Stockez la taille de

tous les athlètes dans une liste. Ce programme doit imprimer la taille de ces athlètes qui ont
hauteur supérieure à la moyenne.

7) Écrire un programme en Python qui contient une liste G(13) qui est le gabarit d'un test
de loterie sportive, contenant les valeurs : A, B ou C pour chaque position de G. Lire, ensuite, le
numéro de la carte d'un parieur et une autre liste réponse R (13). Vérifier le nombre de succès
et écrire le numéro du parieur et son nombre de gains. S'il y a 13 gains, ajouter le
GAGNANT, FÉLICITATIONS
8) Faites un programme en Python qui :

a) Lisez une phrase ;

b) Compte le nombre de blancs dans la phrase;
c) Comptez combien de fois la lettre A apparaît;
d) Imprimez ce qui a été calculé aux items b et c.

Dica : Accédez au site

URL cannot be translated.

9) Faites un programme en Python qui, étant donné deux listes A et B de 20 éléments, effectue les
opérations respectives indiquées par une autre liste C de 20 éléments, également fournie par
utilisateur, contenant les quatre opérations arithmétiques dans n'importe quelle combinaison. Stockez dans

34
une liste résultat de la valeur de l'opération réalisée. Par exemple, supposons que A[1] = 10, B[1] = 3
Si C[1] = '*', alors D[1] = 30.

10) Faites un programme en Python qui lit une liste de 3 éléments et une liste
multidimensionnel de 3 x 3 éléments. Ensuite, le programme doit effectuer la multiplication de la liste
simples par les colonnes de la liste multidimensionnelle. Affichez la nouvelle liste.

11) Créez un programme en Python dans lequel l'utilisateur saisira une matrice de dimensions M × N.
Pour la matrice saisie, imprimez à l'écran les nombres pairs contenus dans la matrice, en tenant compte de
les séparer par ligne. Voir l'exemple pour une matrice 4×4 :

Entrée :

1 2 3 4

5 6 7 8

10 11 23 21

1 2 3 1

Sortie :

2 4 6 8 10 2

12) Créez un programme en Python qui lit une matrice carrée 10x10 de nombres entiers.
Vérifier combien de nombres de la diagonale principale sont impairs, écrire aussi, la somme et la
média de ces éléments.

13) Implémentez un programme, utilisant le langage Python, qui lit 30 noms et prénoms.
des personnes. Pour chaque nom et prénom lu, vérifiez si les mots ont la même taille.

Si le prénom et le nom de famille ont la même longueur, concaténez les mots et

écrivez un message en montrant le nom complet;
Si le prénom et le nom de famille ont des tailles différentes, écrivez un message
montrant qu'ils n'ont pas la même taille.

14) Faire un programme en Python qui lit à la fin de la matinée la clôture de la caisse d'un
loja, c'est-à-dire, votre rendement à la fin de la matinée. Il en sera de même à la fin de l'après-midi.

Ce relevé doit être effectué tous les jours de la semaine (du lundi au vendredi). À
À la fin de la semaine, après avoir effectué toutes les lectures, découvrir et écrire le jour et le quart qui a eu le plus.

rendimento. Obs. : Utiliser le concept de matrice pour résoudre cet exercice.

35
Fonctions

Dans ce chapitre, nous apprendrons ce qu'est une fonction et quel est son but. Considérez la
suivant la situation :

i = 0
tant que i < 3 :
print('Choisissez trois nombres')
n1 = int(input('Numéro 1 : '))
j = 1
1
tant que j <= n1 :
graisse *= j

j += 1
print('Factoriel : {0}'.format(fat))
n2 = int(input('Numéro 2 : '))
j = 1
1
tant que j <= n2 :
graisse *= j

j += 1
imprimer('Factoriel : {0}'.format(fat))
Nombre 3 :
j = 1
1
tant que j <= n3 :
graisse *= j

j += 1
print('Factoriel : {0}'.format(fat))
i += 1

Dans cet exemple, le développeur demande à l'utilisateur de saisir trois nombres trois fois.
Pour chaque nombre, son factoriel est calculé (exemple : 4! = 4 x 3 x 2 x 1) et imprimé sur la
tela. Remarquez que ce code contient une répétition des instructions suivantes :

36
j = 1
1
tandis que j <= n1 :

graisse *= j

j += 1
print('Factoriel : {0}'.format(fat))

Et si le développeur voulait calculer le factoriel de 10 nombres 3 fois ? Peut-il le faire ?

imaginer la quantité de lignes et de codes répétés qui seraient générés ?

Pour éviter des situations comme celles-ci, les langages de programmation offrent une ressource

dénommé fonction.

La fonction correspond à un bloc de code qui pourra être invoqué autant de fois
forem nécessaires. Elle définit un problème. L'utilisation de fonctions a pour objectif :

Minimiser la quantité de code écrit;

Faciliter la compréhension du code source;
Distribuer la résolution du problème en petits modules.

Alors comment le code ci-dessus apparaîtrait-il en utilisant cette fonctionnalité ?

def factoriel(n):
j = 1
1
tandis que j <= n :

gras *= j
j += 1
print('Factorielle : {0}'.format(fat))

i = 0
tant que i < 3 :
print('Choisissez trois nombres')
n1 = int(input('Numéro 1 : '))
factorielle(n1)
n2 = int(input('Nombre 2 : '))
fatorial(n2)

37
 n3 = int(input('Numéro 3 : '))
fatorial(n3)
i += 1

Dans le premier scénario, le code écrit comportait 25 lignes, avec l'application de la fonction, il y avait

la réduction à 17 lignes, avec une économie de 32 %. Remarquez également que le

trecho :

j = 1
fat = 1
tant que j <= n1 :
graisse *= j

j += 1
print('Factoriel : {0}'.format(fat))

a été écrit une seule fois, à l'intérieur de la fonctionfactorielle. Dans le code principal, la fonction a été

appelé par son nom et la valeur d'entrée entre parenthèses.

factorielle(n1)
fatorial(n2)
fatorial(n3)

Caractéristiques

La fonction possède les caractéristiques suivantes :

Ne peut être invoquée qu'après sa création;

Peut recevoir ou non des valeurs externes, des paramètres;

On peut renvoyer ou non un résultat. Lorsque l'on souhaite renvoyer une valeur, c'est
nécessaire d'utiliser la commande retour.

Pour créer la fonction, utilisez cette syntaxe :

def nomDeLaFonction(parametres):
commandes
retourner valeur

où

38
 définir commande utilisée pour définir une fonction;
nomeFonction le nom de la fonction. Évitez les caractères spéciaux et

espace
paramètres définir une entrée de valeurs externes. Si la
si la fonction n'existe pas, il suffit d'ouvrir et de fermer les parenthèses. S'il y en a

mais d'un, il sera nécessaire de les séparer par une virgule;

commandes ensemble d'instructions visant à résoudre le

problème;
retourner commande utilisée pour retourner une valeur. Le return
permet de retourner une seule valeur;

valeur valeur à retourner.

Il est important de souligner qu'un code peut avoir autant de fonctions que nécessaire.

nécessaires.

Exemple 01

Développez une fonction en Python qui imprime une quantité de lignes :

*
**
***
****
*****
L'utilisateur devra choisir combien de lignes il souhaite imprimer dans le format présenté.

Résolution :

def impression(lignes):
pour i dans la plage(1, lignes + 1) :

imprimer('*' * i)

Exemple 02

39
Développez une fonction en Python qui reçoit une liste contenant le nom et
nom de famille. Cette fonction doit renvoyer une autre liste contenant le nom complet des
personnes qui commencent par 'A'.

Résolution :

def filtre(liste):
f = list(filter(lambda item : item[0][:1] == 'A', lista))
r = []
pour i dans f :

[Link](i[0] + ' ' + i[1])

retourner r

Exemple 03

Développez une fonction en Python qui reçoit une liste de commandes. Chaque élément
possède l'une des valeurs suivantes :

CRÈME CHOCOLAT NAPOLITAIN FLOCOS

la fonction doit renvoyer le nom de la commande la plus fréquente.

Résolution :

def commande(liste):
itens = ['CREME', 'CHOCOLATE', 'FLOCOS', 'NAPOLITANO']
maior = 0
sabor
pour élément dans les éléments :

q = len(list(filter(lambda i : i == item, lista)))

si q >= maior :
q
élément
retourner sabor

40
Exemple 04

Développez une fonction en Python qui renvoie les éléments de la diagonale principale d'une
matrice d'ordre N.

Résolution :

def dPrincipal(matrice):
index = 0
diagonal = []
pour ligne dans matrice :

[Link](ligne[index])
index += 1
diagonale de retour

Exemple 05

Développez une fonction en Python qui reçoit un nombre correspondant à

quantité de jeux de la MEGA SENA à générer. La fonction doit retourner tous
les pronostics tirés par l'ordinateur. Un ticket contient des numéros de 1 à 60 et un
Le jeu contient 6 numéros.

Résolution :

def cartelas(quantidade):
saida = []
pour i dans la plage(1, quantité + 1) :
jogo = []
count = 0
tant que vrai :

num = [Link](1, 60)

si num pas dans jogo :
[Link](num)
compte += 1
si le compteur == 6 :

pause
[Link]()

41
 [Link](jogo)
retourner sortie

Liste d'exercices E

1) Développez une fonction en Python qui reçoit un nombre entier. La fonction doit renvoyer
un booléen indiquant : vrai si le nombre est premier ; et faux si le nombre n'est pas premier. Utilisez le
suivant signature.

defisPrimo(numero)

2) Développez une fonction en Python qui reçoit une matrice de texte et un attribut supplémentaire.
aussi de type texte. La fonction devra retourner une liste contenant tous les textes qui
contient la valeur d'entrée. Voici la signature de la méthode :

defchercher(valeurs, entrée)

Exemple :

valores

Un vieux chien n'apprend pas de nouveaux tours Mon crapaud jururu

Super Mario Frère Ne montrez pas de río

rivière

Retour

Super Mario Frère Ne montre pas de ruisseau

3) Développez une fonction en Python qui reçoit quatre entiers : le premier indique la quantité
de lignes ; le deuxième indique le nombre de colonnes ; le troisième l'intervalle initial ; et le quatrième le
intervalle final. La fonction doit retourner une matrice selon la taille spécifiée et
remplie avec des valeurs aléatoires selon l'intervalle stipulé. Voici la signature de
fonction

defmatrizAleatoria(ligne, colonne, intervalleInitial, intervalleFinal)

42
Exemple :

Entrée

matriceAleatoire(2, 3, 30, 60)

Sortie :

45 32 56

31 50 41

43
Structure de Données

Dans ce chapitre, nous apprendrons comment construire un modèle conceptuel à partir d'un
structure de données. Nous verrons également la signification du dictionnaire de données et comment

nous pouvons faire pour gérer ce dictionnaire.

Considérez le modèle de données suivant :

Dans le modèle présenté, les données sont réparties dans les tableaux suivants :
Cours
Cours La table Cours est responsable de garder le nom de tout cours.
relatif à toute institution d'enseignement;
Serveur La table Serveur est responsable de conserver les informations des
serveurs qui agissent en tant que professeurs. Chaque serveur a un nom, un e-
mail et son domaine d'activité;
Discipline La table Discipline est responsable de conserver les informations de
toutes les matières proposées dans un cours. Chaque matière a le cours au
quelle est offerte, son nom, la période d'offre, la charge horaire totale, la charge
horaires en présentiel et sa charge horaire à distance;

44
 Matrice La table Matrice est responsible de relier chaque discipline à son
devoir professeur.
Nous créerons une structure de données qui permettra au développeur d'accéder au modèle
relational présenté. Les fichiers contenant le modèle et les données sont séparés
en deux catégories : données pour des fichiers csv qui stockent les données ; et méta-données

pour les fichiers txt qui stockent la logique structurelle de la façon dont les données sont

organisés.

Par exemple, la table Cours possède sa structure enregistrée endate/meta-

data/[Link]. Ce fichier définit les caractéristiques de la table Cours :

Id grand entier.

NomDuCours varchar.
Institution varchar.

Le fichier contenant les données se trouve dans data/data/[Link]. Voici le format

deux dés

1;Ingénierie Électrique;IF Goiano - Campus Trindade

2;Ingénierie Civile;IF Goiano - Campus Trindade
3;Ingénierie Informatique;IF Goiano - Campus Trindade
Pós-graduação en Humanités

Chaque donnée est séparée par un point-virgule (;), ce qui correspond à une colonne de
tableau construit.

Pour commencer le travail, la première étape consiste à trouver les structures de données de chaque

table et créer un dictionnaire. Le dictionnaire à créer sera basé sur les fichiers
qui définissent la structure et qui sont stockés dans le dossier des métadonnées.

Dictionnaire de données

Également connu sous le nom de carte ou tableau associatif, le dictionnaire de données a pour

fonction recevoir une structure de données abstraite et la relier aux différentes entrées de
données.

Pour créer un dictionnaire de données, suivez l'une des syntaxes suivantes.

45
dicionario = {
'Curso': []
}

Où :
dictionnaire nom du dictionnaire de données;
cours nom de la structure de la table à rechercher.

Cela peut également être écrit de la manière suivante :

dicionario = dict(Curso = [])

ou

dictionnaire = dict()
dicionario['Curso'] = []

Connaissant le mode de construction, nous devrons maintenant créer un dictionnaire qui reçoit
toutes les informations des fichiers contenus dans le chemin meta-données. Le dictionnaire

devra être construit dans le format suivant :

{
'Curso': [
bigint
varchar
Institut
]
}

La clé sera composée des noms des entités ([Link], [Link],

[Link], [Link]) et son contenu par les champs qui définissent chaque entité.

Pour construire le dictionnaire de manière dynamique, nous devrons charger tous les fichiers

contenus dans le dossier meta-data. Pour capturer le nom des fichiers contenus dans un
pâtes, utilisez le code source suivant :

importer os

46
pour fichier dans [Link]('data/meta-data'):
imprimer(fichier)

Le code présenté importe un module appelé 'os'. Ce module permettra

charger les fichiers contenus dans un dossier via la fonction listdir, qui retourne la
liste contenant le nom des fichiers. La sortie attendue pour ce code sera :

[Link]
[Link]
[Link]
[Link]

Bien que nous ayons les noms des fichiers contenus dans les méta-donnees, remarquez que ceux-ci

possèdent le nom avec son extension. Nous devons retirer l'extension .txt. Pouvons-nous retirer
à travers la fonction suivante :

def retirerExtension(fichier):
return [Link]('.')[0]

Ayant le chemin et le nom des fichiers, nous devons maintenant créer une fonction qui permet
charger tout le contenu. Nous créerons alors la fonction suivante :

def lerMetaData(arquivo) :
dados = open('data/meta-data/' + arquivo, 'rt')
metaData = []
pour ligne dans données :

i = [Link]('\t')
[Link]((i[0], i[1].split('.')[0]))
[Link]()
renvoyer les métadonnées

La fonction open ouvre le fichier, il faut y indiquer le chemin du fichier et le

type d'ouverture, dans ce cas elle est ouverte uniquement pour lecture. Un fichier peut être ouvert

selon les caractères :

'r' ouvre pour lecture (par défaut);

47
 'w' ouvre pour l'écriture;
'x' ouvre pour création. S'il existe déjà un fichier avec le même nom, il y aura un
erreur
'a' ouvre pour l'écriture, ajoutant le contenu à la fin du fichier s'il existe;
'b' mode binaire;
't modo texte (standard);
'+' ouvre le fichier de disque en mode mise à jour (lecture et écriture);

'U' mode nouvelle ligne (désuet).

La variable data reçoit tout le contenu du fichier dans la fonction open. En le fermant, c'est
il est nécessaire d'utiliser la fonction close().

En rassemblant tout le code produit, nous arrivons au résultat suivant :

importer os

def retirerExtension(fichier):
return [Link]('.')[0]

def lerMetaData(arquivo):
dados = open('data/meta-data/' + arquivo, 'rt')
metaData = []
pour ligne dans données :

i = [Link]('\t')
[Link]((i[0], i[1].split('.')[0]))
[Link]()
retourner les métadonnées

dicionario = {}
pour fichier dans [Link]('data/meta-data') :
retirerExtension(fichier)
dictionnaire[tabeau] = lireMetaData(fichier)

pour clé, valeur dans [Link]() :

print('Entité: {}'.format(chave))
print('Attributs : ', valeur)

48
Les informations contenues dans cette entité sont définies par le nom de tuple. Un tuple est
créée avec des parenthèses et contrairement à la liste (crochets), le tuple est immuable, cela
cela signifie qu'une fois que le contenu est défini, il ne sera plus possible de le modifier.

Cours
Atributos: [
identifiant
varchar
varchar
]

Dans le cas de Cours, nous avons trois tuples. Dans notre exemple, une tuple est constituée de deux

nom du champ

Exemple : Lien entre les métadonnées et les données

Dans cet exemple, nous relierons les méta-données du cours à ses données.

Lisez tous les métadonnées du fichier

# Retourne une liste
def lireMetaDonnees(fichier):
dados = open('data/meta-data/' + arquivo, 'rt')
metaData = []
pour ligne dans données :

i = [Link]('\t')
[Link]((i[0], i[1].split('.')[0]))
[Link]()
retourner les métadonnées

Sépare une ligne de données du CSV

# Retourne les données au format de liste
def lerDado(tupla, linha):
linha = []
pour l dans la plage(0, len(tupla)):

[Link]([Link](';')[l])
retour ligne

49
# Crée le dictionnaire et extrait les informations
dans un tuple
dicionario = {}
dictionnaire['Cours'] = lireMetaData('[Link]')
tupla = []
pour t dans dicionario['Curso'] :
[Link](t[0])

# Relie les données aux tuples

dados = []
d = open('data/data/[Link]', 'rt')
pour i dans d :

lireDonnées(tupla, i)
Crée un dictionnaire pour chaque ligne de données
x = {}
pour clé, valeur dans zip(tupla, ligne) :
x[key] = valeur
[Link](x)

[Link]()

Liste des exercices F

Développez un code Python qui crée les tuples de l'entité Serveur. Reliez chaque tuple
avec vos données.

2) Développez un code Python qui crée des tuples pour l'entité Discipline. Reliez chaque tuple.
avec vos données.

3) Sur la base de l'exercice 2, élaborez un code Python qui visualise uniquement les disciplines du
1er et 3e période.

4) Développez un code Python qui affiche les données suivantes :

Nom du Cours Unité Curriculaire Période Charge Horaire Totale

NomDuCours UnitéCurriculaire Période Cht

50
Dans cet exercice, il sera nécessaire de relier les entités Cours et Discipline.

5) Créez l'application suivante en Python :

Choisissez une option :

1) Lister les cours

2) Lister les disciplines

3) Lister les serveurs

4) Lister la discipline par période
5) Lister les disciplines par cours

6) Lister le serveur par nom

7) Sortir

51
Python et SQLite

Dans ce chapitre, nous apprendrons comment connecter le langage Python à une base de données.
SQLite. Nous verrons comment réaliser les principales routines de manipulation dans la base de données.

données

Un Système de Gestion de Base de Données (SGBD) est une structure

utilisée pour stocker des données. De plus, elle permet que ces données soient
stockés selon un modèle. Le SGBD propose également des fonctionnalités telles que
intégrité et sécurité de la base de données.

Pour connecter le langage de programmation à la base de données, il ne sera pas

nécessaire d'importer des bibliothèques externes. Le langage Python dispose déjà d'une fonctionnalité de

connexion native avec la base de données SQLite.

Pour tester la connexion à la base de données, créez un projet appelé BancoDados.

Dans le projet créé, construisez un fichier Python et nommez-le [Link].

Téléchargez le fichier [Link] présent dans la matière de l'environnement virtuel (Moodle).

Placez ce fichier dans le même dossier que [Link]. Tapez le code suivant :

01 importer sqlite3
02 conn = [Link]('[Link]')
03 curseur = [Link]()
04 [Link]('SELECT * FROM produit')
05 print([Link]())
06 [Link]()

Ligne 01 : Importe la ressource responsable de connecter le langage à la base de données

données
Ligne 02 : La commande connect établit la connexion à la base de données sélectionnée.

Cette fonction ne reçoit que le nom de la base de données, si le fichier est à côté.
[Link]. Si la base de données est dans un autre dossier, il sera nécessaire de passer tout
chemin. Exemplo:c:\dossier\sous-dossier\[Link];
Lignes 03 à 05 : Nous verrons la signification de ces commandes dans les prochains sujets ;

Ligne 06 : La commande close finalise la connexion. Nécessaire pour fermer la base de

données.

52
Manipulant la base de données

Dans ce chapitre, nous apprendrons comment manipuler des données dans la base de données. Pour cela

considérez le modèle suivant.

Dans le modèle présenté, nous avons trois tables : produit ; achat ; achat_produit. Chaque
le tableau a la fonction suivante :
stocke tous les produits. Enregistre la description du produit et son
prix unitaire
achat: stocke tous les achats effectués. La date est enregistrée
réalisation de l'achat et le lieu où l'achat a été réalisé;
stocke tous les produits qui ont été achetés dans un
achat déterminé. Il enregistre le code d'achat, le code du produit et
combien de produits ont été achetés (quantité).

Commande INSERT

La commande INSERT est utilisée lorsque l'on souhaite insérer une donnée dans la base de données.

L'INSERT a la syntaxe suivante :

INSÉRER DANS tabela (campos) VALEURS (dados);

Où :
INSÉRER DANS : commande de l'instruction ;

tableau : nom de la table qui recevra les données ;

champs : noms des champs séparés par des virgules (,);

valeurs : commande de l'instruction

53
 données : données relatives à chaque champ. Chaque donnée doit être séparée par une virgule
(,). Les données de type texte doivent être entre guillemets simples.

Exemple 01 : On souhaite insérer dans la table produit les données suivantes :

Description Prix unitaire

Cupim bovin 12,89
Costelinha de Porc Sadia ou Perdigão 10,99

Les commandes seraient :

INSÉRER DANS produit (description, prixunité) VALEURS ('Cupim Bovino',

12,89);

INSÉRER DANS produit (description, precounit) VALEURS (‘Costelinha

Suína Sadia ou Perdigão, 10,99)

Pour chaque ensemble de données, un INSERT a été réalisé. Cependant, il est également possible
insérer de la manière suivante :

INSÉRER DANS le produit (description, prixunitaire) VALEURS

'Cupim Bovino', 12.89

(‘Costelinha de Porc Sadia ou Perdigão’, 10,99);

Pour exécuter la commande INSERT dans le langage Python, nous devons

écrire le code suivant :

01 importer sqlite3
02 conn = [Link]('base_de_donné[Link]')
03 curseur = [Link]()
04 [Link](
05 'INSÉRER DANS produit (description, prixunitaire) VALUES (?, ?), (?, ?)
06 ('Cupim Bovino', 12.89, 'Costelinha Suína Sadia ou Perdigão', 10.99))
07 [Link]()
08 [Link]()

54
Ligne 03 : La fonction curseur est responsable de réaliser toute manipulation avec le
base de données. Chaque fois qu'il y a besoin de travailler avec une table, ce sera
nécessaire d'appeler cette fonction;
Lignes 04, 05 et 06 : La commande exécuter reçoit quelle commande doit être exécutée.
Dans ce cas, nous exécuterons la commande suivante :

INSERT INTO produit (description, prixunitaire) VALUES (?, ?), (?, ?)

Le symbole de question (?) indique qu'il sera nécessaire de passer un paramètre comme
référence. Dans ce cas, il sera nécessaire de passer quatre paramètres :

('Cupim Bovino', 12.89, 'Costelinha Suína Sadia ou Perdigão', 10.99)

'Cupim Bovino' 12,89 Costelinha de Porc Sadia ou Perdigão 10,99

↑ ↑ ↑ ↑
01 02 03 04

Ligne 07 : La commande commit enregistre l'instruction passée en execute. Cette commande

il est nécessaire d'effectuer l'opération à la banque.

Exemple 02 : Il est souhaité d'insérer dans la table produit les données suivantes :

Description Préféré unitaire

Filé de Tilápia Geneseas 7,79

INSÉRER DANS le produit (description, prix unitaire) VALEURS ('Filé de

Tilapia Geneseas', 7,79)

01 importer sqlite3
02 conn = [Link]('[Link]')
03 curseur = [Link]()
04 [Link](
05 'INSÉRER DANS produit (descricao, precounit) VALUES (?, ?)'
06 ('Filé de Tilápia Geneseas', 7,79)
07 [Link]()
08 [Link]()

Pour tester si les données sont stockées dans [Link], utilisez la commande suivante
site :

55
[Link]

Pour ouvrir la banque, cliquez sur Fichier Ouvrir la base de données.

Cliquez avec le bouton droit sur le produit et choisissez Afficher la table.

56
Commande UPDATE

La commande UPDATE est responsable de l'édition d'une donnée qui existe déjà dans la table. Elle

possède la syntaxe suivante :

METTRE À JOUR tabela SET campo = novoValor WHERE campoChave = valeur

Où :
MISE À JOUR DÉFINIR: commande de l'instruction;

nom de la table à utiliser;

nom du champ à modifier. S'il y a d'autres champs à
alterados utilisez une virgule (,) pour les séparer;
nouvelle valeur du champ
OÙ : condition de mise à jour ;
code de la table
valeur : valeur du code.

Exemple 03 : Changez le prix unitaire du produit :

Identifiant Description Prix unitaire

21 Cupim bovin 12,89

pour 21,99 R$.

METTRE À JOUR produit SET precounit = 21,99 WHERE id = 21

Pour effectuer la commande UPDATE dans le langage Python, nous devrons

écrire le code suivant :

01 importer sqlite3
02 conn = [Link]('base_de_donné[Link]')

03 curseur = [Link]()
04 [Link](
05 'METTRE À JOUR produit SET precounit = ? WHERE id = ?'
06 [Link]()
07 [Link]()

57
Exemple 04 : Changez la description et le prix unitaire du produit :

Identification Description Prix unitaire

23 Filé de Tilapia Geneseas 7,79

pour

Id Description Prix unitaire

23 Camarão DellMare 8,99

METTRE À JOUR produit SET description = 'Camarão DellMare', prixunitaire =

8,99 WHERE id = 23

01 importer sqlite3
02 conn = [Link]('[Link]')
03 curseur = [Link]()
04 [Link](
05 METTRE À JOUR produit SET descricao = ?, precounit = ? WHERE id = ?
Camarão DellMare
07 [Link]()
08 [Link]()

Commande DELETE

La commande DELETE est utilisée pour supprimer une donnée d'une table de la base de données.

données. Il a la syntaxe suivante :

SUPPRIMER DE tabela OÙ champClé = valeur

Où :
SUPPRIMER DE : commande de l'instruction ;

nom de la table à manipuler

OÙ : condition de retrait ;
code de la table
valeur du code.

Exemple : Supprimez l'enregistrement 23.

58
SUPPRIMER DE produit Où id = 23

Pour exécuter la commande DELETE dans le langage Python, nous devrons

écrire le code suivant :

01 importer sqlite3
02 conn = [Link]('[Link]')
03 curseur = [Link]()
04 [Link]('SUPPRIMER DE produit OÙ id = ?', (23,))
05 [Link]()
06 [Link]()

Commande SELECT

La commande SELECT est utilisée pour effectuer des requêtes sur les tables de la base de données.

données. Il possède la syntaxe de base suivante :

SÉLECTIONNER champs À partir de tables;

Où :
SELECT : sélectionne les champs à afficher ;
champs : champs choisis pour l'affichage ;
DE : sélectionnez les tables utilisées;
tabelas choisies.

Exemple 05 : Visualisez la description de tous les produits enregistrés.

SELECT description FROM product

01 importer sqlite3
02 conn = [Link]('base_de_donné[Link]')

03 curseur = [Link]()
04 [Link]('SELECT descricao FROM produit')
05 pour ligne dans [Link]():
06 imprimer(ligne[0])
07 [Link]()
08 [Link]()

Exemple 06 : Visualisez toutes les données du tableau produit.

59
SÉLECTIONNER * À PARTIR DE produit

01 importer sqlite3
02 conn = [Link]('[Link]')
03 curseur = [Link]()
04 [Link]('SELECT * FROM produit')
05 pour ligne dans [Link]():
06 print('{0} - R$ {1}'.format(linha[1], linha[2]))
07 [Link]()
08 [Link]()

Pour visualiser tous les champs d'une table, utilisez le symbole astérisque (*). Dans ce cas
une liste contenant : (id, description, prixunitaire).

Position 0 identifiant
Position 1 description
Position 2 précounit

Commande WHERE

La commande WHERE est utilisée pour tester une certaine condition. Elle peut être
construit dans les commandes : INSERT ; UPDATE ; ou WHERE.

Exemple 07 : Afficher tous les produits dont le prix unitaire est supérieur à 500,00 R$.

SÉLECTIONNER * DE produit OÙ precounit > 500

01 importer sqlite3
02 conn = [Link]('base_de_donné[Link]')
03 curseur = [Link]()
04 [Link]('SELECT * FROM produto WHERE precounit > 500')
05 pour ligne dans [Link]():
06 {0} - R$ {1}
07 [Link]()
08 [Link]()

Exemple 08 : Affichez tous les produits dont la description commence par la lettre 'F'.

SÉLECTIONNER * DE produit OÙ description aime 'F%'

60
 01 importer sqlite3
02 conn = [Link]('[Link]')
03 curseur = [Link]()
04 [Link]("SELECT * FROM produto WHERE descricao LIKE ?", ('F%',))
05 pour ligne dans [Link]():
06 print('{0} - R$ {1}'.format(linha[1], linha[2]))
07 [Link]()
08 [Link]()

Travaillant avec plus d'une table

Supposons que l'on souhaite afficher tous les produits réalisés dans un certain
achat. Dans ce cas, nous aurions besoin de :

de la table d'achat pour identifier quelle achat a été réalisé;

de la table achat_produit pour identifier quels sont les produits de celle-ci
achat; et
de la table produit pour afficher la description.

Le code serait le suivant :

SÉLECTIONNER
description
DE
produit
OÙ
[Link] = compra_produto.idcompra ET
[Link] = compra_produto.id ET
[Link] = 1

Interprétant le code ci-dessus, sélectionnez la description du produit de l'achat dont l'id est

égal à 1. Nous devons relier les tables, et pour cela il est nécessaire de comparer les
champs clés de la table principale avec leurs références respectives :

[Link] = compra_produto.idcompra ET
[Link] = achat_produit.id

Voici le code en Python qui résoudrait ce problème.

61
 01 importer sqlite3
02 conn = [Link]('[Link]')
03 curseur = [Link]()
04 [Link](
05 'SÉLECTIONNER descricao DE produit, achat, achat_produit ' +
06 'OÙ [Link] = compra_produto.idcompra ET ' +
07 '[Link] = compra_produto.id ET [Link] = 1')
08 pour ligne dans [Link]():
09 imprime('{0}'.format(linha[0]))
10 [Link]()
11 [Link]()

Exemple 09 : Présentez le montant total à payer pour l'achat dont l'id est égal à 1.

Pour obtenir le total d'un achat, il sera nécessaire de multiplier les colonnes
préconiser la quantité de chaque article. Pour cela, nous devons réaliser la suivante

consultation:

SÉLECTIONNER
Description
DE
produit
OÙ
[Link] = compra_produto.idcompra ET
[Link] = achat_produit.id ET
[Link] = 1

Voici le code qui résout le problème.

01 importer sqlite3
02 conn = [Link]('[Link]')
03 curseur = [Link]()
04 [Link](
05 'SÉLECTIONNER descricao, precounit, quantité DE produit, achat,
06 achat_produit OÙ [Link] = achat_produit.idachat ET ' +
07 '[Link] = achat_produit.id ET [Link] = 1')
08 total = 0
09 pour ligne dans [Link]():
10 print('{0} (R$ {1}) QUANT: {2}'.format(ligne[0], ligne[1], ligne[2]))
11 total += ligne[1] * ligne[2]
12 print('Total à payer : R$ {0}'.format(total))

62
 13 [Link]()
14 [Link]()

Lignes 08 et 11 : crée une variable et ensuite accumule la somme de la multiplication du

prix unitaire en fonction de la quantité de chaque produit.

Liste d'exercices G

1) Sur la base de la base de données présentée, créez le système suivant.

L'utilisateur accédera à un menu qui contiendra les options suivantes :

Choisissez une option :

Créer un nouveau produit

2) Créer un nouvel achat
3) Ajouter un produit à l'achat
4) Consulter les produits par nom
5) Consulter les données d'achat
6) Exclure un achat
7) Sortir

Chaque option effectue l'opération suivante :

1 L'utilisateur va saisir les données du nouveau produit et les enregistrer dans la base de données;

2 L'utilisateur pourra créer un nouvel achat

3 À partir d'un achat, l'utilisateur pourra ajouter un article, un produit, à la liste de courses.
4 À partir de la description, l'utilisateur pourra consulter les produits enregistrés.
5 À partir d'un achat, toutes les données du produit et sa quantité seront listées, ainsi
comme le total à payer
6 L'utilisateur sortira du système

63
Traitement des Exceptions

En écrivant un code, le développeur peut commettre trois types d'erreurs : erreur logique ;
erreur de syntaxe; erreur d'exécution.

L'erreur logique se produit lorsque le développeur commet une erreur dans les règles de
dans le cadre de l'application, ce type d'erreur est généralement découvert lorsque des utilisateurs qui

utilisent le système découvrent l'incohérence du problème avec la solution présentée.

L'erreur de syntaxe se produit au moment où le code est écrit. Ce type d'erreur

est le plus simple à détecter étant donné qu'il se produit lors de la création de
projet

L'erreur d'exécution se produit lorsque l'utilisateur demande à appeler une action et celle-ci
pour sa part n'arrive pas à être complétée en raison d'une erreur dans quelque instruction de

code. La phrase suivante est un exemple classique d'une erreur d'exécution :

division par zéro

Dans cette instruction, le système ne signale pas d'erreur et permet l'exécution du code. Dans

En l'exécutant, le message suivant s'affichera :

Traceback (appel le plus récent en dernier):

Fichier "C:/desenvolvimento/ [Link]", ligne 1, dans <module>

x = 1/0
ZeroDivisionError: division par zéro

Dans ce chapitre, nous verrons comment traiter les erreurs d'exécution à travers le traitement de

exceptions. Les mots-clés try/except utilisés dans la construction du traitement

d'exception. En utilisant le traitement d'exception, le même code pourrait être écrit de la
suivant la forme :

essayer :
x = 1/0
sauf BaseException :
Erreur de division par zéro
print('Continuation...')

64
Bien qu'une erreur se produise, l'exécution n'est pas interrompue.

Il est possible de déclarer plus d'un 'except' pour traiter différents types d'erreurs. Exemple :

import zipfile
essayer :
banco_zip = [Link]("[Link]")
banco_zip.extractall(path="banco")
banco_zip.close()
except FileNotFoundError :
print("Fichier inexistant")
sauf PermissionError :
Erreur de permission

Dans ce cas, le code traite deux types d'exceptions : la première est si le fichier n'est pas trouvé.

(FileNotFoundError); et en second, si vous n'avez pas la permission d'extraction de

fichier (PermissionError).

Hiérarchie des exceptions

Pour chaque erreur, il est possible de spécifier son type, par exemple, lorsque un nombre est divisé.

par zéro l'erreur invoquée sera ZeroDivisionError. En Python, il existe une hiérarchie
des erreurs.

BaseException
o SystemExit
o KeyboardInterrupt
o GeneratorExit
o Exception
. Arrêter l'itération
. ErreurArithmétique
ErreurDePointFlottant
OverflowError
Erreur de division par zéro
. AssertionError
. Erreur d'attribut
. Erreur de tampon
. Erreur EOF
. ImportationError
. Erreur de recherche

65
 IndexError
KeyError
. Erreur de mémoire
. NameError
UnboundLocalError
. OSError
BlockingIOError
Erreur de processus enfant
Erreur de connexion
erreur BrokenPipe
Erreur de connexion abandonnée
ErreurConnectionRefusée
ErreurConnectionRéinitialisée
FileExistsError
Erreur de fichier introuvable
Erreur d'interruption
IsADirectoryError
NotADirectoryError
Erreur de permission
Erreur de recherche de processus
Erreur de délai d'attente
. Référence d'erreur
. Erreur d'exécution
NotImplementedError
. Erreur de syntaxe
Erreur d'indentation
erreur de tabulation

. Erreur système
. TypeError
. ValueError
Erreur Unicode
une UnicodeDecodeError
erreur d'encodage Unicode
Erreur de traduction Unicode
. Avertissement
Avertissement de désapprobation
Avertissement de dépréciation en attente
Avertissement d'exécution
Avertissement de syntaxe
Avertissement utilisateur
Avertissement futur
Avertissement d'importation
Avertissement Unicode
Avertissement de bytes
Avertissement de ressource

S'il y a un doute sur quelle exception utiliser, il est possible d'invoquer le traitement d'erreur.

primárioBaseException. Chaque classe d'exception possède ses particularités.

66
Action de nettoyage

En écrivant un code qui contient le traitement des exceptions, il peut arriver que
développer a besoin de nettoyer une variable, de fermer un fichier ou une procédure qui
soyez ouvert. Considérant ces cas, il existe une commande optionnelle qui peut être
utilisé en conjonction avec try/except. Cette commande est connue sous le nom de finally.

Le commandofinallysempre exécutera le code, que l'erreur se soit produite ou non.

non. Exemple :

def lerMetaData(arquivo):
essayer
dados = open('data/meta-données/' + arquivo, 'rt')
metaData = []
pour ligne dans des données :

i = [Link]('\t')
[Link]((i[0], i[1].split('.')[0]))
sauf FileNotFoundError :
Fichier non trouvé.
enfin :
[Link]()
retourner les métadonnées

Commande raise

Cette commande est utilisée lorsque le développeur a besoin de provoquer une erreur contrôlée.
Suivez la syntaxe :

lever une erreur

où
augmenter mot-clé utilisé pour provoquer l'erreur;
Erreur erreur à être invoquée.

Exemple :

def verifier(sabor):

67
 si sabor pas dans ('CREME', 'CHOCOLATE', 'NAPOLITANO') :
lever BaseException

essayer :
Choisissez la saveur de glace à l'eau :
vérifier(saveur)
Bon choix
sauf BaseException :
Nous ne travaillons pas avec ce goût.

Liste d'exercices H

1) À partir du code présenté :

x = [1, 3, 5, 6, 7, 8]
i = 0
tant que i <= len(x):
imprimer(x[i])
i += 1

créer un traitement d'exception pour éviter la survenue de l'erreur.

2) Créez un programme en Python qui reçoit n nombres et additionne ces nombres tant que la somme

ne dépassant pas 100. Le programme doit imprimer la valeur additionnée (avant d'atteindre le nombre
maior que 100) et devra informer combien de nombres ont été additionnés et quelle est la moyenne. Refaites votre

programme utilisant les règles suivantes :

a. Utilisez le traitement des exceptions pour gérer l'entrée des données;
b. Lorsque la somme est supérieure à 100, le programme doit générer une exception.

3) Écrivez un programme en Python qui remplit un tableau avec 10 positions.

l'utilisateur va informer les valeurs à insérer et leurs positions respectives dans le tableau.
le programme doit traiter les exceptions lorsqu'une position inexistante du tableau est renseignée

quand la valeur renseignée n'est pas un nombre.

68
4) Supposons que l'utilisateur réalise des transactions sur son compte courant. Développez un code dans

Quel utilisateur saisira son solde initial. Il pourra effectuer un Débit ou un Crédit. Lancez une
exception si le solde du client devient négatif. Le montant du solde ne doit pas devenir négatif.

69
Fichiers

CROIX

70
Python et Arduino

71
Référence Bibliographique

CRUZ, [Link] : Écrivez vos premiers programmes. 1ère éd. Casa do Código : São
Paulo. 1998.

MENEZES, N. Introduction à la programmation avec Python : algorithmes et logique de

programmation pour débutants. 2e éd. Novatec : São Paulo. 2014.

72