un tour du langage Python

# ceci est un commentaire

10 * 10   # et ici aussi

# j'importe le module math
import math

# attention cette façon d'obtenir de l'aide est 
# spécifique à IPython / notebooks
# avec un interprète Python standard, on ferait 
# help(math)
math?

# ceci se lit comme:
# aller chercher l'attribut 'pi' dans l'objet module 'math'
math.pi

math.cos(math.pi)

# entiers 
10

# flottants
3.14

# complexes
1j * (2+4j)

# booléens True et False
True

# les nombres ont des opérateurs (arithmétiques et de comparaison...)

# 3 est impair
10 % 3 == 1

# sur les architectures actuelles 
# un flottant est encodé sur 64 bits

0.2 + 0.1

0.2 + 0.1 == 0.3

0.2 + 0.2 == 0.4

# cette fonction est pratique pour faire 
# un test de quasi-égalité sur les flottants
math.isclose(0.2+0.1, 0.3)

# remarquez que ceci n'affiche rien
a = 10

# l'utilité c'est bien sûr 
# de garder un résultat pour
# s'en reservir ensuite
a + a

# un texte est entre deux '

texte1 = 'bonjour le monde'
print(texte1)

# ou si on préfère entre "

texte2 = "bonjour le monde"
print(texte2)

# comme ça on peut insérer un "

print('Python est un langage "typé"')

# ou un '

print("Python est un langage 'typé'")

# simplement pour illustration des possibilités d'appel de fonction
# car on va voir plus loin une forme beaucoup plus pratique
# pour faire ce genre de choses
#
x = 12
print("la somme de", x, "et", 13, "vaut", x+13)

# une f-string se présente comme une chaine 
# mais préfixée par un f collé
# avant le guillement ouvrant
# qui peut être ' ou " 

f"une f-string"

# l'intérêt est qu'on peut 
# alors insérer des variables
# directement dans la chaine
# en les mettant entre {}

print(f'pi = {math.pi}')

# en fait j'ai dit 'variable' mais on peut mettre n'importe quelle expression
# c'est à dire qu'à l'intérieur des {} on peut faire des calculs, ici sin(pi)
print(f"pi = {math.pi} et sin(pi) = {math.sin(math.pi)}")

print(f"bla {2*math.pi:.2f} bla")

# on définit une fonction en donnant son nom
# et les noms de ses paramètres
def P(x):
    return x**2 + 3*x + 2

# mintenant que la fonction est définie
# on peut maintenant l'appeler (l'exécuter)
P(10)

# une curiosité: True se comporte comme le nombre 1
P(True)

x = 12
if x%2 == 0:
    print(f'{x} est pair')
else:
    print(f'{x} est impair')

x = 3
while x != 0:
    print(x)
    x = x-1

# pour anticiper un peu
L = [1, 2, 3]
for item in L:
    print(item)

D = {'pierre': 20, 'jean': 32}
for key, value in D.items():
    print(key, '->', value)

from math import pi, sin

pi

# idem
sin(pi)

# la librairie numpy doit être installée
# dans votre environnement ...
import numpy as np

# grâce à la forme import .. as
# on a installé la librairie numpy
# mais dans notre code on l'utilise sous le nom np
np.sin(np.pi)

# la liste permet de préserver l'ordre, avec d'éventuels duplicats
L = [10, 20, 10, 20, 10, 20]
L

# l'ensemble au contraire élimine les duplicats
S = {10, 20, 10, 20, 10, 20}
S

# le dictionnaire, c'est un peu comme un ensemble
# dans lequel chaque élément (qu'on appelle une clé)
# possède une valeur
D = {'dix': 10, 'vingt': 20}
D

# pour accéder, les indices commencent toujours à 0
print(L[0], L[5])

# dans les dictionnaires on accède par la clé
D['dix']

# on ne peut pas accéder au i-ème élément d'un ensemble
# mais on peut chercher si un élément existe
100 in S

