Mam DataFramez pand:

import pandas as pd
inp = [{'c1':10, 'c2':100}, {'c1':11,'c2':110}, {'c1':12,'c2':120}]
df = pd.DataFrame(inp)
print df

Wynik:

   c1   c2
0  10  100
1  11  110
2  12  120

Teraz chcę iterować po wierszach tej ramki. Dla każdego wiersza chcę mieć dostęp do jego elementów (wartości w komórkach) według nazw kolumn. Na przykład:

for row in df.rows:
   print row['c1'], row['c2']

Czy można to zrobić w pandach?

Znalazłem podobne pytanie . Ale nie daje mi odpowiedzi, której potrzebuję. Na przykład zaleca się użycie:

for date, row in df.T.iteritems():

lub

for row in df.iterrows():

Ale nie rozumiem, czym rowjest przedmiot i jak mogę z nim pracować.

DataFrame.iterrows to generator generujący zarówno indeks, jak i wiersz

import pandas as pd
import numpy as np

df = pd.DataFrame([{'c1':10, 'c2':100}, {'c1':11,'c2':110}, {'c1':12,'c2':120}])

for index, row in df.iterrows():
    print(row['c1'], row['c2'])

Output: 
   10 100
   11 110
   12 120

Jak iterować po wierszach DataFrame w Pandach?

Odpowiedź: NIE ^* !

Iteracja w pandach jest anty-wzorem i jest czymś, co powinieneś zrobić tylko wtedy, gdy wyczerpiesz każdą inną opcję. Nie powinieneś używać żadnej funkcji z „ iter” w jej nazwie dla więcej niż kilku tysięcy wierszy, w przeciwnym razie będziesz musiał przyzwyczaić się do długiego oczekiwania.

Czy chcesz wydrukować ramkę danych? Zastosowanie DataFrame.to_string().

Chcesz coś obliczyć? W takim przypadku wyszukaj metody w tej kolejności (lista zmodyfikowana tutaj ):

1. Wektoryzacja
2. Procedury cytonowe
3. Zrozumienie listy ( forpętla waniliowa )
4. DataFrame.apply(): i) Redukcje, które można wykonać w cytonie, ii) Iteracja w przestrzeni pytona
5. DataFrame.itertuples() i iteritems()
6. DataFrame.iterrows()

iterrowsi itertuples(oba otrzymujące wiele głosów w odpowiedziach na to pytanie) powinny być używane w bardzo rzadkich okolicznościach, takich jak generowanie obiektów wierszy / imion do przetwarzania sekwencyjnego, co jest naprawdę jedyną rzeczą, do której te funkcje są przydatne.

Apel do organu
Na stronie z dokumentami na iteracji znajduje się ogromne czerwone pole ostrzegawcze z napisem:

Iteracja po obiektach pand jest zwykle powolna. W wielu przypadkach ręczne iterowanie po wierszach nie jest potrzebne [...].

_{* To jest trochę bardziej skomplikowane niż „nie”. df.iterrows()jest poprawną odpowiedzią na to pytanie, ale „wektoryzacja operacji” jest lepsza. Przyznaję, że istnieją okoliczności, w których nie można uniknąć iteracji (na przykład niektóre operacje, w których wynik zależy od wartości obliczonej dla poprzedniego wiersza). Jednak potrzeba pewnej znajomości biblioteki, aby wiedzieć, kiedy. Jeśli nie masz pewności, czy potrzebujesz rozwiązania iteracyjnego, prawdopodobnie nie. PS: Aby dowiedzieć się więcej o moim uzasadnieniu napisania tej odpowiedzi, przejdź na sam dół.}

Szybszy niż zapętlenie : wektoryzacja , cython

Wiele podstawowych operacji i obliczeń jest „wektoryzowanych” przez pandy (za pomocą NumPy lub funkcji cytonizowanych). Obejmuje to operacje arytmetyczne, porównania, (większość) redukcji, przekształcanie (takie jak przestawianie), łączenia i operacje grupowania. Przejrzyj dokumentację Essential Basic Functionality, aby znaleźć odpowiednią metodę wektorową dla twojego problemu.

Jeśli nie istnieje, możesz napisać własny przy użyciu niestandardowych rozszerzeń cytonów .

Następna najlepsza rzecz: lista zrozumień ^*

