Questions d'entretien sur le dictionnaire Python

Estimation du temps de lecture : 6 procès-verbal

Dans notre première vidéo sur les questions d'entretien relatives à Python, nous avons abordé certaines des questions de haut niveau qui peuvent vous être posées lors d'un entretien.

Dans ce post, nous allons discuter des questions d'entretien sur les dictionnaires python.

Que sont donc les dictionnaires Python et leurs propriétés ?

Tout d'abord, elles sont mutables, ce qui signifie qu'elles peuvent être modifiées, veuillez lire la suite pour voir des exemples.

Par conséquent, vous pouvez ajouter ou retirer des paires clé-valeur comme bon vous semble.

De même, les noms des clés peuvent être modifiés.

L'une des autres propriétés à noter est qu'ils sont sensibles à la casse, ce qui signifie que le même nom de clé peut exister s'il est en différentes capitales.

Alors comment créer un dictionnaire vide en Python?

Comme on peut le voir ci-dessous, le processus est simple, il suffit de déclarer une variable égale à deux accolades, et hop, c'est parti.

Une alternative est de déclarer une variable égale à dict(), et dans une instance, vous avez un dictionnaire vide.

Le bloc de code ci-dessous est un bon exemple de la façon de procéder :

# How do you create an empty dictionary?
empty_dict1 = {}
empty_dict2 = dict()
print(empty_dict1)
print(empty_dict2)
print(type(empty_dict1))
print(type(empty_dict2))

Output:
{}
{}
<class 'dict'>
<class 'dict'>

Comment ajouter des valeurs à un dictionnaire Python?

Si vous voulez ajouter des valeurs à votre dictionnaire Python, il y a plusieurs façons possibles, le code ci-dessous, peut vous aider à avoir une meilleure idée :

#How do add values to a python dictionary
empty_dict1 = {}
empty_dict2 = dict()

empty_dict1['Key1'] = '1'
empty_dict1['Key2'] = '2'
print(empty_dict1)

#Example1 - #Appending values to a python dictionary
empty_dict1.update({'key3': '3'})
print(empty_dict1)

#Example2 - Use an if statement
if "key4" not in empty_dict1:
    empty_dict1["key4"] = '4'
else:
    print("Key exists, so not added")
print(empty_dict1)

Output:
{'Key1': '1', 'Key2': '2'}
{'Key1': '1', 'Key2': '2', 'key3': '3'}
{'Key1': '1', 'Key2': '2', 'key3': '3', 'key4': '4'}

Comment trier un dictionnaire Python ?

L'une des propriétés des dictionnaires est qu'ils ne sont pas ordonnés. Par conséquent, s'ils sont volumineux, trouver ce dont vous avez besoin peut prendre un certain temps.

Heureusement, Python a prévu la possibilité de trier comme suit :

#How to sort a python dictionary?
empty_dict1 = {}

empty_dict1['Key2'] = '2'
empty_dict1['Key1'] = '1'
empty_dict1['Key3'] = '3'
print("Your unsorted by key dictionary is:",empty_dict1)
print("Your sorted by key dictionary is:",dict(sorted(empty_dict1.items())))

#OR - use list comprehension
d = {a:b for a, b in enumerate(empty_dict1.values())}
print(d)
d["Key2"] = d.pop(0) #replaces 0 with Key2
d["Key1"] = d.pop(1) #replaces 1 with Key1
d["Key3"] = d.pop(2) #replaces 2 with Key3
print(d)
print(dict(sorted(d.items())))

Output:
Your unsorted by key dictionary is: {'Key2': '2', 'Key1': '1', 'Key3': '3'}
Your sorted by key dictionary is: {'Key1': '1', 'Key2': '2', 'Key3': '3'}
{0: '2', 1: '1', 2: '3'}
{'Key2': '2', 'Key1': '1', 'Key3': '3'}
{'Key1': '1', 'Key2': '2', 'Key3': '3'}

Comment supprimer une clé d'un dictionnaire Python ?

De temps en temps, certaines clés peuvent ne plus être nécessaires. Dans ce cas, vous devrez les supprimer. Ce faisant, vous supprimez également la valeur associée à la clé.

#How do you delete a key from a dictionary?
empty_dict1 = {}

empty_dict1['Key2'] = '2'
empty_dict1['Key1'] = '1'
empty_dict1['Key3'] = '3'
print(empty_dict1)

#1. Use the pop function
empty_dict1.pop('Key1')
print(empty_dict1)

#2. Use Del

del empty_dict1["Key2"]
print(empty_dict1)

#3. Use dict.clear()
empty_dict1.clear() # Removes everything from the dictionary.
print(empty_dict1)

Output:
{'Key2': '2', 'Key1': '1', 'Key3': '3'}
{'Key2': '2', 'Key3': '3'}
{'Key3': '3'}
{}

Comment supprimer plus d'une clé d'un dictionnaire Python ?

Parfois, vous pouvez avoir besoin de supprimer plusieurs clés et leurs valeurs. L'utilisation répétée du code ci-dessus n'est pas forcément le moyen le plus efficace d'y parvenir.

Pour y parvenir, Python a prévu un certain nombre de moyens :

#How do you delete more than one key from a dictionary
#1. Create a list to lookup against
empty_dict1 = {}

empty_dict1['Key2'] = '2'
empty_dict1['Key1'] = '1'
empty_dict1['Key3'] = '3'
empty_dict1['Key4'] = '4'
empty_dict1['Key5'] = '5'
empty_dict1['Key6'] = '6'

print(empty_dict1)

dictionary_remove = ["Key5","Key6"] # Lookup list

#1. Use the pop method

for key in dictionary_remove:
  empty_dict1.pop(key)
print(empty_dict1)

#2 Use the del method
dictionary_remove = ["Key3","Key4"]
for key in dictionary_remove:
  del empty_dict1[key]
print(empty_dict1)

Comment changer le nom d'une clé dans un dictionnaire Python ?

Dans certains cas, les noms des clés ne correspondent pas à ce dont vous avez besoin et doivent donc être modifiés.

Il convient de noter que lors de la modification des noms de clés, le nouveau nom ne doit pas déjà exister.

Vous trouverez ci-dessous quelques exemples qui vous montreront les différentes façons d'y parvenir.

# How do you change the name of a key in a dictionary
#1. Create a new key , remove the old key, but keep the old key value

