Une introduction à Python 3

# -*- coding : utf8 -*-
"""Volume d'un cône droit."""

# Import ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
from math import pi

# Programme principal =========================================================
rayon = float(input("Rayon du cône (m) :"))
hauteur = float(input("Hauteur du cône (m) :"))

volume = (pi*rayon*rayon*hauteur)/3.0
print("Volume du cône =", volume, "m3")

# -*- coding : utf8 -*-
"""Calcul d'un prix TTC."""

# Programme principal =========================================================
prixHT = float(input("Prix HT (0 pour terminer) ?"))
while prixHT > 0:
    print("Prix TTC : { :.2f}\n".format(prixHT * 1.196))
    prixHT = float(input("Prix HT (0 pour terminer) ?"))

print("Au revoir !")

# -*- coding : utf8 -*-
"""Somme d'entiers et nombre d'entiers supérieurs à 100."""

# Programme principal =========================================================
somme, nombreTotal, nombreGrands = 0, 0, 0

x = int(input("x (0 pour terminer) ?"))
while x > 0:
    somme += x
    nombreTotal += 1
    if x > 100:
        nombreGrands += 1
    x = int(input("x (0 pour terminer) ?"))

print("\nSomme :", somme)
print(nombreTotal, "valeur(s) en tout, dont", nombreGrands, "supérieure(s) à 100")

# -*- coding : utf8 -*-
"""Parité."""

# Programme principal =========================================================
n = int(input("Entrez un entier strictement positif :"))
while n < 1:
    n = int(input("Entrez un entier STRICTEMENT POSITIF, s.v.p. :"))

if n%2 == 0:
    print(n, "est pair.")
else :
    print(n, "est impair.")

# -*- coding : utf8 -*-
"""Nombre de fois qu'un entier est divisible par 2."""

# Programme principal =========================================================
n = int(input("Entrez un entier strictement positif :"))
while n < 1:
    n = int(input("Entrez un entier STRICTEMENT POSITIF, s.v.p. :"))
save = n

cpt = 0
while n%2 == 0:
    n /= 2
    cpt += 1

print(save, "est", cpt, "fois divisible par 2.")

# -*- coding : utf8 -*-
"""Diviseurs propres d'un entier."""

# Programme principal =========================================================
n = int(input("Entrez un entier strictement positif :"))
while n < 1:
    n = int(input("Entrez un entier STRICTEMENT POSITIF, s.v.p. :"))

i = 2 # plus petit diviseur possible de n
cpt = 0 # initialise le compteur de divisions
p = n/2 # calculé une fois dans la boucle

print("Diviseurs propres sans répétition de", n, " :", end=' ')
while i <= p :
    if n%i == 0:
        cpt += 1
        print(i, end=' ')
    i += 1

if not cpt :
    print("aucun ! Il est premier.")
else :
    print("(soit", cpt, "diviseurs propres)")

# -*- coding : utf8 -*-
"""Approximation de 'e'."""

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def fact(n) :
    r = 1
    for i in range(1, n+1) :
        r *= i
    return r

# Programme principal =========================================================
n = int(input("n ?"))
exp = 0.0
for i in range(n) :
    exp = exp + 1.0/fact(i)

print("Approximation de 'e' : { :.3f}".format(exp))

# -*- coding : utf8 -*-
"""Gardien de phare."""

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def hauteurParcourue(nb, h) :
    print("Pour { :d} marches de { :d} cm, il parcourt { :.2f} m par semaine !"
         .format(nb, h, nb*h*2*5*7/100.0))

# Programme principal =========================================================
nbMarches = int(input("Combien de marches ?"))
hauteurMarche = int(input("Hauteur d'une marche (cm) ?"))

hauteurParcourue(nbMarches, hauteurMarche)

# -*- coding : utf8 -*-
"""Permis de chasse."""

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def permisSup(p, c, v, a) :
    pointsPerdus = p + 3*c + 5*v + 10*a
    nbrePermis = pointsPerdus/100.0
    return 200*nbrePermis

# Programme principal =========================================================
poules = int(input("Combien de poules ?"))
chiens = int(input("Combien de chiens ?"))
vaches = int(input("Combien de vaches ?"))
amis = int(input("Combien d'amis ?"))

