bonjour
Comme annoncé je m’intéresse à scratch qui parait il est destiné aux enfants pour apprendre le code . Ce code est dit on presque du python . Serait ce également un pseudo code ? Je ne sais pas . En tout cas j’ai fait votre exercice avec scratch et cela a été assez vite mais on voit déjà que ce que j’ai fait m’apparaît déjà compliqué pour un adolescent (encore faut il déterminer son age ) . Donc à mon avis , ce code scratch est également largement utile à des adultes ( comme moi ) . donc je vous montre une image de ce que j’ai réussi à faire et j’ai un livre qui aide à transcrire en python ce que je vais vous montrer :

SCRATCH.png1249×895 90.4 KB

donc dans mon livre ils disent
dessiner c’est : from turtle import *
definir c’est la fonction def
à droite de 50 : forward(50)
tournerà droite de 20 : right(20)
stylo position écriture : pendown()
répéter : while
mettre valeur à 3 : valeur = 3

etc etc
voilà c’est mon idée
qu’en pensez vous ?

Bonjour trx337,

En collège, où j’enseigne les mathématiques, nous travaillons avec les élèves sur Scratch, et je dirais que ce script est tout à fait à la portée de ces adolescents.
As-tu testé la conversion de ce programme en Python ?

très bien mais j’aimerais savoir l’age a laquelle on écris déjà ce script en scrach

oui je suis en train de l’écrire mais j’ai déjà une incompréhension si vous pouvez m’aider :

# dessiner


from turtle import *
pas = 10
def àdroiteC(pas):
    pendown()
    forward(pas)
    penup()

blou = input('entre ton code génétique :' )
position = 1
while len(blou) != 100 :
    caractère = blou[position]
    if caractère == "A" :
        àdroiteC(pas)
    position +=1

entre ton code génétique :AAAAAAAAAAAAAAAAUTTTTTTTTTTTT
Traceback (most recent call last):
File “C:/Users/genevieve/AppData/Local/Programs/Python/Python37/dessiner dna.py”, line 14, in
caractère = blou[position]
IndexError: string index out of range

mais j’ai quand même un début de dessin

Première chose, il est déconseillé d’utiliser des lettres accentuées dans les noms de variables ou de fonctions.

Je ne suis pas sûre de comprendre la condition de ta boucle while.
Comme tu ne modifies pas la chaîne blou, sa longueur ne va pas être modifiée et ton code entre dans une boucle infinie, ce qui fait qu’à un moment, position dépasse la longueur de la chaîne et ton programme s’arrête sur une erreur Index out of range.

j’ai avancé d’un cran mais je ne sais pas faire mieux:

# dessiner


from turtle import *
pas = 20
def AdroiteC(pas):
    pendown()
    forward(pas)
    penup()

def AgaucheG(pas):
    pendown()
    backward(pas)
    penup()
    
def MonterA(pas):
    pendown()
    left(90)
    forward(pas)
    penup()
    right(90)

def DescendreT(pas):
    pendown()
    right(90)
    forward(pas)
    penup()
    left(90)    


blou = input('entre ton code génétique :' )
position = 0



while len(blou) != position :

    caractere = blou[position]    
    if caractere == "C" :
        AdroiteC(pas)
    elif caractere == "G" :
        AgaucheG(pas)    
    elif caractere == "A" :
        MonterA(pas)
    elif caractere == "T" :
        DescendreT(pas)

    position +=1

mon dessin:
peux t on enlever la flèche sur le dessin ?

Si tu testes que le caractère est différent de ‘#’, il faut que la chaîne que tu passes en argument à la fonction termine bien par ce caractère.
Une autre façon de procéder est bien de considérer la longueur de la chaîne, mais dans ce cas, ce n’est pas le caractère qui doit être différent de len(blou), mais l’indice.
Donc while position != len(blou) et non while blou[position] != len(blou).

oui je venais de la trouver tout seul
voir ci dessus

(quand j’écrivais ma chaine , je mettais bien mon dièze et ça faisait une erreur
)
peux t on enlever la flèche sur le dessin ?

Essaie avec l’instruction hideturtle().

super , merci ça a fonctionné

comment écrit on la position en x et y de la tortue ?
et comment lui dire de commencer son dessin à la marge gauche de l’écran ?

et comment récupérer la position de deux points pour ensuite lui dire de tracer un trait entre les deux points ?

L’instruction goto(x, y) permet de déplacer la tortue en ligne droite vers le point correspondant. Si la plume est baissée, alors la tortue tracera le segment correspondant.
Pour connaître les coordonnées actuelles de la tortue, il y a les méthodes xcor() et ycor().

Tu trouveras dans la doc python toutes les instructions de ce module.

merci

je viens de comprendre que vous avez écris le mot mooc ; très drôle
j’ai regardé la doc

si on écrit turtle.position() , il dit qu’il ne comprend pas turtle
mais si on écrit position() seul , il comprend
cela vient surement du fait que j’avais écrit :from turtle import *

mais je n’ai pas compris comment on trace un trait d’un point A à un point B ; pas trouvé

pour finir je dois travailler avec la tortue ou bien je dois apprendre ceci ?
import matplotlib.pyplot as pyplot

la taille à utiliser pour les figures

import pylab

et est ce que je dois finir les exercices car ils deviennent compliqués pour moi ?

