Aide-mémoire Python : un guide pratique de Python

Vous cherchez une feuille de triche pratique pour Python pour vous rafraîchir la mémoire ? Cherchez pas plus loin. Dans cet article, je couvre les fonctionnalités et les opérations les plus élémentaires de Python dans un format condensé.

Ce guide devrait être une excellente ressource pour vous rappeler comment fonctionne la syntaxe de Python. Vous pouvez le trouver particulièrement utile si cela fait longtemps que vous n’avez pas codé en Python.

Aide-mémoire Python

  • Commentaires en Python
  • Types de données les plus courants de Python
  • Comment créer, enregistrer et mettre à jour des variables
  • Nommer les variables
  • Conversion de type en Python
  • Opérateurs mathématiques Python
  • Opérateurs d’affectation augmentée en Python
  • Opérateurs de comparaison en Python
  • Opérateurs booléens en Python
  • Chaînes et opérations sur les chaînes en Python
  • Instructions conditionnelles en Python
  • Listes en Python
  • Tuples en Python
  • Dictionnaires en Python
  • Ensembles en Python
  • Boucles en Python
  • Fonctions Python intégrées
  • Définition de la fonction
  • Cours en Python

Plus d’Artturi Jalli: Python 4 ne sortira pas de sitôt

Commentaires en Python

Vous pouvez ajouter des commentaires à votre code Python. Les commentaires sur une seule ligne commencent par le symbole #. Les commentaires multilignes commencent et se terminent par trois apostrophes ””.

#Single line comments start with the '#' -symbol.

'''
Alternatively, you can start and end a multi-line comment with 3 apostrophes
'''

Types de données les plus courants de Python

Les types de données sont un concept important en programmation. Les variables peuvent stocker différents types de données, et ces différents types de données sont gérés de différentes manières.

Python a de nombreux types de données intégrés par défaut. Je vais vous présenter quatre des plus courantes ici :

Quatre types de données courants en Python. | Image : Arturi Jalli

Comment créer, enregistrer et mettre à jour des variables

En Python, il n’y a pas de commande pour déclarer des variables. Au lieu de cela, il les crée lorsque vous leur attribuez une valeur.

Aucun type de variable n’est déclaré non plus. Au lieu de cela, Python choisit automatiquement le type de données en fonction du type de données que vous lui attribuez.

Vous pouvez créer, enregistrer et mettre à jour des variables avec l’opérateur d’affectation ‘=’ :

#Integer 2 is saved into variable var1:
var1 = 2

#Integer 1 is updated into variable var1:
var1 = 1

#Floating point number 2.0 is saved into variable var2:
var2 = 2.0

#String "Hello, World!" is saved into variable str1:
str1 = "Hello, World!"

#Boolean value True is saved into variable var3:
var3 = True

Nommer les variables

En Python, les noms de variables ne peuvent contenir que des caractères alphanumériques et des traits de soulignement (Az, 0-9 et _).

Les noms de variables ne peuvent pas commencer par un nombre.

Les noms de variables sont sensibles à la casse (par exemple, une variable nommée var est différent d’une variable nommée Varet ceux-ci sont tous deux différents d’une variable nommée VAR).

#Viable variable names:
var = 1
var2 = 2
VAR_3 = 3

#Viable variable name, that would not overwrite the first one:
Var = 10

#Not viable variable names:
1_var = 1 #Starts with a number
var 2 = 2 #Contains the whitespace character ' ', which is not
#allowed
var-3 = 3 #Contains the dash character '-', which is not allowed

'''
Viable but not often used variable name (the underscore character '_' in front of the name signifies that the variable, function or method should only be used internally):
'''
_var = 1

Conversion de type en Python

Vous pouvez également convertir les données dans un type différent de celui par défaut :

#Boolean value True is saved into variable var:
var = True

#var is updated to the string 'True' by casting:
var = str(True)

Opérateurs mathématiques Python

