Introduction à Python

Dans cet article, nous couvrirons les bases de Python. Nous nous rapprochons de plus en plus de l'objectif, en général, nous commencerons bientôt à travailler avec les bibliothèques principales de Data Science et utiliserons TensorFlow (pour écrire et déployer des réseaux de neurones, vous comprendrez le Deep Learning).

L'installation

Python peut être téléchargé sur python.org. Cependant, s'il n'est pas déjà installé, alors à la place
Je recommande le package de distribution Anaconda, qui comprend déjà la plupart des bibliothèques nécessaires pour travailler dans le domaine de la science des données.

Si vous n'utilisez pas la distribution Anaconda, assurez-vous d'installer le gestionnaire de packages pip, ce qui facilite l'installation de packages tiers, car nous en aurons besoin. Il vaut également la peine d'installer le shell IPython interactif beaucoup plus convivial. Gardez à l'esprit que la distribution Anaconda est livrée avec pip et IPython.

Espace blanc

De nombreux langages de programmation utilisent des blocs de code différenciateurs.
accolades. L'indentation est utilisée en Python:

#      for for i in [ 1, 2, 3, 4, 5] : print (i) #     for i for j in (1, 2, , 4, 5 ] : print ( j ) #     for j print (i + j) #     for j print (i) #     for i print ( "  ") 

Cela rend le code facile à lire, mais en même temps, il suit le formatage. L'espace entre parenthèses et crochets est ignoré, ce qui facilite l'écriture d'expressions verbeuses:

 #    long_winded_computation = (1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 15 + 16 + 17 + 18 + 19 + 20) 

et code facile à lire:

 #   list_of_lists = [ [ 1 , 2, 3 ) , [4, 5, 6 ] , [ 7 , 8, 9 ] ] #      easy_to_read_list_of_lists = [1, 2, 3 ) , [4, 5, 6 ) , [7, 8, 9 ) ] 

Pour continuer l'instruction, la barre oblique inverse est utilisée sur la ligne suivante, cependant, un tel enregistrement sera rarement utilisé:

 two_plus_three = 2 + \ 3 

Le formatage du code avec des espaces rend difficile la copie et le collage de code dans le shell Python. Par exemple, en essayant de copier le code suivant:

 for i in [ 1, 2, 3, 4, 5] : #      print (1) 

dans le shell Python standard générera une erreur:

 #    :     IndentationError : expected an indented blk 

car pour l'interpréteur, une chaîne vide indique la fin d'un bloc de code avec une boucle for.

L'encapsuleur IPython a une fonction% magique «magique» qui colle correctement tout dans le presse-papiers, y compris les espaces.

Modules (importation de bibliothèques)

Certaines bibliothèques d'environnement de programmation basées sur Python ne sont pas chargées par défaut. Pour pouvoir utiliser ces outils, vous devez importer les modules qui les contiennent.

Une approche consiste à simplement importer le module lui-même:

 import re my_regex = re.compile ("[0-9]+",re.I) 

Voici le nom du module contenant des fonctions et des constantes pour travailler avec des expressions régulières. En important le module entier de cette manière, vous pouvez accéder aux fonctions en les préfixant avec re.

Si le code portant le nom re existe déjà dans le code, vous pouvez utiliser l'alias du module:

 import re as regex my_regex = regex.compile("[0-9)+",regex.I) 

L'alias est également utilisé dans les cas où le module importé a un nom encombrant ou lorsque le module accède fréquemment au module.

Par exemple, lors de la visualisation de données basées sur le module matplotlib , il est généralement
utilisez l'alias standard suivant:

 import matplotlib.pyplot as plt 

Si vous avez besoin d'obtenir plusieurs valeurs spécifiques du module, vous pouvez les importer explicitement et utiliser sans restrictions:

 from collections import defaultdict , Counter lookup = defaultdict(int) my_counter = Counter() 

Les fonctions

Une fonction est une règle qui accepte zéro ou plusieurs arguments d'entrée et renvoie le résultat correspondant. En Python, les fonctions sont généralement définies à l'aide de l'instruction def:

 def double() : """,  ,     docstring,  ,    . ,       2""" return  * 2 

