Tôi có một DataFrametừ gấu trúc:

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

Đầu ra:

   c1   c2
0  10  100
1  11  110
2  12  120

Bây giờ tôi muốn lặp lại các hàng của khung này. Đối với mỗi hàng tôi muốn có thể truy cập các phần tử của nó (giá trị trong các ô) theo tên của các cột. Ví dụ:

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

Có thể làm điều đó trong gấu trúc?

Tôi tìm thấy câu hỏi tương tự này . Nhưng nó không cho tôi câu trả lời tôi cần. Ví dụ, nó được đề xuất sử dụng:

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

hoặc là

for row in df.iterrows():

Nhưng tôi không hiểu rowđối tượng là gì và làm thế nào tôi có thể làm việc với nó.

DataFrame.iterrows là một trình tạo mang lại cả chỉ mục và hàng

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

Làm cách nào để lặp lại qua các hàng trong DataFrame trong Pandas?

Trả lời: KHÔNG ^* !

Lặp lại trong gấu trúc là một mô hình chống, và là điều bạn chỉ nên làm khi bạn đã hết tất cả các lựa chọn khác. Bạn không nên sử dụng bất kỳ chức năng nào có " iter" trong tên của nó trong hơn một vài nghìn hàng hoặc bạn sẽ phải làm quen với rất nhiều sự chờ đợi.

Bạn có muốn in DataFrame không? Sử dụng DataFrame.to_string().

Bạn có muốn tính toán một cái gì đó? Trong trường hợp đó, tìm kiếm các phương thức theo thứ tự này (danh sách được sửa đổi từ đây ):

1. Vector hóa
2. Thói quen của Cython
3. Danh sách hiểu ( forvòng vanilla )
4. DataFrame.apply(): i) Việc giảm có thể được thực hiện trong cython, ii) Lặp lại trong không gian python
5. DataFrame.itertuples() và iteritems()
6. DataFrame.iterrows()

iterrowsvà itertuples(cả hai nhận được nhiều phiếu trong câu trả lời cho câu hỏi này) nên được sử dụng trong các trường hợp rất hiếm, chẳng hạn như tạo các đối tượng hàng / bảng tên để xử lý tuần tự, đây thực sự là điều duy nhất các hàm này hữu ích.

Khiếu nại với chính quyền
Trang tài liệu về Lặp lại có một hộp cảnh báo màu đỏ rất lớn có nội dung:

Lặp lại thông qua các đối tượng gấu trúc nói chung là chậm. Trong nhiều trường hợp, việc lặp lại thủ công qua các hàng là không cần thiết [...].

_{* Nó thực sự phức tạp hơn một chút so với "không". df.iterrows()là câu trả lời chính xác cho câu hỏi này, nhưng "vectorize ops của bạn" là câu trả lời tốt hơn. Tôi sẽ thừa nhận rằng có những trường hợp không thể tránh được việc lặp lại (ví dụ: một số thao tác trong đó kết quả phụ thuộc vào giá trị được tính cho hàng trước đó). Tuy nhiên, phải mất một số quen thuộc với thư viện để biết khi nào. Nếu bạn không chắc chắn liệu bạn có cần một giải pháp lặp đi lặp lại hay không, có lẽ bạn không nên. PS: Để biết thêm về lý do của tôi khi viết câu trả lời này, hãy bỏ qua đến tận cùng.}

Nhanh hơn Looping: Vectorization , Cython

Một số lượng lớn các hoạt động và tính toán cơ bản được "véc tơ" bởi gấu trúc (thông qua NumPy hoặc thông qua các hàm Cythonized). Điều này bao gồm số học, so sánh, giảm (hầu hết), định hình lại (chẳng hạn như xoay vòng), tham gia và hoạt động nhóm. Xem qua các tài liệu về Essential Basic Functionality để tìm ra một phương pháp vector hóa phù hợp cho vấn đề của bạn.

Nếu không tồn tại, vui lòng tự viết bằng các tiện ích mở rộng cython tùy chỉnh .