Voici une liste d’opérateurs mathématiques en Python dans l’ordre de priorité le plus élevé au plus bas :

Une liste d'opérateurs mathématiques en Python.
Une liste d’opérateurs mathématiques en Python. | Image : Arturi Jalli

Opérateurs d’affectation augmentée en Python

En plus de l’opérateur d’affectation habituel =, Python a également des opérateurs d’affectation augmentés, qui enchaînent les opérateurs mathématiques avec l’opérateur d’affectation :

Une liste d'opérateurs d'affectation augmentée en Python.
Une liste d’opérateurs d’affectation augmentée en Python. | Image : Arturi Jalli

Opérateurs de comparaison en Python

Voici une liste d’opérateurs de comparaison en Python :

Une liste d'opérateurs de comparaison en Python.
Une liste d’opérateurs de comparaison en Python. | Image : Arturi Jalli

Vous pouvez les utiliser pour comparer différents types de données. Ceux-ci évaluent True ou False Selon les valeurs que vous entrez.

Opérateurs booléens en Python

Une liste d'opérateurs booléens en Python.
Une liste d’opérateurs booléens en Python. | Image : Arturi Jalli

Chaînes et opérations sur les chaînes en Python

Nous avons déjà vu quelques exemples de chaînes plus tôt, mais regardons maintenant de plus près.

En Python, les chaînes commencent et se terminent soit par le guillemet simple ‘ ou le guillemet double “. Les chaînes multilignes peuvent être affectées à des variables à l’aide de trois guillemets.

#This is how you assign a string to a variable:
str1 = 'Hello, World!'
str2 = "Hello, World!"
#Strings str1 and str2 are equivalent.

#This is how you assign a multiline string to a variable (single quotations would work as well):
long_str = """Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."""

Les chaînes en Python sont en fait des tableaux d’octets qui représentent des caractères Unicode. Les crochets peuvent être utilisés pour accéder aux éléments de la chaîne. C’est ce qu’on appelle l’indexation des chaînes :

>>> "Hello, World!"[0]
'H'

Le découpage de chaîne est similaire à l’indexation de chaîne, sauf que vous sélectionnez une plus grande partie de la chaîne :

>>> "Hello, World!"[0:5]
'Hello'

La in L’opérateur peut être utilisé pour vérifier si une sous-chaîne est contenue dans une chaîne (il peut généralement être utilisé pour vérifier si une valeur est présente dans une séquence) :

>>> "Hello" in "Hello, World!"
True

>>> "HELLO" in "Hello, World!"
False

La not l’opérateur booléen peut être chaîné avec le in opérateur:

>>> "Hello" not in "Hello, World!"
False

Vous pouvez utiliser le upper() et lower() méthodes pour transformer les chaînes en majuscules et minuscules. Vous pouvez utiliser le isupper() et islower() méthodes pour vérifier si une chaîne est en majuscule ou en minuscule :

>>> "Hello".upper()
'HELLO'

>>> "Hello".lower()
'hello'

>>> "Hello".islower()
False

>>> "HELLO".isupper()
True

Vous pouvez utiliser le + opérateur pour concaténer (ou joindre) deux chaînes :

>>> "Hello" + ", World!"
'Hello, World!'

Utilisez le join() méthode pour joindre plusieurs chaînes (et spécifier le séparateur), la split() méthode pour diviser les chaînes, et la replace() méthode pour remplacer une partie d’une chaîne par une autre chaîne :

>>> ", ".join(["Hello", "World!"])
'Hello, World!'

>>> #The default separator of the split() method is whitespace:
>>> "Hello, World!".split()
['Hello,', 'World!']

>>> #But you can also define the separator yourself:
>>> "Hello, World!".split("l")
['He', '', 'o, Wor', 'd!']

>>> #Use the replace() method to replace with a specific part of a
>>> #string with something else:
>>> "Hello, World!".replace("H", "G")
'Gello, World!'

