Konvertera Excel till NumPy med Aspose.Cells för Python

Att arbeta med Excel-data i Python är vanligt. Det innebär ofta att flytta data från Excel till ett format som kan manipuleras effektivt. Att konvertera Excel-data till ett format som är redo för analys kan vara knepigt. I detta blogginlägg kommer du att lära dig hur man konverterar Excel till NumPy-arrayer med bara några rader kod.

Varför NumPy?

NumPy (Numerical Python) är ett öppen källkod Python-bibliotek. Det är ryggraden i datavetenskap och maskininlärning i Python. NumPy erbjuder snabba arrayoperationer och effektiv numerisk beräkning. Det fungerar smidigt med pandas, TensorFlow och scikit-learn. Biblioteket stöder multidimensionella arrayer, matriser, linjär algebra och Fouriertransformer. Arrayer använder sammanhängande minne, vilket gör dem snabbare än Python-listor. Denna hastighet gör NumPy till ett kärnverktyg för vetenskaplig beräkning och dataanalys.

Excel används i stor utsträckning för att lagra datamängder, men det är inte optimerat för Python-arbetsflöden. Traditionella konverteringsmetoder kräver ofta extra bibliotek, flera steg och manuell parsning. Aspose.Cells låter dig exportera data från Excel, TSV, CSV, och JSON format direkt till NumPy-arrayer. Detta kopplar samman kalkylblad med Pythons numeriska verktyg.

What is Aspose.Cells for Python?

Aspose.Cells är det bästa Excel-biblioteket för Python utvecklare. Det möjliggör att läsa, skapa och manipulera kalkylblad utan att förlita sig på Microsoft Excel. Python via .NET-varianten integrerar .NET-versionen av Aspose.Cells och exponerar den för Python. Aspose.Cells förenklar processen att konvertera Excel till NumPy. Det låter dig exportera en hel arbetsbok, arbetsblad, intervall, rad, kolumn eller till och med ett listobjekt direkt till NumPy ndarrays. Detta innebär att du kan gå från rå Excel-filer till rena, färdiga data för analys eller maskininlärning med minimal ansträngning.

Du kan installera det från PyPI:

pip install aspose‑cells‑python

När den väl är installerad, importera biblioteket tillsammans med NumPy:

import aspose.cells as cells
import numpy as np

Hur man konverterar Excel-arbetsbok till NumPy

Ett kalkylblad kan innehålla flera arbetsblad. Du kan exportera en hel Excel-arbetsbok till en NumPy ndarray på en gång. Detta är praktiskt när du vill bearbeta data från alla blad direkt i Python.

Följ stegen nedan för att konvertera en Excel-arbetsbok till en NumPy ndarray:

Ladda Excel-arbetsboken med hjälp av Workbook-klassen.
Åtkomst till alla arbetsblad från arbetsboken.
Loopa igenom varje arbetsblad för att läsa dess använda rader och kolumner.
Extrahera cellvärden rad för rad.
Lagra varje arks data i en lista av listor.
Konvertera de insamlade uppgifterna till en NumPy ndarray med hjälp av np.asarray().

Här är ett förenklat Python-skript som exporterar en provarbetsbok:

import aspose.cells as cells
import numpy as np

# ladda arbetsbok
workbook = cells.Workbook("sample_data.xlsx")
sheets = workbook.worksheets

# förbered en tom lista för att hålla arkdata
sheets_data = []

# loop through worksheets
for sheet in sheets:
    # sheet = workbook.worksheets.get(sheetindex)
    sheet_cells = sheet.cells
    max_row = sheet_cells.max_data_row + 1  # number of populated rows
    max_col = sheet_cells.max_data_column + 1  # number of populated columns

    sheet_rows = []
   for r in range(max_row):
        row_values = []
       for c in range(max_col):
            cell = sheet_cells.check_cell(r, c)
            row_values.append(cell.value if cell else "")
        sheet_rows.append(row_values)
    sheets_data.append(sheet_rows)

# konvertera till ndarray med dtype=object för att bevara strängar
excel_array = np.asarray(sheets_data, dtype=object)
print(excel_array)

Hur man konverterar Excel-arbetsbok till NumPy

Detta skript ersätter eventuella tomma celler med tomma strängar och kombinerar alla kalkylblad till en NumPy-array. Den slutliga excelarrayen är tredimensionell: den första nivån representerar blad, den andra representerar rader, och den tredje representerar kolumner.

[[['City', 'Region', 'Store'],
  ['Chicago', 'Central', '3055'],
  ['New York', 'East', '3036'],
  ['Detroit', 'Central', '3074']],

 [['City2', 'Region2', 'Store3'],
  ['Seattle', 'West', '3000'],
  ['philadelph', 'East', '3082'],
  ['Detroit', 'Central', '3074']],

 [['City3', 'Region3', 'Store3'],
  ['Seattle', 'West', '3166'],
  ['New York', 'East', '3090'],
  ['Chicago', 'Central', '3055']]]

Konvertera ett enskilt arbetsblad till NumPy