Les fonctions en Python sont traitées comme des objets de première classe. Cela signifie qu'ils peuvent être affectés à des variables et passés à d'autres fonctions de la même manière que tout autre argument:

 #   f   def apply_to_one(f): '""'  f      """ return f(1) my _ double = double #       = apply_to_one(my_double) # = 2 

De plus, vous pouvez facilement créer de courtes fonctions anonymes ou expressions lambda:

  = apply_to_one(lambda :  + 4) # = 5 

Les expressions lambda peuvent être affectées à des variables. Cependant, il est recommandé d'utiliser l'opérateur def:

 another double = lmbd : 2 *  #    def another_double (x) : return 2 *  #   

De plus, vous pouvez passer des arguments par défaut aux paramètres de fonction, qui ne doivent être spécifiés que lorsqu'une valeur autre que la valeur par défaut est attendue:

 def my_print (message="oe   " ): print (message ) my_print ( "pe") #  '' my_print () #  '   ' 

Il est parfois conseillé de spécifier des arguments par leur nom:

 #   def subtract ( a=0, =0 ) : return  - b subtract (10, 5)#  5 subtract (0, 5)#  -5 subtract (b=5 )#  ,      

À l'avenir, les fonctions seront utilisées très souvent.

Lignes

Les chaînes de caractères (ou séquences de caractères) des deux côtés sont limitées à des guillemets simples ou doubles (elles doivent correspondre):

 single_quoted_string = '    ' #  double_quoted_string = "  " #  

La barre oblique inverse est utilisée pour coder les caractères spéciaux. Par exemple:

 tab_string = "\t" #    len (tab_string)# = 1 

Si vous avez besoin de la barre oblique inverse elle-même, ce qui se produit directement
dans les noms de répertoire du système d'exploitation Windows, puis en utilisant r '"', vous pouvez créer une chaîne non formatée :

 not_tab_string = r"\t" #   ' \ '  ' t ' len (not_tab_string) # = 2 

Des blocs de texte multilignes sont créés à l'aide de triple single (ou
doubles) citations:

 multi_line_string = """   .        """ 

Exceptions

En cas de problème, Python lève une exception. Les exceptions non gérées provoquent l'arrêt inattendu du programme. Les exceptions sont gérées à l'aide des instructions try et except :

 try: print (0 / 0) except ZeroDivisionError : rint ( "    ") 

Bien que dans de nombreux langages de programmation, l'utilisation des exceptions soit considérée comme un mauvais style de programmation, en Python, il n'y a rien à craindre s'il est utilisé pour rendre le code plus propre, et parfois nous le ferons.

Listes

La structure de données la plus importante en Python est probablement une liste. Il s'agit simplement d'une collection ordonnée (ou collection), similaire à un tableau dans d'autres langages de programmation, mais avec des fonctionnalités supplémentaires.

 integer_list = [1, 2, ] #    heterogeneous_list = ["", 0.1 , True] #   list_of_lists = [integer_list, heterogeneous_list, [] ] #   list_length = len(integer_list) #  = 3 list_sum = sum(integer_list)#    = 6 

Vous pouvez définir la valeur et accéder au nième élément de la liste à l'aide de crochets:

  = list(range (10)) #   {0, 1 , . . . , 9] zero =  [0] # = 0 ,  -, .  .  1-  = 0 one = x [1] # = 1 nine =  [-1] # = 9, -    eight =  [-2] # = 8, -     [0] = -1 #   = { - 1 , 1 , 2, 3, . . . , 9] 

De plus, des crochets sont utilisés pour «couper» les listes:

 first_three = [:] #   = [-1 , 1, 2] three_to_end = [3:] #    = {3, 4, ... , 9] one_to_four = [1:5] #     = {1 , 2, 3, 4] last_three = [-3:] #   = { 7, 8, 9] without_first_and_last = x[1:-1] #     = {1 , 2, ... , 8] _ of _ = [:] #   = [ -1, 1, 2, ... , 91 