Effectivement, puisque tu as importé toutes les méthodes du module turtle, tu as juste besoin de les appeler directement dans ton code.
Je dirais que l’autre solution est préférable:
import turtle
turtle.forward(100)

Pour tracer un segment, si tu connais les coordonnées des points A et B, il te suffit de placer la tortue au point A avec un appel à goto, puis de baisser la plume, puis de rejoindre le point B avec un deuxième appel à goto.

Le module matplotlib.pyplot sera plutôt utile pour tracer des graphes.

voilà j’ai commencé , je comprends bien qu’il n’est pas content et je vous montre ce qui ne va pas :

mon code :

from turtle import *
pas = 20
def dessine_un_segment():
    showturtle()
    penup()
    goto(0,0)
    pendown()
    goto(100,100)
    penup()
    hideturtle()

dessine_un_segment()    

nbA = nbC = nbG = nbT = TotalNb = NbStepsRight = NbStepsUp = 0
SeqLength = L = I = InitW = 0
XEndSegment = YEndSegment = Step = 0.00



def compte_bases(chaine):



    for base in chaine :

        
        if base == "A":
            nbA +=1
        elif base == "C":
            nbC +=1
        elif base == "G":
            nbG +=1
        elif base == "T":
            nbT +=1
        TotalNb +=1

    NbStepsRight = nbC - nbG        
    NbStepsUp =    nbA - nbT

    return(TotalNb, nbA, nbC, nbG, nbT,  NbStepsRight, NbStepsUp )

blou = input("écris ton ADN: ")
glu = compte_bases(blou)
print(glu)

def dessine_un_segment_adn():
    showturtle()
    penup()
    goto(0,0)
    pendown()
    goto(NbStepsRight,NbStepsUp)
    penup()
    hideturtle()

dessine_un_segment_adn()

tout d’abord le premier appel à la fonction
dessine_un_segment()
il dessine bien un segment mais après il se met en colère : je pense du’il tourne dans le vide et il bug et je ne sais pas pourquoi

deux : je connais le problème des variables qui sont soit à l’extérieur des fonctions soit à l’intérieur

j’ai donc tout mis à l’extérieur après avoir mis à l’intérieur
vu qu’il fallait cher un résultat de la fonction pour dessiner
mis à l’intérieur , la fonction
compte_bases(chaine) fonctionne bien mais c’est ensuite la fonction dessine un segment adn qui ne fonctionne plus
mis à l’extérieur compte_bases(chaine) ne fonctionne pas .

Les variables nbA, nbC, etc… doivent être définies à l’intérieur de la fonction compte_bases

Ensuite, ta fonction dessine_un_segment_adn devrait prendre les coordonnées du point d’arrivée comme paramètres.

def dessine_un_segment_adn():
    showturtle()
   # penup()
    #goto(0,0)
    pendown()
    #goto(0,0)
    goto(NbStepsRight,NbStepsUp)
    penup()
    #hideturtle()

dessine_un_segment_adn()

j’ai mis les variables dans la fonction , maintenant
il dessine rien , il est en grève mais au moins il ne bugge pas , il reste à 0,0
pas de messages d’erreurs

NbStepsRight et NbStepsUp sont égales à 0, donc la tortue ne bouge pas.

Il faut au préalable affecter les résultats de la fonction de comptage à ces deux variables.
Mais je continue de penser qu’il serait préférable d’utiliser des paramètres :

def dessine_un_segment_adn(x, y):
    ...
    goto(x, y)
    ...

et l’appel deviendrait :
dessine_un_segment_adn(NbStepsRight, NbStepsUp)

from turtle import *
pas = 20
def dessine_un_segment(x,y):
        showturtle()
        penup()
        goto(0,0)
        pendown()
        goto(x,y)
        penup()
        hideturtle()

dessine_un_segment(NbStepsRight,NbStepsUp)

ça n’a pas changé le problème , les deux variables restent dans la fonction du dessus donc sont interne

je viens d’écrire
print(glu)
print(NbStepsRight)

et il réponds
écris ton ADN: AAAAAACCCCCGGGGGGGGGGGGTTTTTTT
(30, 6, 5, 12, 7, -7, -1)
0
c’est pour cela que je voulais mettre mes variables à l’extérieur de la fonction
dès que l’on utilise plusieurs fonctions , on tombe toujours sur ce genre de problèmes variables internes ou variables externes

Les variables qui sont définies à l’intérieur d’une fonction sont locales à cette fonction. Tu n’y as pas accès en dehors, sauf si la fonction retourne leurs valeurs.

C’est le cas ici, puisque ta fonction compte_bases retourne toutes ces informations. Mais il faut encore les récupérer, ce que tu fais en affectant le retour de la fonction à la variable blou.
Cette variable contient désormais un tuple de 7 composantes, tu as besoin des deux dernières.
Tu peux donc par exemple définir avant l’appel à la fonction dessine_un_segment_adn les deux variables :
NbStepsRight = blou[5]
NbStepsUp = blou[6]

puis appeler cette fonction avec ces deux variables en arguments.

super ça a marché sauf que c’était glu[5]
bon j’arrête pour aujourd’hui
Merci Isabelle et à bientôt

Ah oui, pardon

Bonjour
me voici de retour
je suis à nouveau tombé sur un os :
j’ai écrit ceci :