payer = permisSup(poules, chiens, vaches, amis)

print("\nA payer :", end=' ')
if payer == 0:
    print("rien à payer")
else :
    print(payer, "euros")

# -*- coding : utf8 -*-
"""Histoire de train."""

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def tchacatchac(v) :
    """Affiche l'heure du drame."""
    heure = 9 + int(170/v)
    minute = (60 * 170 / v) % 60
    print("A { :>3} km/h, je me fais déchiqueter à { :>2} h { :.2f} min."
         .format(v, heure, minute))

# Programme principal =========================================================
i = 100
    while i <= 300:
        tchacatchac(i)
        i += 10

# -*- coding : utf8 -*-
"""Proportion d'une séquence dans une chaîne d'ADN."""

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def valide(seq) :
    """Retourne vrai si la séquence est valide, faux sinon."""
    ret = any(seq)
    for c in seq :
        ret = ret and c in "atgc"
    return ret

def proportion(a, s) :
    """Retourne la proportion de la séquence <s> dans la chaîne <a>."""
    return 100*a.count(s)/len(a)

def saisie(ch) :
    s = input("{ :s} :".format(ch))
    while not valide(s) :
        print("'{ :s}' ne peut contenir que les chaînons 'a', 't', 'g' et 'c'"
              " et ne doit pas être vide".format(ch))
        s = input("{ :s} :".format(ch))
    return s

# Programme principal =========================================================
adn = saisie("chaîne")
seq = saisie("séquence")

print('Il y a { :.2f} % de"{ :s}" dans votre chaîne.'
     .format(proportion(adn, seq), seq))

# -*- coding : utf8 -*-
"""Echanges."""

# Import ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
from random import seed, randint

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def listAleaInt(n, a, b) :
    """Retourne une liste de <n> entiers aléatoires dans [<a> .. <b>]."""
    return [randint(a, b) for i in range(n)]

# Programme principal =========================================================
seed() # initialise le générateur de nombres aléatoires
t = listAleaInt(100, 2, 125) # construction de la liste

iMin = t.index(min(t)) # calcule l'index du minimum de la liste

print("Avant échange :")
print("\tt[0] =", t[0], "\tt[iMin] =", t[iMin])
t[0], t[iMin] = t[iMin], t[0] # échange
print("Apres échange :")
print("\tt[0] =", t[0], "\tt[iMin] =", t[iMin])

# -*- coding : utf8 -*-
"""Amplitude et moyenne d'une liste de flottants."""

# Import ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
from random import seed, random

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def listAleaFloat(n) :
    "Retourne une liste de <n> flottants aléatoires"
    return [random() for i in range(n)]

# Programme principal =========================================================
n = int(input("Entrez un entier [2 .. 100] :"))
while not(n >= 2 and n <= 100) :
    n = int(input("Entrez un entier [2 .. 100], s.v.p. :"))

seed() # initialise le générateur de nombres aléatoires
t = listAleaFloat(n) # construction de la liste

print("Amplitude : { :.2f}".format(max(t) - min(t)))
print("Moyenne : { :.2f}".format(sum(t)/n))

# -*- coding : utf8 -*-
"""Min, max et moyenne d'une liste d'entiers."""

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def minMaxMoy(liste) :
    """Renvoie le min, le max et la moyenne de la liste."""
    min, max, som = liste[0], liste[0], float(liste[0])
    for i in liste[1:]:
        if i < min :
            min = i
        if i > max :
            max = i
        som += i
    return (min, max, som/len(liste))

# Programme principal =========================================================
lp = [10, 18, 14, 20, 12, 16]

print("liste =", lp)
l = minMaxMoy(lp)
print("min : {0[0]}, max : {0[1]}, moy : {0[2]}".format(l))

# -*- coding : utf8 -*-
"""Nombres romains (version 1)."""

# Programme principal =========================================================
n = int(input('Entrez un entier [1 .. 4000[ : '))

while not(n >= 1 and n < 4000) :
    n = int(input('Entrez un entier [1 .. 4000[, s.v.p. : '))

s = "" # Chaîne résultante

while n >= 1000:
    s += "M"
    n -= 1000
if n >= 900:
    s += "CM"
    n -= 900
if n >= 500:
    s += "D"
    n -= 500