# create a dictionary
European_countries = {
    "Ireland": "Dublin",
    "France": "Paris",
    "UK": "London"
}
print(European_countries)
#1. rename key in dictionary
European_countries["United Kingdom"] = European_countries.pop("UK")
# display the dictionary
print(European_countries)

#2. Use zip to change the values

European_countries = {
    "Ireland": "Dublin",
    "France": "Paris",
    "United Kingdom": "London"
}

update_elements=['IRE','FR','UK']

new_dict=dict(zip(update_elements,list(European_countries.values())))

print(new_dict)

Output:
{'Ireland': 'Dublin', 'France': 'Paris', 'UK': 'London'}
{'Ireland': 'Dublin', 'France': 'Paris', 'United Kingdom': 'London'}
{'IRE': 'Dublin', 'FR': 'Paris', 'UK': 'London'}

Comment obtenir la clé et les valeurs min et max dans un dictionnaire Python ?

Enfin, vous pouvez disposer d'un grand dictionnaire et avoir besoin de voir les frontières ou les limites des valeurs qu'il contient.

Dans le code ci-dessous, quelques exemples de ce que vous pouvez parler devraient vous aider à expliquer vos connaissances.

#How do you get the min and max keys and values in a dictionary?
dict_values = {"First": 1,"Second": 2,"Third": 3}

#1. Get the minimum value and its associated key
minimum = min(dict_values.values())
print("The minimum value is:",minimum)
minimum_key = min(dict_values.items())
print(minimum_key)

#2. Get the maximum value and its associated key
maximum = max(dict_values.values())
print("The maximum value is:",maximum)
maximum_key = max(dict_values.items())
print(maximum_key)

#3. Get the min and the max key
minimum = min(dict_values.keys())
print("The minimum key is:",minimum)

#2. Get the maximum value and its associated key
maximum = max(dict_values.keys())
print("The maximum key is:",maximum)

Output:
The minimum value is: 1
('First', 1)
The maximum value is: 3
('Third', 3)
The minimum key is: First
The maximum key is: Third

Questions d'entretien sur la vue d'ensemble de Python

Estimation du temps de lecture : 4 procès-verbal

Vous avez donc décroché un entretien et travaillé dur pour améliorer vos connaissances de Python . Il y aura des questions sur Python et ses différents aspects dont vous devrez être capable de parler et qui ne concernent pas uniquement le codage !

Nous abordons ici certains des éléments clés que vous devez être à l'aise pour expliquer.

Quelles sont les principales caractéristiques de Python ?

Dans la capture d'écran ci-dessous qui figurera dans notre vidéo, si cette question vous est posée, ils vous aideront à pouvoir en discuter.

Je vous présente ci-dessous quelques-uns des principaux avantages dont vous devriez pouvoir discuter.

C'est un excellent outil, car il s'agit d'une source ouverte et bien supportée. Vous trouverez toujours une réponse à votre question quelque part.

De plus, comme il est facile à coder et à comprendre, la possibilité de se perfectionner rapidement et de fournir de bons programmes est un avantage considérable.

Comme il existe un grand nombre de plates-formes différentes, il a été adapté pour fonctionner facilement sur toutes les plates-formes sans trop d'effort. Il s'agit d'un coup de pouce considérable qui permet de l'utiliser dans un certain nombre d'environnements de développement sans trop d'ajustements.

Enfin, certains langages nécessitent que vous compiliez d'abord l'application, ce qui n'est pas le cas de Python : il s'exécute tout simplement.

Quelles sont les limites de Python ?

Si Python fait l'objet d'un grand nombre de discussions, il s'accompagne également de certaines réserves dont vous devriez pouvoir parler.

L'un des premiers points à aborder est que sa vitesse peut nuire aux performances d'une application. Si vous avez besoin de données en temps réel et que vous utilisez Python, vous devez tenir compte de la façon dont les performances seront inhibées par ce langage.

Il existe des scénarios dans lesquels une application est écrite dans une ancienne version du code, et vous voulez introduire de nouvelles fonctionnalités, avec une version plus récente. Cela peut entraîner des problèmes de non fonctionnement du code existant, qui doit être réécrit. Par conséquent, il faudra peut-être prévoir du temps de programmation supplémentaire pour résoudre les problèmes de compatibilité constatés.

Enfin, comme Python utilise beaucoup de mémoire, vous devez le placer sur un ordinateur ou un serveur capable de gérer les demandes de mémoire. Ceci est particulièrement important lorsque l'application est utilisée en temps réel et doit fournir des résultats assez rapidement à l'interface utilisateur.

À quoi sert Python ?

Comme détaillé ci-dessous, il existe de nombreuses utilisations de Python, cette liste n'est pas exhaustive je le précise.

Un thème commun à certains des points ci-dessous est que Python peut traiter des données et fournir des informations dont vous n'avez pas conscience et qui peuvent faciliter la prise de décision.

Il peut aussi être utilisé comme un outil d'automatisation ou de prédiction du comportement des sujets auxquels il se rapporte, parfois non évident, mais qui permet d'accélérer l'exécution de certaines tâches répétitives.

Quels sont les types de données supportés par Python ?

Enfin, vous trouverez ci-dessous une liste des types de données que vous devriez connaître et être en mesure de discuter. Certains d'entre eux sont fréquemment utilisés.

Celles-ci proviennent de la page Web des types de données Python elle-même, et constituent donc un bon point de référence si vous devez approfondir ou améliorer vos connaissances.

ValueError : Les colonnes doivent avoir la même longueur que la clé

Estimation du temps de lecture : 3 procès-verbal

Vous cherchez à apprendre le langage python et, ce faisant, vous rencontrez cette erreur et essayez de comprendre pourquoi elle se produit ?

En fait, cela se produit généralement lorsque vous avez plus d'un cadre de données et que, lors de l'écriture de votre programme, vous essayez d'utiliser les cadres de données et leurs données, mais qu'il y a un décalage dans le nombre d'éléments dans chacun d'eux que le programme ne peut pas traiter jusqu'à ce qu'il soit corrigé.

Un scénario courant où cela peut se produire est lorsque vous joignez des cadres de données ou que vous séparez des données, comme nous allons le voir ci-dessous.

Scénario 1 - Joindre des cadres de données

