Tworzenie ramki danych pandy poprzez dołączanie jednego wiersza na raz
Rozumiem, że pandy są przeznaczone do ładowania w pełni wypełnionych DataFrame
, ale muszę utworzyć pustą ramkę danych, a następnie dodać wiersze, jeden po drugim.
Jak najlepiej to zrobić ?
Udało mi się utworzyć pustą ramkę z:
res = DataFrame(columns=('lib', 'qty1', 'qty2'))
Następnie Mogę dodać nowy wiersz i wypełnić pole:
res = res.set_value(len(res), 'qty1', 10.0)
To działa, ale wydaje się bardzo dziwne : - / (nie dodaje wartości ciągu)
Jak mogę dodać nowy wiersz do ramki danych (z różnymi typami kolumn) ?
29 answers
Możesz użyć df.loc[i]
, Gdzie wiersz z indeksem i
będzie tym, co określisz w ramce danych.
>>> import pandas as pd
>>> from numpy.random import randint
>>> df = pd.DataFrame(columns=['lib', 'qty1', 'qty2'])
>>> for i in range(5):
>>> df.loc[i] = ['name' + str(i)] + list(randint(10, size=2))
>>> df
lib qty1 qty2
0 name0 3 3
1 name1 2 4
2 name2 2 8
3 name3 2 1
4 name4 9 6
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-12-18 15:00:26
W przypadku, gdy można uzyskać wszystkie dane dla ramki danych z góry, istnieje znacznie szybsze podejście niż dołączanie do ramki danych:
- Utwórz listę słowników, w których każdy słownik odpowiada wierszowi danych wejściowych.
- utwórz ramkę danych z tej listy.
Miałem podobne zadanie, w którym dodawanie do ramki danych wiersz po wierszu zajęło 30 minut, a tworzenie ramki danych z listy słowników ukończonych w ciągu kilku sekund.
rows_list = []
for row in input_rows:
dict1 = {}
# get input row in dictionary format
# key = col_name
dict1.update(blah..)
rows_list.append(dict1)
df = pd.DataFrame(rows_list)
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2018-06-28 01:39:36
Możesz użyć pandas.concat()
LUB DataFrame.append()
. Aby uzyskać szczegółowe informacje i przykłady, zobacz Merge, join i concatenate.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2012-10-17 19:38:13
Minęło sporo czasu, ale ja też miałam ten sam problem. I znaleźć tutaj wiele ciekawych odpowiedzi. Więc byłem zdezorientowany, jakiej metody użyć.
W przypadku dodawania wielu wierszy do dataframe interesowałem się szybkością działania . Wypróbowałem więc 4 najpopularniejsze metody i sprawdziłem ich szybkość.
Aktualizacja w 2019 przy użyciu nowych wersji pakietów. Aktualizacja po @ FooBar komentarz
WYDAJNOŚĆ PRĘDKOŚCI
- za pomocą .append (odpowiedź NPE )
- używanie .loc (odpowiedź Freda )
- używanie .loc z prealokacją (odpowiedź Foobara )
- używanie dict i tworzenie DataFrame na końcu ( odpowiedź ShikharDua )
Wyniki (w sekundach):
|------------|-------------|-------------|-------------|
| Approach | 1000 rows | 5000 rows | 10 000 rows |
|------------|-------------|-------------|-------------|
| .append | 0.69 | 3.39 | 6.78 |
|------------|-------------|-------------|-------------|
| .loc w/o | 0.74 | 3.90 | 8.35 |
| prealloc | | | |
|------------|-------------|-------------|-------------|
| .loc with | 0.24 | 2.58 | 8.70 |
| prealloc | | | |
|------------|-------------|-------------|-------------|
| dict | 0.012 | 0.046 | 0.084 |
|------------|-------------|-------------|-------------|
Również podziękowania dla @ krassowski za przydatny komentarz-zaktualizowałem kod.
Więc używam dodawania przez słownik dla siebie.
Kod:
import pandas as pd
import numpy as np
import time
del df1, df2, df3, df4
numOfRows = 1000
# append
startTime = time.perf_counter()
df1 = pd.DataFrame(np.random.randint(100, size=(5,5)), columns=['A', 'B', 'C', 'D', 'E'])
for i in range( 1,numOfRows-4):
df1 = df1.append( dict( (a,np.random.randint(100)) for a in ['A','B','C','D','E']), ignore_index=True)
print('Elapsed time: {:6.3f} seconds for {:d} rows'.format(time.perf_counter() - startTime, numOfRows))
print(df1.shape)
# .loc w/o prealloc
startTime = time.perf_counter()
df2 = pd.DataFrame(np.random.randint(100, size=(5,5)), columns=['A', 'B', 'C', 'D', 'E'])
for i in range( 1,numOfRows):
df2.loc[i] = np.random.randint(100, size=(1,5))[0]
print('Elapsed time: {:6.3f} seconds for {:d} rows'.format(time.perf_counter() - startTime, numOfRows))
print(df2.shape)
# .loc with prealloc
df3 = pd.DataFrame(index=np.arange(0, numOfRows), columns=['A', 'B', 'C', 'D', 'E'] )
startTime = time.perf_counter()
for i in range( 1,numOfRows):
df3.loc[i] = np.random.randint(100, size=(1,5))[0]
print('Elapsed time: {:6.3f} seconds for {:d} rows'.format(time.perf_counter() - startTime, numOfRows))
print(df3.shape)
# dict
startTime = time.perf_counter()
row_list = []
for i in range (0,5):
row_list.append(dict( (a,np.random.randint(100)) for a in ['A','B','C','D','E']))
for i in range( 1,numOfRows-4):
dict1 = dict( (a,np.random.randint(100)) for a in ['A','B','C','D','E'])
row_list.append(dict1)
df4 = pd.DataFrame(row_list, columns=['A','B','C','D','E'])
print('Elapsed time: {:6.3f} seconds for {:d} rows'.format(time.perf_counter() - startTime, numOfRows))
print(df4.shape)
P. S. uważam, że moja realizacja nie jest idealna i może jest jakaś optymalizacja.Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2019-08-19 07:22:29
Jeśli znasz liczbę wpisów ex ante, powinieneś przedalokować przestrzeń, podając również indeks (na przykładzie danych z innej odpowiedzi):
import pandas as pd
import numpy as np
# we know we're gonna have 5 rows of data
numberOfRows = 5
# create dataframe
df = pd.DataFrame(index=np.arange(0, numberOfRows), columns=('lib', 'qty1', 'qty2') )
# now fill it up row by row
for x in np.arange(0, numberOfRows):
#loc or iloc both work here since the index is natural numbers
df.loc[x] = [np.random.randint(-1,1) for n in range(3)]
In[23]: df
Out[23]:
lib qty1 qty2
0 -1 -1 -1
1 0 0 0
2 -1 0 -1
3 0 -1 0
4 -1 0 0
Porównanie Prędkości
In[30]: %timeit tryThis() # function wrapper for this answer
In[31]: %timeit tryOther() # function wrapper without index (see, for example, @fred)
1000 loops, best of 3: 1.23 ms per loop
100 loops, best of 3: 2.31 ms per loop
I-jak wynika z komentarzy - przy rozmiarze 6000 różnica prędkości staje się jeszcze większa:
Zwiększenie rozmiaru tablicy (12) i liczby wierszy (500) powoduje różnica prędkości bardziej uderzająca: 313ms vs 2.29 s
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2015-04-02 12:03:48
Nigdy nie hoduj ramki danych!
Tak, ludzie już wyjaśnili, że nigdy nie należy rozwijać ramki danych, i że należy dołączyć swoje dane do listy i przekonwertować je na ramkę danych raz na końcu. Ale czy rozumiesz dlaczego?
Oto najważniejsze powody, zaczerpnięte z mojego postu tutaj .
- zawsze tańsze / szybsze jest dołączanie do listy i tworzenie ramki danych za jednym zamachem.
- listy zajmują mniej pamięci i są dużo lżejszymi danymi struktura do pracy, dodawania i usuwania.
-
dtypes
są automatycznie wnioskowane dla Twoich danych. Z drugiej strony, utworzenie pustej ramki Nan automatycznie spowoduje ichobject
, co jest złe. - indeks jest tworzony automatycznie dla ciebie, zamiast dbać o przypisanie odpowiedniego indeksu do wiersza, który dodajesz.
data = []
for a, b, c in some_function_that_yields_data():
data.append([a, b, c])
df = pd.DataFrame(data, columns=['A', 'B', 'C'])
Te opcje to straszne
-
append
lubconcat
wewnątrz pętliappend
iconcat
nie są z natury złe w izolacji. Na problem zaczyna się, gdy iteracyjnie wywołujesz je wewnątrz pętli - to powoduje kwadratowe zużycie pamięci.# Creates empty DataFrame and appends df = pd.DataFrame(columns=['A', 'B', 'C']) for a, b, c in some_function_that_yields_data(): df = df.append({'A': i, 'B': b, 'C': c}, ignore_index=True) # This is equally bad: # df = pd.concat( # [df, pd.Series({'A': i, 'B': b, 'C': c})], # ignore_index=True)
-
Pusta ramka danych NaNs
Nigdy nie twórz ramki danych Nan, ponieważ kolumny są inicjalizowane za pomocą
object
(wolny, nie-wektoryzowalny dtype).# Creates DataFrame of NaNs and overwrites values. df = pd.DataFrame(columns=['A', 'B', 'C'], index=range(5)) for a, b, c in some_function_that_yields_data(): df.loc[len(df)] = [a, b, c]
Dowód jest w Budyń
Timing te metody są najszybszym sposobem, aby zobaczyć, jak bardzo różnią się one pod względem pamięci i użyteczności.Kod porównawczy dla odniesienia.
Takie posty przypominają mi, dlaczego jestem częścią tej społeczności. Ludzie rozumieją, jak ważne jest uczenie ludzi, aby uzyskali właściwą odpowiedź za pomocą właściwego kodu, a nie właściwej odpowiedzi za pomocą {69]}niewłaściwego kodu {70]}. Teraz można twierdzić, że jest nie ma problemu z używaniem loc
lub append
, Jeśli dodajesz tylko jeden wiersz do ramki danych. Jednak ludzie często patrzą na to pytanie, aby dodać więcej niż tylko jeden wiersz - często wymogiem jest iteratywne dodanie wiersza wewnątrz pętli za pomocą danych pochodzących z funkcji (zobacz podobne pytanie). W takim przypadku ważne jest, aby zrozumieć, że iteratywne rozwijanie ramki danych nie jest dobrym pomysłem.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-12-26 12:38:31
mycolumns = ['A', 'B']
df = pd.DataFrame(columns=mycolumns)
rows = [[1,2],[3,4],[5,6]]
for row in rows:
df.loc[len(df)] = row
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2015-06-24 21:06:31
Możesz dodać pojedynczy wiersz jako słownik za pomocą opcji ignore_index
.
>>> f = pandas.DataFrame(data = {'Animal':['cow','horse'], 'Color':['blue', 'red']})
>>> f
Animal Color
0 cow blue
1 horse red
>>> f.append({'Animal':'mouse', 'Color':'black'}, ignore_index=True)
Animal Color
0 cow blue
1 horse red
2 mouse black
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-02-23 16:43:07
Aby uzyskać skuteczne dodawanie Zobacz Jak dodać dodatkowy wiersz do ramki danych pandy i ustawienie z powiększeniem.
Dodaj wiersze przez loc/ix
na nieistniejące dane indeksu klucza. np.:
In [1]: se = pd.Series([1,2,3])
In [2]: se
Out[2]:
0 1
1 2
2 3
dtype: int64
In [3]: se[5] = 5.
In [4]: se
Out[4]:
0 1.0
1 2.0
2 3.0
5 5.0
dtype: float64
Lub:
In [1]: dfi = pd.DataFrame(np.arange(6).reshape(3,2),
.....: columns=['A','B'])
.....:
In [2]: dfi
Out[2]:
A B
0 0 1
1 2 3
2 4 5
In [3]: dfi.loc[:,'C'] = dfi.loc[:,'A']
In [4]: dfi
Out[4]:
A B C
0 0 1 0
1 2 3 2
2 4 5 4
In [5]: dfi.loc[3] = 5
In [6]: dfi
Out[6]:
A B C
0 0 1 0
1 2 3 2
2 4 5 4
3 5 5 5
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2017-05-23 12:26:33
Ze względu na sposób Pythoniczny, tutaj Dodaj moją odpowiedź:
res = pd.DataFrame(columns=('lib', 'qty1', 'qty2'))
res = res.append([{'qty1':10.0}], ignore_index=True)
print(res.head())
lib qty1 qty2
0 NaN 10.0 NaN
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2017-10-11 01:44:34
Możesz również zbudować listę list i przekonwertować ją na ramkę danych -
import pandas as pd
columns = ['i','double','square']
rows = []
for i in range(6):
row = [i, i*2, i*i]
rows.append(row)
df = pd.DataFrame(rows, columns=columns)
Daje
i double square 0 0 0 0 1 1 2 1 2 2 4 4 3 3 6 9 4 4 8 16 5 5 10 25
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2019-07-26 11:34:51
Wymyśliłem prosty i miły sposób:
>>> df
A B C
one 1 2 3
>>> df.loc["two"] = [4,5,6]
>>> df
A B C
one 1 2 3
two 4 5 6
Zwróć uwagę na zastrzeżenie dotyczące wydajności, jak wspomniano w komentarzach
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-07-11 10:20:31
To nie jest odpowiedź na pytanie OP, ale zabawkowy przykład ilustrujący odpowiedź @ShikharDua powyżej, która okazała się bardzo przydatna.
Podczas gdy ten fragment jest trywialny, w rzeczywistych danych miałem 1000 s wierszy i wiele kolumn, i chciałem być w stanie pogrupować według różnych kolumn, a następnie wykonać poniższe statystyki dla więcej niż jednej kolumny taget. Tak więc posiadanie niezawodnej metody budowania ramki danych z jednego rzędu na raz było wielką wygodą. Dziękuję @ShikharDua !
import pandas as pd
BaseData = pd.DataFrame({ 'Customer' : ['Acme','Mega','Acme','Acme','Mega','Acme'],
'Territory' : ['West','East','South','West','East','South'],
'Product' : ['Econ','Luxe','Econ','Std','Std','Econ']})
BaseData
columns = ['Customer','Num Unique Products', 'List Unique Products']
rows_list=[]
for name, group in BaseData.groupby('Customer'):
RecordtoAdd={} #initialise an empty dict
RecordtoAdd.update({'Customer' : name}) #
RecordtoAdd.update({'Num Unique Products' : len(pd.unique(group['Product']))})
RecordtoAdd.update({'List Unique Products' : pd.unique(group['Product'])})
rows_list.append(RecordtoAdd)
AnalysedData = pd.DataFrame(rows_list)
print('Base Data : \n',BaseData,'\n\n Analysed Data : \n',AnalysedData)
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-07-13 09:49:18
Możesz użyć obiektu generator do stworzenia ramki danych, która będzie bardziej wydajna w pamięci niż lista.
num = 10
# Generator function to generate generator object
def numgen_func(num):
for i in range(num):
yield ('name_{}'.format(i), (i*i), (i*i*i))
# Generator expression to generate generator object (Only once data get populated, can not be re used)
numgen_expression = (('name_{}'.format(i), (i*i), (i*i*i)) for i in range(num) )
df = pd.DataFrame(data=numgen_func(num), columns=('lib', 'qty1', 'qty2'))
Aby dodać raw do istniejącej ramki danych, możesz użyć metody append.
df = df.append([{ 'lib': "name_20", 'qty1': 20, 'qty2': 400 }])
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2019-10-21 07:26:08
Utwórz nowy rekord (ramka danych) i dodaj do old_data_frame.
przekaż listę wartości i odpowiadających im nazw kolumn , aby utworzyć new_record (data_frame)
new_record = pd.DataFrame([[0,'abcd',0,1,123]],columns=['a','b','c','d','e'])
old_data_frame = pd.concat([old_data_frame,new_record])
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-07-18 09:54:03
Zamiast listy słowników, jak w odpowiedzi ShikharDua, możemy również reprezentować naszą tabelę jako słownik list , gdzie każda lista przechowuje jedną kolumnę w rzędzie-kolejność, biorąc pod uwagę, że znamy nasze kolumny wcześniej. na końcu konstruujemy nasz DataFrame raz.
Dla C kolumn i N wierszy używa się 1 słownika i C list, kontra 1 listy i N słowników. Lista słowników ma każdy słownik przechowujący wszystkie klucze i wymaga utworzenia nowego słownika dla każdego wiersza. Tutaj dodajemy tylko listy, co jest stałym czasem i teoretycznie bardzo szybko.
# current data
data = {"Animal":["cow", "horse"], "Color":["blue", "red"]}
# adding a new row (be careful to ensure every column gets another value)
data["Animal"].append("mouse")
data["Color"].append("black")
# at the end, construct our DataFrame
df = pd.DataFrame(data)
# Animal Color
# 0 cow blue
# 1 horse red
# 2 mouse black
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2019-12-30 01:46:17
Oto sposób na dodanie / dodanie wiersza w pandas DataFrame
def add_row(df, row):
df.loc[-1] = row
df.index = df.index + 1
return df.sort_index()
add_row(df, [1,2,3])
Może być używany do wstawiania / dołączania wierszy w pustych lub wypełnionych ramkach danych pand
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-01-20 10:02:18
Jeśli chcesz dodać wiersz na końcu dodaj go jako listę
valuestoappend = [va1,val2,val3]
res = res.append(pd.Series(valuestoappend,index = ['lib', 'qty1', 'qty2']),ignore_index = True)
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-03-26 14:09:19
Inny sposób na to (prawdopodobnie niezbyt wydajny):
# add a row
def add_row(df, row):
colnames = list(df.columns)
ncol = len(colnames)
assert ncol == len(row), "Length of row must be the same as width of DataFrame: %s" % row
return df.append(pd.DataFrame([row], columns=colnames))
Możesz również ulepszyć klasę DataFrame w następujący sposób:
import pandas as pd
def add_row(self, row):
self.loc[len(self.index)] = row
pd.DataFrame.add_row = add_row
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2016-11-11 18:25:00
Wszystko czego potrzebujesz to loc[df.shape[0]]
lub loc[len(df)]
# Assuming your df has 4 columns (str, int, str, bool)
df.loc[df.shape[0]] = ['col1Value', 100, 'col3Value', False]
Lub
df.loc[len(df)] = ['col1Value', 100, 'col3Value', False]
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-05-01 15:10:31
initial_data = {'lib': np.array([1,2,3,4]), 'qty1': [1,2,3,4], 'qty2': [1,2,3,4]}
df = pd.DataFrame(initial_data)
df
lib qty1 qty2
0 1 1 1
1 2 2 2
2 3 3 3
3 4 4 4
val_1 = [10]
val_2 = [14]
val_3 = [20]
df.append(pd.DataFrame({'lib': val_1, 'qty1': val_2, 'qty2': val_3}))
lib qty1 qty2
0 1 1 1
1 2 2 2
2 3 3 3
3 4 4 4
0 10 14 20
Możesz użyć pętli For do iteracji wartości lub możesz dodać tablice wartości
val_1 = [10, 11, 12, 13]
val_2 = [14, 15, 16, 17]
val_3 = [20, 21, 22, 43]
df.append(pd.DataFrame({'lib': val_1, 'qty1': val_2, 'qty2': val_3}))
lib qty1 qty2
0 1 1 1
1 2 2 2
2 3 3 3
3 4 4 4
0 10 14 20
1 11 15 21
2 12 16 22
3 13 17 43
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-06-13 15:09:31
Uprość to. Biorąc listę jako dane wejściowe, które będą dołączane jako wiersz w ramce danych: -
import pandas as pd
res = pd.DataFrame(columns=('lib', 'qty1', 'qty2'))
for i in range(5):
res_list = list(map(int, input().split()))
res = res.append(pd.Series(res_list,index=['lib','qty1','qty2']), ignore_index=True)
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2017-08-25 15:47:04
Często widzimy konstrukcję df.loc[subscript] = …
do przypisania do jednego wiersza ramki danych. Mikhail_Sam opublikował benchmarki zawierające m.in. ten konstrukt, a także metodę wykorzystującą dict I create DataFrame na końcu . Ten ostatni okazał się najszybszy. Ale jeśli zamienimy df3.loc[i] = …
(z prealokowaną ramką danych) w jego kodzie na df3.values[i] = …
, wynik zmieni się znacząco, w tym, że ta metoda działa podobnie do tej używającej dict. Więc powinniśmy częściej korzystać z df.values[subscript] = …
pod uwagę. Należy jednak pamiętać, że .values
przyjmuje indeks dolny oparty na zero, który może różnić się od ramki danych.indeks.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2019-08-22 12:39:32
Pandy.Ramka danych.append
DataFrame.append (self, other, ignore_index=False, verify_integrity=False, sort=False) → 'DataFrame'
df = pd.DataFrame([[1, 2], [3, 4]], columns=list('AB'))
df2 = pd.DataFrame([[5, 6], [7, 8]], columns=list('AB'))
df.append(df2)
Z ignore_index ustawionym na True:
df.append(df2, ignore_index=True)
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-02-19 06:35:18
Można w tym celu połączyć dwa ramki danych. W zasadzie natknąłem się na ten problem, aby dodać nowy wiersz do istniejącej ramki danych z indeksem znaków(nie numerycznym). Tak więc wprowadzam dane dla nowego wiersza w kanale () i indeksu w liście.
new_dict = {put input for new row here}
new_list = [put your index here]
new_df = pd.DataFrame(data=new_dict, index=new_list)
df = pd.concat([existing_df, new_df])
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-04-30 14:07:19
Jeśli wszystkie dane w ramce danych mają ten sam typ dtype, możesz użyć tablicy numpy. Możesz zapisywać wiersze bezpośrednio do predefiniowanej tablicy i konwertować ją na ramkę danych na końcu. Wydaje się być nawet szybsze niż konwersja listy dictów.
import pandas as pd
import numpy as np
from string import ascii_uppercase
startTime = time.perf_counter()
numcols, numrows = 5, 10000
npdf = np.ones((numrows, numcols))
for row in range(numrows):
npdf[row, 0:] = np.random.randint(0, 100, (1, numcols))
df5 = pd.DataFrame(npdf, columns=list(ascii_uppercase[:numcols]))
print('Elapsed time: {:6.3f} seconds for {:d} rows'.format(time.perf_counter() - startTime, numOfRows))
print(df5.shape)
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-10-11 18:46:55
Jeśli posiadasz ramkę danych df
i chcesz dodać listę new_list
jako nowy wiersz df
możesz po prostu zrobić:
df.loc[len(df)] = new_list
Jeśli chcesz dodać nową ramkę danych new_df
w ramce danych df
możesz użyć:
df.append(new_df)
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-12-21 09:57:20
Przed dodaniem wiersza, musimy przekonwertować dataframe do słownika tam można zobaczyć klucze jako kolumny w dataframe i wartości kolumn są ponownie przechowywane w słowniku, ale tam kluczem dla każdej kolumny jest numer indeksu w dataframe. Ten pomysł skłonił mnie do napisania poniższego kodu.
df2=df.to_dict()
values=["s_101","hyderabad",10,20,16,13,15,12,12,13,25,26,25,27,"good","bad"] #this is total row that we are going to add
i=0
for x in df.columns: #here df.columns gives us the main dictionary key
df2[x][101]=values[i] #here the 101 is our index number it is also key of sub dictionary
i+=1
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-04-17 17:54:13
To zajmie się dodaniem elementu do pustej ramki danych. Problem polega na tym, że df.index.max() == nan
dla pierwszego indeksu:
df = pd.DataFrame(columns=['timeMS', 'accelX', 'accelY', 'accelZ', 'gyroX', 'gyroY', 'gyroZ'])
df.loc[0 if math.isnan(df.index.max()) else df.index.max() + 1] = [x for x in range(7)]
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2019-07-01 12:12:13