Điều tốt nhất tiếp theo: Danh sách toàn diện ^*

Việc hiểu danh sách sẽ là cổng gọi tiếp theo của bạn nếu 1) không có giải pháp véc tơ khả dụng, 2) hiệu suất rất quan trọng, nhưng không đủ quan trọng để vượt qua rắc rối của việc mã hóa mã của bạn và 3) bạn đang cố gắng thực hiện chuyển đổi theo yếu tố trên mã của bạn. Có một lượng bằng chứng tốt để đề xuất rằng việc hiểu danh sách là đủ nhanh (và thậm chí đôi khi nhanh hơn) cho nhiều nhiệm vụ gấu trúc thông thường.

Công thức rất đơn giản,

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

Nếu bạn có thể gói logic logic kinh doanh của mình vào một hàm, bạn có thể sử dụng một cách hiểu danh sách gọi nó. Bạn có thể làm cho những thứ phức tạp tùy ý hoạt động thông qua sự đơn giản và tốc độ của trăn thô.

Việc
hiểu danh sách Caveats cho rằng dữ liệu của bạn dễ làm việc - điều đó có nghĩa là loại dữ liệu của bạn nhất quán và bạn không có NaN, nhưng điều này không thể luôn được đảm bảo.

1. Cách thứ nhất thì rõ ràng hơn, nhưng khi giao dịch với NaN, hãy thích các phương pháp gấu trúc dựng sẵn nếu chúng tồn tại (vì chúng có logic xử lý tình huống góc tốt hơn nhiều) hoặc đảm bảo logic nghiệp vụ của bạn bao gồm logic xử lý NaN thích hợp.
2. Khi xử lý các loại dữ liệu hỗn hợp, bạn nên lặp đi lặp lại zip(df['A'], df['B'], ...)thay vì df[['A', 'B']].to_numpy()kiểu sau sẽ ngầm định dữ liệu thành loại phổ biến nhất. Ví dụ nếu A là số và B là chuỗi, to_numpy()sẽ truyền toàn bộ mảng thành chuỗi, đây có thể không phải là điều bạn muốn. May mắn là zipping các cột của bạn với nhau là cách giải quyết đơn giản nhất cho việc này.

_{* YMMV vì những lý do được nêu trong phần Caveats ở trên.}

Một ví dụ rõ ràng

Hãy chứng minh sự khác biệt bằng một ví dụ đơn giản về việc thêm hai cột gấu trúc A + B. Đây là một toán hạng có thể vector hóa, vì vậy nó sẽ dễ dàng tương phản hiệu suất của các phương pháp được thảo luận ở trên.

Mã điểm chuẩn, để bạn tham khảo.

Tôi nên đề cập, tuy nhiên, nó không phải lúc nào cũng bị cắt và khô. Đôi khi, câu trả lời cho "phương pháp tốt nhất cho hoạt động" là "nó phụ thuộc vào dữ liệu của bạn". Lời khuyên của tôi là thử nghiệm các cách tiếp cận khác nhau trên dữ liệu của bạn trước khi giải quyết một.

Đọc thêm

• 10 phút cho gấu trúc và Chức năng cơ bản thiết yếu - Các liên kết hữu ích giới thiệu cho bạn về gấu trúc và thư viện các hàm được mã hóa * / cythonized của nó.

• Tăng cường hiệu suất - Một mồi từ các tài liệu về tăng cường hoạt động của gấu trúc tiêu chuẩn

• Là vòng lặp for trong gấu trúc thực sự xấu? Khi nào tôi nên quan tâm? - một bài viết chi tiết của tôi về khả năng hiểu danh sách và sự phù hợp của chúng đối với các hoạt động khác nhau (chủ yếu là các hoạt động liên quan đến dữ liệu không phải là số)

• Khi nào tôi muốn sử dụng gấu trúc áp dụng () trong mã của mình? - applychậm (nhưng không chậm như iter*gia đình. Tuy nhiên, có những tình huống mà người ta có thể (hoặc nên) coi applylà một sự thay thế nghiêm trọng, đặc biệt là trong một số GroupByhoạt động).