Wyjaśnienia list powinny być Twoim następnym portem wywoławczym, jeśli 1) nie ma dostępnego rozwiązania wektorowego, 2) wydajność jest ważna, ale niewystarczająco ważna, aby przejść przez kłopot związany z cytonizacją kodu, i 3) próbujesz przeprowadzić transformację elementarną na twoim kodzie. Istnieje wiele dowodów na to, że zrozumienie listy jest wystarczająco szybkie (a czasem nawet szybsze) do wielu typowych zadań pand.

Formuła jest prosta,

# iterating over one column - `f` is some function that processes your data
result = [f(x) for x in df['col']]
# iterating over two columns, use `zip`
result = [f(x, y) for x, y in zip(df['col1'], df['col2'])]
# iterating over multiple columns - same data type
result = [f(row[0], ..., row[n]) for row in df[['col1', ...,'coln']].to_numpy()]
# iterating over multiple columns - differing data type
result = [f(row[0], ..., row[n]) for row in zip(df['col1'], ..., df['coln'])]

Jeśli umiesz zawrzeć logikę biznesową w funkcji, możesz skorzystać ze spisu, który ją wywołuje. Możesz sprawić, by dowolnie złożone rzeczy działały dzięki prostocie i szybkości surowego pytona.

Wyjaśnienia dotyczące
listy zastrzeżeń zakładają, że dane są łatwe w obsłudze - oznacza to, że typy danych są spójne i nie masz NaN, ale nie zawsze można to zagwarantować.

1. Pierwsza jest bardziej oczywista, ale w przypadku NaN preferuj wbudowane metody pand, jeśli istnieją (ponieważ mają znacznie lepszą logikę obsługi przypadków narożnych) lub upewnij się, że logika biznesowa zawiera odpowiednią logikę obsługi NaN.
2. W przypadku mieszanych typów danych należy iterować zip(df['A'], df['B'], ...)zamiast, df[['A', 'B']].to_numpy()ponieważ ten drugi domyślnie upcastuje dane do najbardziej powszechnego typu. Na przykład, jeśli A jest liczbą, a B jest ciągiem, to_numpy()rzutuje całą tablicę na ciąg, co może nie być tym, czego chcesz. Na szczęście zippingowanie kolumn razem jest najprostszym obejściem tego problemu.

_{* YMMV z powodów przedstawionych w zastrzeżeń sekcji powyżej.}

Oczywisty przykład

Pokażmy różnicę na prostym przykładzie dodania dwóch kolumn pand A + B. Jest to operatyzowalna wektoryzacja, więc łatwo będzie skontrolować wydajność metod omówionych powyżej.

Kod porównawczy, w celach informacyjnych.

Powinienem jednak wspomnieć, że nie zawsze jest to tak cięte i suche. Czasami odpowiedź na „najlepszą metodę operacji” brzmi „zależy to od twoich danych”. Radzę przetestować różne podejścia do swoich danych, zanim zdecydujesz się na jedno.

Dalsza lektura

• 10 minut do pand i niezbędna podstawowa funkcjonalność - Przydatne linki, które przedstawiają pandy i bibliotekę wektorowych * / cytonizowanych funkcji.

• Zwiększanie wydajności - elementarz z dokumentacji na temat ulepszania standardowych operacji pand

• Czy pętle for w pandach są naprawdę złe? Kiedy powinno mnie to obchodzić? - szczegółowy opis przeze mnie opisów list i ich przydatności do różnych operacji (głównie tych obejmujących dane nienumeryczne)

• Kiedy powinienem kiedykolwiek chcieć użyć pandas apply () w moim kodzie? - applyjest wolny (ale nie tak wolny jak iter*rodzina. Są jednak sytuacje, w których można (lub należy) rozważyć applypoważną alternatywę, szczególnie w niektórych GroupByoperacjach).

_{* Metody łańcuchowe pand są „wektoryzowane” w tym sensie, że są określone w serii, ale działają na każdym elemencie. Mechanizmy leżące u ich podstaw są wciąż iteracyjne, ponieważ operacje łańcuchowe są z natury trudne do wektoryzacji.}

Dlaczego napisałem tę odpowiedź

Częstym trendem, który zauważam od nowych użytkowników, jest zadawanie pytań w formie „w jaki sposób mogę iterować nad moim df, aby zrobić X?”. Pokazuje kod, który wywołuje iterrows()podczas wykonywania czegoś w pętli for. Oto dlaczego. Nowy użytkownik biblioteki, który nie został zaznajomiony z koncepcją wektoryzacji, prawdopodobnie wyobrazi sobie kod, który rozwiązuje ich problem podczas iteracji danych, aby coś zrobić. Nie wiedząc, jak wykonać iterację w DataFrame, pierwszą rzeczą, którą robią, jest Google i kończy się tutaj, na to pytanie. Następnie widzą zaakceptowaną odpowiedź, mówiąc im, jak to zrobić, i zamykają oczy i uruchamiają ten kod, nie pytając nigdy, czy iteracja nie jest właściwa.