Lorsque vous souhaitez formater des chaînes en Python, utilisez le format() méthode. Le formatage consiste à ajouter des nombres à la chaîne. Cette méthode prend un nombre illimité d’arguments et les place dans des espaces réservés entre accolades {} dans la chaîne :

>>> name = "John"
>>> amount = 10
>>> food_item = "apple"
>>> "{} ate {} {}s.".format(name, amount, food_item)
'John ate 10 apples.'

Vous pouvez vérifier la longueur d’une chaîne en caractères avec la len() method (qui est en fait une méthode généralement pour les itérables):

>>> len("Hello, World!")
13

Plus en génie logiciel : Feuille de triche des commandes Linux avec exemples

Instructions conditionnelles en Python

Comme de nombreux autres langages de programmation, Python prend en charge les instructions conditionnelles if, elif et else qui utilisent les opérateurs de comparaison introduits ci-dessus. La comparaison d’instructions peut également être chaînée avec les opérateurs booléens, qui sont également présentés ci-dessus.

Après l’instruction logique, la syntaxe Python vous oblige à utiliser un point-virgule (:), après quoi vient généralement un saut de ligne et une indentation. L’indentation (espace blanc au début d’une ligne) est utilisée en Python pour définir la portée du code (plutôt que les accolades’{}‘ comme dans de nombreux autres langages de programmation).

Voici quelques exemples pratiques d’utilisation des instructions conditionnelles en Python :

a = 1
b = 2

#Print something, if a is greater than b:
if a > b:
	print("a is greater than b")

#Print something, if a is greater than b, and something else if not:
if a > b:
	print("a is greater than b")
else:
	print("a is not greater than b")

#Print something, if a is greater than b, something else if a is equal to b and something else if not:
if a > b:
	print("a is greater than b")
elif a == b:
	print("a is equal to b")
else:
	print("b is greater than a")

En utilisant le and opérateur booléen pour enchaîner deux instructions logiques :

#Print something, if a is greater than b and b is equal to c:
c = 3
if a > b and b == c:
	print("a is greater than b, and b is equal to c")
else:
	print("a is not greater than b, and/or b is not equal to c")

L’enchaînement de plusieurs instructions conditionnelles est également possible. Ceci est également connu sous le nom d’instructions conditionnelles imbriquées :

c = 3
if a > b:
	if b == c:
		print("a is greater than b, and b is equal to c")
	else:
		print("a is greater than b, but b is not equal to c")
else:
	print("a is not greater than b")

Vous pouvez également utiliser des expressions abrégées d’une ligne pour if et ifelse déclarations. Voici quelques exemples:

#One line if:
if a > b:	print("a is greater than b")

#One line if … else:
print("a is greater than b") if a > b else print("a is not greater than b")

Python n’autorise pas les instructions conditionnelles vides, mais si vous en avez besoin pour une raison quelconque, vous pouvez utiliser un pass déclaration pour éviter d’obtenir une erreur:

#Does not produce an error:
if 1 > 2:
	pass

Listes en Python

Vous pouvez utiliser des listes en Python pour stocker plusieurs éléments (avec éventuellement des types de données différents) dans une seule variable. Les tuples sont définis avec des crochets []. Une liste en Python est ordonnée, modifiable et autorise les membres en double. Voici des exemples d’utilisation d’une liste :

#Defining a list and printing it:
my_list = [1, 2, "Hello, World!"]
print(my_list)

#Indexing of lists starts from 0, and you can access elements of the
#list with square brackets:
print(my_list[0])	#Print the first element of the list
print(my_list[-1])	#Print the last element of the list

#Updating an element in the list:
my_list[2] = 3	#The last element is now 3
print(my_list)

#You can append items to the end of the list with the append()
#method, or insert items at a specific index with the insert()
#method:
my_list.append(4)	#Appends 4 to the end of the list
my_list.insert(0,"Hello, World!")	#Inserts a string to index 0
#in the list
print(my_list)

