wake-up-neo.net

Excel-Datei in Python lesen

Ich habe eine Excel-Datei

Arm_id      DSPName        DSPCode          HubCode          PinCode    PPTL
1            JaVAS            01              AGR             282001    1,2
2            JaVAS            01              AGR             282002    3,4
3            JaVAS            01              AGR             282003    5,6

Ich möchte eine Zeichenfolge in der Form Arm_id,DSPCode,Pincode speichern. Dieses Format ist konfigurierbar, dh es kann sich DSPCode,Arm_id,Pincode ändern. Ich speichere das Format in einer Liste ab

FORMAT = ['Arm_id', 'DSPName', 'Pincode']

Wie lese ich den Inhalt einer bestimmten Spalte mit dem angegebenen Namen, sofern die Variable FORMAT konfigurierbar ist?.

Das habe ich versucht. Derzeit kann ich den gesamten Inhalt der Datei lesen

from xlrd import open_workbook
wb = open_workbook('sample.xls')
for s in wb.sheets():
    #print 'Sheet:',s.name
    values = []
    for row in range(s.nrows):
        col_value = []
        for col in range(s.ncols):
            value  = (s.cell(row,col).value)
            try : value = str(int(value))
            except : pass
            col_value.append(value)
        values.append(col_value)
print values

Meine Ausgabe ist 

[[u'Arm_id', u'DSPName', u'DSPCode', u'HubCode', u'PinCode', u'PPTL'], ['1', u'JaVAS', '1', u'AGR', '282001', u'1,2'], ['2', u'JaVAS', '1', u'AGR', '282002', u'3,4'], ['3', u'JaVAS', '1', u'AGR', '282003', u'5,6']]

Dann schleife ich um values[0] herum und versuche, den FORMAT-Inhalt in values[0] herauszufinden, und dann den Index von Arm_id, DSPname and Pincode in values[0] zu bekommen und dann von der nächsten Schleife kenne ich den Index aller FORMAT-Faktoren .

Dies ist jedoch eine so schlechte Lösung.

Wie erhalte ich die Werte einer bestimmten Spalte mit Namen in der Excel-Datei?

68

Dies ist ein Ansatz:

from xlrd import open_workbook

class Arm(object):
    def __init__(self, id, dsp_name, dsp_code, hub_code, pin_code, pptl):
        self.id = id
        self.dsp_name = dsp_name
        self.dsp_code = dsp_code
        self.hub_code = hub_code
        self.pin_code = pin_code
        self.pptl = pptl

    def __str__(self):
        return("Arm object:\n"
               "  Arm_id = {0}\n"
               "  DSPName = {1}\n"
               "  DSPCode = {2}\n"
               "  HubCode = {3}\n"
               "  PinCode = {4} \n"
               "  PPTL = {5}"
               .format(self.id, self.dsp_name, self.dsp_code,
                       self.hub_code, self.pin_code, self.pptl))

wb = open_workbook('sample.xls')
for sheet in wb.sheets():
    number_of_rows = sheet.nrows
    number_of_columns = sheet.ncols

    items = []

    rows = []
    for row in range(1, number_of_rows):
        values = []
        for col in range(number_of_columns):
            value  = (sheet.cell(row,col).value)
            try:
                value = str(int(value))
            except ValueError:
                pass
            finally:
                values.append(value)
        item = Arm(*values)
        items.append(item)

for item in items:
    print item
    print("Accessing one single value (eg. DSPName): {0}".format(item.dsp_name))
    print

Sie müssen keine benutzerdefinierte Klasse verwenden, Sie können einfach eine dict() verwenden. Wenn Sie jedoch eine Klasse verwenden, können Sie wie oben beschrieben über die Punktnotation auf alle Werte zugreifen.

Hier ist die Ausgabe des obigen Skripts:

Arm object:
  Arm_id = 1
  DSPName = JaVAS
  DSPCode = 1
  HubCode = AGR
  PinCode = 282001 
  PPTL = 1
Accessing one single value (eg. DSPName): JaVAS

Arm object:
  Arm_id = 2
  DSPName = JaVAS
  DSPCode = 1
  HubCode = AGR
  PinCode = 282002 
  PPTL = 3
Accessing one single value (eg. DSPName): JaVAS

Arm object:
  Arm_id = 3
  DSPName = JaVAS
  DSPCode = 1
  HubCode = AGR
  PinCode = 282003 
  PPTL = 5
Accessing one single value (eg. DSPName): JaVAS
62
tamasgal

Eine etwas späte Antwort, aber bei Pandas ist es möglich, direkt eine Spalte einer Excel-Datei zu erhalten:

import pandas
import xlrd
df = pandas.read_Excel('sample.xls')
#print the column names
print df.columns
#get the values for a given column
values = df['Arm_id'].values
#get a data frame with selected columns
FORMAT = ['Arm_id', 'DSPName', 'Pincode']
df_selected = df[FORMAT]
74
sheinis

