Informatique Pour Tous Interrogation n°2 Conversions Syntaxe Python

Nom :
Prénom :
Informatique Pour Tous
Interrogation n°2
Conversions
1) Donner en base 10 la valeur des nombres suivants considérés comme des entiers signés codés
en machine sous forme d’octets
a) 10111001
– 71
b) 10010111
– 105
Syntaxe Python
2) Soit une variable prix contenant une valeur numérique de type float, par exemple 20.3.
Comment obtenir la variable chaine contenant la chaîne de caractères :
« cet objet coûte 20.3 euros, ce n’est pas cher » dit-il
où 20.3 est la valeur contenue dans prix ?
chaine = ‘ ‘‘cet objet coûte’ + str(prix) + ’euros, ce n\’est pas
cher’’ dit-il’
3) Préciser le type des variables dans la série d’instructions suivantes :
v0 = 365892145
type(v0): int
v5=["deux",3,
"trois",2]
type(v5): list
v1 = 3.65892145
type(v1): float
v7 = v5[2]
type(v6):str
v2 = 3 > 2
type(v2): bool
v6 = v5[1:4]
type(v7): lst
v3
‘3.65892145’
v4 =
input(« entrez
un float »)
= type(v3): str
type(v4): str
v8 =
v1,int(v5[2])
v9 = v0 / 2
erreur
type(v9): float
4) Soit une liste lst définie par : lst = [2, (2,1), ‘2’, 2 < 1, 2 + 1]
Indiquez les valeurs des variables suivantes :
v1 = lst[2]
v1 = ‘2’
v2 = lst[1:3]
v2
=
‘2’]
v3 = lst[-2]
v3 = False
Informatique Pour Tous
v4 = lst[3:]
[(2,1), v5 = lst[2]
lst[4]
v6 = lst[0]
lst[4]
page 1/6
v4 = [False, 3]
* v5 = ‘222’
* v6 = 6
PCSI1 2015-2016
5) Quelles sont les valeurs entières produites par l'instruction range(4,13,2) ?
# attention range(4, 13, 2) s’arrête à 13 – 1 ; il ne signifie pas « ordonner »
4, 6, 8, 10, 12
6) Quelle est l’affichage produit par le programme suivant :
def f(n) :
s = 0
for k in range(1 , n+1) :
s += 1/k
return s
print(f(5))
1.0
# car le return arrête la
fonction dès la première
itération de la boucle, pour
laquelle k = 1 et s = 1.0
Sémantique Python
7) On considère les scripts Python suivants :
Script 1 :
exp = 2
for i in range(3):
exp = 2**exp
print(exp)
Script 2 :
expo=2
for i in range(3):
expo=expo**2
print(expo)
Compléter les tableaux d’état suivants correspondant à chaque script:
t
i
0
exp
t
2
0
i
expo
2
1
0
4
1
0
4
2
1
16
2
1
16
3
2
65536
3
2
256
8) On considère le programme Python suivant :
from math import sqrt
def mystere(n):
if n <= 1:
return False
if n <= 3:
return True
for k in range(2,1 + int(sqrt(n))):
if n % k == 0 :
return False
return True
Qu’affiche print(mystere(12) ? print(mystere(13) ? print(mystere(n)) où n
est une variable contenant une valeur entière quelconque.
print(mystere(12) renvoie False
print(mystere(13) renvoie True
print(mystere(n) renvoie True si n est premier, False sinon.
Informatique Pour Tous
page 2/6
PCSI1 2015-2016
Algorithmique
On sait depuis le début des années 1950 que l’information génétique d’un
organisme vivant est mémorisée dans la molécule d’ADN de ses chromosomes.
Cette molécule, constituée de deux brins complémentaires, est un long
enchaînement de nucléotides de quatre types différents (distingués par leur base
azotée : adénine, thymine, cytosine et guanine) désignés par les lettres A, T, C et G.
Séquencer le génome d’un organisme, c’est établir l’enchaînement de ces
nucléotides.
La taille du génome peut varier de quelques milliers de nucléotides chez les
virus à plusieurs milliards de nucléotides (3,4 milliards pour l’homme par avec les
quatre lettres A, T, C et G. exemple). La molécule d’ADN apparaît ainsi comme un
très long texte écrit
À titre de comparaison un livre de poche de 1 000 pages comporte environ
deux millions de caractères. D’autre part, seules certaines parties de cet enchaînement, appelées
régions codantes et correspondant aux gènes, ont un problème technique. Les difficultés
commencent avec l’interprétation de ce sens. Aujourd’hui séquencer le génome d’un organisme ne
pose plus de très long texte sans espace, ni point, ni virgule.
Une séquence d’ADN sera représentée par une chaîne de caractères comportant uniquement
les caractères A, T, C et G.
Exemple utilisé dans la suite :
ADN_exemple =’ATCTCATGCTCGGTAATATGTCATAGCCGATGCTACGATGACCTAC’
COMPLEMENT PYTHON
La bibliothèque random, est supposée préalablement chargée par l’instruction from
random import *, l’instruction choice(range(n)) permet de générer un nombre entier
(pseudo-)aléatoire compris entre 0 et n – 1.
9) On définit la variable car = (‘A’, ‘T’, ‘C’, ‘G’) contenant l’ensemble des caractères
possibles d’une séquence ADN. Justifiez le choix du type de cette variable.
La variable est un tuple car les éléments qu’il contient ne changent pas pendant le traitement ultérieur.
10) En utilisant la variable car définie ci-dessus comme variable locale, écrire une fonction
sequence_ADN(n) ayant pour paramètre d’entrée un entier naturel n et renvoyant une séquence
d’ADN aléatoire de longueur n. Ajouter tout commentaire utile.
def sequenceADN(n):
car = ('A', 'T', 'C', 'G')
adn = ' '
# initialisation de la chaine
for k in range(n):
r=choice(range(4))
# tirage au sort d’un entier compris
# entre 0 et 3
adn = adn + car[r]
# ajout à la chaîne du caractère
# d’indice r du tuple car
return(adn)
Informatique Pour Tous
page 3/6
PCSI1 2015-2016
Une région codante est une succession de codons (triplet de nucléotides) non-chevauchants
qui commence par un triplet ATG (appelé codon start) et s’achève par l’un des trois triplets TAA,
TAG ou TGA (appelés codons stop).
Exemple :
...AGTT
ATG
CTC
GGA
ACC
TGT
ATG
TCA
GGG
GTT
TAA
CTAC...
région codante
Une région codante est composée d’un nombre entier de codons.
11) Écrire une fonction codon_start(ADN) prenant en entrée une séquence d’ADN (chaîne de
caractères) et renvoyant une liste contenant la position de tous les codons start ‘ATG’ trouvés (on
indiquera l’indice du ‘A’). Si aucun codon ‘ATG’ n’est trouvé, la fonction doit renvoyer une liste vide.
Ajouter tout commentaire utile.
Par exemple codon_start(ADN_exemple) renvoie [5,17,29,37].
def codon_start(ADN):
n = len(ADN)
liste = []
# liste initialement vide à
construire
for k in range(n - 2):
# inutile de parcourir la chaîne
# jusqu’au bout puisque un codon
# contient 3 éléments
if ADN[k : k+3] == 'ATG': #on cherche un ATG
liste.append(k)
return(liste)
12) Écrire une fonction codon_stop(ADN, i) prenant en entrée une séquence d’ADN (chaîne de
caractères) et l’indice i du début d’un codon start et renvoyant l’indice du début du premier codon stop
(de la forme TAA, TAG ou TGA) suivant celui-ci. Les codons start et stop doivent être en phase, c’est-àdire séparés par un nombre de nucléotides multiple de 3. Si aucun codon stop n’est trouvé, la fonction
doit renvoyer le booléen False. Ajouter tout commentaire utile.
Par exemple :
codon_stop(ADN_exemple,5) donne 23 ; codon_stop(ADN_exemple,17) donne 23 ;
codon_stop(ADN_exemple,29) donne 38 ; codon_stop(ADN_exemple,37) donne
False.
def codon_stop(ADN, i):
codons_cherches = (‘TAA’, ‘TAG’, ‘TGA’)
pos = i + 3
#on commence après le codon start
while pos <= len(ADN)- 2:
# tant que pos n’est pas
# au bout de la chaine
if ADN[pos : pos + 3] in codons_cherches :
return(pos)
# on a trouvé un codon stop
else :
pos = pos + 3
return(False)
Informatique Pour Tous
# on n’a pas trouvé, on décale pos de 3
# on a rien trouvé dans la chaîne
page 4/6
PCSI1 2015-2016
13) Écrire une fonction regions_codantes(ADN) prenant en entrée une séquence d’ADN et
renvoyant la liste des emplacements des régions codantes de cette séquence. Les emplacements seront de
la forme (a,b) où a est l’indice du début du codon start et b est l’indice du début du codon stop de
la région. Cette fonction renvoie donc une liste de tuples. On fera attention à ne pas renvoyer de régions
codantes chevauchantes. Si aucune région codante n’est trouvée, la fonction doit renvoyer la liste vide.
Ajouter tout commentaire utile.
Par exemple : : regions_codantes(ADN_exemple)=[(5,23),(29,38)].
def regions_codantes(ADN):
liste_start = codon_start(ADN)
#emplacements des codons start
n = len(liste_start)
#nombre de codons starts
liste_regions = []
# initialisation de la liste
# des emplacements des régions codantes
stop_prec = 0
# initialisation des codons stop trouvés
for start in liste_start :
# on prend la position
# d’un codon start
stop = codon_stop(ADN , start) # on cherche un codon stop
# en phase avec start
if stop != False and start >= stop_prec: #si on en a un
# et si la région ne chevauche pas la précédente
liste_regions.append((start, stop))
stop_prec = stop
# dernier codon stop trouvé
return(liste_regions)
14) Écrire une fonction detail_regions_codantes_aff(ADN) prenant en entrée une séquence
d’ADN et renvoyant la liste des caractères de chaque région codante de cette séquence. Chaque région
codante sera donnée sous la forme d’une chaîne de caractères et chaque codon sera séparé par le
caractère |. Si aucune région codante n’est trouvée, la fonction doit renvoyer la liste vide. Ajouter tout
commentaire utile. Par exemple : detail_regions_codantes_aff(ADN_ exemple) donne
[’|ATG|CTC|GGT|AAT|ATG|TCA|TAG|’,’|ATG|CTA|CGA|TGA|’].
def detail_regions_codantes(ADN):
liste_tuple_region = regions_codantes(ADN)
#liste des tuples
# désignant les régions
liste_regions=[]
# initialisation de la liste
#des régions détaillées
for region in liste_tuple_region :
chaine_region = '|'
# intialisation d’une chaîne
start = region[0]
# debut du codon start
stop =
#fin du codon stop
region[1]+2
for i in range(start, stop+1, 3):
chaine_region = chaine_region + ADN[i : i+3]+'|'
liste_regions.append(chaine_region)
return(liste_regions)
Informatique Pour Tous
page 5/6
PCSI1 2015-2016
Informatique Pour Tous
page 6/6
PCSI1 2015-2016