Bonsoir    
 
Je suis en physique et malheureusement pour moi je dois faire un programme en python. Voilà mon problème: j'aimerai créer un tableau de 1000 colonnes, avec dans chacune de ces colonnes un tableau de 100 colonnes, ça donnerai [[x1_1,...,x1_100], .... , [x1000_1,...,x1000_100]].
 
tab1=N.array([])
#print tab1
for x in range(1,1000):  #pour x entre 0 et 10 m
 
 
 for i in range(1,100):
  E[i]=random.gauss(mean,ecart) #distribution gaussienne en energie
 
 for i in range(1,100):
   
  v_x[i]=c*sqrt(1-(mpion*c**2/E[i])**2)
  Ga_x[i]=1/sqrt(1-(v_x[i]/c)**2)
  GTAU_x[i]=Ga_x[i]*tau
  p_x[i]=1-M.exp(-x/(v_x[i]*GTAU_x[i]))
 
 tab1=N.append(tab1,p_x)
 
 print tab1[999]
 
print tab1
 
Dans ma boucle x, je créer une distribution gaussienne de 100 nombres.  Pour chaqun de ces nombres je calcule une probabilité p[i] (les v_x, ga_x sont des calculs intermédiaires) associé à la valeur x=1 pour commencer, jusqu'à x = 1000. J'ai donc 1000 tableaux de 100 colonnes.  Mais j'aimerai afficher seulement le 1000 em tableau par exemple. il faut donc que je mette mes 1000 tableaux dans un seul gros tableau, je créer donc un tableau vide tab1 avant la boucle et j'ajoute les 1000 tableaux au fur et à mesure: tab1=N.append(tab1,p_x). Mais ça ne marche pas, je dois faire une erreur mais je ne vois pas laquelle, si quelqu'un pouvait m'éclairer    
 
Merci d'avance

1. Utilises le bloc [ code=python ] (en enlevant les espaces) quand tu postes du code, ça sera largement plus lisible.
2. Quand tu parles de tableaux, c'est ce sont des arrays NumPy? (donc numpy.array)?
3. "ça ne marche pas", c'est typiquement le genre de choses qui ne sert strictement à rien quand tu cherches de l'aide, parce que ça ne fournit aucune info. Qu'est-ce que se passe précisément, quel est le message ou l'erreur renvoyée par la console, ... sont des infos essentielles

ok, bon je vais faire plus simple car sinon c'est trop dur à expliquer. Comment faire pour avoir un grand tableau de 1000 colonnes 1 ligne avec dans chacune des colonnes un autre tableau de 100 colonnes 1 ligne ?

Je voudrais que tu répondes à la question 2, selon que tu utilises numpy ou pas la situation n'est pas du tout la même.
 
La question 3 serait également pas mal, mais la 2 est essentielle.

2. Pour tab1 oui j'utilise numpy (import numpy as N). Mes E et p sont définis au départ par des zeros(100, float).
3. quand j'essaye de récupérer le 999 élément de tab1 il m'affiche "index out of bound" donc le tableau ne va pas jusqu'à 999. Par contre quand je veux récupérer le 99 élément par exemple il m'affiche 1000 fois le même, j'ai l'impression qu'il crée 99900 tableaux de 100 éléments.

Pourquoi ne pas tout simplement définir ton tab1 (après lui avoir donné un meilleur nom) comme

t = zeros((1000, 100))

?
Ca va créer un array de 1000 * 100 (enfin un array de 1000 contenant des arrays de 100 tous initialisés à 0, plus précisément) et t'as plus qu'à bricoler là dedans.

Merci c'est une bonne idée, j'ai travaillé là dessus mais je n'obtiens toujours pas le résultat voulu j'aimerai bien poster mon code mais le bloc [code=python] n'a pas l'air de marcher.

Il marche très bien, c'est ce que j'ai utilisé pour mettre mon bout de code (faut penser à le fermer avec [/code])

ok, je le fermais avec [/code = python]    
 

t=zeros((1000, 100))
 
for x in range(1,1000):    
    for i in range(1,100):
        E[i]=random.gauss(mean,ecart) #distribution gaussienne en energie
        
        v[i]=c*sqrt(1-(mpion*c**2/E[i])**2)
        Ga[i]=1/sqrt(1-(v[i]/c)**2)   #calculs intermediaires
        GTAU[i]=Ga[i]*tau
        
        p=1-M.exp(-x/(v[i]*GTAU[i]))
    t2=N.append(p,t2)
        
    print t2

 