_{* Các phương thức chuỗi Pandas được "vector hóa" theo nghĩa là chúng được chỉ định trên chuỗi nhưng hoạt động trên từng phần tử. Các cơ chế cơ bản vẫn còn lặp đi lặp lại, bởi vì các hoạt động chuỗi vốn đã khó để vector hóa.}

Tại sao tôi viết câu trả lời này

Một xu hướng phổ biến mà tôi nhận thấy từ những người dùng mới là đặt câu hỏi theo mẫu "làm thế nào tôi có thể lặp lại trên df của mình để làm X?". Hiển thị mã gọi iterrows()trong khi thực hiện một cái gì đó bên trong một vòng lặp for. Đây là lý do tại sao. Một người dùng mới vào thư viện chưa được giới thiệu về khái niệm vector hóa sẽ có khả năng hình dung mã giải quyết vấn đề của họ khi lặp lại dữ liệu của họ để làm gì đó. Không biết làm thế nào để lặp lại trên DataFrame, điều đầu tiên họ làm là Google nó và kết thúc ở đây, tại câu hỏi này. Sau đó, họ thấy câu trả lời được chấp nhận cho họ biết làm thế nào, và họ nhắm mắt lại và chạy mã này mà không bao giờ đặt câu hỏi đầu tiên nếu việc lặp lại không phải là điều đúng đắn.

Mục đích của câu trả lời này là giúp người dùng mới hiểu rằng lặp đi lặp lại không nhất thiết là giải pháp cho mọi vấn đề và các giải pháp tốt hơn, nhanh hơn và thành ngữ hơn có thể tồn tại và đáng để đầu tư thời gian để khám phá chúng. Tôi không cố bắt đầu cuộc chiến lặp lại so với vector hóa, nhưng tôi muốn người dùng mới được thông báo khi phát triển giải pháp cho các vấn đề của họ với thư viện này.

Trước tiên hãy xem xét nếu bạn thực sự cần lặp lại qua các hàng trong DataFrame. Xem câu trả lời này để thay thế.

Nếu bạn vẫn cần lặp lại qua các hàng, bạn có thể sử dụng các phương thức bên dưới. Lưu ý một số cảnh báo quan trọng không được đề cập trong bất kỳ câu trả lời nào khác.

• 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() được cho là nhanh hơn iterrows()

Nhưng hãy lưu ý, theo các tài liệu (gấu trúc 0.24.2 tại thời điểm này):

• iterrows: dtypecó thể không khớp từ hàng này sang hàng khác

  Bởi vì các vòng lặp trả về một Chuỗi cho mỗi hàng, nó không bảo toàn các kiểu chữ trên các hàng (các kiểu chữ được bảo toàn trên các cột cho DataFrames). Để bảo toàn các kiểu chữ trong khi lặp qua các hàng, tốt hơn là sử dụng itertuples () trả về các tên được đặt tên của các giá trị và thường nhanh hơn nhiều so với iterrows ()

• iterrows: Không sửa đổi hàng

  Bạn không bao giờ nên sửa đổi một cái gì đó bạn đang lặp đi lặp lại. Điều này không được đảm bảo để làm việc trong mọi trường hợp. Tùy thuộc vào các loại dữ liệu, iterator trả về một bản sao chứ không phải dạng xem và việc ghi vào nó sẽ không có hiệu lực.

  Sử dụng DataFrame.apply () thay thế:

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

• lặp đi lặp lại:

  Tên cột sẽ được đổi tên thành tên vị trí nếu chúng là định danh Python không hợp lệ, được lặp lại hoặc bắt đầu bằng dấu gạch dưới. Với số lượng cột lớn (> 255), các bộ dữ liệu thông thường được trả về.

Xem tài liệu về gấu trúc trên vòng lặp để biết thêm chi tiết.

Bạn nên sử dụng df.iterrows(). Mặc dù lặp đi lặp lại từng hàng không đặc biệt hiệu quả do Seriescác đối tượng phải được tạo.