#You can remove specific items from the list with the remove()
#method, or remove items at a specific index with the pop() method:
my_list.remove(4)	#Removes 4 from the list
my_list.pop(0)	#Removes the first item in the list
print(my_list)

#You can get the length of the list with the len() method:
print(len(my_list))

#You can concatenate lists with the + operator or with the extend
#method:
print(my_list + [5, 6, 7])	#Makes a new list
my_list.extend([5, 6, 7])	#Adds new elements to existing list
print(my_list)

Tuples en Python

Vous pouvez utiliser des tuples en Python pour stocker plusieurs éléments, éventuellement avec différents types de données) dans une seule variable. Les tuples sont définis avec des parenthèses (). Un tuple diffère d’une liste en ce qu’il est immuable (ce qui signifie que vous ne pouvez pas le modifier, y ajouter des éléments ou en supprimer après sa création). Voici un exemple d’utilisation d’un tuple :

#Defining a tuple
tuple_var = (1, 2, "Hello, World!")

#Indexing is done with the square brackets []. The first item has index
#0. This line can be used to access the last element in the above
#tuple:
tuple_var[2]

Dictionnaires en Python

Vous pouvez utiliser des dictionnaires en Python pour stocker des paires clé-valeur. Les dictionnaires peuvent avoir différents types de données et sont définis avec des accolades {}. Les clés et les valeurs sont séparées par les deux-points et les éléments séparés sont séparés par la virgule. Les dictionnaires sont ordonnés, modifiables et n’autorisent pas les doublons. Voici un exemple d’utilisation d’un dictionnaire :

#Defining a dictionary
dict = {
	"name": "John",
	"age": 42,
	"favorite color": "Blue"
	}

#Accessing values is done with the square brackets []. An example of
#accessing values based on the keys:
info_str = "{} is {} years old and their favorite color is {}.".format(dict["name"], dict["age"], dict["favorite color"])

print(info_str)

Ensembles en Python

Vous pouvez utiliser des ensembles en Python pour stocker plusieurs éléments, éventuellement avec différents types de données, dans une seule variable. Les tuples sont définis avec des accolades {}. Un ensemble est non ordonné, non modifiable (toutefois, vous pouvez ajouter et supprimer des éléments) et non indexé. Voici un exemple d’utilisation d’un ensemble :

#Defining a set
new_set = {"Blue", "Green", "Red", 1, 2}

#Since sets are unordered, you can’t know the order in which items
#will be printed. Here’s how you print a set:
print(new_set)
#Here’s how you add and remove items:
new_set.add("Yellow")
new_set.remove(1)
new_set.remove(2)
print(new_set)

Boucles en Python

Prise en charge de Python boucles for et boucles while.

Vous pouvez exécuter un ensemble d’instructions tant qu’une condition est vraie en utilisant le while boucle. La syntaxe d’un while la boucle commence par le while -statement, suivi de la condition, puis de deux-points. L’ensemble des instructions à exécuter dans la boucle suit cette première ligne et est indenté. L’indentation définit la portée de la boucle, de la même manière que les instructions conditionnelles introduites précédemment. Voici quelques exemples de boucles while :

#This loop prints numbers from 1 to 9
i = 1
while i < 10:
print("i is currently {}".format(i))
i += 1

#You can use nested while loops:
i = 1
j = 1
while i < 10:
	while j < 10:
print("i is currently {}, and j is {}".format(i,j))
j += 1
i += 1

Vous pouvez utiliser un for Boucle pour parcourir une séquence, comme une liste, un tuple, un dictionnaire, un ensemble ou une chaîne. La syntaxe est similaire à une boucle while, sauf que vous remplacez le while déclaration avec un for instruction, et la condition avec une variable d'itérateur, un in déclaration et une séquence. Voici quelques exemples utilisant la boucle for :