if n >= 400:
    s += "CD"
    n -= 400

while n >= 100:
    s += "C"
    n -= 100
if n >= 90:
    s += "XC"
    n -= 90
if n >= 50:
    s += "L"
    n -= 50
if n >= 40:
    s += "XL"
    n -= 40
while n >= 10:
    s += "X"
    n -= 10
if n >= 9:
    s += "IX"
    n -= 9
if n >= 5:
    s += "V"
    n -= 5
if n >= 4:
    s += "IV"
    n -= 4
while n >= 1:
    s += "I"
    n -= 1

print("En romain :", s)

# -*- coding : utf8 -*-
"""Nombres romains (version 2)."""

# globales ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
CODE = zip(
    [1000,  900, 500,  400, 100,  90,   50,  40,   10,  9,    5,    4,   1],
    [ "M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
)

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def decToRoman(num) :
    res = []
    for d, r in CODE :
        while num >= d :
            res.append(r)
            num -= d
    return ''.join(res)

# Programme principal =========================================================
for i in range(1, 4000) :
    print(i, decToRoman(i))

# -*- coding : utf8 -*-
"""Liste d'entiers différents."""

# Import ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
from random import seed, randint

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def listAleaInt(n, a, b) :
    """Retourne une liste de <n> entiers aléatoires entre <a> et <b>."""
    return [randint(a, b) for i in range(n)]

# Programme principal =========================================================
n = int(input("Entrez un entier [1 .. 100] :"))
while not(n >= 1 and n <= 100) :
    n = int(input("Entrez un entier [1 .. 100], s.v.p. :"))

# construction de la liste
seed() # initialise le générateur de nombres aléatoires
t = listAleaInt(n, 0, 500)

# Sont-ils différents ?
tousDiff = True
i = 0
while tousDiff and i < (n-1) :
    j = i + 1
    while tousDiff and j < n :
        if t[i] == t[j]:
            tousDiff = False
        else :
            j += 1
    i += 1

if tousDiff :
    print("\nTous les éléments sont distincts.")
else :
    print("\nAu moins une valeur est répétée.")
print(t)

# -*- coding : utf8 -*-
"""Liste d'entiers différents (seconde version)."""

# Import ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
from random import seed, randint

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def listAleaInt(n, a, b) :
    """Retourne une liste de <n> entiers aléatoires entre <a> et <b>."""
    return [randint(a, b) for i in range(n)]

# Programme principal =========================================================
n = int(input("Entrez un entier [1 .. 100] :"))
while not(n >= 1 and n <= 100) :
    n = int(input("Entrez un entier [1 .. 100], s.v.p. :"))

seed() # initialise le générateur de nombres aléatoires
avant = listAleaInt(n, 0, 500)
apres = list(set(avant))

if len(avant) == len(apres) :
    print("\nTous les éléments sont distincts.")
else :
    print("\nAu moins une valeur est répétée.")
print(avant)

# -*- coding : utf8 -*-
"""Jeu de dés (1)."""

# Programme principal =========================================================
n = int(input("Entrez un entier [2 .. 12] :"))
while not(n >= 2 and n <= 12) :
    n = int(input("Entrez un entier [2 .. 12], s.v.p. :"))

s = 0
for i in range(1, 7) :
    for j in range(1, 7) :
        if i+j == n :
            s += 1

print("Il y a { :d} façon(s) de faire { :d} avec deux dés.".format(s, n))

# -*- coding : utf8 -*-
"""Jeu de dés (2)."""

# Programme principal =========================================================
n = int(input("Entrez un entier [3 .. 18] :"))
while not(n >= 3 and n <= 18) :
    n = int(input("Entrez un entier [3 .. 18], s.v.p. :"))

s = 0
for i in range(1, 7) :
    for j in range(1, 7) :
        for k in range(1, 7) :
            if i+j+k == n :
                s += 1

print("Il y a { :d} façon(s) de faire { :d} avec trois dés.".format(s, n))

# -*- coding : utf8 -*-
"""Jeu de dés (3)."""

# Globale ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
MAX = 8

# Programme principal =========================================================
nbd = int(input("Nombre de dés [2 .. { :d}] :".format(MAX)))
while not(nbd >= 2and nbd <= MAX) :
    nbd = int(input("Nombre de dés [2 .. { :d}], s.v.p. :".format(MAX)))

s = int(input("Entrez un entier [{ :d} .. { :d}] :".format(nbd, 6*nbd)))
while not(s >= nbd and s <= 6*nbd) :
    s = int(input("Entrez un entier [{ :d} .. { :d}], s.v.p. :".format(nbd, 6*nbd)))

if s == nbd or s == 6*nbd :
    cpt = 1 # 1 seule solution
else :
    I = [1]*nbd # initialise une liste de <nbd> dés
    cpt, j = 0, 0
    while j < nbd :
        som = sum([I[k] for k in range(nbd)])

        if som == s :
            cpt += 1 # compteur de bonnes solutions
        if som == 6*nbd :
            break

        j = 0
        if I[j] < 6:
            I[j] += 1
        else :
            while I[j] == 6:
                I[j] = 1
                j += 1
            I[j] += 1

print("Il y a { :d} façons de faire { :d} avec { :d} dés.".format(cpt, s, nbd))

# -*- coding : utf8 -*-
"""Jeu de dés (récursif)."""

# Globale ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
MAX = 8

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def calcul(d, n) :
    """Calcul récursif du nombre de façons de faire <n> avec <d> dés."""
    resultat, debut = 0, 1
    if (d == 1) or (n == d) or (n == 6*d) : # conditions terminales
        return 1
    else : # sinon appels récursifs
        if n > 6*(d-1) : # optimisation importante
            debut = n - 6*(d-1)
        for i in range(debut, 7) :
            if n == i :
                break
            resultat += calcul(d-1, n-i)
    return resultat

# Programme principal =========================================================
d = int(input("Nombre de dés [2 .. { :d}] :".format(MAX)))
while not(d >= 2and d <= MAX) :
    d = int(input("Nombre de dés [2 .. { :d}], s.v.p. :".format(MAX)))

n = int(input("Entrez un entier [{ :d} .. { :d}] :".format(d, 6*d)))
while not(n >= d and n <= 6*d) :
    n = int(input("Entrez un entier [{ :d} .. { :d}], s.v.p. :"
            .format(d, 6*d)))

print("Il y a { :d} façon(s) de faire { :d} avec { :d} dés."
      .format(calcul(d, n), n, d))

# !/usr/bin/env python
# -*- coding : utf8 -*-
"""Module pour les nombres parfaits et chanceux."""

#==============================================================================
# fichier : parfait_chanceux_m.py
#
# auteur : Bob Cordeau
#==============================================================================

# Définition de fonction ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def somDiv(n) :
    """Retourne la somme des diviseurs propres de <n>."""
    som_div = 1
    for div in range(2, (n//2)+1) :
        if n % div == 0:
            som_div += div
    return som_div

def estParfait(n) :
    """Retourne True si <n> est parfait, False sinon."""
    return somDiv(n) == n

def estPremier(n) :
    """Retourne True si <n> est premier, False sinon."""
    return somDiv(n) == 1

def estChanceux(n) :
    """Retourne True si <n> est chanceux, False sinon."""
    est_chanceux = True
    for i in range(0, n-1) :
        est_chanceux = est_chanceux and estPremier(n + i + i*i)
    return est_chanceux

# Auto-test ===================================================================
if __name__== '__main__' :
    from verif_m import verif

    verif(somDiv(12), 16)
    verif(estParfait(6), True)
    verif(estPremier(31), True)
    verif(estChanceux(11), True)

# !/usr/bin/env python
# -*- coding : utf8 -*-
"""Nombres chanceux et parfaits."""

#==============================================================================
# fichier : parfait_chanceux.py
#
# auteur : Bob Cordeau
#==============================================================================

# Import ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
from parfait_chanceux_m import estParfait, estChanceux

# programme principal =========================================================
parfait, chanceux = [], []
for n in range(2, 1001) :
    if estParfait(n) :
        parfait.append(n)
    if estChanceux(n) :
        chanceux.append(n)

print("\nIl y a {} nombres parfaits dans [2, 1000] : {}"
     .format(len(parfait), parfait))
print("\nIl y a {} nombres chanceux dans [2, 1000] : {}"
     .format(len(chanceux), chanceux))