Trong khi iterrows()là một lựa chọn tốt, đôi khi itertuples()có thể nhanh hơn nhiều:

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

Bạn cũng có thể sử dụng df.apply()để lặp qua các hàng và truy cập nhiều cột cho một hàm.

tài liệu: 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)

Bạn có thể sử dụng hàm df.iloc như sau:

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

Tôi đang tìm kiếm Cách lặp trên các hàng VÀ cột và kết thúc ở đây như vậy:

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

Bạn có thể viết iterator của riêng bạn mà thực hiện 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)

Điều này là trực tiếp so sánh với pd.DataFrame.itertuples. Tôi đang nhắm đến việc thực hiện cùng một nhiệm vụ với hiệu quả cao hơn.

Đối với khung dữ liệu đã cho với chức năng của tôi:

list(myiter(df))

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

Hoặc với pd.DataFrame.itertuples:

list(df.itertuples(index=False))

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

Một thử nghiệm toàn diện
Chúng tôi kiểm tra làm cho tất cả các cột có sẵn và đặt lại các cột.

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

Làm thế nào để lặp lại hiệu quả?

Nếu bạn thực sự phải lặp lại một khung dữ liệu gấu trúc, có lẽ bạn sẽ muốn tránh sử dụng iterrows () . Có nhiều phương pháp khác nhau và thông thường iterrows()không phải là tốt nhất. itertuples () có thể nhanh hơn 100 lần.

Nói ngắn gọn:

• Như một quy tắc chung, sử dụng df.itertuples(name=None). Đặc biệt, khi bạn có một cột số cố định và ít hơn 255 cột. Xem điểm (3)
• Mặt khác, sử dụng df.itertuples()trừ khi các cột của bạn có các ký tự đặc biệt như dấu cách hoặc '-'. Xem điểm (2)
• Có thể sử dụng itertuples()ngay cả khi khung dữ liệu của bạn có các cột lạ bằng cách sử dụng ví dụ cuối cùng. Xem điểm (4)
• Chỉ sử dụng iterrows()nếu bạn không thể các giải pháp trước đó. Xem điểm (1)

Các phương thức khác nhau để lặp lại qua các hàng trong khung dữ liệu gấu trúc:

Tạo một khung dữ liệu ngẫu nhiên với một triệu hàng và 4 cột:

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

1) Thông thường iterrows()là thuận tiện nhưng chậm chết tiệt:

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) Mặc định itertuples()đã nhanh hơn nhiều nhưng nó không hoạt động với các tên cột như My Col-Name is very Strange(bạn nên tránh phương thức này nếu các cột của bạn được lặp lại hoặc nếu một tên cột không thể được chuyển đổi đơn giản thành tên biến 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) Mặc định itertuples()sử dụng name = none thậm chí còn nhanh hơn nhưng không thực sự tiện lợi vì bạn phải xác định một biến trên mỗi cột.

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) Cuối cùng, tên itertuples()được đặt chậm hơn điểm trước nhưng bạn không phải xác định biến trên mỗi cột và nó hoạt động với các tên cột như 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))

Đầu ra:

         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

Bài viết này là một so sánh rất thú vị giữa iterrow và itertuples

Để lặp tất cả các hàng trong một dataframebạn có thể sử dụng:

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]

Đôi khi một mẫu hữu ích là:

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

Kết quả nào trong:

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

Để lặp tất cả các hàng trong a dataframevà sử dụng các giá trị của mỗi hàng một cách thuận tiện , namedtuplescó thể được chuyển đổi thành ndarrays. Ví dụ:

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

Lặp lại qua các hàng:

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

kết quả trong:

[ 1.   0.1]
[ 2.   0.2]

Xin lưu ý rằng nếu index=True, chỉ mục được thêm vào như là thành phần đầu tiên của bộ dữ liệu , điều này có thể không mong muốn đối với một số ứng dụng.