a=n*(pas-r)
b=(n*(pas-r)+pas)
mini_chaines_nucleotides = chaine_nucleotides[a,b]
print(mini_chaines_nucleotides)

il répond ceci :
mini_chaines_nucleotides = chaine_nucleotides[a,b]
TypeError: string indices must be integers

je ne sais pas résoudre le problème

j’ai écrit ceci :

mini_chaines_nucleotides = chaine_nucleotides[2,7]
print(mini_chaines_nucleotides)

il écrit :
mini_chaines_nucleotides = chaine_nucleotides[2,7]
TypeError: string indices must be integers

je comprends pas

Bonjour trx337,

Pour obtenir une sous-chaîne d’une chaîne de caractères, la syntaxe est chaine[a:b].

je crois avoir trouvé ; vous en pensez quoi ?

#depart code

nbA = nbC = nbG = nbT = TotalNb = NbStepsRight = NbStepsUp = 0
#SeqLength = L = I = InitW = 0
#XEndSegment = YEndSegment = Step = 0.00

from turtle import *
def compte_bases(chaine):

nbA = nbC = nbG = nbT = TotalNb = NbStepsRight = NbStepsUp = 0




for base in chaine :

    #elif base i "A":
    if base in "A":
        nbA +=1
    elif base == "C":
        nbC +=1
    elif base == "G":
        nbG +=1
    elif base == "T":
        nbT +=1
    TotalNb +=1

NbStepsRight = nbC - nbG        
NbStepsUp =    nbA - nbT

return(TotalNb, nbA, nbC, nbG, nbT,  NbStepsRight, NbStepsUp )

def dessine_un_segment_adn2(x,y):

    showturtle()
    penup()
    goto(0,0)
    pendown()
    goto(x,y)
    penup()
    hideturtle()

#on entre la chaine
chaine_nucleotides = input("écris ta chaine de nucléotides : ")

#on écrit le code
Lg=longueur_chaine_nucleotides = len(chaine_nucleotides)
print("Lg: " + str(Lg))

n=0
pas=32
r=recouvrement=2

nbNC = Nombre_de_mini_chaines_nucléotides = Lg/(pas-r)

print("nbNC: " + str(nbNC))
#On ne veut pas des derniers nucléotides inférieur à pas
nbNC = int(nbNC)
print("nbNC: " + str(nbNC))

for mini_chaines_nucleotides in range (n,nbNC):
a=n*(pas-r)
b=(n*(pas-r)+pas)
mini_chaines_nucleotides = chaine_nucleotides[a:b]
print(mini_chaines_nucleotides)

#on compte
glu = compte_bases(mini_chaines_nucleotides)
print(glu)

#return renvoie un tuple

TotalNb = glu[0]
nbA = glu[1]
nbC = glu[2]
nbG = glu[3]
nbT = glu[4]

NbStepsRight = glu[5]
NbStepsUp = glu[6]

print("total Nb : " + str(TotalNb) )
print("NBA: " + str(nbA))
print("NBC: " + str(nbC))
print("NBG: " + str(nbG))
print("NBT: " + str(nbT))
print("NBStepsRight: " + str(NbStepsRight))
print("NBStepsUP: " + str(NbStepsUp))


#on dessine
dessine_un_segment_adn2(NbStepsRight,NbStepsUp)
n +=1
print(n)

je crois que pour l’instant le dessin repart toujours de 0,0 pour dessiner

Pour obtenir la partie entière de nbNC, tu peux aussi effectuer directement la division entière : nbNC = Lg // (pas - r)

Pour récupérer les variables à partir du tuple, tu peux aussi procéder ainsi :

TotalNb, nbA, nbC, nbG, nbT, NbStepsRight, NbStepsUp = glu

merci
pour l’instant mon dessin repart toujours à 0
def dessine_un_segment_adn2(x,y):

    showturtle()

    pendown()
    goto(x,y)
    penup()
    hideturtle()

Tu avais l’instrution goto(0, 0) qui ramène la tortue à cette position à chaque appel de la fonction, avant le tracé du segment.

je viens de le retirer , ça fait pareil , je crois !
c’est peut etre le penup qui le fait repartir à 0
non je viens d’essayer , c’est pas ça

def dessine_un_segment_adn2(x,y):

    showturtle()

    pendown()
    goto(x,y)
    penup()
    hideturtle()

faudrait lui dire de commencer au segment précédent
donc de mettre deux go to

Je me demande si le souci n’est pas plutôt que l’appel à la fonction introduit systématiquement une nouvelle tortue (qui démarre par défaut à (0, 0)).
Tu peux en effet ajouter comme autre paramètre les coordonnées du point d’origine.

j’ai écrit ceci pour éviter la fonction mais il dessine toujours à partir de 0,0
et je n’arrive pas à determiner le point d’avant ;

#on dessine
x=NbStepsRight
y=NbStepsUp
#showturtle()
pendown()
goto(x,y)
setposition(x,y)
#hideturtle()

Pour cela, tu peux utiliser deux nouvelles variables, auxquelles tu affectes les valeurs de NbStepsRight, nbStepsUp après chaque tracé.

j’ai essayé beaucoup de chose mais ça ne marche pas
La fonction goto() commence toujours par le point (0,0)
à la boucle suivante

x1=glu[5]
y1=glu[6]
#on dessine
dessine_un_segment_adn2(NbStepsRight,NbStepsUp)
goto(x1,y1)
n +=1
print(n)