Ta odpowiedź ma na celu pomóc nowym użytkownikom zrozumieć, że iteracja niekoniecznie jest rozwiązaniem każdego problemu oraz że mogą istnieć lepsze, szybsze i bardziej idiomatyczne rozwiązania oraz że warto poświęcić czas na ich zbadanie. Nie próbuję rozpocząć wojny iteracji z wektoryzacją, ale chcę, aby nowi użytkownicy byli informowani podczas opracowywania rozwiązań ich problemów z tą biblioteką.

Najpierw zastanów się, czy naprawdę musisz iterować wiersze w ramce danych. Zobacz tę odpowiedź, aby znaleźć alternatywy.

Jeśli nadal musisz wykonywać iterację po wierszach, możesz użyć poniższych metod. Zwróć uwagę na kilka ważnych zastrzeżeń, które nie zostały wymienione w żadnej z pozostałych odpowiedzi.

• DataFrame.iterrows ()

  for index, row in df.iterrows():
      print(row["c1"], row["c2"])

• DataFrame.itertuples ()

  for row in df.itertuples(index=True, name='Pandas'):
      print(row.c1, row.c2)

itertuples() ma być szybszy niż iterrows()

Ale uważaj, zgodnie z dokumentami (w tej chwili pandy 0.24.2):

• iterrows: dtypemoże nie pasować między wierszami

  Ponieważ iterrows zwraca serię dla każdego wiersza, nie zachowuje dtypów w wierszach (dtypy są zachowywane w kolumnach dla DataFrames). Aby zachować dtypy podczas iteracji po wierszach, lepiej jest użyć itertuples (), która zwraca nazwane wartości i która jest generalnie znacznie szybsza niż iterrows ()

• iterrows: Nie modyfikuj wierszy

  Nigdy nie powinieneś modyfikować czegoś, nad czym się iteruje. Nie gwarantuje się, że zadziała we wszystkich przypadkach. W zależności od typów danych iterator zwraca kopię, a nie widok, a zapis do niej nie przyniesie żadnego efektu.

  Zamiast tego użyj DataFrame.apply () :

  new_df = df.apply(lambda x: x * 2)

• itertule:

  Nazwy kolumn zostaną przemianowane na nazwy pozycyjne, jeśli są niepoprawnymi identyfikatorami Pythona, powtórzone lub zaczynają się od podkreślenia. Przy dużej liczbie kolumn (> 255) zwracane są regularne krotki.

Zobacz dokumentację pandy na temat iteracji, aby uzyskać więcej informacji.

Powinieneś użyć df.iterrows(). Chociaż iteracja rząd po rzędzie nie jest szczególnie wydajna, ponieważ Seriesobiekty muszą być tworzone.

Chociaż iterrows()jest to dobra opcja, czasami itertuples()może być znacznie szybsza:

df = pd.DataFrame({'a': randn(1000), 'b': randn(1000),'N': randint(100, 1000, (1000)), 'x': 'x'})

%timeit [row.a * 2 for idx, row in df.iterrows()]
# => 10 loops, best of 3: 50.3 ms per loop

%timeit [row[1] * 2 for row in df.itertuples()]
# => 1000 loops, best of 3: 541 µs per loop

Możesz także użyć df.apply()do iteracji po wierszach i uzyskać dostęp do wielu kolumn dla funkcji.

docs: DataFrame.apply ()

def valuation_formula(x, y):
    return x * y * 0.5

df['price'] = df.apply(lambda row: valuation_formula(row['x'], row['y']), axis=1)

Możesz użyć funkcji df.iloc w następujący sposób:

for i in range(0, len(df)):
    print df.iloc[i]['c1'], df.iloc[i]['c2']

Szukałem sposobu iteracji w wierszach ORAZ kolumnach i zakończyłem tutaj tak:

for i, row in df.iterrows():
    for j, column in row.iteritems():
        print(column)

Możesz napisać własny iterator, który implementuje namedtuple

from collections import namedtuple

def myiter(d, cols=None):
    if cols is None:
        v = d.values.tolist()
        cols = d.columns.values.tolist()
    else:
        j = [d.columns.get_loc(c) for c in cols]
        v = d.values[:, j].tolist()

    n = namedtuple('MyTuple', cols)

    for line in iter(v):
        yield n(*line)

