No Pandas, quando seleciono um rótulo que tem apenas uma entrada no índice, recebo uma série, mas quando seleciono uma entrada que tem mais de uma entrada, recebo um quadro de dados.
Por que é que? Existe uma maneira de garantir que sempre recebo um quadro de dados?
In [1]: import pandas as pd
In [2]: df = pd.DataFrame(data=range(5), index=[1, 2, 3, 3, 3])
In [3]: type(df.loc[3])
Out[3]: pandas.core.frame.DataFrame
In [4]: type(df.loc[1])
Out[4]: pandas.core.series.Series
Respostas:
Admito que o comportamento é inconsistente, mas acho fácil imaginar casos em que isso seja conveniente. Enfim, para obter um DataFrame todas as vezes, basta passar uma lista para loc. Existem outras formas, mas na minha opinião esta é a mais limpa.
In [2]: type(df.loc[[3]])
Out[2]: pandas.core.frame.DataFrame
In [3]: type(df.loc[[1]])
Out[3]: pandas.core.frame.DataFrame
KeyErrorquando tento .loc[[nonexistent_label]].
.locé muito mais lento do que sem ela. Para ser ainda legível, mas também muito mais rápido, use melhordf.loc[1:1]
Você tem um índice com três itens de índice 3. Por esse motivo df.loc[3], retornará um dataframe.
O motivo é que você não especifica a coluna. Então df.loc[3]seleciona três itens de todas as colunas (que é coluna 0), enquanto df.loc[3,0]retornará uma Série. Por exemplo, df.loc[1:2]também retorna um dataframe, porque você divide as linhas.
Selecionar uma única linha (as df.loc[1]) retorna uma Série com os nomes das colunas como o índice.
Se você quiser ter certeza de sempre ter um DataFrame, pode fazer um slice como df.loc[1:1]. Outra opção é a indexação booleana ( df.loc[df.index==1]) ou o método take ( df.take([0]), mas este local usado não é rótulos!).
locdf.loc[:]= Dataframe
df.loc[int]= Dataframe se você tiver mais de uma coluna e Series se você tiver apenas 1 coluna no dataframe
df.loc[:, ["col_name"]]= Dataframe
df.loc[:, "col_name"]= Série
locdf["col_name"]= Série
df[["col_name"]]= Dataframe
Você escreveu em um comentário à resposta de joris:
"Não entendo a decisão de design para que linhas únicas sejam convertidas em uma série - por que não um quadro de dados com uma linha?"
Uma única linha não é convertida em uma série.
Ele é uma série:No, I don't think so, in fact; see the edit
A melhor maneira de pensar sobre as estruturas de dados do pandas é como recipientes flexíveis para dados dimensionais inferiores. Por exemplo, DataFrame é um contêiner para Series e Panel é um contêiner para objetos DataFrame. Gostaríamos de poder inserir e remover objetos desses contêineres como um dicionário.
http://pandas.pydata.org/pandas-docs/stable/overview.html#why-more-than-1-data-structure
O modelo de dados dos objetos Pandas foi escolhido assim. A razão certamente está no fato de garantir algumas vantagens que não conheço (não entendi bem a última frase da citação, talvez seja o motivo)
.
A trama de dados não pode ser composto de elementos que iria ser Series, porque o código a seguir dá o mesmo tipo "Series", bem como para uma linha como para uma coluna:
import pandas as pd
df = pd.DataFrame(data=[11,12,13], index=[2, 3, 3])
print '-------- df -------------'
print df
print '\n------- df.loc[2] --------'
print df.loc[2]
print 'type(df.loc[1]) : ',type(df.loc[2])
print '\n--------- df[0] ----------'
print df[0]
print 'type(df[0]) : ',type(df[0])resultado
-------- df -------------
0
2 11
3 12
3 13
------- df.loc[2] --------
0 11
Name: 2, dtype: int64
type(df.loc[1]) : <class 'pandas.core.series.Series'>
--------- df[0] ----------
2 11
3 12
3 13
Name: 0, dtype: int64
type(df[0]) : <class 'pandas.core.series.Series'>Portanto, não faz sentido fingir que um DataFrame é composto de Séries, porque o que essas Séries seriam: colunas ou linhas? Pergunta e visão estúpidas.
.
Então o que é um DataFrame?
Na versão anterior desta resposta, fiz esta pergunta, tentando encontrar a resposta para a Why is that?parte da pergunta do OP e a interrogação semelhante single rows to get converted into a series - why not a data frame with one row?em um de seus comentários,
enquanto a Is there a way to ensure I always get back a data frame?parte foi respondida por Dan Allan.
Então, como os documentos dos Pandas citados acima dizem que as estruturas de dados dos pandas são mais bem vistas como contêineres de dados dimensionais inferiores, pareceu-me que a compreensão do porquê seria encontrada nas características da natureza das estruturas DataFrame.
No entanto, percebi que este conselho citado não deve ser tomado como uma descrição precisa da natureza das estruturas de dados do Pandas.
Este conselho não significa que um DataFrame seja um contêiner de Series.
Expressa que a representação mental de um DataFrame como um container de Séries (sejam linhas ou colunas conforme a opção considerada em um momento de raciocínio) é uma boa forma de considerar DataFrames, mesmo que não seja estritamente o caso na realidade. "Bom" significa que esta visão permite usar DataFrames com eficiência. Isso é tudo.
.
Então, o que é um objeto DataFrame?
A classe DataFrame produz instâncias que possuem uma estrutura particular originada na classe base NDFrame , ela própria derivada da classe base PandasContainer que também é uma classe pai da classe Series .
Observe que isso é correto para Pandas até a versão 0.12. Na próxima versão 0.13, Series derivará também da classe NDFrame apenas.
# with pandas 0.12
from pandas import Series
print 'Series :\n',Series
print 'Series.__bases__ :\n',Series.__bases__
from pandas import DataFrame
print '\nDataFrame :\n',DataFrame
print 'DataFrame.__bases__ :\n',DataFrame.__bases__
print '\n-------------------'
from pandas.core.generic import NDFrame
print '\nNDFrame.__bases__ :\n',NDFrame.__bases__
from pandas.core.generic import PandasContainer
print '\nPandasContainer.__bases__ :\n',PandasContainer.__bases__
from pandas.core.base import PandasObject
print '\nPandasObject.__bases__ :\n',PandasObject.__bases__
from pandas.core.base import StringMixin
print '\nStringMixin.__bases__ :\n',StringMixin.__bases__resultado
Series :
<class 'pandas.core.series.Series'>
Series.__bases__ :
(<class 'pandas.core.generic.PandasContainer'>, <type 'numpy.ndarray'>)
DataFrame :
<class 'pandas.core.frame.DataFrame'>
DataFrame.__bases__ :
(<class 'pandas.core.generic.NDFrame'>,)
-------------------
NDFrame.__bases__ :
(<class 'pandas.core.generic.PandasContainer'>,)
PandasContainer.__bases__ :
(<class 'pandas.core.base.PandasObject'>,)
PandasObject.__bases__ :
(<class 'pandas.core.base.StringMixin'>,)
StringMixin.__bases__ :
(<type 'object'>,)Portanto, meu entendimento é que uma instância de DataFrame tem certos métodos que foram criados para controlar a maneira como os dados são extraídos de linhas e colunas.
As maneiras como esses métodos de extração funcionam são descritas nesta página:
http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing
Encontramos nele o método fornecido por Dan Allan e outros métodos.
Por que esses métodos de extração foram elaborados da forma como eram?
Certamente porque foram avaliados como os que apresentam melhores possibilidades e facilidade na análise dos dados.
É exatamente o que está expresso nesta frase:
A melhor maneira de pensar sobre as estruturas de dados do pandas é como recipientes flexíveis para dados dimensionais inferiores.
O porquê da extração de dados de uma instância de DataFRame não está em sua estrutura, mas no porquê dessa estrutura. Eu acho que a estrutura e o funcionamento da estrutura de dados do Pandas foram esculpidos para serem o mais intuitivos intelectualmente possíveis, e que para entender os detalhes, é preciso ler o blog de Wes McKinney.
Se o objetivo for obter um subconjunto do conjunto de dados usando o índice, é melhor evitar o uso de locou iloc. Em vez disso, você deve usar uma sintaxe semelhante a esta:
df = pd.DataFrame(data=range(5), index=[1, 2, 3, 3, 3])
result = df[df.index == 3]
isinstance(result, pd.DataFrame) # True
result = df[df.index == 1]
isinstance(result, pd.DataFrame) # TrueSe você também selecionar o índice do dataframe, o resultado pode ser um DataFrame ou uma Série ou pode ser uma Série ou um escalar (valor único).
Esta função garante que você sempre obtenha uma lista de sua seleção (se o df, índice e coluna forem válidos):
def get_list_from_df_column(df, index, column):
df_or_series = df.loc[index,[column]]
# df.loc[index,column] is also possible and returns a series or a scalar
if isinstance(df_or_series, pd.Series):
resulting_list = df_or_series.tolist() #get list from series
else:
resulting_list = df_or_series[column].tolist()
# use the column key to get a series from the dataframe
return(resulting_list)