Si j’exécute ce petit bout de code:

def segment(a, b):
    pendown()
    goto(a, b)
    penup()

segment(20, 20)
segment(30, -10)
exitonclick()

les deux segments sont bien tracés successivement.
Le problème ne vient donc pas de là.

Si j’ôte l’instruction goto(0,0) de ton code, j’obtiens bien un tracé dans lequel les segments se succèdent.
Je ne comprends donc pas pourquoi cela ne le fait pas pour toi.

Par contre, on peut reprendre la syntaxe de la boucle for.
Lorsque l’on écrit for i in range(nb), i va prendre successivement toutes les valeurs entières comprises entre 0 (inclus) et nb (exclu).
Ainsi, c’est exactement ce que tu souhaites pour ta variable n.
Tu peux donc modifier ta boucle ainsi :

for n in range (nbNC):
    a=n*(pas-r)
    b=(n*(pas-r)+pas)
    mini_chaines_nucleotides = chaine_nucleotides[a:b]
    ...
    #n += 1
    print(n)

Vois le message cité

Bonjour trx337, elle retourne à 0,0, parce que tu lui demandes! . Ci-dessus dans la fonction dessine_un_segment_adn2(x,y). Supprime le goto(0,0) de cette fonction, et ça ira.

Oups, pas vu qu’Isabelle avait déjà répondu ci-dessus, sorry

Ceci dit, si ça ne marche pas, trx337, tu peux aussi essayer d’effacer un __pycache__ qui m’a déjà joué des tours (dans le répertoire d’exécution)

Enfin, une suggestion quand ça marche: ajouter un facteur de grandeur à goto(x,y), par exemple goto(x*10, y*10) si la visualisation est trop petite.

Bien à vous tous
Robert.

Bonjour,
Ah, la tortue Python !

pour info, le système des tortues fonctionnent comme suit:

Si vous importez le module turtle, vous disposez alors d’une tortue par défaut nommée turtle

import turtle
turtle.fd(100)
turtle.exitonclick()

Pour le multi-tortues, on peut jouer avec la classe Turtle

#Créons 3 tortues:
from turtle import Turtle, Screen
ecran = Screen()
t1 = Turtle()
t2 = Turtle()
t3 = Turtle()

t1.fd(100)
t2.setheading(90)
t2.fd(100)
t3.setheading(180)
t3.fd(100)

ecran.exitonclick()

Voir le message cité
La classe Screen est là pour le ecran.exitonclick() qui fermera la fenêtre graphique seulement quand je cliquerai dessus (si j’exécute le programme hors de la ligne de commande Python ou de idle).

Il y a un tutoriel turtle assez agréable ici

Bien cordialement à tous,
Robert.

rebonjour
revoici mon code corrigé avec tout ce que l’on a dit .
Je crois qu’il est bon
.y a t il une différence entre ma boucle for et la votre
car je crois que ça fait pareil
j’ai changé n avec i pour ne pas mélanger
for i in range (nbNC):
je suppose que i commence à 0 puis va jusqu’à (nbNC-1) en ajoutant +1 à chaque boucle si on ne lui dit rien et avant et à la fin de la boucle ?
j’ai mis r le recouvrement à 0 pour mieux visualiser si le dessin est bon
et pour ma boucle j’ai écrit
for mini_chaines_nucleotides in range (n,nbNC):
vu que mini_chaines_nucleotides est une suite de lettre et que i est un nombre entier
il y a surement une différence .
donc il y a quand même quelque chose qui ne va pas mais j’ai compris :
si tu entres maintenant AAAACCC AAAACCCCAAAACCCCAAAACCCC
x vaut 4 et y vaut 4
donc tu lui dit va au point ( 4,4) puis va au point ( 4,4) puis va au point ( 4,4)
il me semble que ce n’est pas cela que l’on veut ; on veut qu’il aille à (4,4) puis (8,8)
puis (12,12) puis (16, 16)
c’est pour cela qu’il me semblait qu’il revenait toujours au point de départ
il faudrait maintenant revoir l’énoncé du problème

ben oui , on veut ça :

aaaaaaaaaaaaaaaaaaaaaaaaaa.png703×381 66.4 KB

il faut maintenant ajouter à chaque fois le x d’avant avec le x d’après et idem pour y
est ce difficile ?

#depart code

nbA = nbC = nbG = nbT = TotalNb = NbStepsRight = NbStepsUp = 0
#SeqLength = L = I = InitW = 0
#XEndSegment = YEndSegment = Step = 0.00



from turtle import *
def compte_bases(chaine):

    nbA = nbC = nbG = nbT = TotalNb = NbStepsRight = NbStepsUp = 0




    for base in chaine :

        #elif base i "A":
        if base in "A":
            nbA +=1
        elif base == "C":
            nbC +=1
        elif base == "G":
            nbG +=1
        elif base == "T":
            nbT +=1
        TotalNb +=1

    NbStepsRight = nbC - nbG        
    NbStepsUp =    nbA - nbT

    return(TotalNb, nbA, nbC, nbG, nbT,  NbStepsRight, NbStepsUp )


def dessine_un_segment_adn2(x,y):

        showturtle()
        
        #tracer(3,20)
        goto(x,y)
        #setpos(x,y)
        #goto(50,12)
        #fd(y)        
        #setpos(x,y)
        hideturtle()
        #x1=x
        #y1=y
        speed(1)
