<jupyter_start><jupyter_text>Bienvenue à Python 101  Sommaire- [Introduction à Python](Utiliser-Python-comme-une-calculatrice) - [Contrôle du flux](Contrôle-du-flux)- [Structures de données](Structures-de-données)- [Modules](Modules) *** Utiliser Python comme une calculatriceAprès avoir installé Python, vous pouvez ouvrir une *console* ou *l'invite de commande*, tapez python et un intepréteur Python s'ouvre.Pour l'instant, nous utilisons ce notebook.  Essayons quelques commandes Python simples<jupyter_code>2+3 # Un commentaire<jupyter_output><empty_output><jupyter_text><jupyter_code>20 + 11 * 3<jupyter_output><empty_output><jupyter_text><jupyter_code>(20 - 11) / 4<jupyter_output><empty_output><jupyter_text>Les nombres entiers (comme 2, 3 et 11) sont de type **`int`**, alors que les décimaux (comme 10.0 et 3.14) sont de type **`float`**.<jupyter_code>19 / 3 # La division (/) donne toujours un nombre de type 'float'<jupyter_output><empty_output><jupyter_text><jupyter_code>19 // 3 # L'opérateur (//) effectue des divisions entières<jupyter_output><empty_output><jupyter_text><jupyter_code>19 % 3  # L'opérateur (%) donne le reste de la division entière.<jupyter_output><empty_output><jupyter_text>Il est possible de calculer des puissances (X y) avec l’opérateur `**`<jupyter_code>3 ** 2 
# 11 ** 12. # les opérations avec des types d'opérandes mélangés donnent un résultat en virgule flottante<jupyter_output><empty_output><jupyter_text>Le signe égal ( `=` ) permet d'affecter une valeur à une variable<jupyter_code>hauteur = 7
base = 9
aire_du_triangle = (hauteur * base) / 2
aire_du_triangl    # pour afficher le résultat {to talk about errors and their importance}<jupyter_output><empty_output><jupyter_text>*** Les chaînes de caractèresLes chaînes de caractères peuvent être exprimés de différentes manières :<jupyter_code>'Bonjour' # guillemets simples
"Hello" # guillemets doubles<jupyter_output><empty_output><jupyter_text><jupyter_code>'de l\'art' # utiliser \' pour protéger les guillemets
# "de l'art" # ou utiliser les guillemets doubles<jupyter_output><empty_output><jupyter_text><jupyter_code>'"Le petit chat est mort. ", dit Agnès'
# "\"Le petit chat est mort. \", dit Agnès"<jupyter_output><empty_output><jupyter_text>La fonction **`print()`** affiche les chaînes de caractères de manière plus lisible.<jupyter_code>'"L\'art !" dit Michel.'
# print ('"L\'art !" dit Michel.')
# p = 'Première ligne.\nDeuxième ligne.' # \n signifie nouvelle ligne
# p
# print (p)<jupyter_output><empty_output><jupyter_text>Utilisez les chaînes brutes (`raw strings`) en préfixant la chaîne d’un **`r`**, pour éviter que les caractères précédés d’un antislash ne soient interprétés comme étant spéciaux.<jupyter_code>print('C:\Documents\nom')
# print(r'C:\Documents\nom') # les guillemets précédés par (r)<jupyter_output><empty_output><jupyter_text>Utilisez des triples guillemets : `'''abc'''` ou `"""xyz"""` pour écrire des chaînes de caractères qui s'étalent sur plusieurs lignes.    Empêcher le retour à la ligne en ajoutant **`\`**<jupyter_code>print("""\
Définitions:
     -dictionnaire           Une structure de donnée associant des clefs et des valeurs
     -fonction               Une suite d’instructions qui renvoient une valeur à celui qui l’appelle
""")<jupyter_output><empty_output><jupyter_text>L’opérateur **`+`** permet de coller (concaténer) plusieurs chaînes. L'opérateur **`*`** permet de répéter les chaînes.<jupyter_code>'OUI ' * 3 + 'Hurrah!'
# prefix = 'Hello Wo'
# prefix + 'rld!'<jupyter_output><empty_output><jupyter_text>Les caractères peuvent être accédés par leur position. Pour l'indexation des chaînes de caractères, le premier caractère est à la position **0**.<jupyter_code>phrase = "<NAME> Brian"
phrase[0]
# phrase[15]<jupyter_output><empty_output><jupyter_text>Pour effectuer un décompte en partant de la droite, nous utilisons des indices négatifs (commencent par **-1**).<jupyter_code>phrase[-1]
# phrase[-3]
# phrase[-18]<jupyter_output><empty_output><jupyter_text>Pour obtenir une sous-chaîne :<jupyter_code>phrase[0:2] # caractères de la position 0 (inclut) à 2 (exclu)
# phrase[13:18]
# phrase[:12]
# phrase[12:] # s[:i] + s[i:] = s
# phrase[-5:]
# phrase[20] # indice trop grand (hors bornes)
# phrase[5:20] # gérés silencieusement si utilisés dans des tranches<jupyter_output><empty_output><jupyter_text>Les chaînes de caractères sont `immutable` : elles ne peuvent pas être modifiées.<jupyter_code>phrase = "<NAME>'appelle Brian"
phrase[1] = 'j'
# phrase[13:] = 'Stewie'
# phrase[:13] + 'Stewie !'<jupyter_output><empty_output><jupyter_text>La fonction **`len()`** donne la longueur d'une chaîne :<jupyter_code>p = 'I have a dream'
len(p)<jupyter_output><empty_output><jupyter_text>*** Les listesUne suite d'éléments séparés par des virgules, placés entre crochets. Les éléments d’une liste ne sont pas obligatoirement du même type.<jupyter_code>premiers  = [2, 3, 5, 7, 11]
premiers<jupyter_output><empty_output><jupyter_text>Les listes peuvent être indicées et découpées :<jupyter_code>premiers[0]
# premiers[-1]
# premiers[2:10]<jupyter_output><empty_output><jupyter_text>Les opérations de découpage (en tranches) renvoient une nouvelle liste contenant les éléments spécifiés.<jupyter_code>premiers[:] # une copie de la liste<jupyter_output><empty_output><jupyter_text>Les listes supportent des opérations comme pour les chaînes de caratcères.<jupyter_code>premiers + [13, 17, 19]
# premiers * 2<jupyter_output><empty_output><jupyter_text>Il est possible de changer le contenu des listes : elles sont `mutables`<jupyter_code>nbres = [1, 2, 'c', 4] 
# nbres[2] = 3
nbres<jupyter_output><empty_output><jupyter_text><jupyter_code>nbres.append(5) # méthode pour ajouter des éléments à la fin
nbres<jupyter_output><empty_output><jupyter_text><jupyter_code>nbres[2:4] = [10, 100] # affectation par tranches
# nbres[:] = [] # supprimer toutes les valeurs 
nbres<jupyter_output><empty_output><jupyter_text>Il est possible de créer des listes contenant d'autres listes :<jupyter_code>a = [1, 2, 3]
b = ['f', 'r', 'a']
res = [a, b]
# res
# res[1]
# res[0][2]<jupyter_output><empty_output><jupyter_text>La compréhension des listes (`list comprehension`) permet de construire des nouvelles listes où chaque élément est le résultat d'une opération appliquée à chaque élément d’une autre séquence; ou de créer une sous-séquence d'éléments satisfaisants une certaine condition.  Elle consiste en deux crochets contenants une expression suivie par une clause **`for`**, puis par une ou plusieurs clauses **`for`** ou **`if`**.<jupyter_code>[x for x in range(6) if x % 2 == 0]<jupyter_output><empty_output><jupyter_text><jupyter_code>[(x, y) for x in [1,2,3] for y in [3,1] if x != y]<jupyter_output><empty_output><jupyter_text>*** Contrôle du flux L’instruction `if` :<jupyter_code>x = 11
if x % 2 == 0:
    print ('foo')
    s = 'nombre pair'
else:    
    print ('bar')    # x % 2 != 0<jupyter_output><empty_output><jupyter_text><jupyter_code>x = 20
if x % 5 == 0 and x % 2 == 0:
    print ('foobar')
elif x % 5 == 0:
    print ('foo')
else:
    print ('bar')<jupyter_output><empty_output><jupyter_text>L'instruction `for` :Elle permet d'itérer sur les éléments d'une séquence (une liste, une chaîne de caractères, etc.) par ordre.<jupyter_code>pays = ['France', 'Canada', 'Belgique', 'Suisse']
for p in pays:
    print (p, len(p))<jupyter_output><empty_output><jupyter_text><jupyter_code>mot = '1 chat'
for c in mot:
    print (c)<jupyter_output><empty_output><jupyter_text><jupyter_code>for i in range(1, 4): 
    print (i ** 2)<jupyter_output><empty_output><jupyter_text>L'instruction `while` :<jupyter_code>x = 1
while x <= 5:
    print (x, end=' ') # Le paramètre (end) sert à enlever le retour à la ligne, ou terminer par un autre caractère
    x += 2 # x = x + 2<jupyter_output><empty_output><jupyter_text>Les fonctions :Le mot-clé **`def`** définit la fonction. Il est suivi du nom de la fonction, et de ses paramètres entre parenthèses.<jupyter_code>def add(n):         # calculer la somme des chiffres de 1 à n
    somme = 0       # une variable locale
    for i in range(1, n+1):
        somme += i
    return somme
add(3)
# add(10)

# somme # n'est pas défini 'globalement' 
# somme = 100        # variable globale
# somme<jupyter_output><empty_output><jupyter_text><jupyter_code>def fib(a, b, n):
    """ print une suite de fibnoacci à partir des termes a et b, jusqu'à n """
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
fib(5, 8, 2000) '''{même les fonctions sans instruction 
                 return renvoient une valeur, quoique ennuyeuse. Cette valeur est appelée None }'''<jupyter_output><empty_output><jupyter_text>*** Structures de données Tuples Une séquence d'éléments séparés par des virgules (et encadrés par des parenthèses si nécessaire)<jupyter_code>t = 'python', 3.5, 101
t
# t[2]

# n = t,  'Guido', ('2.7', 2010), [0, 90] # tuples imbriqués
# n<jupyter_output><empty_output><jupyter_text><jupyter_code>n[1] = '<NAME>' # ils sont immutables
# n[3][1] = 100 
n<jupyter_output><empty_output><jupyter_text><jupyter_code>vide = () # initier un tuple vide
# un = 'python',<jupyter_output><empty_output><jupyter_text>Les ensembles (`sets`)Une collection non ordonnée, sans élément dupliqué.<jupyter_code>notes = {18, 15, 14, 11 ,18, 14}
notes
# fruits = {'orange', 'raisin', 'pomme' ,'kiwi' , 'orange', 'pomme'}
# fruits<jupyter_output><empty_output><jupyter_text><jupyter_code>a = set('abccba')
a
# a & set('atta') # supportent d'autres opérations (unions, intersections, différences, etc.)<jupyter_output><empty_output><jupyter_text>DictionnairesDes ensembles non ordonnés de pairs **`clé` : `valeur`** (`key` : `value` pairs). Ils sont indexés par des `clés` (keys), qui peuvent être de n’importe quel type immuable : chaînes de caractères, nombres et tuples (s’ils ne contiennent que des `immutables`).  Les clés doivent être uniques au sein d'un dictionnaire.<jupyter_code>d = {} # créer un dictionnaire vide

# d = {'Marie':15, 'Jean':2, 'Victor':9}
# d['Marie']
# del d['Victor']
# d['Charles'] = 33
d<jupyter_output><empty_output><jupyter_text><jupyter_code>p = dict([('Anthony', 'a'), ('Guido', [0, 'g']), ('Marie', 'm')])
# p.keys()
# p.values()
# 'guido' in p
# 'Guido' in p<jupyter_output><empty_output><jupyter_text>Création des dictionnaires par compréhension (`dict comprehensions`).<jupyter_code>{x: x**3 for x in range(1, 6)}<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13432122370936903, 'fraction_numerical': 0.019311663479923517, 'mean_word_length': 5.932405566600398, 'pattern_counts': {'":': 0, '<': 190, '<?xml version=': 0, '>': 188, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '46', 'dir': 'jupyter-structured-clean-dedup', 'id': '606360', 'license': 'MIT', 'n_tokens_mistral': 4118, 'n_tokens_neox': 4002, 'n_words': 1038, 'path': 'assets/IntroductionPython.ipynb', 'repo_name': 'meherbejaoui/meherbejaoui.github.io', 'size': '10474'}