Bonjour le monde!

Le message « Bonjour tout le monde ! » est un programme simple qui

affiche Hello World! à l'écran.

Il est souvent utilisé comme première introduction à un nouveau langage de

programmation.

Jetons un coup d'œil au "Hello World!" programme en Python :

print("Hello World!")

Nombres
Les variables sont des conteneurs qui contiennent des valeurs de
données. Ils sont utilisés pour stocker, manipuler et afficher des
informations dans un programme.

En bref, une variable est comme une unité de mémoire à laquelle on peut
accéder en tapant le nom de la variable.

Chaque variable possède un nom unique et une valeur qui peut être de
différents types. Python est capable de détecter automatiquement le type
de variable, ce qui rend le codage plus efficace.

Pour initialiser une variable, nous utilisons le format suivant :

variableName = value

Jetons un coup d'œil aux différents types de nombres :

int - nombre entier, tel que 1 ou -2 .

float - nombre réel, tel que 1.32 ou 0.98 .

Dans l'exemple suivant :

 On initialise une variable de type int avec le nom a et la valeur 3 .

 On initialise une variable de type float avec le nom b et la valeur 13.2 .
Chaîne
Un caractère est un caractère unique (Par exemple : 1, 6, %, b, p, ., T,
etc.)

Le type str (string) est un type spécial composé de plusieurs char .

Pour initialiser une valeur de chaîne dans une variable, placez-la entre
guillemets simples ou doubles :
s1 = 'This is a string'
s2 = "This is also a string"
Dans l'exemple ci-dessus, deux variables chaîne initialisées,
nommées s1et s2.

Booléen
Un type bool (booléen) n'a que 2 valeurs possibles : True ou False .

Pour attribuer une valeur booléenne à une variable,

variable_true = True
variable_false = False

Dans l'exemple ci-dessus, deux variables

nommées variable_true et variable_false sont initialisées, avec les
valeurs True et False respectivement.

Les booléens sont les éléments constitutifs de la création de logique dans

les programmes que nous écrivons. Nous avons un chapitre entier sur la
logique et les conditions.

Opérateurs arithmétiques
Opérateurs utilisés pour effectuer des opérations sur les valeurs.

Nous aborderons d’abord les opérateurs arithmétiques les plus

élémentaires , ils peuvent être familiers dans les cours de mathématiques.

Opérateur Opération Exemple

+ Ajout 3+2=5
 Opérateur Opération Exemple

- Soustraction 3-2=1

* Multiplication 3*2 = 6

/ Division 4/2 = 2

% Module (Rappel après division) 3%2=1

Voyons un exemple d'utilisation,

a = 3
b = 5
c = a + b # c holds 8

L'opération de module fournit le reste résultant de la division de la

première valeur par la deuxième valeur.

Par exemple:

14 % 4 renvoie 2 car 4 peut

être inséré 14 trois fois (4*3 = 12) et maintenant 14
moins 12 est égal 2 (Le reste).

Raccourcis arithmétiques
Python a créé un raccourci intéressant pour les opérations d'auto-
arithmétique.

Par exemple au lieu d'écrire :

a = 5
a = a + 3 # a holds 8

On peut le simplifier en écrivant += :

a = 5
a += 3 # a hold 8

Le += s'ajoute à a lui-même la valeur 3

Cette opération est valable pour toutes les opérations arithmétiques :

Opérateur Raccourci

+ +=
Opérateur Raccourci

- -=

* *=

/ /=

% %=

Opérateurs de comparaison
Les opérateurs de comparaison sont utilisés pour comparer deux
opérandes.

Parfois, nous devons vérifier si un opérande est plus grand/plus petit/...

qu'un autre opérande. Le tableau suivant présente les opérateurs possibles
à des fins de comparaison :

Opérateur Signification Exemple

== Égal 1 == 2 renvoie faux

!= Inégal 1 != 2 renvoie vrai

> Meilleur que 1 > 2 renvoie faux

< Plus bas alors 1 < 2 renvoie vrai

Supérieur ou
>= 1 >= 2 renvoie faux
égal

<= Inférieur ou égal 1 <= 2 renvoie vrai

L'opérateur de comparaison renvoie True si la comparaison est correcte

ou False non.

