Сначала подумайте, действительно ли вам нужно перебирать строки в DataFrame. Альтернативы см. В этом ответе.

Если вам все еще нужно перебирать строки, вы можете использовать методы, указанные ниже. Обратите внимание на некоторые важные предостережения, которые не упоминаются ни в одном из других ответов.

• 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() должен быть быстрее, чем iterrows()

Но имейте в виду, согласно документации (на данный момент pandas 0.24.2):

• # P7 #

  # P8 #

• # P9 #

  # P10 #

  # P11 #

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

• # P12 #

  # P13 #

Дополнительные сведения см. В документации pandas по итерации.

Вам следует использовать df.iterrows(). Хотя итерация строка за строкой не особенно эффективна, поскольку необходимо создавать Series объектов.

Хотя iterrows() - хороший вариант, иногда itertuples() может быть намного быстрее:

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

Вы также можете использовать df.apply() для перебора строк и доступа к нескольким столбцам для функции.

документы: 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)

Вы можете использовать функцию df.iloc следующим образом:

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

Как эффективно выполнять итерацию

Если вам действительно нужно выполнить итерацию фрейма данных Pandas, вы, вероятно, захотите избежать использования iterrows (). Есть разные методы, и обычный iterrows() далеко не лучший. itertuples () может работать в 100 раз быстрее.

Короче:

• Как правило, используйте df.itertuples(name=None). В частности, когда у вас есть фиксированное количество столбцов и меньше 255 столбцов. См. пункт (3)
• В противном случае используйте df.itertuples(), кроме случаев, когда в ваших столбцах есть специальные символы, такие как пробелы или '-'. См. пункт (2)
• Можно использовать itertuples(), даже если в вашем фрейме данных есть странные столбцы, используя последний пример. См. пункт (4)
• Используйте iterrows() только в том случае, если вы не можете использовать предыдущие решения. См. пункт (1)

Различные методы перебора строк в кадре данных Pandas:

Создайте случайный фрейм данных с миллионом строк и 4 столбцами:

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

1) Обычный iterrows() удобно, но чертовски медленно:

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) Значение по умолчанию itertuples() уже намного быстрее, но оно не работает с именами столбцов, такими как My Col-Name is very Strange (вам следует избегать этого метода, если ваши столбцы повторяются или если имя столбца не может быть просто преобразовано в имя переменной 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) Значение по умолчанию itertuples() с использованием name = None даже быстрее, но не очень удобно, поскольку вам нужно определять переменную для каждого столбца.

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) Наконец, именованный itertuples() медленнее, чем предыдущий пункт, но вам не нужно определять переменную для каждого столбца, и он работает с именами столбцов, такими как 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))

Выход:

         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

Эта статья представляет собой очень интересное сравнение iterrows и iterrows

Я искал Как перебирать строки и столбцы и закончил вот так:

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

Вы можете написать свой собственный итератор, реализующий 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)

Это напрямую сопоставимо с pd.DataFrame.itertuples. Я стремлюсь выполнять ту же задачу с большей эффективностью.

Для данного фрейма данных с моей функцией:

list(myiter(df))

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

Или с pd.DataFrame.itertuples:

list(df.itertuples(index=False))

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

Комплексный тест
Мы тестируем доступность всех столбцов и подмножество столбцов.

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);

Чтобы зациклить все строки в dataframe, вы можете использовать:

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

Иногда полезный паттерн:

# 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)

Что приводит к:

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

Чтобы зациклить все строки в dataframe и использовать значения каждой строки, удобно, namedtuples можно преобразовать в ndarrays. Например:

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

Итерации по строкам:

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

приводит к:

[ 1.   0.1]
[ 2.   0.2]

Обратите внимание, что если index=True, индекс добавляется как первый элемент кортежа, что может быть нежелательно для некоторых приложений.

И для просмотра, и для изменения значений я бы использовал iterrows(). В цикле for и с использованием распаковки кортежей (см. Пример: i, row) я использую row только для просмотра значения и использую i с методом loc, когда я хочу изменить значения. Как указано в предыдущих ответах, здесь вам не следует изменять то, что вы повторяете.

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

Здесь row в цикле - это копия этой строки, а не ее представление. Следовательно, вам НЕ следует писать что-то вроде row['A'] = 'New_Value', это не изменит DataFrame. Однако вы можете использовать i и loc и указать DataFrame для выполнения работы.

Суммируя

• Если возможно, используйте векторизацию
• Если операция не может быть векторизована - используйте составные части списка.
• Если вам нужен один объект, представляющий всю строку - используйте itertuples
• Если это слишком медленно, попробуйте swifter.apply.
• Если он по-прежнему слишком медленный, попробуйте процедуру Cython.