#This for loop prints the characters in the string "Hello, World!"
for char in "Hello, World!":
print(char)

#Using the range() -function in a for loop to print numbers from 0
#to 9
for i in range(10):
print(i)

#Iterating (or looping) through a list:
for x in ["Hello, World!", 1, 2, 3]:
print(x)

#And here is an example of two nested for loops:
for i in range(10):
	for j in range(10):
print("i is currently {}, and j is {}".format(i,j))

Vous pouvez également utiliser le continue, break, pass, et else déclarations en boucles.

Vous pouvez utiliser le break pour arrêter l'exécution de la boucle avant que la condition d'une boucle while ne soit remplie ou avant que tous les éléments d'une boucle for aient été itérés :

#These loops print numbers from 0 to 4, because they stop when they
#reach i == 5
i = 0
while i < 10:
	if i == 5:
		break
print(i)
i += 1

for i in range(10):
if i == 5:
break
print(i)

Vous pouvez utiliser le continue pour arrêter l'itération en cours d'une boucle et continuer avec l'itération suivante :

#These loops print numbers from 0 to 9, except they skip printing
#number 5
i = 0
while i < 10:
	if i == 5:
		continue
print(i)
i += 1

for i in range(10):
if i == 5:
continue
print(i)

Python n'autorise pas les boucles for vides, mais si vous en avez besoin pour une raison quelconque, vous pouvez utiliser un passer déclaration pour éviter d'obtenir une erreur:

#This loop does nothing sensible but does not produce an error
for i in range(10):
	pass

Vous pouvez également utiliser un else instruction pour exécuter un ensemble d'instructions lorsqu'une boucle est terminée :

#These loops print the numbers from 0 to 9, and when they are finished, they print "Loop is finished"
i = 0
while i < 10:
print(i)
i += 1
else:
	print("Loop is finished")

for i in range(10):
print(i)
else:
	print("Loop is finished")

Fonctions Python intégrées

Nous avons déjà vu certaines fonctions Python intégrées, mais passons en revue certaines des plus courantes et généralement utiles.

imprimer()

La print() La fonction peut être utilisée pour imprimer des objets (le plus souvent des chaînes) dans le fichier de flux de texte. Exemple:

>>> print("Hello, World!")
Hello, World!

intervalle()

La range() La fonction renvoie une séquence de nombres. Par défaut, il commence à zéro et utilise des incréments de un, mais vous pouvez les spécifier à votre guise. Le seul argument que vous devez donner est le nombre avant lequel il s'arrête. La syntaxe est range(start, stop, step). Cette fonction est utile lors de la construction de boucles for, entre autres, et je vais démontrer son utilisation dans ce contexte. Exemple:

>>> #Starts from 0, increments by 1 and stops before 4:
>>> for i in range(4): print(i)
0
1
2
3
>>> #Starts from 2, increments by 3 and stops before 10:
>>> for i in range(2,10,3): print(i)
2
5
8

len()

La len() La fonction renvoie la longueur ou le nombre d'éléments d'un objet. Exemple:

>>> #Length of a string:
>>> len("Hello, World!")
13
>>> #Length of a list
>>> len([1, 10, 3, "Hello, World!"])
4

maximum()

La max() La fonction renvoie le plus grand élément d'un itérable. Exemple:

>>> #Max of a list:
>>> max([1,2,5,1000])
1000

min()

La min() La fonction renvoie le plus petit élément d'un itérable. Exemple:

>>> #Min of a list:
>>> min([1,2,5,1000])
1

somme()

La sum() La fonction renvoie la somme des éléments d'un itérable. Vous pouvez également spécifier une valeur de départ, à laquelle le sum() fonction commence à ajouter. Exemple:

>>> #Sum of a list:
>>> sum([1,2,5,1000])
1008
>>> #Sum of a list, starting from 1000:
>>> sum([1,2,5,1000],1000)
2008

saisir()