Lorsque nous avons df1[['a']] = df2, nous attribuons les valeurs du côté gauche du signe égal à ce qui se trouve à droite.

Lorsque nous regardons le côté droit, il y a trois colonnes, le côté gauche en a une.

En conséquence, l'erreur "ValueError: Columns must be same length as key" apparaîtra, comme ci-dessous.

import pandas as pd

list1 = [1,2,3]
list2 = [[4,5,6],[7,8,9]]

df1 = pd.DataFrame(list1,columns=['column1'])
df2 = pd.DataFrame(list2,columns=['column2','column3','column4'])

df1[['a']] = df2

Le code ci-dessus génère l'erreur suivante :

L'objectif ici est d'avoir toutes les colonnes du côté droit, à côté des colonnes du côté gauche comme suit :

Ce que nous avons fait, c'est rendre les deux côtés égaux en ce qui concerne le nombre de colonnes à afficher de df2
Essentiellement, nous prenons la colonne de DF1, puis nous apportons les trois colonnes de DF2.
Les colonnes colna, columnb, columnc ci-dessous correspondent aux trois colonnes de DF2, et stockeront les données de celles-ci.

La correction de ce problème est : df1[['columna', 'columnb', 'columnc']] = df2

print (df1)

Scénario 2 - Séparation des données

Il peut arriver que vous ayez une liste python et que vous deviez répartir les valeurs de cette liste dans des colonnes distinctes.

new_list1 = ['1 2 3']
df1_newlist = pd.DataFrame(new_list1,columns=['column1'])

Dans l'exemple ci-dessus, nous avons créé une liste, avec trois valeurs qui font partie d'une chaîne. Ici, ce que nous cherchons à faire est de créer une nouvelle colonne avec le code ci-dessous :

df1_newlist[["column1"]] = df1_newlist["column1"].str.split(" ", expand=True) #Splitting based on the space between the values.

print(df1_newlist)

Lorsque nous exécutons le programme ci-dessus, l'erreur suivante se produit :

La raison de l'erreur est que la logique a trois valeurs à répartir en trois colonnes, mais nous n'avons défini qu'une seule colonne dans df1_newlist[["column1"]].

Pour corriger cela, nous exécutons le code ci-dessous :

df1_newlist[["column1","column2","column3"]] = df1_newlist["column1"].str.split(" ", expand=True) #Splitting based on the space between the values.

print(df1_newlist)

Cela renvoie la sortie suivante, avec le problème résolu !

Comment vérifier les caractères indésirables à l'aide de boucles avec Python ?

Estimation du temps de lecture : 3 procès-verbal

Sur ce site, nous avons publié des articles sur la façon de supprimer les caractères indésirables de vos données et sur la façon de supprimer les caractères d'un fichier CSV importé. Ces deux articles vous montrent différentes approches.

Dans ce billet de blog, nous allons aborder le processus en utilisant des boucles dans une fonction. Essentiellement, nous allons passer une liste , puis nous allons parcourir en boucle les chaînes de caractères pour vérifier les données par rapport à cette liste.

Étape 1 - Importation des données et création d'un cadre de données

Le premier travail que nous devons effectuer est de charger les données. Ici, nous créons un dictionnaire avec leurs paires clé-valeur respectives.

Afin de préparer les données à être traitées par la fonction de l'étape 2, nous les chargeons ensuite dans un cadre de données.

import pandas as pd
#Create a dataset locally
data = {'Number':  ["00&00$000", '111$11111','2222€2222','3333333*33','444444444£','555/55555','666666@666666'],
        'Error' : ['0','0','0','0','0','0','0']}

#Create a dataframe and tell it where to get its values from
df = pd.DataFrame (data, columns = ['Number','Error'])

Étape 2 - Créez la fonction qui vérifie les données invalides.

C'est la pièce principale de la logique qui donne la sortie. Comme vous pouvez le voir, il y a une liste "L" qui est envoyée à la fonction run.

Une chose à noter est que *l est passé à la fonction, car il y a plus d'une valeur dans la liste, sinon le programme ne s'exécuterait pas correctement.

Pour commencer, nous créons un cadre de données, qui extrait à l'aide d'une expression régulière les caractères que nous ne voulons pas avoir.

Ensuite, nous devons supprimer une colonne qui est générée avec des valeurs NAN, car celles-ci ne sont pas nécessaires.

Ensuite, nous avons mis à jour la célébrité des données originales avec les valeurs que nous avons trouvées.

Au cas où il y aurait des valeurs NAN dans cette colonne "Erreur" mise à jour, nous les supprimons sur la ligne suivante.

Le principal élément suivant est la boucle qui crée une nouvelle colonne appelée "Fix". Elle contient les valeurs qui seront introduites dans le correctif après que les données que nous ne voulons pas soient supprimées et que les données soient nettoyées.

Les données dont nous n'avons pas besoin se trouvent dans str.replace.

#Function to loop through the dataset and see if any of the list values below are found and replace them
def run(*l):
    #This line extracts all the special characters into a new column
    #Using regular expressions it finds values that should not appear
    df2 = df['Number'].str.extract('(\D+|^(0)$)') # New dataframe to get extraction we need
    print(df2)
    df2 = df2.drop(1, axis=1) # Drops the column with NAN in it, not required

    df['Error'] = df2[0] # Updates original dataframe with values that need to be removed.
    #This line removes anything with a null value
    df.dropna(subset=['Error'], inplace=True)
    #This line reads in the list and assigns it a value i, to each element of the list.
    #Each i value assigned also assigns an index number to the list value.
    #The index value is then used to check whether the value associated with it is in the df['Number'] column 
    #and then replaces if found
    for i in l:
        df['Fix']= df['Number'].str.replace(i[0],"").str.replace(i[1],"").str.replace(i[2],"").str.replace(i[3],"") \
        .str.replace(i[4],"").str.replace(i[5],"").str.replace(i[6],"")
        print("Error list to check against")
        print(i[0])
        print(i[1])
        print(i[2])
        print(i[3])
        print(i[4])
        print(i[5])
        print(i[6])
    print(df)

#This is the list of errors you want to check for
l = ['$','*','€','&','£','/','@']

Étape 3 - Exécuter le programme

Pour exécuter ce programme, il suffit d'exécuter le code ci-dessous. Tout ce qu'il fait est de lire la liste "L" dans la fonction "run" et de produire la sortie de l'étape 4.