Python a une instruction ln qui vérifie si un élément appartient à une liste:

 1 ln [1, 2, 3] #True 0 ln [1, 2, 3] #False 

La vérification consiste à visualiser tous les éléments un par un, donc cela vaut la peine de l'utiliser uniquement quand on sait avec certitude que la liste est petite ou peu importe le temps de vérification.

Les listes sont faciles à enchaîner:

  = [1, 2, 3] . extend ( [ 4, 5, 6] ) #   = {1, 2, 3, 4, 5, 6} 

Si vous souhaitez laisser la liste x inchangée, vous pouvez utiliser l'ajout de listes:

  = [1, 2, 3]  =  + [4, 5, 6] #= (1, 2, 3, 4, 5, 6] ;    

Habituellement, un élément est ajouté aux listes en une seule opération:

  = [1, 2, 3] x.append (0)#   = [1,2,3,0] =  [-1] # = 0 z = len (x)# = 4 

Il est souvent pratique de décompresser une liste si vous savez combien d'éléments elle contient:

 ,  = [1, 2] #   = 1,  = 2 

Si le nombre d'éléments n'est pas le même des deux côtés de l'expression, un message d'erreur ValueError s'affiche.

Pour une valeur supprimée, un trait de soulignement est généralement utilisé:

 _,  = [1, 2] #   == 2,     

Tuples

Les tuples sont des cousins ​​immuables (ou immuables) des listes.

Presque tout ce qui peut être fait avec une liste sans y apporter de modifications peut être fait avec un tuple. Au lieu de crochets, un tuple est composé de crochets ronds, ou ils peuvent s'en passer du tout:

 my_list = [1, 2] #   my_tuple = (1, 2) #   other_tuple = 3, 4 #    my_list [1] = 3 #  my_list = [1 , 3] try: my_tuple [1] = 3 except ypeError : print ( "   " ) 

Les tuples offrent un moyen pratique de renvoyer plusieurs valeurs à partir des fonctions:

 #        def sum_and_product (x,  ) : return ( + ) , ( * ) sp = sum_and_product (2, 3) # = (5, 6) s,  = sum_and_product (S, 10) # s = 15,  = 50 

Les tuples (et les listes) sont également utilisés dans plusieurs affectations:

 ,  = 1, 2 #   = 1,  = 2 ,  = ,  #   -;   = 2,  = 1 

Dictionnaires

Un dictionnaire ou une liste associative est une autre structure de données de base.

Dans ce document, les valeurs sont associées à des clés, ce qui vous permet de récupérer rapidement la valeur correspondant à une clé spécifique:

 empty_dict = {} #   - empty_dict2 = dict () #   - grades = { "Grigoriy" : 80, "Tim" : 95 } #   (  ) 

La valeur de clé est accessible à l'aide de crochets:

 rigory_aleksee = grades[ "Grigoriy"] # = 80 

Si vous essayez de demander une valeur qui n'est pas dans le dictionnaire, vous recevrez un message d'erreur KeyError:

 try: kates_grade = grades [ "Kate "] except eyError: rint ( "    ! " ) 

Vous pouvez rechercher une clé à l'aide de l'opérateur in:

 grigoriy_has_grade = "Grigoriy" in grades #true kate_has_grade = "Kate" in grades #false 

Les dictionnaires ont une méthode get () qui, lors de la recherche d'une clé manquante, au lieu de lancer une exception, renvoie la valeur par défaut:

 grigoriy_grade = grades. get ( "Grigoriy ", 0) # =80 kates_grade = grades.get ("Kate" , 0) # = 0 no_ones_grade = grades.get ( "No One" ) #    = None 

L'affectation des valeurs clés est effectuée à l'aide des mêmes crochets:

 grades [ "Tim" ] = 99 #    grades [ "Kate"] = 100 #    num_students = len(grades) # = 3 

Les dictionnaires sont souvent utilisés comme un moyen facile de représenter la structure
données:

 tweet = { "user" : " grinaleks", "text" : "   -  ", " retweet_count" : 100, "hashtags " : [ "# data", " #science", " #datascience " , " #awesome", "#yolo" ] } 

