L'idéal pour comencer avec Python est de fonctionnaliser son code; on crée des "petits bouts de programmes" qui font des petites choses, puis dans le programme principal on appelle ces "petits bouts de programmes" à la suite quand on en a besoin. On appelle ces "petits bouts de programmes" des FONCTIONS. def permet de créer une fonction et tout ce qui est décalé d'une tabulation fait partie de la fonction (voir 1er exemple plus bas).
Un code clair est un code compréhensible. Les # en PYTHON permettent de commenter le code, c'est à dire que python ne s'occupe absolument pas de ce qui est écrit après un #.
def multiplieParDeux(nombre): # C'est une fonction qui s'appelle multiplieParDeux et qui prend un argument appelé nombre
# c'est à dire que la fonction va agir sur cet argument appelé nombre.
resultat=int(nombre)*2 # Dans cette fonction la variable resultat va prendre la valeur entière de nombre (int)
# et la multiplier par 2
return resultat # Puis cette fonction renvoie la valeur de resultat
def entreeAuClavier(texte): # C'est une fonction qui s'appelle entreeAuClavier et qui prend un argument appelé texte
# Cet argument texte précise à l'utilisateur ce qu'il doit rentrer au clavier...
variable=input(texte) # variable va prendre la valeur entrée par l'utilisateur.
return variable # variable va être renvoyé au programme qui l'a appelé.
Afin que mes programmes soient bien lisibles, je place toujours mes fonction au début dans une section nommmée FONCTIONS puis j'appelle ensuite mes fonctions dans une section nommmée PROGRAMME PRINCIPAL. Les fonctions ne seront lues et executées par python que si je les appelle... Pour créer un programme qui multiplie par deux une valeur entrée par l'utilisateur on peut alors créer le programme suivant :
##############################################################################################################
# FONCTIONS
##############################################################################################################
def multiplieParDeux(nombre): # C'est une fonction qui s'appelle multiplieParDeux et qui prend un argument appelé nombre
resultat=int(nombre)*2 # Dans cette fonction la variable resultat va prendre la valeur entière de nombre (int)
# et la multiplier par 2
return resultat # Puis cette fonction renvoie la valeur de resultat
def entreeAuClavier(texte): # C'est une fonction qui s'appelle entreeAuClavier et qui prend un argument appelé texte
variable=input(texte) # variable va prendre la valeur entrée par l'utilisateur.
return variable # variable va être renvoyé au programme qui l'a appelé.
##############################################################################################################
# PROGRAMME PRINCIPAL
##############################################################################################################
# Ceci est la zone où j'appelle mes fonctions :
# je commence par dire à python que la variable que j'ai décidé d'appeler monNombre va prendre pour valeur
# ce que me retournera la fonction entreeAuClavier(), c'est à dire que ce que va ecrire l'utilisateur
# lorsqu'il répondra à la question "Veuiller entrer un nombre à multiplier par deux : " sera enregistré
# comme étant la valeur de ma variable monNombre.
monNombre=entreeAuClavier("Veuiller entrer un nombre à multiplier par deux : ")
# Ensuite je dis à python que la variable que j'ai décidé d'appeler monResultat va prendre pour valeur
# ce que me retournera la fonction multiplieParDeux(monNombre). Cette fonction va donc multiplier par deux la valeur
# de monNombre, et le résultat sera enregistré comme étant la valeur de ma variable monResultat.
monResultat=multiplieParDeux(monNombre)
# Il ne me reste plus qu'à afficher la valeur de la variable monResultat...
print("Voici le résultat de la multiplication par deux : ",monResultat)
On veut réaliser un programme permettant de créer l’ARN pré-messager à partir d’une séquence de nucléotides d’un gène.
Voici les fonctions proposées pour ce projet :
##############################################################################################################
# FONCTIONS
##############################################################################################################
def entreeAuClavier(texte): # C'est une fonction qui s'appelle entreeAuClavier et qui prend un argument appelé texte
variable=input(texte) # variable va prendre la valeur entrée par l'utilisateur.
return variable # variable va être renvoyé au programme qui l'a appelé.
def adnArn(seqAdn): # Cette fonction permet transcrire une séquence de nucléotides d'ADN en ARN et qui prend pour argument
# seqAdn c'est à dire une variable qui a pour valeur une sequence d'ADN.
# Vous n'avez pas besoin de comprendre comment fonctionne dans le détail cette
# fonction pour l'utiliser.
arn="" # Au départ la sequence d'ARN est une chaine vide
for i in seqAdn: # On va faire une boucle où i va prendre tour à tour la valeur de chaque caractère (nucleotide)
# de la sequence d'ADN
if i=="A": # Si i a la valeur "A"
arn=arn+"U" # On ajoute le caractère "U" à la séquence d'ARN
elif i=="T": # Sinon si i a la valeur "T"
arn=arn+"A" # On ajoute le caractère "A" à la séquence d'ARN
elif i=="C": # Sinon si i a la valeur "C"
arn=arn+"G" # On ajoute le caractère "G" à la séquence d'ARN
elif i=="G": # Sinon si i a la valeur "G"
arn=arn+"C" # On ajoute le caractère "C" à la séquence d'ARN
else:# Sinon si aucune des valeurs précédentes n'est valide c'est qu'il y eu une erreur de saisie dans la
# séquence d'ADN
# Et on affiche l'erreur
print("La séquence de votre gène n'est pas correcte. Seules les nucléotides A,T,C et G sont acceptés.")
break # Et le programme s'arrête
# Une fois que l'on a parcouru tous les caractères de la sequence de nucléotides d'ADN on sort de la boucle
return arn # On renvoie alors la chaine d'ARN
##############################################################################################################
# PROGRAMME PRINCIPAL
##############################################################################################################
# Donc on commence par entrer dans une variable dont on choisi le nom judicieusement
# la séquence d'ADN à entrer au clavier en appelant la bonne fonction. On y va :
# On choisi alors un nouveau nom de variable judicieusement choisi qui va recevoir la sequence d'ARN
# générée par la bonne fonction qui va réaliser la transcription. On y va :
# Cette ligne permet d'afficher le résultat. Vous devez la personnaliser en remplacant seqARN
# par le nom de la variable que vous avez choisi pour contenir le resultat de la transcription.
print ("On obtient l'ARN messager suivant : ",seqARN)
On peut se demander à partir d’un nombre de bactéries de départ dans un aliment, combien on peut obtenir théoriquement de bactéries au bout d’un temps donné en minute si on reste en phase exponentielle en partant du principe que cette bactérie se divise toutes les 20 mn.
Voici différentes fonctions qui vous permettrons de réaliser cet exercice. A vous de créer le programme principal ... commencez déjà sur un papier par écrire l'algorhime avant de vous jeter sur le code...
##############################################################################################################
# FONCTIONS
##############################################################################################################
def entreeAuClavier(texte): # C'est une fonction qui s'appelle entreeAuClavier et qui prend un argument appelé texte
variable=input(texte) # variable va prendre la valeur entrée par l'utilisateur.
return variable # variable va être renvoyé au programme qui l'a appelé.
def diviseUnNombre(nombre,diviseur): # C'est une fonction qui s'appelle diviseUnNombre et qui prend un argument appelé nombre
# et un autre appelé diviseur
resultat=int(nombre)/int(diviseur) # resultat va prendre la valeur du nonbre divisé par le diviseur
return resultat # resultat va être renvoyé au programme qui l'a appelé.
def multiplieUnNombre(nombre,multiplicateur): # C'est une fonction qui s'appelle multiplieUnNombre et qui prend
# un argument appelé nombre et un autre appelé diviseur
resultat=int(nombre)*int(multiplicateur) # resultat va prendre la valeur du nombre multiplié par le multiplicateur
return resultat # resultat va être renvoyé au programme qui l'a appelé.
##############################################################################################################
# PROGRAMME PRINCIPAL
##############################################################################################################
# Cette partie est à remplir par vos soins en appelant les bonnes fonctions au bon moment...
nbBacteries=entreeAuClavier("Nombre de bactéries au départ :")
tpsDivision=entreeAuClavier("Temps en minutes où la bactérie va se diviser : ")
# Puis votre programme principal va devoir faire une boucle. La boucle est en place ci dessous.
# il vous reste à la personnaliser en calculant nombreDeTours et en personnalisant action
# par ce qu'il faut faire à chaque tour;
# reste à donner la valeur de total au départ c'est à dire le nombre de bactéries au départ :
total=nbBacteries
# Puis il faut le nombre de tour de boucles à réaliser c'est à dire le nombre de divisions dans le temps donné :
nombreDeTours=diviseUnNombre(tpsDivision,20)
# Et on lance la boucle qui va tourner pendant un sertain nombre de tours :
for i in range(int(nombreDeTours)): # la variable i va prendre les valeurs de 1 à nombreDeTours
# Le total doit être modifié à chaque tour :
total=
# la ligne suivante affichera le résultat de votre multiplication bactérienne :
print ("Le nombre de bactéries obtenues est de ",total,".")