J'aimerai avoir quelque chose comme [ [p(x=1, v1), ... , p(x=1, v100)], ... [p(x=1000, v1), ... , p(x=1000, v100)] ]. Mais quand je lance le programme il m'affiche pleins de tableaux (de plus de 100 colonnes) à la suite, ça n'a rien à voir avec mon tableau t.  
 
     

t=zeros((1000, 100))
 
for x in range(1,1000):    
    for i in range(1,100):
        E[i]=random.gauss(mean,ecart) #distribution gaussienne en energie
        
        v[i]=c*sqrt(1-(mpion*c**2/E[i])**2)
        Ga[i]=1/sqrt(1-(v[i]/c)**2)   #calculs intermediaires
        GTAU[i]=Ga[i]*tau
        
        p=1-M.exp(-x/(v[i]*GTAU[i]))
    t2=N.append(p,t2)
        
    print t2

Déjà, les arrays Pytnon commencent à l'index 0, et range(a, b) crée une suite [a, b[, donc tes appels range(1, 1000) et range(1, 100) itèrent sur [1, 999] et [1, 99]. C'est vraiment ce que tu veux?
 
Ensuite, tu es sûr de comprendre ce que fait t2=N.append(p,t2)? C'est censé servir à quoi exactement? Je remarques également que tu ne remets jamais rien dans t, et que dans la première expression tu utilises un élément qui n'est pas défini dans la même scope (le scoping de Python le permet, mais c'est sale...)
 
Accessoirement, il y a une palanquée de valeurs dont la définition n'est pas indiquée (M, mean, ecart, mpion, E, ...)

 
Non, je ne savais pas    donc je vais jusqu'à 1001 ?
 

 
   oui en effet je n'avais pas vu, je voulais plutôt mettre t=N.append(t,p). Le append c'est censé servir à ajouter des éléments à un tableau   , donc il faudrait plutôt une commande qui remplace les 0 par mes p. Je ne comprend pas ce que tu veux dire par "scope". Je suis désolé si j'ai l'air nul c'est la première fois que je fais de la programmation je n'ai jamais eu de cours juste un poly assez mal fait, donc j'apprends un peu sur le tas.
 

 
M est un raccourci pour math, et pour le reste comme c'était assez long j'ai pas voulu encombrer:
 

E=zeros(100, float)    
p=zeros(100, float)
v=zeros(100, float)
Ga=zeros(100, float)
GTAU=zeros(100, float)
 
 
#definitions
 
mean=10*1.6*10**(-10) #moyenne de la gausienne
ecart=1*1.6*10**(-10) 
 
tau= 2.603305*10**(-8) #duree de vie moyenne des pions
tau2= 2 #duree de vie moyenne des muons
c= 3*10**8 #vitesse de la lumiere
mpion= 139.5701835*10**(6)*1.783*10**(-36) #masse du pion en kg
mmuon=1.88*10**(-28) #masse du muon en kg

Non, tu vas jusqu'à 999 mais tu pars de 1 au lieu de partir de 0, donc tu ne parcours que 999 éléments et non 1000

Ce serait t[x, i] (au passage pourquoi ne pas utiliser i et j?). append sert à étendre le tableau, donc à rajouter des éléments à la fin (en plus de ceux que tu as déjà), c'est sûrement pas ce que tu veux puisqu'avec ton initialisation tu as déjà créé un array qui a toutes les bonnes dimensions

La scope, c'est le domaine de définition (d'une variable habituellement). Donc les parties du code où elle existe (ou est censée exister). Pour te montrer un exemple:

a = 0
for i in range(42):
    a = 5
    b = 2
# ici

la scope de a contient le for mais n'est pas limitée à celui-ci (puisqu'on a créé a avant de rentrer dans le for). Par contre celle de b est limitée à l'intérieur du for

Donc à l'emplacement ici on devrait pouvoir accéder à a mais pas à b.

Dans les faits, à cause de la manière dont Python fonctionne on peut accéder à b, mais il faut éviter de le faire aussi bien pour des raisons de style que de maintenabilité.

Ok

Là je vais aller me pieuter, je continuerais à regarder ça demain.

 
Oui mais comme je veux des tableaux de 100, il faut que je parte de 1 et que j'aille à 101 (puisqu'il s'arrête à 100) ?
 

 
 
Ok, j'utilisais x car ça représente une distance en fait, mais i et j ça me va . Ca fait quoi t[x, i] ?  
 

 
ok merci  
 

 
bonne nuit    et merci encore pour l'aide.

Non, tu pars de 0 et tu vas jusqu'à 99, comme partout ailleurs en informatique (ou presque). C'est d'ailleurs précisément ce que donne range(100): ça donne une série de 100 entiers, en partant de 0