Ibland kan du vilja arbeta med ett enda kalkylblad istället för en hel arbetsbok. Du kan direkt extrahera cellvärdena från ett kalkylblad och konvertera dem till ett NumPy ndarray genom att följa stegen nedan:

Ladda Excel-filen med Workbook-klassen.
Åtkomst till målarbetsbladet med hjälp av dess index.
Hämta de maximalt använda raderna och kolumnerna.
Loopa genom varje rad och kolumn för att samla in cellvärden.
Lagra den extraherade datan i en lista.
Konvertera listan till en NumPy ndarray med np.asarray().

Här är Python-skriptet som exporterar ett enda kalkylblad:

import aspose.cells as cells
import numpy as np

# ladda arbetsbok
workbook = cells.Workbook("sample_data.xlsx")

# åtkomst till det första kalkylbladet
sheet = workbook.worksheets[0]

# get max rows and columns with data
max_row = sheet.cells.max_data_row + 1
max_col = sheet.cells.max_data_column + 1

# extract data
rows = []
for r in range(max_row):
    row_values = []
   for c in range(max_col):
        cell = sheet.cells.check_cell(r, c)
        row_values.append(cell.value if cell else "")
    rows.append(row_values)

# convert to numpy ndarray
worksheet_array = np.asarray(rows, dtype=object)
print(worksheet_array)

Detta skapar en 2D ndarray där rader motsvarar Excel-rader och kolumner motsvarar Excel-kolumner.

[['City' 'Region' 'Store']    
 ['Chicago' 'Central' '3055'] 
 ['New York' 'East' '3036']   
 ['Detroit' 'Central' '3074']]

Hur man konverterar ett intervall av Excel till NumPy

I vissa fall behöver du bara ett specifikt intervall av celler. Aspose.Cells låter dig definiera ett intervall och exportera det direkt till en NumPy ndarray.

Följ stegen nedan:

Ladda arbetsboken med Workbook-klassen.
Välj målarbetsbladet.
Definiera ett intervall med hjälp av metoden worksheet.cells.createrange().
Gå igenom raderna och kolumnerna i intervallet för att extrahera värden.
Konvertera värdena till en NumPy ndarray med hjälp av np.asarray().

Följande kodexempel visar hur man konverterar ett intervall av celler från Excel till NumPy ndarray:

import aspose.cells as cells
import numpy as np

# ladda arbetsbok
workbook = cells.Workbook("sample_data.xlsx")

# välj första arbetsbladet
sheet = workbook.worksheets.get(0)

# definiera ett område (B1 till C3)
cell_range = sheet.cells.create_range("B1", "C3")

# extract data from range
range_data = []
for r in range(cell_range.row_count):
    row_values = []
   for c in range(cell_range.column_count):
        cell = sheet.cells.check_cell(r, c)
        row_values.append(cell.value if cell else "")
    range_data.append(row_values)

# konvertera till numpy ndarray
range_array = np.asarray(range_data, dtype=object)
print(range_array)

Om det valda området täcker två kolumner och tre rader, kommer den resulterande arrayen att vara 3×2, som:

[['City' 'Region']
 ['Chicago' 'Central']
 ['New York' 'East']]

Konvertera en Excel-tabell (ListObject) till NumPy

Ett Excel-tabell är ett strukturerat dataområde med rubriker och rader. I Aspose.Cells representeras detta som en ListObject. Du kan enkelt exportera innehållet i en Excel-tabell till en NumPy ndarray för vidare bearbetning i Python.

Ladda arbetsboken och välj kalkylbladet.
Åtkomst till ListObject (Excel-tabell) från kalkylbladet.
Exportera tabellens data till en tvådimensionell array.
Konvertera arrayen till en NumPy ndarray.
Använd ndarray för data science eller maskininlärningsarbetsflöden.

Följande kodexempel visar hur man exporterar en Excel-tabell (ListObject) till NumPy:

import aspose.cells as cells
import numpy as np

# Ladda Excel-fil
workbook = cells.Workbook("sample_data.xlsx")
sheet = workbook.worksheets.get(0)

# Skapa en tabell som täcker A1:C4 med rubriker
index = sheet.list_objects.add("A1", "C4", True)
table = sheet.list_objects[index]

rows = []
for r in range(table.start_row, table.end_row + 1):
    row_vals = []
   for c in range(table.start_column, table.end_column + 1):
        cell = sheet.cells.check_cell(r, c)
        row_vals.append(cell.value if cell else "")
    rows.append(row_vals)

list_object_array = np.asarray(rows, dtype=object)
print(list_object_array)

Det resulterande NumPy ndarray kommer att innehålla raderna och kolumnerna i Excel-tabellen, inklusive rubriker om de är en del av dataintervallet.

[['City', 'Region', 'Store'],
 ['Chicago', 'Central', '3055'],
 ['New York', 'East', '3036'],
 ['Detroit', 'Central', '3074']]

Hur man konverterar en rad i Excel till NumPy

Ibland behöver du bara data från en enda rad i Excel. Aspose.Cells gör det enkelt att extrahera en rad och ladda den direkt i en NumPy ndarray.