Có một cách để lặp lại các hàng ném trong khi lấy lại DataFrame và không phải là Sê-ri. Tôi không thấy ai đề cập rằng bạn có thể chuyển chỉ mục dưới dạng danh sách cho hàng được trả về dưới dạng DataFrame:

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

Lưu ý việc sử dụng dấu ngoặc kép. Điều này trả về một DataFrame với một hàng duy nhất.

Đối với cả xem và sửa đổi giá trị, tôi sẽ sử dụng iterrows(). Trong một vòng lặp for và bằng cách sử dụng bộ giải nén tuple (xem ví dụ i, row:), tôi sử dụng rowchỉ để xem giá trị và sử dụng ivới locphương thức khi tôi muốn sửa đổi giá trị. Như đã nêu trong các câu trả lời trước, ở đây bạn không nên sửa đổi một cái gì đó bạn đang lặp đi lặp lại.

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

Ở đây, rowtrong vòng lặp là một bản sao của hàng đó, và không phải là một khung nhìn của nó. Do đó, bạn KHÔNG nên viết một cái gì đó như thế row['A'] = 'New_Value', nó sẽ không sửa đổi DataFrame. Tuy nhiên, bạn có thể sử dụng ivà locvà chỉ định DataFrame để làm việc.

Tôi biết tôi đến trễ bên trả lời, nhưng tôi chỉ muốn thêm vào câu trả lời của @ cs95 ở trên, mà tôi tin rằng đó phải là câu trả lời được chấp nhận. Trong câu trả lời của mình, ông cho thấy rằng vector hóa gấu trúc vượt xa các phương pháp gấu trúc khác để tính toán các công cụ với dataframes.

Tôi muốn thêm rằng nếu trước tiên bạn chuyển đổi khung dữ liệu thành một mảng numpy và sau đó sử dụng vector hóa, nó thậm chí còn nhanh hơn so với vector hóa khung dữ liệu của gấu trúc, (và bao gồm cả thời gian để biến nó trở lại thành chuỗi dataframe).

Nếu bạn thêm các chức năng sau vào mã điểm chuẩn của @ cs95, điều này trở nên khá rõ ràng:

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]

Bạn cũng có thể thực hiện numpylập chỉ mục để tăng tốc độ thậm chí còn lớn hơn. Nó không thực sự lặp nhưng hoạt động tốt hơn nhiều so với lặp cho một số ứng dụng nhất định.

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

Bạn cũng có thể muốn đúc nó thành một mảng. Các chỉ mục / lựa chọn này được cho là hoạt động giống như các mảng Numpy nhưng tôi gặp vấn đề và cần phải truyền

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

Có rất nhiều cách để lặp lại qua các hàng trong khung dữ liệu gấu trúc. Một cách rất đơn giản và trực quan là:

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

Ví dụ này sử dụng iloc để cô lập từng chữ số trong khung dữ liệu.

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

Một số thư viện (ví dụ: thư viện interop Java mà tôi sử dụng) yêu cầu các giá trị được truyền liên tiếp tại một thời điểm, ví dụ, nếu truyền dữ liệu. Để tái tạo bản chất phát trực tuyến, tôi 'truyền' các giá trị khung dữ liệu của mình từng cái một, tôi đã viết bên dưới, đôi khi nó rất hữu ích.

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

Mà có thể được sử dụng:

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

Và duy trì ánh xạ giá trị / tên cho các hàng được lặp lại. Rõ ràng, chậm hơn rất nhiều so với việc sử dụng áp dụng và Cython như được chỉ ra ở trên, nhưng là cần thiết trong một số trường hợp.

Nói ngắn gọn

• Sử dụng vector hóa nếu có thể
• Nếu hoạt động không thể được vector hóa - sử dụng danh sách hiểu
• Nếu bạn cần một đối tượng đại diện cho toàn bộ hàng - hãy sử dụng itertuples
• Nếu cách trên quá chậm - hãy thử swifter.apply
• Nếu vẫn còn quá chậm - hãy thử thói quen Cython

Chi tiết trong video này

Điểm chuẩn