#on entre la chaine
chaine_nucleotides = input("écris ta chaine de nucléotides : ")

#on écrit le code
Lg=longueur_chaine_nucleotides = len(chaine_nucleotides)
print("Lg: " + str(Lg))


n=0
pas=8
r=recouvrement=0

nbNC = Nombre_de_mini_chaines_nucléotides = Lg/(pas-r)
# ou bien               nbNC = Lg // (pas - r)
print("nbNC: " + str(nbNC))
# On ne veut pas des derniers nucléotides inférieur à pas
nbNC = int(nbNC)
print("nbNC: " + str(nbNC))



for mini_chaines_nucleotides in range (n,nbNC):

#for i in range (nbNC):
    a=n*(pas-r)
    b=(n*(pas-r)+pas)
    mini_chaines_nucleotides = chaine_nucleotides[a:b]
    print(mini_chaines_nucleotides)
 


    #on compte
    glu = compte_bases(mini_chaines_nucleotides)
    print(glu)

    #return renvoie un tuple

    TotalNb = glu[0]
    nbA = glu[1]
    nbC = glu[2]
    nbG = glu[3]
    nbT = glu[4]

    NbStepsRight = glu[5]
    NbStepsUp = glu[6]
    #x=glu[5]
    #y=glu[6]
    print("total Nb : " + str(TotalNb) )
    print("NBA: " + str(nbA))
    print("NBC: " + str(nbC))
    print("NBG: " + str(nbG))
    print("NBT: " + str(nbT))
    print("NBStepsRight: " + str(NbStepsRight))
    print("NBStepsUP: " + str(NbStepsUp))
    #goto(glu[5],glu[6])
    
    #on dessine
    dessine_un_segment_adn2(NbStepsRight,NbStepsUp)
    
    #goto(0,0)
    #goto(103,20)
    #goto(30,50)
    n +=1
    #i +=1
    print(n)

Bonjour trx337,

    NbStepsRight = glu[5]
    NbStepsUp = glu[6]

puis:
dessine_un_segment_adn2(NbStepsRight,NbStepsUp)

mais entre 2 fenêtres, un des 2 (x ou y) a été remis à 0 dans :
compte_bases(chaine), et donc, le goto(x, y) dans dessine_un_segment_adn2(x,y) ne sera jamais correct.

bien à toi.

Non.
Si tu écris for mini_chaines_nucleotides in range (n,nbNC):, mini_chaines_nucleotides ne sera pas une suite de lettres mais va prendre successivement toutes les valeurs entières comprises entre n (0) inclus et nbNC exclu.
Ce qui fait qu’il s’agit effectivement d’une suite de lettres dans ton code est que tu lui affectes dans la foulée la sous-chaîne chaine_nucleotides[a:b].

Par conséquent, autant faire plus simple et utiliser directement une variable compteur, telle que n ou i (et dans ce cas, pas besoin de l’incrémenter à la fin du corps de la boucle, cela se fera tout seul).

Bonjour trx337,

il me semble que ton code est en train - pour moi, de se compliquer; alors j’ai refait un script sur base du tien (mais épuré) et qui semble bien fonctionner.

Souhaites-tu l’avoir pour l’étudier, ou préfères-tu attendre et continuer à chercher par toi-même?

Cordialement,
Robert.

merci zenjo
oui merci envoie moi ton code parce que je’ n’arrive pas à additionner le x d’avant avec le x d’après et idem pour y
il faudrait écrire quelque chose comme
x1= x1+x
y1=y1+y
pour faire avancer la tortue du point A au point B puis de B à C mais cela ne marche pas
ou alors il faut rentrer les valeurs dans une liste et se servir de la liste pour dessiner

Bonjour trx337,

Dans ce cas, tu peux utiliser la méthode position, qui donne les coordonnées de la tortue.
Dans ta fonction dessine_un_segment_adn2(x, y), tu utilises cette méthode pour stocker dans deux variables a,b les coordonnées courantes : a, b = position(), puis tu appelles goto avec les arguments a + x, b + y.
Les paramètres x et y ne représentent plus les coordonnées du point arrivée, mais l’écart entre le point origine et le point arrivée.

bonjour Isabelle ; cette fois ci j’ai réussi
j’avais déjà posé la question pour trouver la position de la tortue
et vous aviez répondu xcor() et ycor()
ce qui donne tout simplement

x1= xcor() + NbStepsRight
y1= ycor() + NbStepsUp
#on dessine
dessine_un_segment_adn2(x1,y1)

pour votre script , il fonctionne pareil :

def dessine_un_segment_adn2(x,y):

    showturtle()
    
    a, b =position()
    print("a, b "+ str(a) + " , " + str(b)   )
    
    goto(x+a,y+b)

Bravo trx337 pour cette dernière ligne droite et la réussite finale.
Isabelle, tu as vraiment un sens pédagogique de l’explication que je n’ai pas trop

Puisque plus rien ne s’y oppose, voici alors mon code:
2 éléments ajouté au code de trd337:
va(x,y) qui envoie la tortue à son point de départ du dessin
zoom = qui agrandit ou diminue la taille du dessin dans la fenêtre.

from turtle import *

#######################
# configuration écran #
#######################
# La vitesse à fond (speed(0) + hideturtle())
speed(0)
hideturtle()
setup(640, 480, 100, 100)