Par exemple:
var1 = 13
var2 = 12
var3 = var1 != var2
var3 tiendra True parce que var1 et var2 ne sont pas égaux

Rappelez-vous que le boolean type var3 est un booléen.

Opérateurs logiques, partie 1

Les opérateurs logiques sont utilisés pour vérifier les combinaisons de
comparaisons qui renvoient True ou False .

Par exemple, l'instruction suivante contient deux comparaisons :

5 est-il supérieur à 3 et inférieur à 6 ?

Opérateur Signification Exemple

and Et - True si tous les opérandes sont True a and b

or Ou - True si un opérande est True a or b

not Non - True si l'opérande est False not a

Voyons quelques exemples,

5 est plus grand que 3 et 1 est égal à 1,

b1 = (5 > 3) and (1 == 1) # holds true

Explication : Tous les opérandes le sont True , donc b1 ils

tiendront True ( and l'opération est True si les deux opérandes le sont True ).

5 n'est pas égal à 4 ou cinq est égal à 2,

b2 = not 5 == 4 or 5 == 2 # holds true

Explication : Le premier opérande ( 5 != 4 ) est True ainsi b2 l'est

également True ( or l'opération est True si l'un des opérandes est True )
1 n'est pas égal à 1 ou faux,
b3 = not 1 == 1 or False # holds false

Explication : Tous les opérandes sont False , donc b3 ils

tiendront False ( or opération).

pas (3 plus gros que 4),

b4 = not (3 > 4) # holds true

Explication : L'opérande est False , donc b4 tiendra True ( not opération).

pas (5 plus grand que 10 ou 5 plus grand que 1),

b5 = not (5 > 10 or 5 > 1) # holds false

Explication : 5 > 10 or 5 > 1 est True (un des opérandes est True ), donc au
total b5 est False ( not opération).

Opérateurs logiques, partie 2

Les opérateurs logiques ont une table spéciale appelée « Table de vérité »
qui montre ce que renvoie la combinaison d'opérateurs logiques.

Table de vérité pour l' and opérateur :

un b un et b

FAU
FAUX FAUX
X

FAUX Vrai FAUX

FAU
Vrai FAUX
X

Vrai Vrai Vrai

La seule façon d'obtenir un True pour l' and opérateur est si les
deux a et b sont True

Table de vérité pour l' or opérateur :

un b a ou B

FAUX FAUX FAUX

FAUX Vrai Vrai

Vrai FAUX Vrai

Vrai Vrai Vrai

Dans ce cas, pour obtenir un True résultat, soit a ou b devrait être True .

Table de vérité pour l' not opérateur :

un pas un

FAUX Vrai

Vrai FAUX

Ici, la valeur de a est inversée. Si a c'est False alors not a c'est True

Si l'instruction
Les instructions If nous permettent d'exécuter du code avec des conditions.

Par exemple, regardons le code suivant :

age = 20
status = "Child"
if age > 18:
status = "Adult"
age += 1

Le code ci-dessus vérifie si la age variable est supérieure à 18 . Si tel est le

cas, il sera configuré status pour conserver "Adult" la chaîne.

En fin de compte, le code augmentera age selon 1 que l’âge est supérieur ou
non à 18 ans.
Pour utiliser une if instruction, nous devons ajouter deux points : à la fin du
if, et tout ce qui se trouve à l'intérieur du if if est indenté de 4 espaces :
if condition:
code
code
code

Si la condition est True , nous entrerons le bloc de code à l'intérieur du if (le

code en retrait)

Sinon
if nous permet d'exécuter un code particulier si une condition est remplie,
mais que se passe-t-il si nous voulons exécuter autre chose si la condition
n'est pas remplie ?

Pour cela nous avons la else déclaration :

age = 15
status = "None"
if age >= 18
status = "Adult"
else:
status = "Young"

Dans l'exemple ci-dessus, age est plus petit que 18 ce qui signifie qu'il entre
le code else et status qu'il conservera "Young" .

Nous pouvons même le rendre plus profond en utilisant la elif déclaration :

age = 68
status = "None"
if age < 18:
status = "Young"
elif age >= 18 and age <= 65:
status = "Adult"
else:
status = "Old"

Ici, il vérifie si l'âge est inférieur à 18 ans, sinon il passera à la condition