Ladda Excel-arbetsboken.
Välj kalkylbladet.
Välj den radindex du vill exportera.
Exportera radvärdena som en array.
Konvertera arrayen till en NumPy ndarray för bearbetning.

Följande Python-kod visar hur man konverterar en rad i ett Excel-ark till en NumPy ndarray:

import aspose.cells as cells
import numpy as np

# Ladda Excel-fil
workbook = cells.Workbook("sample_data.xlsx")
sheet = workbook.worksheets.get(0)
sheet_cells = sheet.cells

max_col = sheet_cells.max_data_column + 1

# välj en rad (t.ex. sista dataraden)
row_index = sheet_cells.max_data_row
row_vals = []
for c in range(max_col):
    cell = sheet_cells.check_cell(row_index, c)
    row_vals.append(cell.value if cell else "")

row_array = np.asarray(row_vals, dtype=object)
print(row_array)

Den resulterande NumPy ndarray kommer att vara en endimensionell array som innehåller alla värden från den valda raden.

['Detroit' 'Central' 3074]

Konvertera en kolumn i Excel till NumPy

I vissa fall kan du bara behöva värden från en enda kolumn i ett Excel-blad. Aspose.Cells låter dig exportera en kolumn enkelt och omvandla den till en NumPy ndarray.

Ladda Excel-arbetsboken.
Välj målarbetsbladet.
Välj kolumnindex för att exportera.
Exportera kolumnvärdena.
Konvertera värdena till en NumPy ndarray.

Följande Python-kod visar hur man konverterar en kolumn i ett Excel-ark till NumPy ndarray:

import aspose.cells as cells
import numpy as np

# Ladda Excel-fil
workbook = cells.Workbook("D:\\Files\\sample_data.xlsx")
sheet = workbook.worksheets.get(0)
sheet_cells = sheet.cells
max_row = sheet_cells.max_data_row + 1

# välj en kolumn (t.ex. sista datakolumnen)
col_index = sheet_cells.max_data_column
col_vals = []
for r in range(max_row):
    cell = sheet_cells.check_cell(r, col_index)
    col_vals.append(cell.value if cell else "")

column_array = np.asarray(col_vals, dtype=object)
print(column_array)

Den resulterande NumPy ndarray kommer att vara en endimensionell array som innehåller alla värden från den valda kolumnen.

['Store' 3055 3036 3074]

Tips för att arbeta med Aspose.Cells och NumPy

Minnesöverväganden: Att konvertera mycket stora arbetsböcker till NumPy-arrayer kan konsumera betydande minne. Bearbeta arbetsblad individuellt eller läs specifika områden om möjligt.
Datatyper: Om ditt kalkylblad innehåller blandade typer (strängar, nummer, datum), ange dtype=object när du konverterar listor till NumPy-arrayer. För homogena numeriska data kan du låta NumPy härleda typen.
Missing values: Aspose.Cells returnerar None för tomma celler. I exemplen ovan ersatte vi dem med tomma strängar. Du kan också ersätta med np.nan eller ett annat sentinelvärde beroende på din användning.

Skaffa en gratis licens

Vill du utforska den fulla kraften av Aspose.Cells för Python? Du kan begära en gratis tillfällig licens.Detta gör att du kan testa alla funktioner utan begränsningar eller utvärderingsvattenmärken.

Med ett tillfälligt körkort kan du:

Arbeta med stora Excel-filer.
Apply advanced formatting and styling.
Utför konverteringar (t.ex. Excel till PDF, NumPy och mer).

Det är det bästa sättet att utvärdera prestanda och kompatibilitet med dina projekt innan du fattar ett köpbeslut.

Användbara resurser

Här är några värdefulla resurser för att hjälpa dig att komma igång med Aspose.Cells för Python via .NET:

Slutsats

Aspose.Cells för Python via .NET förenklar konverteringen av Excel-data till NumPy-arrayer. Oavsett om du behöver hela arbetsboken, ett enda blad, ett specifikt intervall, en tabell, en rad eller en kolumn, erbjuder biblioteket tydliga metoder för att iterera genom celler och bygga listor som NumPy kan använda. Genom att kombinera Aspose.Cells förmåga att läsa många kalkylbladsformat med NumPys numeriska kraft kan du integrera Excel-data sömlöst i dina Python-datapipelines.

Om du har några frågor, tveka inte att fråga på vårt free support forum, och vi kommer att vara glada att hjälpa till.

Varför NumPy?#

What is Aspose.Cells for Python?#

Hur man konverterar Excel-arbetsbok till NumPy#

Konvertera ett enskilt arbetsblad till NumPy#

Hur man konverterar ett intervall av Excel till NumPy#

Konvertera en Excel-tabell (ListObject) till NumPy#

Hur man konverterar en rad i Excel till NumPy#

Konvertera en kolumn i Excel till NumPy#

Tips för att arbeta med Aspose.Cells och NumPy#

Skaffa en gratis licens#

Användbara resurser#

Slutsats#

Se även#