# liste ordonnée d'objets
# de type hétérogène
l = ['il', 12, 78.5, False, 'il']
l.append('bonjour')
print(l)

# ensemble d'objets de type hétérogène
s = {'il', 12, 78.5, False, 'il'}
s.add('bonjour')
print(s)

# dictionnaire i.e. ensemble de couples (clé, valeur)
d = {'zero':0, 'un':1,'trois':3}
d['deux'] = 2 
print(d)

# sur une chaine len()
# retourne le nombre de caractères
#
# remarquez que les guillemets ne comptent pas
len("abc")

# on compte les caractères 
# et pas les octets

len("été")

# sur un objet d'un type structuré
# retourne le nombre d'éléments
d = {'zero': 0, 'un': 1, 'trois': 3}
len(d)

bafouille = \
"""To be, or not to be: that is the question:
Whether 'tis nobler in the mind to suffer
The slings and arrows of outrageous fortune,"""

print(bafouille)

# idem avec '''
# le changement de ligne compte 
# pour un caractère (newline) 
court = '''a
b'''

print(court)

# les caractères sont 'a', '\n', et 'b'
len(court)

a = 10
type(a)

b = -17.5
type(b)

# le résultat d'une expression
# est un objet et du coup il a un type
type(10 < 3)

# une fonction usuelle
def incr (x):
    return x+1

type(incr)

# une fonction builtin
type(len)

# un module
import math
type(math)

# on écrit des chaînes de caractères
file = 'hamlet.txt'
f = open(file, 'w') # w pour le mode écriture
f.write(bafouille)
f.write('Or to take Arms ...')
f.close()
# ne pas oublier de fermer le fichier !

# en beaucoup beaucoup plus élégant ....
file = 'hamlet.txt'

with open(file, 'w') as f:
    f.write(bafouille)
    f.write('Or to take Arms ...')
# vous ne pouvez pas oublier
# de fermer le fichier

# tout le contenu
file = 'hamlet.txt'
with open(file, 'r') as f:
    print(f.read())

# ligne par ligne
file = 'hamlet.txt'
with open(file, 'r') as f:
    for line in f:
        print(line, end='') # la fin de ligne est ''

class Rational:
    
    # le constructeur
    def __init__ (self, n, d):
        # self est par convention l'objet qu'on construit
        self.num = n # on range un attribut dans l'objet construit
        self.denom = d # on range un autre attribut dans self
        
    # une méthode = une fonction qui travaille sur un objet (ici self)
    def reduce (self):
        # à vous de la faire ...
        pass
    
    # la méthode qui sera appelée
    # quand votre objet sera affiché ou mis dans une chaîne de caractère
    def __str__ (self):
        return f'{self.num}/{self.denom}'

# on construit un objet de type Rational
# de numérateur 2 et dénominateur 4
r = Rational(2, 4)

# on le réduit ... (si vous implémentez la fonction)
r.reduce()

print(r) # on l'affiche sous la forme 1/2 si reduce est implémentée, sinon 2/4

# on le représente
r # pour changer cette représentation assez technique ... implémentez la fonction __repr__

# je construis une liste vide
l = list()
len(l)

# j'ajoute des éléments en fin de liste
l.append(12)
l.append(13)
print(l)

# méthodes sur les chaines
chaine = "bonjour"

chaine.capitalize()

longue_chaine = "une liste de mots à découper"

# sert à découper une chaine 
# en morceaux

mots = longue_chaine.split()
mots

# et avec join on peut réassembler
# avec le caractère spécifié

"+".join(mots)

# on peut toujours appeler type() 
x, y = 1, 3.14
type(x)
type(y)

# une variable peut changer de type
x = [1, 2, 3]
type(x)

# vraiment tout a un type
import math
type(math)

# vraiment tout a un type
def foo(x):
    pass
type(foo)

# vraiment tout a un type
type(None)

# vous avez compris l'idée générale
type(type(x))