Tabellen Problem , der kleine Anfang

[Phil-_-]

Guten Tag zusammen,

ich bin neu im Gebiet "Python" und allgemein im Bereich Programmierung.
Bei meinem ersten Projekt möchte ich durch Eingabe von Werten eine Tabelle erhalten.
Bisher hatte ich dies schon einmal in VBA (Excel) umgesetzt würde dies aber nun gerne in Python lösen.

Leider hakt es hier schon bei den ersten Schritten mit Python. Ich hoffe, jemand hat Lust mir zu Helfen und einige Fragen zu klären.

Meine erste Frage bezieht sich auf das Speichern einer Tabelle als Txt-Datei.


Der Code lautet bisher:

Code: Alles auswählen

import numpy as np  # import externe programming libraries
import math
import sys
import argparse


print("Hallo world!")
print("\n")



Z = 0.30 # Z-Wert aktuell
B = 0.30 # Schichtdicke Fixwert
m = 2 # Anzahl der Schichten insgesamt
z1= 0.30
z2= B*m
s = 5 # Schritte je Layer
i=1 # LAufvariable Zeilen
n=1 # Layer counter
g=2
S_ges = s * m  # Zeilen insgesamt

while n<= m:
	
	for g in range(1,m, 1):
		
			
		I=np.linspace(i , S_ges , S_ges)
	

	
		table=np.zeros((S_ges, 3) )  # (Zeilen,Spalten) , np.zeros(shape, dtype=float, order='C')



		table[:,0]= I
		table[:,1]=Z 
		table[:,2]=n

		i +=1

		print (table)
		
	
	n +=1
	Z += B
	g +=n

np.savetxt("Loop.txt", table, fmt = "%.4f") # %.3f Dezimalstellen der gesamten Tabelle

Die Ausgabe sieht wie folgt aus:

Code: Alles auswählen

[[ 1.   0.3  1. ]
 [ 2.   0.3  1. ]
 [ 3.   0.3  1. ]
 [ 4.   0.3  1. ]
 [ 5.   0.3  1. ]
 [ 6.   0.3  1. ]
 [ 7.   0.3  1. ]
 [ 8.   0.3  1. ]
 [ 9.   0.3  1. ]
 [10.   0.3  1. ]]
[[ 2.          0.6         2.        ]
 [ 2.88888889  0.6         2.        ]
 [ 3.77777778  0.6         2.        ]
 [ 4.66666667  0.6         2.        ]
 [ 5.55555556  0.6         2.        ]
 [ 6.44444444  0.6         2.        ]
 [ 7.33333333  0.6         2.        ]
 [ 8.22222222  0.6         2.        ]
 [ 9.11111111  0.6         2.        ]
 [10.          0.6         2.        ]]

und die gespeicherte Txt-Datei

Code: Alles auswählen

2.0000 0.6000 2.0000
2.8889 0.6000 2.0000
3.7778 0.6000 2.0000
4.6667 0.6000 2.0000
5.5556 0.6000 2.0000
6.4444 0.6000 2.0000
7.3333 0.6000 2.0000
8.2222 0.6000 2.0000
9.1111 0.6000 2.0000
10.0000 0.6000 2.0000

Ich verstehe also, dass ich mit meinem Code eine Tabelle schreibe und diese immer wieder überschreibe, daher am Ende auch nur die Ausgabe von der letzten Liste. Gewollt ist, aber eigentlich, dass eine große Tabelle mit allen Werten entsteht und diese dann komplett abgespeichert wird.
Wo ist hier mein Fehler?

Die gewünschte Ausgabe und abgespeicherte Txt-Datei, sollte eigentlich nur wie folgt aussehen:

Code: Alles auswählen

1.  0.3 1. 
2.  0.3 1. 
3.  0.3 1. 
4.  0.3 1. 
5.  0.3 1. 
6.  0.6 2. 
7.  0.6 2. 
8.  0.6 2. 
9.  0.6 2. 
10. 0.6 2. 

[__blackjack__]

Python-Schleifen bei Numpy-Code sind in der Regel ein Grund noch mal nachzudenken wie man das ohne Schleifen machen kann.

Code: Alles auswählen

import numpy as np

n = 2
a = 0.3
m = 5

B = np.repeat(np.linspace(a, a * n, n), m)
C = np.repeat(np.arange(n), m)

X = np.stack([np.arange(len(B)) + 1, B, C + 1]).T
print(X)

[Phil-_-]

Vielen Dank für die schnelle Hilfe!
Das sieht wirklich schon wesentlich kürzer aus als das, was ich da versucht hatte.
Bin noch im Anfang und viele Begriffe sind mir noch neu.

Ich habe das nun mal um 2 weitere Spalten erweitert.

Code: Alles auswählen

import numpy as np  
import math
import sys
import argparse

n = 2		# Schichten
a = 0.3
m = 10		# Steps je Layer
Typ = 0

L1_max = 2


A = np.arange(n*m) 				#([start, ]stop, [step, ]dtype=None)
								# linspace start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0 , zahlen über ein Intervall
B = np.repeat(np.linspace(a, a * n, n), m)	 #a, repeats, axis=None - Repeat elements of an array.

#C = np.linspace(0 , L_max , m)

D = np.repeat(np.arange(n), m)	  #(np.arange(n), m)  - gleichverteilte Werte über ein Intervall

E = np.repeat(np.linspace(Typ , Typ , n), m) 	



table = np.stack([A + 1, B , E , D + 1, E ]).T 

print(table)

Nun würde ich jedoch gerne in der dritten Spalte von 0 bis zu L1_max hochzählen und wenn dies erreicht ist auf bis ( -L_max ) und danach wieder bis auf L_max bis die Tabelle ausgefüllt ist.
Dabei bei einer vorgegebenen Schrittweite z.B. 0.5

Die Tabelle sollte wie folgt aussehen:

1. 0.3 0.0 1. 0.
2. 0.3 0.5 1. 0.
3. 0.3 1.0 1. 0.
4. 0.3 1.5 1. 0.
5. 0.3 2.0 1. 0.
6. 0.3 1.5 1. 0.
7. 0.3 1.0 1. 0.
8. 0.3 0.5 1. 0.
9. 0.3 0.0 1. 0.
10. 0.3 -0.5 1. 0.
11. 0.6 -1.0 2. 0.
12. 0.6 -1.5 2. 0.
13. 0.6 -2.0 2. 0.
14. 0.6 -1.5 2. 0.
15. 0.6 -1.0 2. 0.
16. 0.6 -0.5 2. 0.
17. 0.6 0.0 2. 0.
18. 0.6 0.5 2. 0.
19. 0.6 1.0 2. 0.
20. 0.6 1.5 2. 0.

Hättest du hier auch eine Idee zur Lösung?