Ah ok dans ce cas ça me va

C'est un alias pour t[x][i], ça récupère l'élément en position (x, i) dans ton tableau.

ok, ça à l'air de marcher comme ça, mais je poste quand même mon code car j'ai un autre petit problème après    
 

t=zeros((1000, 100))
 
for x in range(0,1000):    
    for i in range(0,100):
        E[i]=random.gauss(mean,ecart) #distribution gaussienne en energie
        
        v[i]=c*sqrt(1-(mpion*c**2/E[i])**2)
        Ga[i]=1/sqrt(1-(v[i]/c)**2)   #calculs intermediaires
        GTAU[i]=Ga[i]*tau
        p=1-M.exp(-x/(v[i]*GTAU[i]))
        t[x][i]=p

t=zeros((1000, 100))
 
for x in range(0,1000):    
    for i in range(0,100):
        E[i]=random.gauss(mean,ecart) #distribution gaussienne en energie
        
        v[i]=c*sqrt(1-(mpion*c**2/E[i])**2)
        Ga[i]=1/sqrt(1-(v[i]/c)**2)   #calculs intermediaires
        GTAU[i]=Ga[i]*tau
        p=1-M.exp(-x/(v[i]*GTAU[i]))
        t[x][i]=p

Quelques modifs supplémentaires:

• Comme je l'ai indiqué plus haut, range(0, a) peut être écrit range(a), c'est équivalent, pas la peine de mettre le 0 donc
• As tu vraiment besoin de E, GTAU, v et Ga (d'avoir des arrays je veux dire)? Je ne vois pas trop où tu les utilise en dehors de ton calcul
• Habituellement (en python), la convention est de mettre les noms constantes en majuscules, donc MEAN, STDEV, TAU, MPION, ...
• Ta variable intermédiaire p (dans les deux dernières lignes) ne sert à rien
• Eviter de mélanger anglais (mean) et français (ecart), tout mettre en anglais dans l'idéal
• La PEP8 (Style Guide for Python Code) suggère que les opérateurs binaires (=, +, -, ==, /, *) soient entourés d'espaces, et que dans les listes d'arguments les virgules soient suivies d'un espace, donc:

for x in range(1000):    
    for i in range(100):
        E[i] = random.gauss(MEAN, STDEV) # distribution gaussienne en energie
        
        v[i] = c * sqrt(1 - (MPION * c**2 / E[i])**2)
        Ga[i] = 1 / sqrt(1 - (v[i] / c)**2) # calculs intermediaires
        GTAU[i] = Ga[i] * TAU
        t[x][i] = 1 - M.exp(-x / (v[i] * GTAU[i]))

Merci pour les petites modifications . Non je n'ai pas vraiment besoin des v GTAU et GA, c'était juste pour pas avoir une trop grosse expression.
 
J'ai un autre petit problème   . Maintenant mon but est de faire des test, je tire un nombre aléatoire K, et je regarde pour les valeurs dans mon tableau quelle sont celles qui sont supérieures à K, si elles le sont alors je remplace ces valeurs par une autre probabilité (c'est un peu tordu je sais   ) et je refais le test sur le nombre K, si  
elles sont plus grandes j'ajoute un 3 dans un nouveau tableau t2, sinon un 1. Et si elles ne vérifient pas le test de départ je met un 0.
 

K = N.random.uniform(0.78,0.85)
 
t2 = zeros((1000, 100))
 
for x in range(1000):  
    for i in range (100):        
        if t[x][i] > K:
            v2[i] = c*sqrt(1-(MMUON*c**2/E[i])**2)
            gtau2[i] = TAU/sqrt(1 - (v2[i]/c)**2)        
            t[x][i] = 1 - M.exp(- 999/(v2[i]*gtau2[i])) 
                if t[x][i] > K:
                    t2[x][i] = 3
                else:
                    t2[x][i] = 1
                    
        else:
            t[x][i] = 0

 