##############
# utilitaire #
##############
def va(x, y):
    "positionne la tortue au départ"
    pu()
    setpos(x, y)
    pd()


##########################################
# configuration calcul, dessin et chaine #
##########################################
## Conf. calcul ##
n=0
pas=1
r=recouvrement=0

## Conf. dessin ##
va(-100, -140)
zoom = 30

## Conf. chaine ##
#chaine_nucleotides = input("écris ta chaine de nucléotides : ")

#chaine_nucleotides = "CCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGCTTCTGAACTGGTTACCTGCCGTGAGTAAATTAAAATTTTATTGACTTAGGTCACTAAATACTTTAACCAATATAGGCATAGCGCACAGACAGATAAAAATTACAGAGTACACAACATCCATGAAACGCATTAGCACCACCATTACCACCACCATCACCATTACCACAGGTAACGGTGCGGGCTGACGCGTACAGGAAACACAGAAAAAAGCCCGCACCTGACAGTGCGGGCTTTTTTTTTCGACCAAAGGTAACGAGGTAACAACCATGCGAGTGTTGAAGTTCGGCGGTACATCAGTGGCAAATGCAGAACGTTTTCTGCGTGTTGCCGATATTCTGGAAAGCAATGCCAGGCAGGGGCAGGTGGCCACCGTCCTCTCTGCCCCCGCCAAAATCACCAACCACCTGGTGGCGATGATTGAAAAAACCATTAGCGGCCAGGATGCTTTACCCAATATCAGCGATGCCGAACGTATTTTTGCCGAACTTTTGACGGGACTCGCCGCCGCCCAGCCGGGGTTCCCGCTGGCGCAATTGAAAACTTTCGTCGATCAGGAATTTGCCCAAATAAAACATGTCCTGCATGGCATTAGTTTGTTGGGGCAGTGCCCGGATAGCATCAACGCTGCGCTGATTTGCCGTGGCGAGAAAATGTCGATCGCCATTATGGCCGGCGTATTAGAAGCGCGCGGTCACAACGTTACTGTTATCGATCCGGTCGAAAAACTGCTGGCAGTGGGGCATTACCTCGAATCTACCGTCGATATTGCTGAGTCCACCCGCCGTATTGCGGCAAGCCGCATTCCGGCTGATCACATGGTGCTGATGGCAGGTTTCACCGCCGGTAATGAAAAAGGCGAACTGGTGGTGCTTGGACGCAACGGTTCCGACTACTCTGCTGCGGTGCTGGCTGCCTGTTTACGCGCCGATTGTTGCGAGATTTGGACGGACGTTGACGGGGTCTATACCTGCGACCCGCGTCAGGTGCCCGATGCGAGGTTGTTGAAGTCGATGTCCTACCAGGAAGCGATGGAGCTTTCCTACTTCGGCGCTAAAGTTCTTCACCCCCGCACCATTACCCCCATCGCCCAGTTCCAGATCCCTTGCCTGATTAAAAATACCGGAAATCCTCAAGCACCAGGTACGCTCATTGGTGCCAGCCGTGATGAAGACGAATTACCGGTCAAGGGCATTTCCAATCTGAATAACATGGCAATGTTCAGCGTTTCTGGTCCGGGGATGAAAGGGATGGTCGGCATGGCGGCGCGCGTCTTTGCAGCGATGTCACGCGCCCGTATTTCCGTGGTGCTGATTACGCAATCATCTTCCGAATACAGCATCAGTTTCTGCGTTCCACAAAGCGACTGTGTGCGAGCTGAACGGGCAATGCAGGAAGAGTTCTACCTGGAACTGAAAGAAGGCTTACTGGAGCCGCTGGCAGTGACGGAACGGCTGGCCATTATCTCGGTGGTAGGTGATGGTATGCGCACCTTGCGTGGGATCTCGGCGAAATTCTTTGCCGCACTGGCCCGCGCCAATATCAACATTGTCGCCATTGCTCAGGGATCTTCTGAACGCTCAATCTCTGTCGTGGTAAATAACGATGATGCGACCACTGGCGTGCGCGTTACTCATCAGATGCTGTTCAATACCGATCAGGTTATCGAAGTGTTTGTGATTGGCGTCGGTGGCGTTGGCGGTGCGCTGCTGGAGCAACTGAAGCGTCAGCAAAGCTGGCTGAAGAATAAACATATCGACTTACGTGTCTGCGGTGTTGCCAACTCGAAGGCTCTGCTCACCAATGTACATGGCCTTAATCTGGAAAACTGGCAGGAAGAACTGGCGCAAGCCAAAGAGCCGTTTAATCTCGGGCGCTTAATTCGCCTCGTGAAAGAATATCATCTGCTGAACCCGGTCATTGTTGACTGCACTTCCAGCCAGGCAGTGGCGGATCAATATGCCGACTTCCTGCGCGAAGGTTTCCACGTTGTCACGCCGAACAA"

chaine_nucleotides = "CAGACCACTCAGACCTCAAGGACCCAGAAGTGAACAC"

#############
# Programme #
#############
## dessin ##

def dessine_segment(chaine_nucleotides, z=zoom):
    x = y = 0
    for base in chaine_nucleotides :
        if base == "A":
            y += 1
        elif base == "T":
            y += -1
        elif base == "C":
            x += 1
        else:
            x += -1
    goto(pos() + (x*z, y*z))

