Utilisation Des Données Contenues Dans Une Liste

Je viens de débuter sous Python et je bloque déjà... J'ai consulté les cours de Gérard Swinnen sans que j'y trouve la réponse que j'attendais.

J'ai un problème au niveau des listes entre les données de type float et les integer.

Je vais vous poster mon "très long car implémenté n'importe comment" programme et l'erreur qu'on lui affecte.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
#calcul des vitesses
Vxfc1=[0.1]
Vyfc1=[0.1]
 
Vxfc1.append(Vxfc0[0])
for i in range (1,10):
    Vxfc1.append(Vxfc0[i])
print(Vxfc1)
 
Vyfc1.append(Vyfc0[0])
for i in range (1,10):
    Vyfc1.append(Vyfc0[i])
print(Vyfc1)
 
#calcul iteratif
 
#conditions initiales
x1=1
x2=[xfc1[1]]
x3=[xfc1[2]]
x4=[xfc1[3]]
x5=[xfc1[4]]
x6=[xfc1[5]]
x7=[xfc1[6]]
x8=[xfc1[7]]
x9=[xfc1[8]]
x10=[xfc1[9]]
x11=[xfc1[10]]
 
y1=[yfc1[0]]
y2=[yfc1[1]]
y3=[yfc1[2]]
y4=[yfc1[3]]
y5=[yfc1[4]]
y6=[yfc1[5]]
y7=[yfc1[6]]
y8=[yfc1[7]]
y9=[yfc1[8]]
y10=[yfc1[9]]
y11=[yfc1[10]]
 
Vx1=[Vxfc1[0]]
Vx2=[Vxfc1[1]]
Vx3=[Vxfc1[2]]
Vx4=[Vxfc1[3]]
Vx5=[Vxfc1[4]]
Vx6=[Vxfc1[5]]
Vx7=[Vxfc1[6]]
Vx8=[Vxfc1[7]]
Vx9=[Vxfc1[8]]
Vx10=[Vxfc1[9]]
Vx11=[Vxfc1[10]]
 
Vy1=[Vyfc1[0]]
Vy2=[Vyfc1[1]]
Vy3=[Vyfc1[2]]
Vy4=[Vyfc1[3]]
Vy5=[Vyfc1[4]]
Vy6=[Vyfc1[5]]
Vy7=[Vyfc1[6]]
Vy8=[Vyfc1[7]]
Vy9=[Vyfc1[8]]
Vy10=[Vyfc1[9]]
Vy11=[Vyfc1[10]]
 
