Ergebnis einer Funktion in globaler Variable speichern

[mrarno]

Hallo,
ich habe folgendes Problem...
Ich lese Zellen einer Exceltabelle in Python aus und rechne damit rum und speichere die Werte innerhalb der Funktion in einem neuen Numpy array. Das klappt auch wunderbar und er gibt mir auch die richtigen Werte aus. Nur wenn ich danach dann den Befehl print array(in meinem Fall print semi_data) eingebe ( also nachdem ich die Funktion im kernel ausgefuehrt habe) wird mir der array so ausgegeben "[]" also als waere dieser leer.
Daraus folgt natuerlich,dass ich diesen Array auch nicht wieder in Zellen in Excel schreiben kann. Hilfe waere echt gut LG
P.S.
Das Beispiel mit semi_data findet sich eher in den letzten Zeilen

Code: Alles auswählen

from openpyxl import load_workbook
import numpy as np
wb = load_workbook(filename='hallo.xlsx') #entering Excel file
sheet = wb.get_sheet_by_name('Sheet') #entering worksheet

#Import  Data (d,D,W) Inner Ring:
#target_array : 
bearing_data_in=[]
row_start_in= 3 
row_end_in= 101
columns_str_in= "CDE"

#Import  Data (d,D,W) Outer Ring:
#target_array : 
bearing_data_out=[]
row_start_out= 3 
row_end_out= 101
columns_str_out= "FGH"


#Import  Data (d,D,W) semi-finished :
#target_array : 
semi_data=[]
row_start_semi= 3 
row_end_semi= 101
columns_str_semi= "KLM"
semi_data= np.array=([])

def import_data_in(x):
    import_array=np.array=([])
    for row in range(row_start_in,row_end_in): #go through rows
        pass_array = []
        for column in columns_str_in:  #go through columns
            if sheet[str(column)+ str(row)].value != None:
                pass_array.append(sheet[str(column)+ str(row)].value)
        if len(pass_array) <=2:
            pass
        else:
            import_array.append(pass_array)
    x=np.asarray(import_array)

    #return bearing_data_in

def import_data_out():
    import_array=np.array=([])
    for row in range(row_start_out,row_end_out): #go through rows
        pass_array = []
        for column in columns_str_out:  #go through columns
            if sheet[str(column)+ str(row)].value != None:
                pass_array.append(sheet[str(column)+ str(row)].value)
        if len(pass_array) <=2:
            pass
        else:
            import_array.append(pass_array)
    numpy_array=np.asarray(import_array)
    bearing_data_out=numpy_array
   # return bearing_data_out


def import_data_semi():
    import_array=np.array=([])
    
    
    for row in range(row_start_semi,row_end_semi): #go through rows
        pass_array = []
        for column in columns_str_semi:  #go through columns
            if sheet[str(column)+ str(row)].value != None:
                pass_array.append(sheet[str(column)+ str(row)].value)
        if len(pass_array) <=2:
            pass
        else:
            import_array.append(pass_array)
        semi_data=np.asarray(import_array)
print semi_data

[BlackJack]

@mrarno: Lass das mit den globalen Variablen einfach sein. Auf Funktionsebene sollten nur Konstanten, Funktionen, und Klassen definiert werden, das Hauptprogramm steht üblicherweise in einer Funktion mit dem Namen `main()` und Werte (ausser Konstanten) betreten und verlassen Funktionen und Methoden als Argumente und Rückgabewerte. Globale Variablen machen mehr Probleme als sie lösen und haben in sauberen Programmen eigentlich nichts zu suchen.

[BlackJack]

@mrarno: Mal von globalen Variablen völlig abgesehen rufst Du ja auch keine der Funktionen auf, wie soll `semi_data` da am Ende an etwas anderes gebunden sein als der Wert den Du auf Modulebene zuletzt daran bindest‽

Du hast dort viel zu viel Code der so gar nicht läuft. Aber so wirklich gar nicht. So viel dürfte sich nicht ansammeln wenn man ein Programm entwickelt denn man schreibt ja nicht ein komplettes Programm und testet *dann* ob es läuft, sondern entwickelt das Stück für Stück und testet zwischendurch ob die Teillösungen das tun was sie sollen und macht erst mit der nächsten Teillösung weiter wenn das bisherige tut was es soll.

Die drei Funktionen sehen auch *sehr* ähnlich aus. Das ist eigentlich *eine* Funktion der man die entsprechenden Argumente übergibt. Wenn man Quelltext kopiert und die Kopie(n) leicht anpasst, macht man fast sicher etwas falsch.

Dieses Muster hier fand ich am interessantesten: ``import_array=np.array=([])``. Wie ist denn das zweite ``=`` dort hingekommen und kannst Du mal erklären was diese Zeile dadurch bewirkt und wie man auf *die* Idee kommt?

Die API von `openpyxl` kann man etwas ökonomischer Nutzen als die Zellennamen alle selber zu generieren: Man kann auch auf einen rechteckigen Bereich durch Angabe von den Zellen links oben und rechts unten per Indexzugriff bekommen. Ungetestet:

Code: Alles auswählen

#!/usr/bin/env python
# coding: utf-8
from __future__ import absolute_import, division, print_function
import numpy as np
from openpyxl import load_workbook

 
def get_data_as_array(sheet, cell_range):
    result = list()
    for row in sheet[cell_range]:
        values = [cell.value for cell in row]
        if all(value is not None for value in values):
            result.append(values)
    return np.array(result)


def main():
    workbook = load_workbook('hallo.xlsx')
    sheet = workbook.get_sheet_by_name('Sheet')
     
    bearing_data_in = get_data_as_array(sheet, 'C3:E100')
    bearing_data_out = get_data_as_array(sheet, 'F3:H100')
    semi_data = get_data_as_array(sheet, 'K3:M100')
    
    print(semi_data)


if __name__ == '__main__':
    main()