La input() La fonction permet à un programme Python de recevoir une entrée de texte de l'utilisateur. Lorsque la fonction est exécutée, le programme s'arrête pour attendre une entrée de l'utilisateur. Exemple (notez que dans l'exemple, l'utilisateur doit taper "James Bond") :

>>> print("What is the name of your character?")
What is the name of your character?
>>> char_name = input()
James Bond
>>> print("Hello {}!".format(char_name))
Hello James Bond!
>>> #You can also specify a default message in the input() function:
>>> char_name = input("What is the name of your character?nName: ")
What is the name of your character?
Name: James Bond
>>> print("Hello {}!".format(char_name))
Hello James Bond!

Définition de la fonction

Utilisez des fonctions en Python pour exécuter un ensemble d'instructions lors de l'appel de la fonction. Les fonctions peuvent prendre des arguments (également appelés paramètres) et renvoyer également des données.

Les fonctions sont définies avec le def mot-clé, suivi de deux-points : . Après cette première ligne, utilisez un espace blanc pour définir la portée de la fonction.

Voici un exemple de fonction simple qui prend deux nombres comme arguments et renvoie leur somme :

def sum_of_two_numbers(num1, num2):
return num1 + num2

print(sum_of_two_numbers(5,10))

Les arguments de mot-clé et les valeurs de paramètre par défaut sont également des concepts utiles lorsqu'il s'agit de fonctions.

Vous pouvez utiliser des arguments de mot-clé pour envoyer des arguments avec le key = value syntaxe. Le fait est que l'ordre des arguments n'a pas d'importance lors de cette opération.

Avec la valeur de paramètre par défaut, vous pouvez définir une valeur par défaut pour un paramètre qui est utilisé lorsque la fonction est appelée sans cet argument.

Voici un exemple illustrant l'utilisation d'arguments de mots clés et de valeurs de paramètres par défaut :

def my_fun(name, age, favorite_color = "Blue"):
info_str = "{} is {} years old and their favorite color is {}.".format(name, age, favorite_color)
print(info_str)

#Not using keyword arguments or the default parameter value:
my_fun("John", 42, "Red")

#Using keyword arguments and the default parameter value:
my_fun(age = 52, name= "John")

Plus en génie logiciel : 16 commandes Bash que les data scientists doivent connaître

Cours en Python

Python est un langage de programmation orienté objet, il est donc naturel qu'il ait également des classes. Les classes sont un constructeur d'objets, vous pouvez donc les définir à votre guise.

Pour créer une classe, utilisez le class mot-clé suivi de deux-points : . Après cette ligne, utilisez l'indentation pour définir la portée de la classe et ajoutez les propriétés souhaitées.

Vous pouvez utiliser le __init__() fonction pour définir l'initiation de la classe. Utilisez cette fonction pour attribuer les valeurs nécessaires aux propriétés de la classe et effectuer d'autres opérations nécessaires pour créer une instance de la classe (ou, en d'autres termes, créer un objet).

Vous pouvez utiliser le __str__() fonction pour définir ce qui est renvoyé lorsque l'objet est représenté sous forme de chaîne.

Utilisez le self paramètre pour référencer l'instance actuelle de la classe. Il doit être le premier paramètre de toute fonction utilisée dans la classe.

Voici un exemple de création et d'utilisation d'une classe :

class human:
def __init__(self, name, age, favorite_color):
self.name = name
self.age = age
self.favorite_color = favorite_color

def __str__(self):
info_str = "{} is {} years old and their favorite color is {}.".format(self.name,self.age,self.favorite_color)
return info_str


new_human = human("John", 42, "Blue")

print(new_human)

#You can modify object properties:
new_human.age = 52
print(new_human)

#You can also delete object properties:
del new_human.age
print(new_human)		#This will now produce an error

#You can also delete objects:
del new_human
print(new_human)		#This will now produce a different error

.

Leave a Comment

Your email address will not be published. Required fields are marked *