run(l)

Étape 4 - Sortie

Error list to check against
$
*
€
&
£
/
@
          Number Error           Fix
0      00&00$000     &       0000000
1      111$11111     $      11111111
2      2222€2222     €      22222222
3     3333333*33     *     333333333
4     444444444£     £     444444444
5      555/55555     /      55555555
6  666666@666666     @  666666666666

Process finished with exit code 0

Comment créer plusieurs fichiers XML à partir d'Excel avec Python

Vous disposez donc d'un fichier Excel contenant des centaines, voire des milliers d'enregistrements, mais vous souhaitez le convertir en fichier XML et faire en sorte que chaque ligne constitue un fichier distinct ?

Cela peut être réalisé très facilement en utilisant Python, en trois étapes simples.

Tout d'abord, qu'est-ce que le XML ?

XML est l'abréviation de "extensible markup language" (langage de balisage extensible). Il est largement utilisé dans les sites web, les services web et lorsque les entreprises souhaitent transférer des données entre elles dans un format prédéfini qui suit une norme reconnue.

Pour en savoir plus sur ce qu'est le xml, suivez le lien. Une chose à noter est qu'il peut faire référence au secteur des services financiers, mais le XML est largement utilisé dans de nombreux secteurs également. Comme nous numérisons maintenant beaucoup de nos processus, le transfert de données doit suivre une norme avec laquelle tout le monde peut travailler de manière transparente.

Étape 1 - Regardons nos données brutes

Vous trouverez ci-dessous un fichier Excel comportant trois colonnes et huit lignes. L'objectif est de créer huit fichiers XML distincts pour chaque ligne.

données brutes pour alimenter plusieurs fichiers excel

Étape 2 - Importation des données et création d'un fichier maître XML

Vous trouverez ci-dessous la logique que j'ai utilisée dans Comment créer un fichier XML à partir d'Excel en utilisant Python. J'ai joint des commentaires lorsque cela était nécessaire pour expliquer ce que fait chaque ligne.

L'objectif à ce stade est de créer un fichier contenant toutes les données d'Excel, appelé output.xml. Nous l'utiliserons ensuite pour créer les fichiers séparés dont nous avons besoin, puis nous le supprimerons.

Les étapes suivantes vous permettront de le faire.

import pandas as pd
from lxml import etree as et
import os


# STEP 1 - This step creates a master XML file

raw_data = pd.read_excel(r'\Users\haugh\OneDrive\dataanalyticsireland\YOUTUBE\how_to_read_each_excel_row_into_a_separate_XML_file\excel_raw_data_city.xlsx')

root = et.Element('root')

for row in raw_data.iterrows(): #==> This is a loop that takes runs through each record and populates for each tag.
    root_tags = et.SubElement(root, 'ExportData') #=== > Root name
# These are the tag names for each row (SECTION 1)
    Column_heading_1 = et.SubElement(root_tags, 'City')
    Column_heading_2 = et.SubElement(root_tags, 'Area')
    Column_heading_3 = et.SubElement(root_tags, 'Population')


###These are the values that will be populated for each row above
# The values inside the [] are the raw file column headings.(SECTION 2)
    Column_heading_1.text = str(row[1]['City'])
    Column_heading_2.text = str(row[1]['Area'])
    Column_heading_3.text = str(row[1]['Population'])

# This Section outputs the data to an xml file
# Unless you tell it otherwise it saves it to the same folder as the script.
tree = et.ElementTree(root) #==> The variable tree is to hold all the values of "root"
et.indent(tree, space="\t", level=0) #===> This just formats in a way that the XML is readable
tree.write('output.xml', encoding="utf-8") #==> The data is saved to an XML file

Étape 3 - Bouclez à travers chaque ligne et créez les fichiers séparés

Dans le code ci-dessous, il ouvre le fichier output.xml et utilise la boucle pour rechercher toutes les données entre les balises "ExportData".

Ensuite, il les copie et crée un nouveau fichier.

Une fois l'une d'entre elles terminée, il passe à l'ensemble de balises suivant et répète le processus jusqu'à ce qu'il atteigne la fin du fichier output.xml.

master_file = et.iterparse('output.xml', events=('end', ))
index = 0
for i, j in master_file:
    if j.tag == 'ExportData':
        index += 1
        filename = format(str(index) + ".xml")
        with open(filename, 'wb') as f:
            f.write(et.tostring(j))

Étape 4 - Supprimer le fichier output.xml - purement facultatif

L'objectif ici était de créer des fichiers XML séparés, basés sur l'entrée du fichier Excel original.

Nous avons également créé un fichier supplémentaire appelé output.xml pour nous permettre d'atteindre notre objectif final.

Si nous n'avons pas besoin de ce fichier, il peut être supprimé avec le code ci-dessous, assurez-vous qu'il est à la toute fin de votre logique.

L'instruction d'importation pour os.unlink se trouve à l'étape 2.

os.unlink(r'\Users\haugh\OneDrive\dataanalyticsireland\YOUTUBE\how_to_read_each_excel_row_into_a_separate_XML_file\output.xml')

Comment corriger l'erreur de type : type 'slice' non hachable.

Estimation du temps de lecture : 2 procès-verbal

Vous disposez donc d'un dictionnaire Python, et vous souhaitez en extraire des données et les imprimer sur un écran. Il y a quelques caractéristiques de Python qu'il faut d'abord comprendre :

  1. Ils sont mutables
  2. Ils ont également la capacité de croître et de rétrécir selon les besoins.
  3. Les données sont accessibles dans le dictionnaire par le biais de clés.

Le dernier point est très important car les dictionnaires n'ont pas de valeur d'index, et c'est pourquoi vous obtenez l'erreur de type (TypeError) que vous devez résoudre ici.

Recréons donc le problème

Dans le code ci-dessous, nous avons un dictionnaire appelé "userdata", avec ses paires clé-valeur.

La boucle essaie de récupérer la valeur d'index 1 pour toutes les valeurs de dai_data.

Comme on peut le voir, dai_data essaie de récupérer les trois dernières valeurs d'index dans le dictionnaire.

Comme indiqué ci-dessus, le seul moyen d'accéder aux valeurs du dictionnaire est de passer par les valeurs de leurs clés.