## Calcul ##
Lg = len(chaine_nucleotides)
#On ne veut pas des derniers nucléotides inférieur à pas
nbNC = int(Lg/(pas-r))

for mini_chaines_nucleotides in range (n,nbNC):
    a=n*(pas-r)
    b=(n*(pas-r)+pas)
    # on dessine
    dessine_segment(chaine_nucleotides[a:b])
    n +=1

# exit
exitonclick()

Bien cordialement à tous
Robert.

salut zenjo
merci je vais regarder

Oui, y avait du verglas sur mon clavier, mon doigt a dérapé tropt tot sur Entrée
Réparé

he zenjo c’est pas ça qu’on veut , ton code y fait ça :

on veut des segments de droite

le point à atteindre est :
NbStepsRight = nbC - nbG
NbStepsUp = nbA - nbT

Hello trx337,
je ne comprends pas ta remarque. Le code fait exactement ce qui est demandé par la vidéo dont tu as montré la photo dans un post ci dessus.

Peux-tu être plus précis?

Et le dessin à droite sur cette photo est réalisé en réglant
pas = 13
r = 0
(le 3e segment de ce dessin a été ajouté à a main par le professeur)

ben oui alors toi le fort , pourquoi tu ne comprends pas
on a fait deux exercices le premier effectivement on va à droite et à gauche
comme sur ton dessin

mais le deuxième consiste à relier des points car pour une chaine très grande on ne verrait rien sur l’écran selon un paramètre qui s’appelle pas selon mon code
le pas peut etre par exemple de 1000 si la chaine fait un million de carateres
puis on relie les points selon ceci :
NbStepsRight = nbC - nbG
NbStepsUp = nbA - nbT
et selon l’image :

bon c’est ok ton code il est bon ,j’ai regardé à nouveau simplement le pas doit être à 8 minimum et non à 1 , I am sorry

à 8 ton code donne ça avec AAAAAAAACCCCCCCCAAAACCCC

les segments sont trop grands vu que la chaine va etre en principe tres longue

Ben, je suppose que c’est toi le plus fort, alors

Plus sérieusement, mon code marche très bien sur la bactérie escheria coli (+ de 4*10^6 caractères) avec un pas de 1000 et un zoom à 0.01 (utilité du zoom pour la grandeur de l’écran!). Tu peux essayer.

En attendant tu peux essayer aussi la chaine de plus de 2000 caractères (présente dans le code) avec un pas = 1 et un zoom = 5, tu verras que ça marche très bien aussi.

Bien à toi
Robert.

ok tu es le plus fort
en tout cas tu ne t’es pas servi de la formule magique :
NbStepsRight = nbC - nbG
NbStepsUp = nbA - nbT

je ne comprends pas ceci :
pu()
setpos(x, y)
pd()

pour la chaine très longue
#chaine_nucleotides = “CCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGCTTCTGAACTGGTTACCTGCCGTGAGTAAATTAAAATTTTATTGACTTAGGTCACTAAATACTTTAACCAATATAGGCATAGCGCACAGACAGATAAAAATTACAGAGTACACAACATCCATGAAACGCATTAGCACCACCATTACCACCACCATCACCATTACCACAGGTAACGGTGCGGGCTGACGCGTACAGGAAACACAGAAAAAAGCCCGCACCTGACAGTGCGGGCTTTTTTTTTCGACCAAAGGTAACGAGGTAACAACCATGCGAGTGTTGAAGTTCGGCGGTACATCAGTGGCAAATGCAGAACGTTTTCTGCGTGTTGCCGATATTCTGGAAAGCAATGCCAGGCAGGGGCAGGTGGCCACCGTCCTCTCTGCCCCCGCCAAAATCACCAACCACCTGGTGGCGATGATTGAAAAAACCATTAGCGGCCAGGATGCTTTACCCAATATCAGCGATGCCGAACGTATTTTTGCCGAACTTTTGACGGGACTCGCCGCCGCCCAGCCGGGGTTCCCGCTGGCGCAATTGAAAACTTTCGTCGATCAGGAATTTGCCCAAATAAAACATGTCCTGCATGGCATTAGTTTGTTGGGGCAGTGCCCGGATAGCATCAACGCTGCGCTGATTTGCCGTGGCGAGAAAATGTCGATCGCCATTATGGCCGGCGTATTAGAAGCGCGCGGTCACAACGTTACTGTTATCGATCCGGTCGAAAAACTGCTGGCAGTGGGGCATTACCTCGAATCTACCGTCGATATTGCTGAGTCCACCCGCCGTATTGCGGCAAGCCGCATTCCGGCTGATCACATGGTGCTGATGGCAGGTTTCACCGCCGGTAATGAAAAAGGCGAACTGGTGGTGCTTGGACGCAACGGTTCCGACTACTCTGCTGCGGTGCTGGCTGCCTGTTTACGCGCCGATTGTTGCGAGATTTGGACGGACGTTGACGGGGTCTATACCTGCGACCCGCGTCAGGTGCCCGATGCGAGGTTGTTGAAGTCGATGTCCTACCAGGAAGCGATGGAGCTTTCCTACTTCGGCGCTAAAGTTCTTCACCCCCGCACCATTACCCCCATCGCCCAGTTCCAGATCCCTTGCCTGATTAAAAATACCGGAAATCCTCAAGCACCAGGTACGCTCATTGGTGCCAGCCGTGATGAAGACGAATTACCGGTCAAGGGCATTTCCAATCTGAATAACATGGCAATGTTCAGCGTTTCTGGTCCGGGGATGAAAGGGATGGTCGGCATGGCGGCGCGCGTCTTTGCAGCGATGTCACGCGCCCGTATTTCCGTGGTGCTGATTACGCAATCATCTTCCGAATACAGCATCAGTTTCTGCGTTCCACAAAGCGACTGTGTGCGAGCTGAACGGGCAATGCAGGAAGAGTTCTACCTGGAACTGAAAGAAGGCTTACTGGAGCCGCTGGCAGTGACGGAACGGCTGGCCATTATCTCGGTGGTAGGTGATGGTATGCGCACCTTGCGTGGGATCTCGGCGAAATTCTTTGCCGCACTGGCCCGCGCCAATATCAACATTGTCGCCATTGCTCAGGGATCTTCTGAACGCTCAATCTCTGTCGTGGTAAATAACGATGATGCGACCACTGGCGTGCGCGTTACTCATCAGATGCTGTTCAATACCGATCAGGTTATCGAAGTGTTTGTGATTGGCGTCGGTGGCGTTGGCGGTGCGCTGCTGGAGCAACTGAAGCGTCAGCAAAGCTGGCTGAAGAATAAACATATCGACTTACGTGTCTGCGGTGTTGCCAACTCGAAGGCTCTGCTCACCAATGTACATGGCCTTAATCTGGAAAACTGGCAGGAAGAACTGGCGCAAGCCAAAGAGCCGTTTAATCTCGGGCGCTTAATTCGCCTCGTGAAAGAATATCATCTGCTGAACCCGGTCATTGTTGACTGCACTTCCAGCCAGGCAGTGGCGGATCAATATGCCGACTTCCTGCGCGAAGGTTTCCACGTTGTCACGCCGAACAA”