suivante et vérifiera si l'âge est compris entre 18 et 65 ans. Si cette
condition n'est pas non plus remplie, il sera défini status sur "Old" .

Nous pouvons ajouter autant elif de déclarations que nous le souhaitons :

if condition1:
code
elif condition2:
code
elif condition3:
code
...

Sortir
Nous avons déjà vu comment générer quelque chose, mais récapitulons.

En programmation, cela est souvent appelé « impression » pour produire

quelque chose.

En Python pour imprimer quelque chose sur l'écran que nous

utilisons print()

Par exemple,
print("Hello")

L'exemple ci-dessus s'imprime "Hello" à l'écran.

Rappelez-vous que vous devez joindre ce que vous voulez imprimer

avec "" ou avec '' , c'est une chaîne à l'intérieur du print() .

Sortie avec des variables

À partir de maintenant, nous avons appris à imprimer des chaînes simples,
mais nous devons parfois insérer des valeurs de variables dans la chaîne.

Par exemple:
age = 10
print("His age is: age")

Cela s'imprimera "His age is: age" au lieu de "His age is: 10"

pour que cela fonctionne nous utiliserons la f chaîne f"" :

age = 10
print(f"His age is: {age}")
Ceci imprime "His age is: 10"

Avant les guillemets "" , nous ajoutons la lettre f et à l'intérieur de la chaîne,

partout où nous mettons des parenthèses, {} la valeur de ce qui est écrit à
l'intérieur sera insérée.

Saisir
À partir de maintenant, nous avons stocké les valeurs auxquelles nous
avions pensé dans des variables. Les programmes ne fonctionnent
généralement pas de cette façon. Nous recevons des valeurs d'une source
externe, un utilisateur par exemple.

Pour obtenir les commentaires d'un utilisateur ou du système, nous devons

écrire :
var = input()

Cela stockera l'entrée dans la variable var .

L'entrée est toujours de type string . Par exemple, si l'entrée est 56, var la
chaîne sera conservée "56" .

Casting
Pour convertir l'entrée en un type différent, nous devons convertir .

Pour convertir une chaîne en int (un nombre entier), nous écrirons :
var = input()
var = int(var)

Ou en une seule ligne,

var = int(input())

Si l'entrée est un nombre, c'est-à-dire 5, 4, 54, alors var il contiendra un

nombre. Si l'entrée contient un nombre invalide : 5ab, bb, akt, etc., le
programme échouera.
Voici un tableau qui montre comment convertir en différents types :

Casting Explication

int() Convertir en nombre entier

flotter(
Convertir en nombre réel
)

bool() Convertir en booléen

str() Convertir en chaîne

Il est important d’utiliser le bon type car cela peut affecter le résultat.

L'ajout de deux chaînes entraînera :

"5" + "5" = "55"

L’ajout de deux nombres donnera :

5 + 5 = 10

Pour la boucle
Parfois, lors de la programmation, il est nécessaire d'effectuer plusieurs fois
la même opération, ou presque.

Pour éviter d'écrire la même chose encore et encore, nous pouvons

utiliser Loops .

La for boucle a la syntaxe suivante

for i in range(start, end):
code

Le range(start, end) détermine quelle est la start valeur et quelle est

la end valeur. Le i recevra toutes les valeurs de start à end ( non
compris end ) séquentiellement. Par exemple:
for i in range(0, 5):
print(i)

Il exécutera l'instruction print 5 fois :

0
1
2
3
4

On peut simplifier le range(0, 5) à range(5) :

for i in range(5):
print(i)

Les boucles ont de nombreux cas d'utilisation, par exemple additionnons

tous les nombres de 1 à 100 :
sum_numbers = 0
for i in range(1, 101):
sum_numbers += i
print(sum_numbers)

Cela parcourra d'abord tous les nombres compris entre 1 et 101 (sans
compter 101) et les additionnera tous, puis imprimera la sum_numbers variable

Boucle while
Une while boucle est différente de la for boucle. Une for boucle nous permet
de parcourir un objet spécifique range , tandis qu'une while boucle nous
permet de continuer à itérer tant qu'une certaine condition est remplie.

Pour utiliser une while écriture en boucle :

while condition:
code

Le code ne s'exécutera que si la condition est True .