userdata = {
	  "name": "Data Analytics Ireland",
	  "Country": "Ireland",
	  "City": "Dublin",
	  "Age": "1000 years!",
}

dai_data = userdata[:3]

for i in dai_data:
	     print(i[1])

Output:
Traceback (most recent call last):
  File "", line 8, in <module>
    dai_data = userdata[:3]
TypeError: unhashable type: 'slice'

Alors comment résoudre ce problème ?

Tout d'abord, les valeurs sont accessibles par la clé dans le dictionnaire

Dans le dictionnaire ci-dessous, les valeurs clés sont : Nom, Pays, Ville, Age

userdata = {
	  "Name": "Data Analytics Ireland",
	  "Country": "Ireland",
	  "City": "Dublin",
	  "Age": "1000 years!",
}

print(userdata["Name"])
print(userdata["Country"])
print(userdata["City"])
print(userdata["Age"])

Output:
Data Analytics Ireland
Ireland
Dublin
1000 years!

En conséquence, nous sommes maintenant en mesure d'accéder aux valeurs associées à chaque clé.

Saviez-vous que vous pouviez ajouter une liste à l'une de vos paires clé-valeur ?

Dans l'exemple ci-dessus, nous nous sommes concentrés sur une seule valeur, mais nous pourrions également rendre une clé égale à une liste.

userdata = {
	  "Name": ["Joe","Jim"],
	  "Country": "Ireland",
	  "City": ["Dublin","Cork","Limerick"],
	  "Age": "1000 years!"
}

print(userdata["Name"])
print(userdata["Country"])
print(userdata["City"])
print(userdata["Age"])

Output:
['Joe', 'Jim']
Ireland
['Dublin', 'Cork', 'Limerick']
1000 years!

Comment exécuter la validation Python à partir de Javascript

Estimation du temps de lecture : 6 procès-verbal

De plus en plus, les développeurs de sites web cherchent à combiner différentes technologies de programmation pour leur permettre d'utiliser des fonctionnalités qui ne sont peut-être pas disponibles dans le langage de programmation actuel qu'ils utilisent.

Dans les articles précédents, comment passer des variables Python à Javascript et comment exécuter Python directement depuis Javascript, nous avons abordé la manière d'utiliser Python et Javascript de manière interchangeable pour passer des données.

Dans ce billet de blog, nous allons nous intéresser à la validation de données à l'aide de Python, avec des données capturées par Javascript. Le but ici est de permettre une autre façon de valider des données que de s'appuyer sur Javascript.

Validation de Python à partir de Javascript

Il y a plusieurs raisons à cela :

  1. Vous voudrez peut-être utiliser Python pour traiter les données et fournir des résultats.
  2. Les données peuvent être transmises de Python à une base de données, mais vous devez effectuer quelques vérifications avant de procéder.
  3. Python est votre langage de base, vous n'utilisez Javascript que pour capturer les données et les transmettre depuis un site web.

Il existe quatre contrôles de validation

  1. Validation si un nom d'utilisateur existe.
  2. Validation si un nombre a été saisi dans un champ de nom d'utilisateur.
  3. Validation d'un mot de passe saisi.
  4. Un contrôle de validation pour s'assurer que l'adresse électronique saisie est au bon format.

Nous avons deux fichiers contenant le code requis comme suit :

  1. app.py ===> Comme cette application est construite en Python Flask, ce fichier contient la logique d'ouverture des fichiers du site web, et il contient les contrôles de validation Python .
  2. index.html ====> Ce fichier contient le HTML qui crée les pages, les étiquettes et les boîtes de saisie qui apparaissent dans le navigateur Web. Il comprend également le Javascript qui capturera les données à transmettre à Python pour validation.

Aperçu du code - App.PY

Je vais tenter d'expliquer ce qui se passe comme suit :

La variable Regex est utilisée dans la validation de l'email pour vérifier si l'email saisi est correct.

def inputcheck ===> Il s'agit juste de vérifier le nom d'utilisateur transmis et d'effectuer quelques validations sur celui-ci.

def inputvalidation ====> Ceci vérifie également le nom d'utilisateur, mais en regardant si seuls des chiffres sont saisis, ou s'il est vide.

def passvalidation ====> Dans ce morceau de logique, il vérifie si le mot de passe est vide, s'il comporte moins de cinq caractères et s'il est composé uniquement de chiffres.

def emailvalidation ====> Tout ce que cela fait est de vérifier si les données reçues du Javascript sont dans le format correct de l'email. Elle fait référence à la variable regex ci-dessus, qui est utilisée pour confirmer si le format est correct ou non.

Dans chacune des fonctions, il y a des instructions if qui sont les contrôles de validation de base utilisés par Python.

De plus, tous les menus déroulants utilisent ctypes, ce qui vous permet d'accéder aux bibliothèques de fenêtres qui contiennent des boîtes de messages, de les personnaliser et de les appeler dans votre programme.

import json
import ctypes
import re
from flask import request,redirect,url_for

from flask import Flask, render_template

app = Flask(__name__)

regex = '^[a-z0-9]+[\._]?[a-z0-9]+[@]\w+[.]\w{2,3}$'

@app.route('/')
def index():
    return render_template('index.html')


@app.route('/inputcheck', methods=['GET','POST'])
def inputcheck():
    output = request.get_json()
    result = json.loads(output) #this converts the json output to a python dictionary
    username_list = ['joe','john']
    if result['username'] in username_list:
        MessageBox = ctypes.windll.user32.MessageBoxW(0, 'Username ' + result['username'] + ' ' + 'exists', "Username check", 0x00001000)
        return render_template('various.html')
    elif result['username'] == '':
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'You cannot enter an empty value', 'Username check', 0x00001000)
    else:
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Username ' + result['username'] + ' ' + 'does not exist', 'Username check', 0x00001000)

@app.route('/inputvalidation', methods=['GET','POST'])
def inputvalidation():
    output = request.get_json()
    result = json.loads(output) #this converts the json output to a python dictionary
    if result['username'].isdecimal():
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your username cannot be numbers',"Number check", 0x00001000)
    elif result['username'] == '':
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'The username cannot be empty', "Number check",0x00001000)
    else:
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your username looks ok', "Number check", 0x00001000)
    return render_template('index.html')