Jest to bezpośrednio porównywalne z pd.DataFrame.itertuples. Chcę wykonać to samo zadanie z większą wydajnością.

Dla podanej ramki danych z moją funkcją:

list(myiter(df))

[MyTuple(c1=10, c2=100), MyTuple(c1=11, c2=110), MyTuple(c1=12, c2=120)]

Lub z pd.DataFrame.itertuples:

list(df.itertuples(index=False))

[Pandas(c1=10, c2=100), Pandas(c1=11, c2=110), Pandas(c1=12, c2=120)]

Kompleksowy test
Testujemy udostępnianie wszystkich kolumn i ich podział.

def iterfullA(d):
    return list(myiter(d))

def iterfullB(d):
    return list(d.itertuples(index=False))

def itersubA(d):
    return list(myiter(d, ['col3', 'col4', 'col5', 'col6', 'col7']))

def itersubB(d):
    return list(d[['col3', 'col4', 'col5', 'col6', 'col7']].itertuples(index=False))

res = pd.DataFrame(
    index=[10, 30, 100, 300, 1000, 3000, 10000, 30000],
    columns='iterfullA iterfullB itersubA itersubB'.split(),
    dtype=float
)

for i in res.index:
    d = pd.DataFrame(np.random.randint(10, size=(i, 10))).add_prefix('col')
    for j in res.columns:
        stmt = '{}(d)'.format(j)
        setp = 'from __main__ import d, {}'.format(j)
        res.at[i, j] = timeit(stmt, setp, number=100)

res.groupby(res.columns.str[4:-1], axis=1).plot(loglog=True);

Jak skutecznie iterować?

Jeśli naprawdę musisz iterować ramkę danych pand, prawdopodobnie będziesz chciał uniknąć używania iterrows () . Istnieją różne metody i zwykle iterrows()daleki jest od bycia najlepszym. itertuples () może być 100 razy szybszy.

W skrócie:

• Zasadniczo używaj df.itertuples(name=None). W szczególności, gdy masz stałą liczbę kolumn i mniej niż 255 kolumn. Patrz punkt (3)
• W przeciwnym razie użyj, df.itertuples()chyba że kolumny zawierają znaki specjalne, takie jak spacje lub „-”. Punkt 2
• Można użyć, itertuples()nawet jeśli twoja ramka danych ma dziwne kolumny, używając ostatniego przykładu. Patrz punkt (4)
• Używaj tylko iterrows()wtedy, gdy nie możesz poprzednich rozwiązań. Zobacz punkt (1)

Różne metody iteracji po wierszach w ramce danych pandy:

Wygeneruj losową ramkę danych z milionem wierszy i 4 kolumnami:

    df = pd.DataFrame(np.random.randint(0, 100, size=(1000000, 4)), columns=list('ABCD'))
    print(df)

1) Zwykle iterrows()jest wygodne, ale cholernie wolne:

start_time = time.clock()
result = 0
for _, row in df.iterrows():
    result += max(row['B'], row['C'])

total_elapsed_time = round(time.clock() - start_time, 2)
print("1. Iterrows done in {} seconds, result = {}".format(total_elapsed_time, result))

2) Wartość domyślna itertuples()jest już znacznie szybsza, ale nie działa z nazwami kolumn, takimi jak My Col-Name is very Strange(należy unikać tej metody, jeśli kolumny są powtarzane lub jeśli nazwy kolumny nie można po prostu przekonwertować na nazwę zmiennej python):

start_time = time.clock()
result = 0
for row in df.itertuples(index=False):
    result += max(row.B, row.C)

total_elapsed_time = round(time.clock() - start_time, 2)
print("2. Named Itertuples done in {} seconds, result = {}".format(total_elapsed_time, result))

3) Domyślne itertuples()użycie name = None jest jeszcze szybsze, ale nie bardzo wygodne, ponieważ musisz zdefiniować zmienną dla kolumny.

start_time = time.clock()
result = 0
for(_, col1, col2, col3, col4) in df.itertuples(name=None):
    result += max(col2, col3)

total_elapsed_time = round(time.clock() - start_time, 2)
print("3. Itertuples done in {} seconds, result = {}".format(total_elapsed_time, result))

4) Wreszcie, nazwany itertuples()jest wolniejszy niż poprzedni punkt, ale nie musisz definiować zmiennej dla kolumny i działa z nazwami kolumn, takimi jak My Col-Name is very Strange.