Il m'affiche bien un tableau avec des 3 des 1 et des 0 (par exemple quand je lui demande t2[999]) mais j'ai vérifié si ça collait (car je m'étonnais de ne jamais avoir de 0) et ça marche un peu de travers, il remplace souvent toutes les valeurs par une même valeur alors que je lui demande de les tester une par une.

Rien ne t'empêche d'avoir juste des variables locales dans ton code, pas besoin de tableaux pour ça

Exemple:

for x in range(1000):    
    for i in range(100):
        e = random.gauss(MEAN, STDEV) # distribution gaussienne en energie
        
        v = c * sqrt(1 - (MPION * c**2 / e)**2)
        ga = 1 / sqrt(1 - (v / c)**2) # calculs intermediaires
        gtau = ga * TAU
        t[x][i] = 1 - M.exp(-x / (v * gtau))

Et tu peux dégager toutes les déclarations en zeros(100, float) au début du script, comme ça

K = N.random.uniform(0.78,0.85)
 
t2 = zeros((1000, 100))
 
for x in range(1000):  
    for i in range (100):        
        if t[x][i] > K:
            v2[i] = c*sqrt(1-(MMUON*c**2/E[i])**2)
            gtau2[i] = TAU/sqrt(1 - (v2[i]/c)**2)        
            t[x][i] = 1 - M.exp(- 999/(v2[i]*gtau2[i])) 
                if t[x][i] > K:
                    t2[x][i] = 3
                else:
                    t2[x][i] = 1
                    
        else:
            t[x][i] = 0

Il est normal que ton calcul dans ce code là soit complètement différent de l'autre (notamment le M.exp(- 999/(v2[i]*gtau2[i])) alors que l'autre utilise -x?

Accessoirement, tu devrais peut-être extraire les calculs physiques dans des fonctions histoire de bien séparer les calculs du flux du code, et je suggère d'inverser la condition de ton if en t[x][i] <= K, de cette manière tu auras d'abord l'expression la plus simple. Et accessoirement dans cette expression tu set t à 0, pas t2, c'est normal?
(et arrêtes d'utiliser des tableaux là où tu n'en as pas besoin la seule chose que ça fasse c'est rendre le code moins lisible)

 
Je me suis trompé  
 

t2=zeros((1000, 100))
 
for x in range(1000):  
    for i in range (100):        
        if t[x][i] <= K:
            v2[i]=c*sqrt(1-(MMUON*c**2/E[i])**2)
            gtau2[i]=tau/sqrt(1-(v2[i]/c)**2)        
            t[x][i]=1-M.exp(-x/(v2[i]*gtau2[i])) 
                if t[x][i] > K:
                    t2[x][i]=3
                else:
                    t2[x][i]=1
                    
        else:
            t[x][i]=0

 
Je n'ai jamais rencontré ce terme, comment ça marche ? je vois pas trop car là mes fonctions dépendent des E(i) donc des i.
 

 
Ok, mais j'ai pas encore vraiment vu comment on utilise les fonctions dans python.

t2=zeros((1000, 100))
 
for x in range(1000):  
    for i in range (100):        
        if t[x][i] <= K:
            v2[i]=c*sqrt(1-(MMUON*c**2/E[i])**2)
            gtau2[i]=tau/sqrt(1-(v2[i]/c)**2)        
            t[x][i]=1-M.exp(-x/(v2[i]*gtau2[i])) 
                if t[x][i] > K:
                    t2[x][i]=3
                else:
                    t2[x][i]=1
                    
        else:
            t[x][i]=0

Elles ne dépendent que de E[i], donc tu gardes E en array, mais pas le reste.
 
Il suffit de transformer  

v2[i]=c*sqrt(1-(MMUON*c**2/E[i])**2)
gtau2[i]=tau/sqrt(1-(v2[i]/c)**2)        
t[x][i]=1-M.exp(-x/(v2[i]*gtau2[i]))

en

v2 = c * sqrt(1 - (MMUON * c**2 / E[i])**2)
gtau2 = tau / sqrt(1 - (v2 / c)**2)        
t[x][i]=1 - M.exp(-x / (v2 * gtau2))

Et d'enlever les déclarations type [i]v2 = zeros(100, float)
 
À noter aussi que ton premier script indique que chaque valeur de E[i] va être écrasée et réécrite 1000 fois, et que le script d'après utilisera uniquement le résultat de la dernière écriture, tu voudras peut-être penser à ça

Tu devrais passer quelques minutes à lire le tuto officiel Python, il n'est ni long ni compliqué

 
Ok, donc il faut que je sépare mes boucles ?  
 

t=zeros((1000, 100))
 
for i in range(100):
    E[i] = random.gauss(MEAN,DEVIATION) #distribution gaussienne en energie
    v = c * sqrt(1 - (MPION * c**2/E[i])**2)
    Ga = TAU / sqrt(1 - (v / c)**2)   #calculs intermediaires
 
for x in range(1000):    
    for i in range(100):
        t[x][i] = 1 - M.exp(- x / (v * Ga))

 
Ok je vais regarder ça

t=zeros((1000, 100))
 
for i in range(100):
    E[i] = random.gauss(MEAN,DEVIATION) #distribution gaussienne en energie
    v = c * sqrt(1 - (MPION * c**2/E[i])**2)
    Ga = TAU / sqrt(1 - (v / c)**2)   #calculs intermediaires
 
for x in range(1000):    
    for i in range(100):
        t[x][i] = 1 - M.exp(- x / (v * Ga))

Uniquement la création de E[i], tes calculs de v et ga dépendent de E[i] mais sont locaux à l'obtention de t[x][i], donc

for i in range(100):
    E[i] = random.gauss(MEAN,DEVIATION) #distribution gaussienne en energie
 
for x in range(1000):    
    for i in range(100):
        v = c * sqrt(1 - (MPION * c**2/E[i])**2)
        Ga = TAU / sqrt(1 - (v / c)**2)   #calculs intermediaires
        t[x][i] = 1 - M.exp(- x / (v * Ga))

plutôt.

Et accessoirement tu pourrais simplifier et unifier la définition de da distro gaussienne en énergie en utilisant une listcomp:

Au lieu de

E=zeros(100, float)  
 
for i in range(100):
    E[i] = random.gauss(MEAN,DEVIATION) #distribution gaussienne en energie

tu peux écrire plus simplement

E = N.array([random.gauss(MEAN, STDEV) for i in range(100)], dtype=float)

merci ça à l'air de fonctionner maintenant   , c'était surement à cause des valeurs de E[i].
 
Je poste mon code au cas ou tu aurais d'autres remarques:
 

K=N.random.uniform(0.75,0.85) 
 
print K
 
t2=zeros((1000, 100))
 
for x in range(1000):  
    for i in range (100):        
        if t[x][i] >= K:
            v2 = c * sqrt(1 - (MMUON * c**2 / E[i])**2)
            ga2 = tau / sqrt(1 - (v2 / c)**2)        
            t[x][i] = 1 - M.exp(-x / (v2 * ga2)) 
            if t[x][i] >= K:
                t2[x][i] = 3
            else:
                t2[x][i] = 1
                    
        else:
            t2[x][i] = 0

K=N.random.uniform(0.75,0.85) 
 
print K
 
t2=zeros((1000, 100))
 
for x in range(1000):  
    for i in range (100):        
        if t[x][i] >= K:
            v2 = c * sqrt(1 - (MMUON * c**2 / E[i])**2)
            ga2 = tau / sqrt(1 - (v2 / c)**2)        
            t[x][i] = 1 - M.exp(-x / (v2 * ga2)) 
            if t[x][i] >= K:
                t2[x][i] = 3
            else:
                t2[x][i] = 1
                    
        else:
            t2[x][i] = 0

K = N.random.uniform(0.75, 0.85) 
 
print K
 
t2 = zeros((1000, 100))

Ne pas oublier les espaces, c'est plus joli et lisible
 

for x in range(1000):  
    for i in range (100):        
        if t[x][i] >= K:
            v2 = c * sqrt(1 - (MMUON * c**2 / E[i])**2)
            ga2 = tau / sqrt(1 - (v2 / c)**2)        
            t[x][i] = 1 - M.exp(-x / (v2 * ga2)) 
            if t[x][i] >= K:
                t2[x][i] = 3
            else:
                t2[x][i] = 1
                    
        else:
            t2[x][i] = 0

Comme dit au dessus, j'inverserais la condition, ce qui demande aussi d'inverser les clauses:

for x in range(1000):  
    for i in range (100):        
        if t[x][i] < K:
            t2[x][i] = 0                     
        else:
            v2 = c * sqrt(1 - (MMUON * c**2 / E[i])**2)
            ga2 = tau / sqrt(1 - (v2 / c)**2)        
            t[x][i] = 1 - M.exp(-x / (v2 * ga2)) 
            if t[x][i] >= K:
                t2[x][i] = 3
            else:
                t2[x][i] = 1

Et pour rester cohérent, on inverse aussi la seconde condition (ça ne change rien, mais ça permet d'avoir le même test aux deux endroits, donc c'est plus clair):

for x in range(1000):  
    for i in range (100):        
        if t[x][i] < K:
            t2[x][i] = 0                     
        else:
            v2 = c * sqrt(1 - (MMUON * c**2 / E[i])**2)
            ga2 = tau / sqrt(1 - (v2 / c)**2)        
            t[x][i] = 1 - M.exp(-x / (v2 * ga2)) 
            if t[x][i] < K:
                t2[x][i] = 1
            else:
                t2[x][i] = 3

ok, merci beaucoup encore une fois, j'ai appris pleins de choses