Die wichtigsten Teile sind also, den Header (col_names = s.row(0)) zu packen und beim Durchlaufen der Zeilen die erste Zeile zu überspringen, die nicht benötigt wird for row in range(1, s.nrows) - Dies geschieht mit einem Bereich von 1 (nicht implizit) 0). Anschließend verwenden Sie Zip, um die Zeilen mit 'name' als Kopfzeile der Spalte zu durchlaufen.

from xlrd import open_workbook

wb = open_workbook('Book2.xls')
values = []
for s in wb.sheets():
    #print 'Sheet:',s.name
    for row in range(1, s.nrows):
        col_names = s.row(0)
        col_value = []
        for name, col in Zip(col_names, range(s.ncols)):
            value  = (s.cell(row,col).value)
            try : value = str(int(value))
            except : pass
            col_value.append((name.value, value))
        values.append(col_value)
print values
10
Noel Evans

Durch die Verwendung von Pandas können wir Excel leicht lesen.

import pandas as pd 
import xlrd as xl 
from pandas import ExcelWriter
from pandas import ExcelFile 

DataF=pd.read_Excel("Test.xlsx",sheet_name='Sheet1')

print("Column headings:")
print(DataF.columns)

Test unter: https://repl.it Referenz: https://pythonspot.com/read-Excel-with-pandas/

5
Mahabubuzzaman

Bei meinem Ansatz werden die Header-Informationen aus der ersten Zeile gelesen, um die Indizes der interessierenden Spalten zu ermitteln.

Sie haben in der Frage erwähnt, dass die Werte auch als Zeichenfolge ausgegeben werden sollen. Ich erzeuge dynamisch eine Formatzeichenfolge für die Ausgabe aus der FORMAT-Spaltenliste. Zeilen werden an die Wertezeichenfolge angehängt, getrennt durch ein neues Zeilenzeichen.

Die Reihenfolge der Ausgabespalten wird durch die Reihenfolge der Spaltennamen in der Liste FORMAT bestimmt.

In meinem Code unten ist der Fall des Spaltennamens in der Liste FORMAT wichtig. In der obigen Frage steht "Pincode" in Ihrer FORMAT-Liste, aber "PinCode" in Ihrem Excel. Das würde unten nicht funktionieren, es müsste 'PinCode' sein.

from xlrd import open_workbook
wb = open_workbook('sample.xls')

FORMAT = ['Arm_id', 'DSPName', 'PinCode']
values = ""

for s in wb.sheets():
    headerRow = s.row(0)
    columnIndex = [x for y in FORMAT for x in range(len(headerRow)) if y == firstRow[x].value]
    formatString = ("%s,"*len(columnIndex))[0:-1] + "\n"

    for row in range(1,s.nrows):
        currentRow = s.row(row)
        currentRowValues = [currentRow[x].value for x in columnIndex]
        values += formatString % Tuple(currentRowValues)

print values

Für die Beispieleingabe, die Sie oberhalb dieser Code-Ausgaben angegeben haben:

>>> 1.0,JaVAS,282001.0
2.0,JaVAS,282002.0
3.0,JaVAS,282003.0

Und weil ich ein Python-Noob bin, sollten Requisiten sein: diese Antwort , diese Antwort , diese Frage , diese Frageund diese Antwort .

1
poida

Hier ist der Code zum Lesen einer Excel-Datei und zum Drucken aller in Spalte 1 vorhandenen Zellen (mit Ausnahme der ersten Zelle, d. H. Der Überschrift):

import xlrd

file_location="C:\pythonprog\xxx.xlsv"
workbook=xlrd.open_workbook(file_location)
sheet=workbook.sheet_by_index(0)
print(sheet.cell_value(0,0))

for row in range(1,sheet.nrows):
     print(sheet.cell_value(row,0))
0
harsha vardhan

Obwohl ich fast immer nur Pandas dazu benutze, wird mein aktuelles kleines Tool in eine ausführbare Datei gepackt und Pandas sind ein Overkill. Also habe ich eine Version von poida erstellt, die zu einer Liste benannter Tupel führte. Sein Code mit dieser Änderung würde folgendermaßen aussehen: 

from xlrd import open_workbook
from collections import namedtuple
from pprint import pprint

wb = open_workbook('sample.xls')

FORMAT = ['Arm_id', 'DSPName', 'PinCode']
OneRow = namedtuple('OneRow', ' '.join(FORMAT))
all_rows = []

for s in wb.sheets():
    headerRow = s.row(0)
    columnIndex = [x for y in FORMAT for x in range(len(headerRow)) if y == headerRow[x].value]

    for row in range(1,s.nrows):
        currentRow = s.row(row)
        currentRowValues = [currentRow[x].value for x in columnIndex]
        all_rows.append(OneRow(*currentRowValues))

pprint(all_rows)
0
TSeymour