@app.route('/passvalidation', methods=['GET','POST'])
def passvalidation():
    output = request.get_json()
    result = json.loads(output) #this converts the json output to a python dictionary
    if result['password'].isdecimal():
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your password cannot be numbers',"Password check", 0x00001000)
    elif result['password'] == '':
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'The password cannot be empty', "Password empty check",0x00001000)
    elif len(result['password']) < 5:
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your username should be greater than five characters', "Password length check", 0x00001000)
    else:
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your password looks ok', "Number check", 0x00001000)
    return render_template('index.html')

@app.route('/emailvalidation', methods=['GET','POST'])
def emailvalidation():
    output = request.get_json()
    result = json.loads(output) #this converts the json output to a python dictionary
    if re.search(regex, result['email']):
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your email is in the correct format', "Email check", 0x00001000)
    else:
        MessageBox = ctypes.windll.user32.MessageBoxW(None, 'Your email is invalid, please correct', "Email check", 0x00001000)
    return render_template('index.html')



if __name__ == "__main__":
    app.run(debug=True)


Aperçu du code - Index.html

Le code ci-dessous est le code de la page, qui permet de capturer des données à travers une page HTML d'un navigateur web.

Between the <style></style> tags these are the CSS properties that format the labels and buttons on the page.

Within the <div></div> tags are where we create the labels and buttons to show on the screen. Also within these, are the references to the on click event function that should run once the buttons are clicked.

Within the <script></script> tags, this is where the javascript is written which captures the data entered into the input boxes within the <div> tags.

Vous verrez également que dans ce javascript, il y a des sections appelées $.ajax, où les données capturées par le javascript sont stockées, puis transmises au fichier script Python (app.py).

Notez que dans chaque ajax, url :"/APAGENAME" est référencé. Ce sont les sections du fichier app.py auxquelles les données sont transmises, puis la logique Python intervient et valide les données.

<html lang="en">

<head>

    <title>Data Analytics Ireland</title></head>
<style>
.button1 {
    position: absolute;
    top: 50%;
    left: 55%;
    width: 900px;
    height: 300px;
    margin-left: -300px;
    margin-top: -80px;
}



.labels {
    position: absolute;
    top: 50%;
    left: 55%;
    width: 900px;
    height: 300px;
    margin-left: -300px;
    margin-top: -150px;
}

</style>

<body>



<div class="labels" id="mem1" >
<label  for="username">username:</label> <input type="text" id="username" name="username">
<label for="password">password:</label><input type="text" id="password" name="password">
    <label for="email">email:</label><input type="text" id="email" name="password">
</div>


<div class="button1" id="mem2" >
<button type="submit" onclick='myfunction();'>Click here to validate your username</button>
<button type="submit" onclick='myfunctionval();'>Click here to check if a number</button>
    <button type="submit" onclick='myfunctionpass();'>Click here to check password</button>
      <button type="submit" onclick='myfunctionemail();'>Click here to check your email</button>
</div>


<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.5/jquery.min.js"></script>

<script>
    function myfunction() {

        const username = document.getElementById("username").value;
        const password = document.getElementById("password").value;


        const dict_values = {username, password} //Pass the javascript variables to a dictionary.
        const s = JSON.stringify(dict_values); // Stringify converts a JavaScript object or value to JSON.
        console.log(s); // Prints the variables to console window, which are in the JSON format
        //window.alert(s)
        $.ajax({
            url:"/inputcheck",
            type:"POST",
            contentType: "application/json",
            data: JSON.stringify(s)});
}
</script>
<script>
    function myfunctionval() {

        const username = document.getElementById("username").value;
        const password = document.getElementById("password").value;


        const dict_values = {username, password} //Pass the javascript variables to a dictionary.
        const s = JSON.stringify(dict_values); // Stringify converts a JavaScript object or value to JSON.
        console.log(s); // Prints the variables to console window, which are in the JSON format
        //window.alert(s)
        $.ajax({
            url:"/inputvalidation",
            type:"POST",
            contentType: "application/json",
            data: JSON.stringify(s)});
}
</script>

<script>
    function myfunctionpass() {

        const username = document.getElementById("username").value;
        const password = document.getElementById("password").value;


        const dict_values = {username, password} //Pass the javascript variables to a dictionary.
        const s = JSON.stringify(dict_values); // Stringify converts a JavaScript object or value to JSON.
        console.log(s); // Prints the variables to console window, which are in the JSON format
        //window.alert(s)
        $.ajax({
            url:"/passvalidation",
            type:"POST",
            contentType: "application/json",
            data: JSON.stringify(s)});
}
</script>

<script>
    function myfunctionemail() {

        const email = document.getElementById("email").value;


        const dict_values = {email} //Pass the javascript variables to a dictionary.
        const s = JSON.stringify(dict_values); // Stringify converts a JavaScript object or value to JSON.
        console.log(s); // Prints the variables to console window, which are in the JSON format
        //window.alert(s)
        $.ajax({
            url:"/emailvalidation",
            type:"POST",
            contentType: "application/json",
            data: JSON.stringify(s)});
}
</script>




</body>
</html>

Comment passer des variables Python à Javascript

Estimation du temps de lecture : 4 procès-verbal

Dans notre récent article de blog intitulé " Comment transmettre une variable Javascript à Python en utilisant JSON", nous avons montré comment utiliser facilement AJAX pour transmettre les données que vous souhaitez et les manipuler avec Python.

Dans cet article de blog, nous allons montrer comment faire l'inverse. Le scénario est le suivant : vous avez une application ou un site Web qui souhaite utiliser des données générées par Python, tout en laissant Javascript les utiliser au sein de l'application.

Comme Python peut être connecté à de nombreuses bases de données et fichiers (txt, excel), etc., cette partie de la logique est très utile pour le programmeur qui cherche à intégrer les deux langages de programmation.

Commençons par examiner le code, et voyons comment cela peut être réalisé.

Étape 1 - Quels sont les fichiers générés ?

Ce programme utilise Python Flask pour créer une page web, qui a un menu déroulant. Les deux fichiers utilisés pour le générer sont les suivants :

(A) app.py - Il s'agit du fichier python qui crée un site Web et charge un fichier HTML modèle comme indiqué ci-dessous.

(B) Index.html - Il s'agit du fichier modèle qui se charge dans le navigateur et exécute tout le javascript. Le javascript chargé ici charge également les données python transmises par app.py.

Étape 2 - Aperçu du code APP.PY