# 1D ODE that has a pitchfork bifurcation
def vitesseX1(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseX2(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseX3(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseX4(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseX5(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseX6(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseX7(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseX8(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseX9(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseX10(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseX11(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
 
def vitesseY1(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(-E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)+(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*9.81/2-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseY2(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(-E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)+(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*9.81/2-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseY3(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(-E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)+(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*9.81/2-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseY4(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(-E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)+(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*9.81/2-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseY5(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(-E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)+(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*9.81/2-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseY6(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(-E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)+(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*9.81/2-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseY7(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(-E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)+(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*9.81/2-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseY8(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(-E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)+(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*9.81/2-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseY9(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(-E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)+(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*9.81/2-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseY10(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(-E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)+(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*9.81/2-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
def vitesseY11(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0):
    return 2/(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*(-E*A*(w-v)*(((w-v)**2+(z-y)**2)**.5-((w0-v0)**2+(z0-y0)**2)**.05/(((w-v)**2+(z-y)**2)**.5*((w0-v0)**2+(z0-y0)**2)**.05)+(Pfc*(((v-u)**2+(y-x)**2)**.5+((w-v)**2+(z-y)**2)**.5))*9.81/2-E*A*(v-u)*(((v-u)**2+(y-x)**2)**.5-((v0-u0)**2+(y0-x0)**2)**.5)/(((v-u)**2+(y-x)**2)**.5*((v0-u0)**2+(y0-x0)**2)**.5)))
 
def coordonneeX1(u):
    return Vx1
def coordonneeX2(u):
    return Vx2
def coordonneeX3(u):
    return Vx3
def coordonneeX4(u):
    return Vx4
def coordonneeX5(u):
    return Vx6
def coordonneeX7(u):
    return Vx7
def coordonneeX8(u):
    return Vx8
def coordonneeX9(u):
    return Vx9
def coordonneeX10(u):
    return Vx10
def coordonneeX11(u):
    return Vx11
 
def coordonneeY1(u):
    return Vy1
def coordonneeY2(u):
    return Vy2
def coordonneeY3(u):
    return Vy3
def coordonneeY4(u):
    return Vy4
def coordonneeY5(u):
    return Vy5
def coordonneeY6(u):
    return Vy6
def coordonneeY7(u):
    return Vy7
def coordonneeY8(u):
    return Vy8
def coordonneeY9(u):
    return Vy9
def coordonneeY10(u):
    return Vy10
def coordonneeY11(u):
    return Vy11
 
# 1D Euler
def OneDEulerVx(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0,f,dt):
	return u + dt * f(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0)
def OneDEulerVy(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0,f,dt):
	return u + dt * f(u,v,w,x,y,z,u0,v0,w0,x0,y0,z0)
def OneDEulerX(u,f,dt):
	return u + dt * f(u)
def OneDEulerY(u,f,dt):
	return u + dt * f(u)
 
#increment de temps
t=[0.0]
dt=0.2
 
# The number of time steps to integrate over
N = 5
 
# The main loop that generates iterates and stores them
for n in range(0,N):
  # at each time step calculate new x(t)
  # and append to list x
    x1.append(OneDEulerX(x1[n],coordonneeX1,dt))
    x2.append(OneDEulerX(x2[n],coordonneeX2,dt))
    x3.append(OneDEulerX(x3[n],coordonneeX3,dt))
    x4.append(OneDEulerX(x4[n],coordonneeX4,dt))
    x5.append(OneDEulerX(x5[n],coordonneeX5,dt))
    x6.append(OneDEulerX(x6[n],coordonneeX6,dt))
    x7.append(OneDEulerX(x7[n],coordonneeX7,dt))
    x8.append(OneDEulerX(x8[n],coordonneeX8,dt))
    x9.append(OneDEulerX(x9[n],coordonneeX9,dt))
    x10.append(OneDEulerX(x10[n],coordonneeX10,dt))
    x11.append(OneDEulerX(x11[n],coordonneeX11,dt))
    y1.append(OneDEulerY(y1[n],coordonneeY1,dt))
    y2.append(OneDEulerY(y2[n],coordonneeY2,dt))
    y3.append(OneDEulerY(y3[n],coordonneeY3,dt))
    y4.append(OneDEulerY(y4[n],coordonneeY4,dt))
    y5.append(OneDEulerY(y5[n],coordonneeY5,dt))
    y6.append(OneDEulerY(y6[n],coordonneeY6,dt))
    y7.append(OneDEulerY(y7[n],coordonneeY7,dt))
    y8.append(OneDEulerY(y8[n],coordonneeY8,dt))
    y9.append(OneDEulerY(y9[n],coordonneeY9,dt))
    y10.append(OneDEulerY(y10[n],coordonneeY10,dt))
    y11.append(OneDEulerY(y11[n],coordonneeY11,dt))
    Vx1.append(OneDEulerVx(x1[n],x2[n],x3[n],y1[n],y2[n],y3[n],xfc1[0],xfc1[1],xfc1[2],yfc1[0],yfc1[1],yfc1[2],vitesseX,dt))
    t.append( t[n] + dt )
print(Vx1)
print(x1,x2)

L'erreur qui vient est :

Citation:

Traceback (most recent call last):
File "C:\Documents and Settings\Sverriest\Bureau\PRD Vossloh\Python\Essais\cÃ¢ble.py", line 266, in <module>
File "C:\Documents and Settings\Sverriest\Bureau\PRD Vossloh\Python\Essais\cÃ¢ble.py", line 251, in OneDEulerX
TypeError: can't multiply sequence by non-int of type 'float'

Tu essayes de multiplier une séquence (une liste, un tuple,...) par un float, ce qui n'est pas possible.
Tu peux multiplier par un int.
Pour multiplier chaque élement de ta séquence, tu peux utiliser une list comprehension:
Code:

1 2 3 4 5 6 7 8 9 >>> liste = ['toto', 'tutu', 'tata'] >>> liste * 2 ['toto', 'tutu', 'tata', 'toto', 'tutu', 'tata'] >>> liste * 2. Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: can't multiply sequence by non-int of type 'float' ' >>> [nom*2 for nom in liste] ['totototo', 'tutututu', 'tatatata']
Le tuple que tu essayes de multiplier peut aussi être le retour d'une fonction.
Je n'ai pas le temps d' explorer minutieusement ton code mais ce doit être le retour de la fonction f() que tu multiplies par dt

Ca doit venir de dt, tu as raison, mais pourtant j'ai l'impression d'avoir codé comme pour le code suivant, je ne vois pas de différence :
Code:

1 2 3 4 5 6 7 8 9 >>> liste=1,2,3,4] >>> for i in range (0,4): print(liste[i]*2.146) 2.146 4.292 6.438 8.584

Que renvoie ta fonction f()?

Merci,

C'est de là que venait le problème, elle renvoyait une liste...

Du coup, le calcul ne se faisait pas.

Du coup, ce point est résolu.

Néanmoins, je pense que beaucoup d'autres problèmes se présenteront dans un futur proche et que j'aurais d'autres questions.

Je garde ce sujet ou j'en fais un autre ?

Un sujet, une question, c'est plus simple pour ceux qui utilisent la recherche ;)

Très bien, je m'y tiendrai.

Merci en tout cas !