Ce tuto est très inspiré de Apprenez à programmer en Python de Vincent Le Goff Licence Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 2.0 Générique (CC BY-NC-SA 2.0) Télécharger le pdf

Cette page est la suite de Python: Atelier Python Niveau 1.

Lis tout ça, tu seras expert python dans 10 ans

bpython version 0.16 on top of Python 3.5.3 /usr/bin/python3
>>> 1
1
>>> 3.14
3.14
>>> 1+2
3
>>> labomedia
Traceback (most recent call last):
  File "<input>", line 1, in <module>
    labomedia
NameError: name 'labomedia' is not defined
>>> "Labomedia"
'Labomedia'
>>> 

1
3.14
"Moi"
1+3.14
1+"toto"
1/2

>>> a=1
>>> b=2
>>> a+b
3

and as class def elif else except False for from global if import in
lambda None not or pass return True try while with

True False None

1  # int 
3.14  # float 
"Labbomedia"  # str 
[1, 2, 3]  # list
{"1": "tot", "2": 1}  # dict

>>> type(1)
<class 'int'>
>>> print("Hello, World", end="!")
Hello, World!

Créer un nouveau fichier et l'enregistrer avec une extension.py

La suite se fait en collant le code dans ce génie.

a = 1
b = 2
c = 3.14
d = "labo"
e = "toto"
 
r = a + b
print(r)
 
s = a - b
print(s)
 
t = a / b
print(t)
 
print(d + e)
 
print(a + e)
 
print(a+e)

a = -6
 
if a < 0:
    print("bingo")
    print("")
    print("tu")
    print("as")
    print("gagné")
    print("")
    if a < -5:
        print("2 ème niveau d'indentation")
else:
    print("tu as perdu")
    print(type("tu as perdu"))
 
print("je fais autre chose")

==    !=    <    >    <=    >=

Trouver si une année est bissextile:

Si une année n'est pas multiple de 4, elle n'est pas bissextile
Si elle est multiple de 4, on regarde si multiple de 100
    Si oui, on regarde si multiple de 400
        Si oui, elle est bissextile
        Si non, elle n'est pas bissextile
    Si non, elle est bissextile

bissextile.py

# Programme testant si une année est bissextile
 
# Demande de l'année au clavier
annee =  input("Saisissez votre année ...")  # attente de la saisie
etc ......

Deux réponses: bissextile.py

Table du 4:

print("1 x 4 =", 1*4)
print("1 x 4 =", 1*4)
...
...
print("10 x 4 =", 10 * 4)

Les répétitions sont très sales !

i = 0
while i >= 10:
    print(str(i) + " x 4 =", i * 4)
    i += 1

ou encore

for i in range(10):
    print(str(i) + " x 4 =", i * 4)

for i in [0, 1, 2, 3]:  # seulement jusque 3
    print(str(i) + " x 4 =", i * 4)

chaine = "Labomedia"
for lettre in chaine:
    print(lettre)

• Pour éviter les répétitions, sources d'erreurs, surtout si une modifications de ces répétitions est nécessaire.
• Pour structurer le projet.
• Pour tester des bouts de code individuellement.
• Pour éviter les problèmes avec les variables globales.
• Pour pouvoir réutiliser des bouts de codes.
• Permettre un travail en équipe en découpant un projet en bout de projet indépendant.

trouver un exemple !

idem

def ma_fonction():
    print("Demain")
 
def ta_fonction(a):
    print(a)
 
def sa_fonction(a, n):
    while i < n:
        print(a, i)
 
ma_fonction()
ta_fonction("1")
ta_fonction("Guido")
sa_fonction(5, 3)

def fonct(a=1, b=2, c=3):
    print(a, b, c)
 
fonct()
fonct(10)
fonct(b=10)

Une fonction sans return retourne None

def test1():
    """Retourne None"""
    print("toto")
 
def test2():
    """Retourne """
    print("toto")
    return "Python c'est fun"
 
a = test1()
print(a)
 
b = test2()
print(b)

La fonction s'arrête sur le return, le code après return n'est pas excécuté.

def test(a):
    if a < 0:
        print("a<0")
        return 1
    else:
        print("a>0")
        return 0
    print("fin")
 
test(1)
test(-1)

print(
       abs(-20),
       max(2, 50),
       int(str(1)),
       type(int(str(1))))
       dir(1)

Une ou des fonctions dans un fichier est un module. Plusieurs modules font un package.

called.py

def je_suis_appeler(phrase):
    print("phrase =", phrase)

I_call.py