y a t il un moyen de passer à la ligne ?

et pour un commentaire très long , n’y a t il pas une autre formule que # ?

Oh, je suis trop vieux pour m’en faire pour ça!

pu = penup (la tortue lève le stylo)
setpos(x,y) la tortue va en x,y sans tracer de trait
pd = pendown la tortue rebaisse son stylo, prête à dessiner la chaine de nucléotides.

Est-ce que ça répond à ta question?

super j’avais écris pendown()
et pour la suite de ma question
dans idle la chaine part à droite pendant un km

tu réponds quoi

ça fait des beaux dessins :

Ici, ça va fausser le calcul en rajoutant des caractères “\n”
Il vaudrait mieux alors, la mettre dans un fichier et ouvrir le fichier pour l’extraire

On n’en n’a pas besoin. on fait les calculs directement pour le dessin (et on épargne ces variables devenues inutiles)

et pour un commentaire très long , n’y a t il pas une autre formule que # ?

dans d’autre langage , il y a ça /* est ce que tu habites à paris */

enfin de l’art

Tu peux écrire des commentaires multi-lignes :

"""commentaire
sur plusieurs
lignes"""

merci
je me suis rappelé de quelque chose qui m’intrigue et que je n’avais pas bien compris :
dans un mooc html 5 et javascript
on avait écrit une fonction d’initialisation de données
je me demande s’il est utile ici pour ce mooc de savoir ce que c’est.
on écrivait ceci :

window.onload = init;

function init() {
bla bla bla }

d’autre part pour la boucle for je me suis aperçu de ceci :

for i in range (23):
i va de 0 à 22

si on écrit

n=0
for i in range (23):
      n +=1

là aussi n va de 0 à 22 alors qu’il n’est pas dans la boucle for
on peut peut etre écrire :
for i , n in range (23): -?
et est ce que for est une fonction ?

Bonjour trx337,

for i , n in range (23): pourquoi n’essaies-tu pas de voir ce que cela donne dans IDLE ?

Et je ne dirais pas que for est une fonction, mais une instruction Python.

le modèle d’exécution de javascript dans un browser est assez différent de Python; les scripts javascript sont téléchargés par le browser dans n’importe quel ordre, et aucun n’est le point d’entrée - en ce sens il n’y a pas par exemple l’équivalent de __main__

window.onload est un mécanisme permettant d’accoupler l’exécution de la machinerie javascript avec le chargement de la page web; ça n’est du coup pas du tout pertinent dans le cadre d’un programme Python

merci pour cette réponse
(je ne sais pas l’utilité de “main”)

je voulais dire, lorsque vous exécutez un programme dans un langage disons traditionnel, le programme commence à un endroit bien identifié

par exemple en python quand vous faites

python fibonacci.py

vous savez exactement par où le programme ca commencer; pareil en C/C++, le linker fait commencer le programme par la fonction main()

eh bien en javascript c’est moins simple; on écrit des bouts, mais comme ils sont exécutés par le browser, donc ce n’est pas nous qui décidons clairement par où tout cela commence, et c’est la raison pour laquelle il existe dans ce cas des mécanismes, comme ce window.onload = init, qui nous permet de contrôler quand même l’exécution de notre programme; ici par exemple, on dit que lorsque la page web sera chargée, il faudra exécuter la fonction init