start_time = time.clock()
result = 0
for row in df.itertuples(index=False):
    result += max(row[df.columns.get_loc('B')], row[df.columns.get_loc('C')])

total_elapsed_time = round(time.clock() - start_time, 2)
print("4. Polyvalent Itertuples working even with special characters in the column name done in {} seconds, result = {}".format(total_elapsed_time, result))

Wynik:

         A   B   C   D
0       41  63  42  23
1       54   9  24  65
2       15  34  10   9
3       39  94  82  97
4        4  88  79  54
...     ..  ..  ..  ..
999995  48  27   4  25
999996  16  51  34  28
999997   1  39  61  14
999998  66  51  27  70
999999  51  53  47  99

[1000000 rows x 4 columns]

1. Iterrows done in 104.96 seconds, result = 66151519
2. Named Itertuples done in 1.26 seconds, result = 66151519
3. Itertuples done in 0.94 seconds, result = 66151519
4. Polyvalent Itertuples working even with special characters in the column name done in 2.94 seconds, result = 66151519

Ten artykuł jest bardzo interesującym porównaniem iteracji i itertu

Aby zapętlić wszystkie wiersze dataframe, możesz użyć:

for x in range(len(date_example.index)):
    print date_example['Date'].iloc[x]

 for ind in df.index:
     print df['c1'][ind], df['c2'][ind]

Czasami przydatnym wzorem jest:

# Borrowing @KutalmisB df example
df = pd.DataFrame({'col1': [1, 2], 'col2': [0.1, 0.2]}, index=['a', 'b'])
# The to_dict call results in a list of dicts
# where each row_dict is a dictionary with k:v pairs of columns:value for that row
for row_dict in df.to_dict(orient='records'):
    print(row_dict)

Co skutkuje w:

{'col1':1.0, 'col2':0.1}
{'col1':2.0, 'col2':0.2}

Aby zapętlić wszystkie wiersze dataframeai wygodnie użyć wartości każdego wiersza , można przekonwertować je na s. Na przykład:namedtuplesndarray

df = pd.DataFrame({'col1': [1, 2], 'col2': [0.1, 0.2]}, index=['a', 'b'])

Iterowanie po wierszach:

for row in df.itertuples(index=False, name='Pandas'):
    print np.asarray(row)

prowadzi do:

[ 1.   0.1]
[ 2.   0.2]

Należy pamiętać, że jeśli index=True, indeks jest dodany jako pierwszy element krotki , co może być niekorzystne dla niektórych aplikacji.

Istnieje sposób na iterację rzutów wierszy podczas uzyskiwania w zamian DataFrame, a nie serii. Nie widzę nikogo wspominającego, że można przekazać indeks jako listę dla wiersza, który ma zostać zwrócony jako DataFrame:

for i in range(len(df)):
    row = df.iloc[[i]]

Zwróć uwagę na użycie podwójnych nawiasów. Zwraca DataFrame z pojedynczym wierszem.

Użyłbym zarówno do przeglądania, jak i modyfikowania wartości iterrows(). W pętli for i przy użyciu rozpakowywania krotek (patrz przykład i, row:) używam rowtylko do przeglądania wartości i używam iz locmetodą, gdy chcę zmodyfikować wartości. Jak stwierdzono w poprzednich odpowiedziach, tutaj nie powinieneś modyfikować czegoś, nad czym się iterujesz.

for i, row in df.iterrows():
    df_column_A = df.loc[i, 'A']
    if df_column_A == 'Old_Value':
        df_column_A = 'New_value'  

Tutaj rowpętla jest kopią tego wiersza, a nie jego widokiem. Dlatego NIE powinieneś pisać czegoś takiego row['A'] = 'New_Value', nie spowoduje to modyfikacji DataFrame. Możesz jednak użyć ii locokreślić DataFrame do wykonania pracy.

Wiem, że spóźniłem się na przyjęcie, ale chciałem tylko dodać powyższą odpowiedź @ cs95, która moim zdaniem powinna być odpowiedzią przyjętą. W swojej odpowiedzi pokazuje, że wektoryzacja pand znacznie przewyższa inne metody obliczania pand przy użyciu ramek danych.

Chciałem dodać, że jeśli najpierw przekonwertujesz ramkę danych na tablicę numpy, a następnie użyjesz wektoryzacji, będzie to nawet szybsze niż wektoryzacja ramki danych pandy (i obejmuje to czas, aby ponownie przekształcić ją w serię ramek danych).