from called import je_suis_appeler
 
p = "Une phrase exemple à la noix"
je_suis_appeler(p)

Exécuter:

python3 I_call.py

import time
 
print(dir(time))
print("Il est", time.time())

import datetime
 
print(dir(datetime))
print("Nous sommes le", datetime.date.today())

labgetobject.py à utiliser dans blender

try:
    resp = 1 / 0
except:
    print("Division par zéro impossible")
 
try:
    resp = 1 / 0
except ZeroDivisionError as e:
    print(e)

La doc officielle

try:
    resp = 1 / 0
    return resp
except:
    pass

Ne jamais passer les erreurs sous silence,
ou les faire taire explicitement.

def exemple_propre(a):
    try:
        return 1 / a
    except ZeroDivisionError as e:
        print(e)
        return None
    except:
        return None

def je_multiplie():
    pass
 
def j_imprime():
    pass

l = [1, 2, 3, 4, 5]
# On compte à partir de zéro
l[1] = 2

Les listes sur apprendre-python.com

d = {1: "blender", 2: "gimp"}
# Les clés doivent être immuables
d[3] = "inkskape"
print(d)

Les dictionnaires sur apprendre-python.com

t = ("127.0.0.1", 8888)
print(t)
t = "127.0.0.1", 8888
print(t)

Les tuples sur apprendre-python.com

Je n'utilise jamais les set ! On a tous des choux-chous.

my_set = {1, 2, 3, 4, 2, 1}
print(my_set)

Le fichier pi.py n'a rien à voir avec pi ou PI ou pi()

pi.py

def pi():
    return "Mauvaise blague"

jeu.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
from pi import pi as pipi
 
# Toutes les variables globales en majuscule
PI = 3.14
 
# Ce pi est une variable globale
pi = pipi()
 
def print_pi(pi):
    """pi est une variable locale"""
    print(pi)
 
def print_a(a):
    print(a)  
 
print_pi(3)
print_a(3)
print_pi(PI)
print_pi(pi)
print_pi()

Seuls les programmeurs experts créent des class dans de gros projets. La suite ne concerne que les curieux.

Pour votre culture personnelle !

Python: Initiation à python Pourquoi des fonctions ou des class

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
class Subliminale:
    pass
 
class Minimale:
    print("Un objet Minimale créé !")
 
class MyTest:
    def my_test(self):
        print("Premier test")
 
class Bicycle:
    """Un vélo"""
 
    def __init__(self, color, kind):
        """C'est le constructeur"""
 
        self.color = color
        self.kind = kind
 
s = Subliminale()
print(type(s))
 
m = Minimale()
 
b = Bicycle("rouge", "vtt")
print(b.color)
print(b.kind)
 
class Contact:
 
    def __init__(self, name):
        self.name = name
 
    def set_phone(phone):
        self.phone = phone
 
    def get_phone(self):
        return self.phone
 
c = Contact("toto")
print(c.get_phone())

Le guide ultime et définitif sur la programmation orientée objet en Python à l’usage des débutants qui sont rassurés par les textes détaillés qui prennent le temps de tout expliquer. Voir les parties 1 à 8.

Dans l'interpréteur

import this

    Préfèrer le beau au laid,
    l’explicite à l’implicite,
    le simple au complexe,
    le complexe au compliqué,
    le déroulé à l’imbriqué,
    l’aéré au compact.
    La lisibilité compte.
    Les cas particuliers ne le sont jamais assez pour violer les règles,
    même s’il faut privilégier l’aspect pratique à la pureté.
    Ne jamais passer les erreurs sous silence,
    ou les faire taire explicitement.
    Face à l’ambiguïté, ne pas se laisser tenter à deviner.
    Il doit y avoir une – et si possible une seule – façon évidente de procéder,
    même si cette façon n’est pas évidente à première vue, à moins d’être Hollandais.
    Mieux vaut maintenant que jamais,
    même si jamais est souvent mieux qu’immédiatement.
    Si l’implémentation s’explique difficilement, c’est une mauvaise idée.
    Si l’implémentation s’explique facilement, c’est peut-être une bonne idée.
    Les espaces de nommage sont une sacrée bonne idée, utilisons-les plus souvent !

• un tuto parmi des tas sur @ chez sametmax.com

Avec python, sommes toujours entre adultes responsables.

• C'est toujours possible d’enfreindre une règle.
• Par contre, certaines règles sont obligatoires: endentation, espaces …
• Lord Acton aurait pu dire: "Les choses cachées ne le sont jamais absolument."