Il existe de nombreux cas d'utilisation dans lesquels a while résoudrait le

problème, mais for pas la boucle.

Par exemple, considérons ce problème :

Trouvez la plus petite puissance de 2 supérieure à un nombre donné.

Pour le résoudre, nous utiliserons une while boucle qui multipliera à
plusieurs reprises la puissance actuelle de 2 par 2 jusqu'à ce qu'elle
devienne supérieure au nombre donné :
number = 27
power_of_two = 1

while power_of_two <= number:

power_of_two *= 2

print(power_of_two)

La boucle suivante produira le plus petit nombre d’une puissance de deux

qui est . 25=32

Casser
L' break instruction arrête la boucle instantanément lorsqu'elle est
rencontrée.

Par exemple,
for i in range(10):
if i == 6:
break
print(i)

Dans l'exemple suivant, la boucle itère régulièrement jusqu'à ce qu'elle

atteigne le numéro 6. Ensuite, le programme entre l' if instruction et
l'exécute break . Cela sort immédiatement de la boucle. Le résultat est :
0
1
2
3
4
5

Continuer
L' continue instruction arrête l'itération en cours et passe à l'itération
suivante. Par exemple:
for i in range(3, 9):
if i == 5:
 continue
print(i)

La boucle parcourra tous les nombres. lorsqu'il atteindra, i=5 il sautera cette
itération et passera à la suivante. Le résultat est :
3
4
6
7
8

Remarquez que le numéro 5 n'est pas dans la sortie.

Déclarer une fonction

Une fonction est une séquence de code qui porte un nom. Le but d’une
fonction est de réutiliser plusieurs fois un morceau de code.

Par exemple, jetez un oeil à ce code :

print("Welcome to Coddy")
print("New session...")
print("Welcome to Coddy")
print("Another session...")
print("Welcome to Coddy")

Nous utilisons le même code print("Welcome to Coddy") encore et

encore. Un autre problème avec ce code est que si nous voulions changer
le message : Welcome to Coddy en quelque chose de différent comme
" Welcome aboard " il faudrait changer 3 lignes de code différentes. Pour
résoudre ce problème, nous utiliserons des fonctions.

Pour déclarer une fonction nous utilisons la syntaxe suivante :

def function_name():
code

Pour notre exemple, nous allons créer une fonction nommée greet et elle
ressemblera à ceci :
def greet():
print("Welcome to Coddy")

Pour utiliser/appeler/exécuter la fonction on écrit greet() :

greet()
print("New session...")
greet()
print("Another session...")
greet()

Cela donnera le même résultat que ci-dessus.

Important! Le code de la fonction doit venir avant son appel/exécution

Arguments
Un argument dans une fonction est une valeur que vous transmettez à la
fonction lorsque vous l'appelez. Pour ajouter des arguments à une fonction,
nous les écrivons entre parenthèses () :
def function_name(arg1, arg2, ...):
code

Nous pouvons nommer les arguments comme nous le souhaitons et écrire

autant d’arguments que nécessaire.

Pour appeler une fonction et lui passer des arguments on écrit :

function_name(value1, value2, value3, ...)

Passer trop d'arguments à une fonction qui attend moins d'arguments

entraînera l'échec du programme

Exemple d'utilisation :
def is_even(number):
if number % 2 == 0:
print(f"{number} is even")
else:
print(f"{number} is odd")

for i in range(15, 34):

is_even(i)
for i in range(153, 219):
is_even(i)

Ici, nous avons une fonction appelée is_even qui accepte un argument
appelé number et s'imprime si le nombre est pair ou impair. Ensuite nous
appelons la fonction deux fois : une fois pour tous les nombres entre 15 et
34, une deuxième fois pour tous les nombres entre 153 et 219.
Retour
L' return instruction dans une fonction est utilisée pour spécifier la ou les
valeurs que la fonction doit produire en sortie.

Par exemple, la fonction suivante affichera 100 :

def function_name():
return 100

Pour passer la valeur à une variable, écrivez :

number = function_name()

Maintenant, la number variable sera conservée 100 car c'est ce que la fonction
a renvoyé.

Déclarer une liste