La bibliothèque Python qui permet la création de pages web s'appelle Flask, et comme on peut le voir ci-dessous, elle doit être importée.

En outre, nous devons également importer render_template qui indique au programme d'aller dans le dossier des modèles et de charger "Index.HTML".

La variable transmise à JavaScript s'appelle nom, et ce sont les valeurs que vous verrez dans le navigateur Web lorsqu'il sera chargé.

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def index():
    name = ['Joe','John','Jim','Paul','Niall','Tom']
    return render_template('index.html', name=name)

if __name__ == "__main__":
    app.run(debug=True)

Étape 3 - Aperçu de Index.HTML

Voici le fichier HTML du modèle qui s'exécute dans le navigateur. Vous pouvez y ajouter des feuilles de style en cascade (CSS) pour le rendre plus agréable et plus convivial.

Comme vous pouvez le voir, il comporte les balises HTML habituelles qui apparaissent dans le cadre d'un site web.

Regardez un peu plus loin le code :

In this bit <select id =’select’> </select>, this is the dropdown menu that will appear when Index.html is opened. It will store all the values passed from python. Note that its id is “select”, this will be used later on.

The main parts to focus on next is between <script></script>. This is what reads in the python data and populates it to the dropdown menu.

Dans l'étape 2, nous avons mentionné qu'il y avait une variable appelée "nom", avec des valeurs à transmettre.

Ceci est réalisé sur cette ligne :

var select = document.getElementById(“select”), test = {{ name | tojson }};

Remarquez que le nom apparaît ici et qu'il fait référence à la même valeur que celle mentionnée à l'étape 2.

Pour le reste des lignes, j'ai expliqué avec des commentaires ce que chacune fait.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Pass Python variable to Javascript</title>
</head>
<body>

<select id ='selectvalue'>
</select>
<script>
    //name = ['Joe','John','Jim','Paul','Niall','Tom']

    var selectvalue = document.getElementById("selectvalue"), test = {{ name | tojson }};
    //The increment operator (++) increments (adds one to) its operand and returns a value.
    for(var i = 0; i < test.length; i++) // This line checks for the length of the data you feeding in i.e the no of items
         {
var selection = document.createElement("OPTION"), // This line creates a variable to store the different values fed in from the JSON object "TEST"
txt = document.createTextNode(test[i]); // This just reads each value from the test JSON variable above
selection.appendChild(txt); // This line appends each value as it is read.
selection.setAttribute("value",test[i]); // This line sets each value read in as a value for the drop down
selectvalue.insertBefore(selection,selectvalue.lastChild); //This reads eah value into the dropdown based on the order in the "TEST" above.
 }
</script>
</body>
</html>

Étape 4 - Ce à quoi ressemble le résultat !

Depuis l'étape 2, ce sont les valeurs que nous avons demandé d'utiliser en Javascript pour remplir une liste déroulante :

nom = ['Joe', 'John', 'Jim', 'Paul', 'Niall', 'Tom']

Variable Python passée à Javascript

Comment passer plusieurs listes à une fonction et les comparer ?

Estimation du temps de lecture : 3 procès-verbal

Avez-vous déjà été confronté à une situation où vous avez plusieurs listes que vous voulez comparer, et où vous avez besoin d'une fonction qui les lira et vous montrera ce qui est différent entre elles ?

Dans ce scénario, cela peut être pratique lorsque vous disposez de grands ensembles de données et que vous avez besoin d'un moyen rapide de trouver ces différences et de les corriger le cas échéant.

Comparaison de deux listes

Regardons et voyons ce qui se passe ci-dessous.

Tout d'abord, nous avons défini deux listes. La seule différence entre les deux est que l'une a une valeur de six, l'autre non.

Ensuite, nous avons la fonction "comparelists". Elle prend les deux listes comme paramètres (a,b), puis les traite.

Les listes sont passées comme arguments aux paramètres dans cette ligne ===> comparelists(list1,list2)

Les paramètres a sont affectés à la liste1, et b est affecté à la liste2.

La partie principale de la fonction est la compréhension de la liste, et elle fait ce qui suit :

  1. x pour x revient à créer une variable x, et à lancer une boucle qui passe en revue toutes les valeurs de b.
  2. Chaque itération de x est stockée et comparée à a.
  3. "Si x n'est pas dans a" achève la comparaison et, si elle est vraie, renvoie la valeur, sinon passe à la valeur suivante.

En conséquence de cette logique, on peut voir que six est la seule valeur renvoyée, et c'est ce que nous attendons sur la base d'une inspection visuelle.

#Reading in two lists
list1 = [1,2,3,4,5] # parameter a below
list2 = [1,2,3,4,5,6] # parameter b below

def comparelists(a,b):
    z = [x for x in b if x not in a] #list comprehension
    print(z)

comparelists(list1,list2)

Output:

[6]

Comparaison de plus de deux listes

Dans la logique ci-dessus, nous avons vu que deux listes peuvent être comparées. Mais que faire si l'on veut comparer une liste à deux autres listes ?

C'est facile à faire, avec quelques modifications du code.

Comme précédemment, les trois listes sont définies, créées comme arguments dans comparelists(list1,list2,list3), puis passées aux paramètres a,b,c de la fonction.

La seule différence dans cette logique est que la compréhension de la liste est écrite un peu différemment comme suit :

  1. x for x revient à créer une variable x et à lancer une boucle qui parcourt toutes les valeurs de b. ====> C'est la même chose que ci-dessus.
  2. Chaque itération de x est stockée et comparée à a et c ===> Cette ligne est différente car elle compare maintenant à deux listes.
  3. "si x n'est pas dans a et x n'est pas dans c" ====> Ici nous avons deux comparaisons
    • Vérification de la valeur x de b dans a
    • Vérification de la valeur x de b dans c
  4. La valeur de six est correcte car elle ne figure ni dans a ni dans c.
  5. Notez que l'instruction if est spécifique quant aux éléments à vérifier avec l'instruction "et". Elle peut être modifiée en fonction de vos besoins.
list1 = [1,2,3,4,5] # parameter a below
list2 = [1,2,3,4,5,6] # parameter b below
list3 = [1,2,3,7,8,9] # parameter c below

def comparelists(a,b,c):
    z = [x for x in b
         if x not in a and x not in c] #list comprehension
    print(z)