Контрольный показатель

Есть способ перебрать строки throw, получая взамен DataFrame, а не Series. Я не вижу, чтобы кто-нибудь упоминал, что вы можете передать index как список для строки, которая должна быть возвращена как DataFrame:

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

Обратите внимание на использование двойных скобок. Это возвращает DataFrame с одной строкой.

cs95 показывает, что Pandas векторизация намного превосходит другие методы Pandas для вычислений с фреймами данных.

Я хотел добавить, что если вы сначала конвертируете фрейм данных в массив NumPy, а затем используете векторизацию, это даже быстрее, чем векторизация фрейма данных Pandas (и это включает время, чтобы превратить его обратно в серию фреймов данных).

Если вы добавите следующие функции в тестовый код cs95, это станет довольно очевидным:

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]

Есть так много способов перебирать строки в фрейме данных Pandas. Один очень простой и интуитивно понятный способ:

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]])

Самый простой способ - использовать функцию apply

def print_row(row):
   print row['c1'], row['c2']

df.apply(lambda row: print_row(row), axis=1)

Вы также можете выполнить индексацию NumPy для еще большего ускорения. Это не совсем итерация, но работает намного лучше, чем итерация для определенных приложений.

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

Вы также можете преобразовать его в массив. Предполагается, что эти индексы / выборки уже действуют как массивы NumPy, но у меня возникли проблемы, и мне нужно было использовать

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

В этом примере iloc используется для выделения каждой цифры во фрейме данных.

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])

Некоторые библиотеки (например, библиотека взаимодействия Java, которую я использую) требуют, чтобы значения передавались по очереди, например, при потоковой передаче данных. Чтобы воспроизвести природу потоковой передачи, я «транслирую» свои значения фрейма данных одно за другим, я написал ниже, что время от времени может пригодиться.

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

Что можно использовать:

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

И сохраняет сопоставление значений / имен для повторяемых строк. Очевидно, это намного медленнее, чем использование apply и Cython, как указано выше, но в некоторых случаях это необходимо.

Наряду с отличными ответами в этом посте я собираюсь предложить подход Разделяй и властвуй, я пишу этот ответ не для отмены других отличных ответов, а для их выполнения с помощью другого подхода, который эффективно работал для меня. . Он состоит из двух шагов splitting и merging фрейма данных pandas:

ПЛЮСЫ «Разделяй и властвуй»:

• Вам не нужно использовать векторизацию или какие-либо другие методы для преобразования типа вашего фрейма данных в другой тип.
• Вам не нужно цитонизировать свой код, что обычно требует от вас дополнительного времени.
• И iterrows(), и itertuples() в моем случае имели одинаковую производительность по всему фрейму данных
• В зависимости от вашего выбора нарезки index вы сможете экспоненциально ускорить итерацию. Чем выше index, тем быстрее будет ваш процесс итерации.

МИНУСЫ «Разделяй и властвуй»:

• Вы не должны зависеть в процессе итерации от одного и того же фрейма данных и другого среза. Это означает, что если вы хотите читать или писать из другого фрагмента, это может быть сложно сделать.

=================== Подход "разделяй и властвуй" =================

Шаг 1. Разделение / нарезка

На этом этапе мы собираемся разделить итерацию на весь фрейм данных. Подумайте, что вы собираетесь прочитать файл csv в pandas df, а затем перебрать его. На всякий случай у меня есть 5 000 000 записей, и я собираюсь разделить их на 100 000 записей.

ПРИМЕЧАНИЕ. Мне нужно повторить, как в другом анализе времени выполнения, описанном в других решениях на этой странице, количество записей имеет экспоненциальную долю времени выполнения при поиске в df. Вот результаты, основанные на тесте на моих данных:

Number of records | Iteration per second
========================================
100,000           | 500 it/s
500,000           | 200 it/s
1,000,000         | 50 it/s
5,000,000         | 20 it/s

Шаг 2. Объединение

Это будет простой шаг, просто объедините все записанные файлы csv в один фрейм данных и запишите его в более крупный файл csv.

Вот пример кода:

# Step 1 (Splitting/Slicing)
import pandas as pd
df_all = pd.read_csv('C:/KtV.csv')
df_index = 100000
df_len = len(df)
for i in range(df_len // df_index + 1):
    lower_bound = i * df_index 
    higher_bound = min(lower_bound + df_index, df_len)
    # splitting/slicing df (make sure to copy() otherwise it will be a view
    df = df_all[lower_bound:higher_bound].copy()
    '''
    write your iteration over the sliced df here
    using iterrows() or intertuples() or ...
    '''
    # writing into csv files
    df.to_csv('C:/KtV_prep_'+str(i)+'.csv')



# Step 2 (Merging)
filename='C:/KtV_prep_'
df = (pd.read_csv(f) for f in [filename+str(i)+'.csv' for i in range(ktv_len // ktv_index + 1)])
df_prep_all = pd.concat(df)
df_prep_all.to_csv('C:/KtV_prep_all.csv')

Ссылка:

Эффективный способ итерации над datafreame

Объедините файлы csv в один фрейм данных Pandas

Как многие ответы здесь правильно и четко указывают, вы обычно не должны пытаться зацикливаться в Pandas, а должны писать векторизованный код. Но остается вопрос, должны ли вы когда-либо писать циклы в Pandas, и если да, то как лучше всего использовать цикл в таких ситуациях.

Я считаю, что существует по крайней мере одна общая ситуация, когда циклы уместны: когда вам нужно вычислить некоторую функцию, которая зависит от значений в других строках несколько сложным образом. В этом случае код цикла часто проще, удобнее для чтения и меньше подвержен ошибкам, чем векторизованный код. Код цикла может быть даже быстрее.

Я попытаюсь показать это на примере. Предположим, вы хотите получить кумулятивную сумму столбца, но сбрасывать ее всякий раз, когда какой-либо другой столбец равен нулю:

import pandas as pd
import numpy as np

df = pd.DataFrame( { 'x':[1,2,3,4,5,6], 'y':[1,1,1,0,1,1]  } )

#   x  y  desired_result
#0  1  1               1
#1  2  1               3
#2  3  1               6
#3  4  0               4
#4  5  1               9
#5  6  1              15

Это хороший пример, в котором вы, безусловно, могли бы написать одну строку Pandas для достижения этой цели, хотя она не особенно удобочитаема, особенно если у вас еще нет опыта работы с Pandas:

df.groupby( (df.y==0).cumsum() )['x'].cumsum()

Это будет достаточно быстро для большинства ситуаций, хотя вы также можете написать более быстрый код, избегая groupby, но он, вероятно, будет еще менее читабельным.

Или что, если мы напишем это в виде цикла? С NumPy вы можете сделать что-то вроде следующего:

import numba as nb

@nb.jit(nopython=True)  # Optional
def custom_sum(x,y):
    x_sum = x.copy()
    for i in range(1,len(df)):
        if y[i] > 0: x_sum[i] = x_sum[i-1] + x[i]
    return x_sum

df['desired_result'] = custom_sum( df.x.to_numpy(), df.y.to_numpy() )

По общему признанию, там есть небольшие накладные расходы, необходимые для преобразования столбцов DataFrame в массивы NumPy, но основной фрагмент кода - это всего лишь одна строка кода, которую вы могли бы прочитать, даже если вы ничего не знали о Pandas или NumPy:

if y[i] > 0: x_sum[i] = x_sum[i-1] + x[i]

И этот код на самом деле быстрее, чем векторизованный код. В некоторых быстрых тестах со 100 000 строк это примерно в 10 раз быстрее, чем подход groupby. Обратите внимание, что одним из ключей к скорости является numba, который не является обязательным. Без строки @ nb.jit код цикла на самом деле примерно в 10 раз медленнее, чем подход groupby.

Очевидно, что этот пример достаточно прост, и вы, вероятно, предпочтете одну строку панд написанию цикла со связанными с ним накладными расходами. Однако есть более сложные версии этой проблемы, для которых удобочитаемость или скорость подхода цикла NumPy / numba, вероятно, имеет смысл.

Используйте 1_. Например, используя dataframe 'rows_df':

Or

Чтобы получить значения из определенной строки, вы можете преобразовать фрейм данных в ndarray.

Затем выберите значения строки и столбца следующим образом:

Просто добавляю свои два цента,

Как говорится в принятом ответе, самый быстрый способ применить функцию к строкам - это использовать векторизованную функцию, так называемые numpy ufuncs (универсальные функции)

Но что делать, если функция, которую вы хотите применить, еще не реализована в numpy?

Хорошо, используя декоратор vectorize из numba, вы можете легко создавать ufuncs прямо в Python следующим образом:

from numba import vectorize, float64

@vectorize([float64(float64)])
def f(x):
    #x is your line, do something with it, and return a float

Документация по этой функции находится здесь: https://numba.pydata.org/numba-doc/latest/user/vectorize.html

df.iterrows () возвращает кортеж (a, b), где a - индекс, а b - строка.