Le typage est dynamique, autrement dit, une variable peut.
changer de type en cours de route.

type(5) → <class 'int'>
type('ab') → <class 'str'>
type(1.2) → <class 'float'>
type(True) → <class 'bool'>
type([1,2,'x']) → <class 'list'>
type({1,1,2,'x'}) → <class 'set'>
type({'key1':1,'key2' : 2, key3 : 3}) → <class 'dict'>
type(type(5)) → <class 'type'>

s='abcd'
s+s → 'abcdabcd'
len(s) → 4
s[:3] → 'abc'

s=0
for i in range(1,10):
    s += i
s → 45

while i>0:
   ....

for i in [2,3,5,7]
   ....

continue # Passe une itération
break      # Sort de la boucle

def f(x,y):
    return x*y
f(2,3) → 6

f=lambda x,y: x**y

if not x<5 :
    x=x//4
elif x==4 :
    x=-5
else:
    x=-3*x+1

x=5 if y==3 else 6     # x est égale à 5 ou 6 selon

[x*x for x in range(1,5)] → [1,4,9,16]
[f(x) if x%2==0 for x in range(1,5)] → [-1,4,-9,16]
[x, for x in range(0,10) if x%2==0] → [0,2,4,8]

D={'key1':1,'key2':2,'key3':3}
D['key2'] → 2
D.items() → dict_items([('key1', 1), ('key2', 2), ('key3', 3)])
A={x:y for x,y in D.items()}
A → {'key1':1,'key2':2,'key3':3}
A={x:y for x,y in D.items() if y>1}
A → {'key2':2,'key3':3}

X=[2,3,4,5]
list( map(lambda x:x*x, X) ) → [4,9,16,25]
def g(x):
    return x*x
list( map(g, X) ) → [4,9,16,25]

from functools import reduce

reduce(lambda x,y: x*y, [1,2,3,4]) → 24     # Egale à ((1*2)*3)*4
reduce(f, X) → 24  

X=[2,4,3,1,5] # Valeurs
P=[1,3,5,4,2] # Poids
list( zip(X,P) ) → [(2,1),(4,3),(3,5),(1,4),(5,2)]

# somme pondérée
reduce(lambda x,y: x+y, map(lambda x: x[0]*x[1], zip(X,P))) → 25

import numpy as np

v=np.array([1,2,3])
print(v) => [1,2,3]
print(v.sum()) => 6           # Somme
print(v.men()) => 2.0       # Moyenne
print(v.std()) => 0.86       # Ecart type

M= np.matrix([[1,2,3],
                        [4,5,6],
                        [7,8,9]]),
print(M.dot(v))                  # Produit matrice par vecteur
print(np.linalg.inv(M))     # Inversion de matrice

import matplotlib.pyplot as plt
from random import random as rd

X=[rd()-0.5 for i in range(0,20)]
Y=[rd()-0.5 for i in range(0,20)]
plt.plot(X,Y)             # Dessine des traits reliant les points (x,y) à la suite
plt.show()                # Affiche le dessin, jusqu'à ce quon appuit la touche q
plt.scatter(X,Y)       # Dessine chaque point (x,y)
plt.show()                # Affiche le dessin, jusqu'à ce quon appuit la touche q

from skimage import data, io
import numpy as np

image=io.imread('test.png')
io.imsave('test.png', image)

from sympy import symbols, expand, diff

x,a,b,c = symbols('x,a,b,c')
p=a*x**2+b*x+c
print(p) => a*x**2+b*x+c      # Expression de p
print(diff(p,x)) => 2*a*x+b    # Dérivée de p selon x
expand(p*p) => ...                 # Expression développée de p*p