Une liste est une collection d’éléments et peut contenir des valeurs de
différents types tels que des nombres, des chaînes ou même d’autres
listes. Les listes sont créées à l'aide de crochets [] et les éléments à
l'intérieur de la liste sont séparés par des virgules.

Voici un exemple de la façon de créer une liste :

my_list = [1, 2, "three", True]

Pour vérifier quelle est la longueur de la liste, nous pouvons utiliser

la len() fonction :
length = len(my_list)

La variable length contiendra 4 car il y a 4 éléments dans la liste.

Accéder aux éléments de la liste

En Python, nous utilisons des listes pour stocker plusieurs valeurs dans
une seule variable. Chaque valeur d'une liste est appelée un élément et
chaque élément possède un index. Les indices commencent 0 à la longueur
de la liste moins un. Par exemple, jetez un œil à la liste suivante :
my_list = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

 L'élément a est à l'index 0

 L'élément b est à l'index 1
 ...
 L'élément g est à l'index 6

Pour accéder à un élément d’une liste, on peut utiliser son index entre
crochets. Par exemple, pour accéder au premier élément d’une liste
nommée my_list , nous utiliserions my_list[0] .

Voici un exemple :
my_list = [10, 20, 30, 40, 50]
element = my_list[2]

La variable element conservera la valeur 30 car elle accédera au troisième

élément (qui a un indice de 2).

Modification des listes

En plus d'accéder aux éléments d'une liste, vous pouvez également les
modifier. Pour modifier un élément spécifique dans une liste, vous pouvez
lui attribuer une nouvelle valeur à l'aide de son index.

Voici un exemple :
my_list = ["apple", "banana", "cherry"]
my_list[1] = "orange"
print(my_list)

Sortir:
["apple", "orange", "cherry"]

banana a été changé en un orange

Méthodes de liste
Les listes regorgent de nombreuses méthodes (fonctionnalités). Pour
accéder à une méthode, écrivez :
some_list.method()

Voici une liste des méthodes de base :

 append(element) - ajoute un élément à la fin de la liste

 clear() - supprime tous les éléments de la liste
 pop(index) - supprime un élément à l'index spécifié
 reverse() - inverse l'ordre de la liste
 sort() - trie la liste par ordre croissant

Voici un exemple d'utilisation de la append méthode :

my_list = ["orange", "banana", "apple"]
my_list.append("strawberry")
print(my_list)

Cela produira ["orange", "banana", "apple", "strawberry"]

Exemple de clear méthode :

my_list = [1, 2, 3, 4, 5]
my_list.clear()
print(my_list)

Cela produira []

Exemple de sort méthode :

my_list = [1, 9, 2, 3]
my_list.sort()
print(my_list)

Cela produira [1, 2, 3, 9]

Pyramide d'astérisque
Des opérations arithmétiques peuvent également être effectuées sur des
chaînes. Par exemple:
str1 = "aaa" + "b"
str1 tiendra "aaab"

C'est la même chose que :

str1 = "aaa"
str1 += "b"

De plus, nous utilisons même des multiplications :

str1 = "a"*10

str1 tiendra "aaaaaaaaaa"

Transposer une liste

Pour accéder à un certain élément dans une liste, nous utilisons des
indices :
lst = ['a', 'b', 'c']
print(lst[0])

Cela affichera a car il s’agit de l’élément à l’index 0 .

Mais les choses peuvent être plus compliquées. Chaque élément d'une liste
peut également être une liste :
lst = [[1, 2, 3], [4, 5, 6]]

Pour accéder au numéro, 2 nous devons accéder à la première liste puis au

2ème élément (index 1) de cette liste :
print(lst[0][1])

Cela affichera 2 .

Biens et construction
Il existe d'autres fonctions intégrées similaires print() et len() que nous
n'avons pas encore abordées.

L'un d'eux est le sum() qui calcule la somme d'une liste :

lst = [1, 2, 3, 4]
print(sum(lst))

Va sortir : 10 parce que 1+2+3+4=10

Pour calculer la moyenne sans utiliser de fonction intégrée, nous pouvons

additionner tous les éléments et les diviser par le nombre d'éléments dans
la liste :
total = 0
for i in range(len(lst)):
total += lst[i]
average = total/len(lst)

Une autre façon de calculer la moyenne consiste à utiliser la sum() fonction :

average = sum(lst)/len(lst)