Jeśli dodasz następujące funkcje do kodu testu porównawczego @ cs95, stanie się to dość oczywiste:

def np_vectorization(df):
    np_arr = df.to_numpy()
    return pd.Series(np_arr[:,0] + np_arr[:,1], index=df.index)

def just_np_vectorization(df):
    np_arr = df.to_numpy()
    return np_arr[:,0] + np_arr[:,1]

Możesz także wykonać numpyindeksowanie, aby uzyskać jeszcze większe przyspieszenia. To nie jest tak naprawdę iteracja, ale działa znacznie lepiej niż iteracja dla niektórych aplikacji.

subset = row['c1'][0:5]
all = row['c1'][:]

Możesz także rzucić go na tablicę. Te indeksy / selekcje powinny już działać jak tablice Numpy, ale napotkałem problemy i musiałem przesyłać

np.asarray(all)
imgs[:] = cv2.resize(imgs[:], (224,224) ) #resize every image in an hdf5 file

Jest tak wiele sposobów na iterację wierszy w ramce danych pand. Jednym z bardzo prostych i intuicyjnych sposobów jest:

df=pd.DataFrame({'A':[1,2,3], 'B':[4,5,6],'C':[7,8,9]})
print(df)
for i in range(df.shape[0]):
    # For printing the second column
    print(df.iloc[i,1])
    # For printing more than one columns
    print(df.iloc[i,[0,2]])

W tym przykładzie użyto programu iloc do wyodrębnienia każdej cyfry w ramce danych.

import pandas as pd

 a = [1, 2, 3, 4]
 b = [5, 6, 7, 8]

 mjr = pd.DataFrame({'a':a, 'b':b})

 size = mjr.shape

 for i in range(size[0]):
     for j in range(size[1]):
         print(mjr.iloc[i, j])

Niektóre biblioteki (np. Używana przeze mnie biblioteka międzyoperacyjna Java) wymagają przekazywania wartości w jednym rzędzie, na przykład w przypadku przesyłania strumieniowego danych. Aby odtworzyć naturę przesyłania strumieniowego, „przesyłam strumieniowo” moje wartości ramek danych jedna po drugiej, napisałem poniżej, co jest przydatne od czasu do czasu.

class DataFrameReader:
  def __init__(self, df):
    self._df = df
    self._row = None
    self._columns = df.columns.tolist()
    self.reset()
    self.row_index = 0

  def __getattr__(self, key):
    return self.__getitem__(key)

  def read(self) -> bool:
    self._row = next(self._iterator, None)
    self.row_index += 1
    return self._row is not None

  def columns(self):
    return self._columns

  def reset(self) -> None:
    self._iterator = self._df.itertuples()

  def get_index(self):
    return self._row[0]

  def index(self):
    return self._row[0]

  def to_dict(self, columns: List[str] = None):
    return self.row(columns=columns)

  def tolist(self, cols) -> List[object]:
    return [self.__getitem__(c) for c in cols]

  def row(self, columns: List[str] = None) -> Dict[str, object]:
    cols = set(self._columns if columns is None else columns)
    return {c : self.__getitem__(c) for c in self._columns if c in cols}

  def __getitem__(self, key) -> object:
    # the df index of the row is at index 0
    try:
        if type(key) is list:
            ix = [self._columns.index(key) + 1 for k in key]
        else:
            ix = self._columns.index(key) + 1
        return self._row[ix]
    except BaseException as e:
        return None

  def __next__(self) -> 'DataFrameReader':
    if self.read():
        return self
    else:
        raise StopIteration

  def __iter__(self) -> 'DataFrameReader':
    return self

Które mogą być użyte:

for row in DataFrameReader(df):
  print(row.my_column_name)
  print(row.to_dict())
  print(row['my_column_name'])
  print(row.tolist())

I zachowuje mapowanie wartości / nazw dla iterowanych wierszy. Oczywiście jest o wiele wolniejszy niż stosowanie aplikacji i Cython, jak wskazano powyżej, ale w niektórych okolicznościach jest konieczne.

W skrócie

• Jeśli to możliwe, użyj wektoryzacji
• Jeśli operacja nie może być wektoryzowana - użyj wyrażeń listowych
• Jeśli potrzebujesz jednego obiektu reprezentującego cały wiersz - użyj itertu
• Jeśli powyższe jest zbyt wolne - spróbuj swifter.apply
• Jeśli nadal jest zbyt wolny - wypróbuj procedurę Cython

Szczegóły w tym filmie

Reper