comparelists(list1,list2,list3)

Output:
[6]

Comment utiliser les paramètres en Python

Estimation du temps de lecture : 5 procès-verbal

Vous utilisez une fonction et vous cherchez à lui transmettre des valeurs à traiter ? Si c'est le cas, vous essayez de passer des arguments aux paramètres de cette fonction afin qu'elle vous renvoie une valeur.

Les paramètres sont simplement des valeurs qui sont associées à la fonction. Pour chaque fonction, vous aurez un ou plusieurs paramètres qu'elle devra traiter.

Par conséquent, il y a plusieurs façons de les créer, explorons comment cela peut être réalisé.

Passage d'arguments directement dans les paramètres d'une fonction

Dans de nombreux cas, les valeurs des arguments à traiter sont transmises aux paramètres de la fonction, qui exécute ensuite une certaine logique et renvoie une valeur.

Les façons typiques dont cela peut se produire :

  1. Un mot de passe est saisi (l'argument saisi), la fonction confirme ensuite s'il est valide ou non.
  2. Vous pouvez avoir besoin de vérifier si une valeur saisie (l'argument d'entrée) est supérieure ou inférieure à une certaine valeur. Il est transmis à un paramètre de la fonction, puis la fonction effectue les contrôles nécessaires et confirme le résultat dans la sortie.

Les exemples ci-dessus sont deux exemples, mais voyons cela en action.

Ci-dessous, nous avons une fonction. Le but est de prendre deux arguments qui lui sont passés et d'effectuer un calcul sur ceux-ci.

Le calcul se fait dans la variable numéro 1 ou numéro 2.

La variable numéro 1 et la variable numéro 2 obtiennent leurs valeurs à partir des paramètres a et b respectivement.

La ligne multiplenumber(1,2) appelle simplement la fonction et passe les arguments aux paramètres a,b qui les traitent ensuite et la sortie est imprimée.

def multiplenumber(a,b):
    number1 = a*2
    number2 = b*3
    print(number1,number2) #===> These values are different to the variables below as they happen as a result of the processing inside the function.

number1=1
number2=2
multiplenumber(number1,number2)
print(number1,number2) #===> These values are outside the function and do not have any relationship to the variables inside the function above, hence are different.

Result:
2 6
1 2

Le résultat du morceau de logique ci-dessus est appelé "Passage par valeur", ce qui signifie essentiellement que les données sont passées des variables ( numéro 1 et numéro 2) aux paramètres de la fonction, mais que lorsque le traitement de la fonction est terminé, il n'y a pas d'impact sur les variables originales en dehors de la fonction.

En effet, les variables d'origine sont immuables.

Passage d'arguments directement en paramètres de fonction à partir d'une liste

Dans l'exemple ci-dessus, comme indiqué, il n'y aura aucun impact sur les variables qui passent les arguments dans la fonction, elles restent les mêmes.

En revanche, si la source originale des arguments est un objet mutable, ses valeurs seront modifiées.

Examinons une situation dans laquelle cela peut se produire.

def addnumber(a):
    number=['3']
    a.append(number)
    print(a) #===> This prints the original value of a with the addition of the value 3

number1=[1,2]
addnumber(number1)
print(number1) #===> As number1 is passed to the function, and number1 is allowed to be changed then this will print out the new list value once the function has completed processing.

Result:
[1, 2, ['3']]
[1, 2, ['3']]

Ainsi, dans ce cas, comme number1 est une liste, et que celle-ci est mutable, sa valeur changera une fois que la fonction aura terminé son traitement.

Cela peut également être appelé "passage par référence".

Passage d'arguments entre fonctions

Dans une autre vidéo, nous avons expliqué comment passer des données entre des fonctions. Cette vidéo explique comment passer les données entre deux fonctions et les imprimer.

Effectivement, dans l'exemple ci-dessous, les arguments sont le nom, le pays, la ville, et ces valeurs sont passées à la fonctionb.

def functiona() :
    nom = "Joseph" 
    pays = "Mars 
    ville = "atlantis" 
    #cette fonction capture les trois variables ci-dessus
    return name,country,city
functiona()

def functionb() :
    monnom,monpays,maville = functiona()
    print(mon nom)
    print(mon pays)
    print(ville)

functionb()

Résultat :
Joseph
Mars
atlantis

Passage d'arguments en utilisant *args comme paramètre

Afin de comprendre cela, avant de regarder du code, nous devons comprendre ce que sont les *args ?

*args vous permet essentiellement de passer plusieurs arguments positionnels à une fonction, et cela peut varier dans le temps.

Par conséquent, vous n'avez pas besoin d'assigner les arguments positionnels à plus d'une variable. Les *args prennent en compte tous les arguments, qu'ils soient longs ou courts, puis renvoient une valeur.

def addnumbers(*args):
    result = 2
    for x in args:
        result = result * x
    return result

print(addnumbers(1,2,3))

Result:
12

Passage d'arguments en utilisant **kwargs comme paramètre

Contrairement à ce qui précède, cette méthode traite un ensemble de valeurs auxquelles est associé un nom.

Comme on peut le voir dans l'exemple précédent, les arguments passés n'avaient pas de nom attaché à eux.

Examinons de près un exemple. Dans ce scénario, les arguments sont affectés d'une valeur de a,b,c.

def addnumbers(**kwargs):
    result = 2
    for x in kwargs.values():
        result = result * x
    return result

print(addnumbers(a=1,b=2,c=3))

Result:
12

Ici, il est clair que la logique prend chaque valeur de a,b,c, la traite et renvoie ensuite le résultat requis.

En fait, *args et **kwargs vous donnent tous deux la même réponse, cela dépend simplement des autres parties de votre code et de la façon dont il traite vos données.

Par exemple, dans les **kwargs, il se pourrait que les valeurs de a,b,c soient remplies par d'autres variables dans le programme.

Ainsi, dans ce scénario, la variable qui a été transmise peut changer et ne pas être statique.

Donc, en résumé :

a. Les arguments peuvent être transmis de plusieurs manières aux fonctions, les paramètres ne faisant alors que les traiter.

b. Les paramètres n'ont pas non plus besoin d'être assignés à une variable, ils peuvent être lus à travers *args.

c. D'autre part, vous pouvez avoir plusieurs arguments lus en même temps en utilisant **kwargs.