En plus de rechercher des clés individuelles, vous pouvez contacter tout le monde à la fois:

 tweet_keys = tweet.keys() #   tweet_values = tweet.values() #   tweet_items = tweet.items() #   (, ) "user" in tweet_keys # True,    in  "user" in tweet # -,   in  "grinaleks" in tweet_values # True 

Les clés doivent être immuables; en particulier, les listes ne peuvent pas être utilisées comme clés. Si vous avez besoin d'une clé composite, il est préférable d'utiliser un tuple ou de trouver un moyen de convertir la clé en chaîne.

Dictionnaire defaultdict

Laissez le document avoir besoin de compter les mots. La solution évidente au problème est de créer un dictionnaire dans lequel les clés sont des mots et les valeurs sont les fréquences des mots (ou le nombre d'occurrences de mots dans le texte). Lors de la vérification des mots, si le mot courant est déjà dans le dictionnaire, alors sa fréquence augmente, et s'il est absent, il est ajouté au dictionnaire:

 #   word_ counts = { } document = { } #  ;    for word in document : if word in word counts: word_counts [word] += 1 else : word_counts [word] = 1 

De plus, vous pouvez profiter d'une méthode appelée "il vaut mieux demander pardon que permission" et intercepter l'erreur en essayant d'accéder à la clé manquante:

 word_ counts = { } for word in document : try: word_counts [word] += 1 except eyError : word_counts [word] = 1 

La troisième astuce consiste à utiliser la méthode get (), qui surmonte gracieusement la situation avec des clés manquantes:

 word_counts = { } for word in document : previous_count = word_counts.get (word, 0) word_counts [word] = previous_count + 1 

Toutes ces techniques sont un peu lourdes, et pour cette raison, il est conseillé d'utiliser le dictionnaire defaultdict (qui est aussi appelé dictionnaire avec: valeur par défaut). Il ressemble à un dictionnaire ordinaire, à l'exception d'une fonctionnalité - lorsque vous essayez d'accéder à une clé qui n'y figure pas, il ajoute d'abord une valeur pour celui-ci en utilisant la fonction sans arguments, qui est fournie lors de sa création. Pour utiliser les dictionnaires defaultdict, vous devez les importer depuis le module collections:

 from collections import defaultdict word_counts = defaultdict(int) # int ()  0 for word in document : word_counts[word] += 1 

De plus, l'utilisation des dictionnaires defaultdict est pratique lorsque vous travaillez avec des listes, des dictionnaires et même avec des fonctions définies par l'utilisateur:

 dd_list = defaultdict (list)# list ()    dd_list [2].append (l) #  dd_list  (2: {1] } dd_dict = defaultdict (dict ) # dict ()    dict dd_dict ["Grigoriy"] [ "City" ] = "Seattle" # { "Grigoriy" : { "City" : Seattle"} dd_pair = defaultdict (lambda: [0,0] ) dd_pair [2][1] = 1 #  dd_pair  (2 : {0,1] } 

Ces fonctionnalités seront nécessaires lorsque des dictionnaires sont utilisés pour la «collecte»
résultats pour une certaine clé et quand il est nécessaire d'éviter les doublons
vérifie la présence d'une clé dans le dictionnaire.

Counter Dictionary

Une sous-classe de contre-dictionnaires transforme une séquence de valeurs en un objet de type defaultdict (int), où les clés sont mappées sur des fréquences ou, plus précisément, les clés sont affichées (carte) en fréquence.

Il sera principalement utilisé lors de la création d'histogrammes:

 from collections import Counter  = Counter([0,1,2,0]) #    = { 0 : 2, 1 : 1, 2 : 1 } 

Sa fonctionnalité permet de résoudre assez facilement le problème du comptage des fréquences des mots:

 #      word_counts = Counter (document) 

Le dictionnaire de compteur a la méthode most_common (), qui est souvent utile:

 #  10       () for word, count in word_counts.most_common(10) : print (word, count ) 

Beaucoup

L'ensemble ou la structure de données d'ensemble est une collection d'éléments non ordonnés sans répétitions:

 s = set ()#    s.add (1) #  s = { 1 } s.add (2) #  s = { 1, 2 } s.add (2) # s    = { 1, 2 }  = len (s) # = 2  = 2 in s # = True z = 3 in s # = False 

Beaucoup seront utilisés pour deux raisons. Premièrement, le fonctionnement sur les décors est très rapide. Si vous devez vérifier qu'un grand ensemble d'éléments appartient à une certaine séquence, la structure de données définie est mieux adaptée à cela qu'une liste:

 #  - stopwords_list = [ "a", "an" , "at "] + hundreds_of_other_words + [ "yet ", " you"] " zip" in stopwords_list # False,     #  - stopwords_set = set(stopwords_list) " zip" in stopwords_set #    

La deuxième raison est d'obtenir des éléments uniques dans l'ensemble de données:

 item_list = [1, 2, 3, 1, 2, 3] #  num_items = len( item_list) #  = 6 item_set = set(item_list) #   (1, 2, 3} num_distinct_items = len(item_set) #   = 3 distinct_item_list = list(item_set) #    = [1,2,3] 

Beaucoup seront utilisés beaucoup moins fréquemment que les dictionnaires et les listes.

Structures de contrôle

Comme dans la plupart des autres langages de programmation, les actions peuvent être effectuées par condition à l'aide de l'instruction if:

 if 1 > 2: message " 1    2 . . . " elif 1 > 3: message "elif  'else if '" else: message = "      ,  else " 

De plus, vous pouvez utiliser l'opérateur triple ligne unique si-alors-autre, qui sera parfois utilisé plus tard:

 parity = "" if  % 2 ===  else " " 

Python a une boucle whlle:

  = 0 while  < 10: print (x, " 10")  += 1 

Cependant, la boucle for sera utilisée plus souvent avec l'opérateur in:

 for  in range (lO) : print (x, " 10" ) 51 

Si vous avez besoin d'une logique de contrôle de boucle plus complexe, vous pouvez utiliser les opérateurs

 continue  break: for  1n range (10) : 1f  == 3: continue #      if  == 5: break print (x) #    

Par conséquent, 0, 1, 2 et 4 seront imprimés.

Authenticité

Les variables booléennes en Python fonctionnent de la même manière que dans la plupart des autres langages de programmation, à une seule exception près: elles sont en majuscules:

 one_is_less_than_two = 1 < 2 #True true_equals_false = True == False #False 

Pour indiquer une valeur inexistante, un objet spécial None est utilisé, ce qui correspond à null dans d'autres langues:

  = None print (x == None )#  True,    - print (  is None ) #  True - 

Python peut utiliser n'importe quelle valeur lorsqu'un type booléen booléen est attendu. Tous les éléments suivants ont une valeur booléenne False:

• Faux .
• Aucun
• set () (set):
• [] (liste vide);
• {} (dictionnaire vide);

Presque tout le reste est considéré comme vrai. Cela facilite l'utilisation d'instructions if pour rechercher des listes vides. lignes vides, dictionnaires vides, etc. Parfois, cependant, cela entraîne des erreurs difficiles à reconnaître, si vous ne tenez pas compte des éléments suivants:

 s = some_function_that_returns_a_string () #    if s: first_char = s [0] #     else: first char = "" 

Voici un moyen plus simple de faire de même:

 first_char = s and s [0] 

car l'opérateur logique renvoie la deuxième valeur, si la première est vraie, et la première valeur, si elle est fausse. De même, si x dans l'expression suivante est soit un nombre, soit éventuellement aucun, le résultat sera en quelque sorte un nombre:

 safe  =  or 0 #   

La fonction intégrée Python all prend une liste et ne renvoie True que lorsque chaque élément de la liste est vrai, et la fonction intégrée any renvoie true lorsqu'au moins un élément est vrai:

 all ( [True, 1, { 3 }]) # True all ( [True, 1, {}] ) # False, {} =  any ( [ True, 1, {}]) # True, True =  all ( [] ) # True,      any ( [ ] ) # False,