O que é pandas?

Pandas é uma biblioteca do Python, de código aberto e com licença BSD, desenvolvida e mantida pelo PуDаtа Dеvеlорmеnt Tеаm. Ela fornece ferramentas de manipulação e análise estatística de dados, capacidade de exibição gráfica E extração de dados análogos (mas não idênticos) aos de consultas sql.

A biblioteca foi construída com Cython e, por isso, é bastante rápida. Ela se destinava inicialmente ao uso no setor financeiro para análise de séries temporiais, tendo se tornado uma ferramenta de uso comum na manipulação de dados, particularmente em data science e machine learning. Ela tem sido usada para substituir as planilhas do Excel, para processar dados sob forma tabular, importando com facilidade dados de arquivos csv ou json.

Os experimentos abaixo foram realizados no Jupyter Notebook. Você encontra nesse site um artigo sobre instalação e uso do Jupyter Notebook. As linhas de código e suas respostas, quando existirem, serão representadas da seguinte forma:

» # Comentários (não são lidos ou executados pelo interpretador)
» Linha de input (entrada de comandos)
↳ Linha de output (resposta do código)

NumPy e matplotlib

NumPy é a abreviação de Numerical Python, a biblioteca base da computação numérica em Python. Ela fornece as estruturas de dados e algoritmos necessários para a maioria das aplicações científicas e de engenharia utilizando cálculo numérico. Entre outros objetos NumPy NumPy fornece

• o objeto multidimensional ndarray onde se pode aplicar operações vetorializadas rápidas e eficientes,
• um conjunto de funções para cálculos elementares com vetores e matrizes,
• ferramentas de leitura e gravação de dados,
• operações da álgebra linear, transformada de Fourier e geração de números aleatórios,
• interação com C e C++.

Para dados numéricos as matrizes do NumPy são armazenadas e manipuladas de modo mais eficiente do que as demais estruturas do Python. Além disso códigos escritos em linguagens de baixo nível, como C ou Fortran, podem operar diretamente nos dados armazenados com o NumPy. Por isso muitas ferramentas de computação numérica do Python usam as matrizes NumPy como um estrutura de dados primária.

matplotlib é a biblioteca Python mais popular usada para a produção de gráficos e visualização de dados. Ela pode ser usada na geração de gráficos estáticos ou animados e visualização interativa.

Pandas

O pandas se utiliza basicamente de 3 objetos de armazenamento de dados com as seguintes estruturas:
Estrutura de dados dos objetos do pandas:

Nome	dimensões	tabela
Series	1D	coluna (vetor)
DataFrame	2D	tabela (matriz)
Panel	3D	várias tabelas (matriz multidimensional)

As series e os dataframes são utilizados com maior frequência.

Como a manipulação de dados usando séries e dataframes frequentemente envolvem operações encontradas no módulo numpy é frequente sua importação junto com pandas.

» import pandas as pd
» import numpy as np

Series

Uma series é um objeto unidimensional, tipo um vetor, que contém uma sequência de objetos do mesmo tipo. A essa sequência está associado um outro vetor de labels chamado de index (índice). O método básico de criação de séries é da seguinte forma:
serie = pd.Series(data, index=index)
onde data pode ser um dict (um dicionário do Python), uma lista ou ndarray do numPy, ou um escalar. index é uma lista de índices que, se omitida, é preenchida com inteiros iniciando em 0.

» serie1 = pd.Series([-1, 9, 0, 2, 5])
↳  0   -1
   1    9
   2    0
   3    2
   4    5

À esquerda estão listados os índices que, por default, são uma lista de inteiros começando por 0. Os valores podem ser listados com .values e os índices com .index.

» serie1.values
↳ array([-1,  9,  0,  2,  5])

» serie1.index
↳ RangeIndex(start=0, stop=5, step=1)

Os índices podem ser inseridos manualmente e não precisam ser inteiros. O valor correspondente ao índice i pode ser acessado com serie[i], como mostrado abaixo, onde os índices são strings.

» serie2 = pd.Series([4, 7, -5, 3], index=['a', 'b', 'c', 'd'])
» serie2
↳ a    4
  b    7
  c   -5
  d    3
  dtype: int64

» serie2['c']
↳ -5

Uma série pode ser filtrada passando como índice outra série de elementos boolenos, (True, False). Além disso operações vetorializadas podem ser realizadas sobre todos os elementos da série.

# O teste seguinte gera uma série de booleanos
» serie2 > 3
↳ a     True
  b     True
  c    False
  d    False
  dtype: bool

# Essa serie de True e False filtra a serie original
» serie2[serie2 > 3]
↳ a    4
  b    7
  dtype: int64

# Operações podem, ser realizadas sobre todos os elementos
» serie2 * 3
↳ a    12
  b    21
  c   -15
  d     9
  dtype: int64

# o módulo Numpy possui a função exponencial
» np.exp(serie2)
↳ a      54.598150
  b    1096.633158
  c       0.006738
  d      20.085537
  dtype: float64

Séries se comportam, em muitos sentidos, como um dicionário. Uma série pode ser criada passando-se um dicionário como argumento para pd.Series().

» populacao = {
           'Sudeste': 89012240, 
           'Nordeste': 57374243,
           'Sul': 30192315,
           'Norte': 18672591,
           'Centro-Oeste':16504303
         }

» serie3 = pd.Series(populacao)

» serie3
↳ Sudeste         89012240
  Nordeste        57374243
  Sul             30192315
  Norte           18672591
  Centro-Oeste    16504303
  dtype: int64 

A ordem dos itens na série pode ser alterada através do fornecimento de uma lista com o ordenamento desejado para o argumento index. A elementos não presentes no dicionário serão atribuídos o valor NaN, Not a Number (não número). O método pd.isnull(serie) permite a avalição de quais elementos estão nulos ou NaN.

# fornecendo uma lista para o argumento index:
» ordem_alfabetica = ['Brasil', 'Centro-Oeste', 'Nordeste', 'Norte', 'Sudeste', 'Sul']
» serie4 = pd.Series(populacao, index=ordem_alfabetica)
» serie4
↳ Brasil               NaN
  Centro-Oeste    16504303
  Nordeste        57374243
  Norte           18672591
  Sudeste         89012240
  Sul             30192315
  dtype: int64

# para verificar quais valores são nulos (NaN)
» pd.isnull(serie4)
↳ Brasil           True
  Centro-Oeste    False
  Nordeste        False
  Norte           False
  Sudeste         False
  Sul             False
  dtype: bool

# os seguintes registros são NaN
» serie4[pd.isnull(serie4)]
↳ Brasil   NaN
  dtype: float64

» serie4[pd.notnull(serie4)]
↳ Centro-Oeste    16504303.0
  Nordeste        57374243.0
  Norte           18672591.0
  Sudeste         89012240.0
  Sul             30192315.0
  dtype: float64

» 'Brasil' in serie4
↳ True
» 'EUA' in serie4
↳ False
# uma excessão KeyError é lançada se o indice não existe
» serie4['EUA']
↳ KeyError

Como não existe no dicionário um valor para o índice Brasil a série atribuiu o valor NaN (Not a Number) para essa chave, a forma de NumPy e pandas indicar a ausência de um valor. O método retorna True ou False para cada item da série e pd.notnull() o seu inverso booleano. Alternativamente se pode usar o método das séries serie4.isnull().

Ainda sobre a semelhança entre séries e dicionários, podemos testar a existência de uma chave usando o operador in, como em 'Brasil' in serie4. A tentativa de recuperar um valor com índice não existente gera uma exceção (um erro do Python).

Observe que uma series tem propriedades de numpy ndarray, mas é um objeto de tipo diferente. Se um ndarray é necessário use series.to_numpy().

» type(serie4)
↳ pandas.core.series.Series

» type(serie4.to_numpy())
↳ numpy.ndarray

Series podem ser fatiadas com a notação serie[i:f] onde serão retornadas a i-ésima linha até a f-ésima, exclusive. Se i for omitido a lista se inicia em 0, se f for omitido ela termina no final da series.

» serie4
↳ Brasil                 NaN
  Centro-Oeste    16504303.0
  Nordeste        57374243.0
  Norte           18672591.0
  Sudeste         89012240.0
  Sul             30192315.0
  dtype: float64

» serie4[2:5]
↳ Nordeste        57374243.0
  Norte           18672591.0
  Sudeste         89012240.0
  dtype: float64

» serie4[:2]
↳ Brasil                 NaN
  Centro-Oeste    16504303.0
  dtype: float64

» serie4[4:]
↳ Sudeste    89012240.0
  Sul        30192315.0
  dtype: float64

Series podem ser exibidas com o método display(serie_0, serie_1, ..., serie_n). O resultado de operações envolvendo mais de uma serie, como a soma, alinha os valores por chaves (como uma UNION). Valores não presentes em um dos operandos terá NaN como resultado.

» serie5 = pd.Series([2, -1, -2, 1], index=['a', 'b', 'c', 'd'])
» serie6 = pd.Series([3, 4, 7, -1], index=['e', 'c', 'b', 'f'])
» display(serie5, serie6)
↳ a    2
  b   -1
  c   -2
  d    1
  dtype: int64

↳ e    3
  c    4
  b    7
  f   -1
  dtype: int64

» serie5 + serie6
↳ a    NaN
  b    6.0
  c    2.0
  d    NaN
  e    NaN
  f    NaN
  dtype: float64

Series possuem a propriedade name que pode ser atribuída na construção ou posteriormente com o método .rename(). No exemplo usamos o método np.random.randn(n) de numpy para fornecer um numpy.ndarray com n números aleatórios. Damos inicialmente a essa série o nome ‘randomica’, depois a renomeamos para ‘aleatoria’.

» serie7 = pd.Series(np.random.randn(5), name='randomica')
» serie7
↳ 0   -1.703662
  1    1.406167
  2    0.966557
  3   -0.557846
  4   -0.264914
  Name: randomica, dtype: float64

» serie7.name
↳ 'randomica'

» serie7= serie7.rename('aleatoria')
» serie7.name
↳ 'aleatoria'

O nome de uma série se torna seu índice ou nome de coluna caso ela seja usada para formar um DataFrame.

Atributos e Métodos das Series

Os atributos e métodos mais comuns e úteis das Series estão listados abaixo. Para uma lista completa consulte pandas.Series: API Reference.

Atributos

Atributo	Descrição
at[n]	Acesso ao valor na posição n
attrs	Retorna ditionario de atributos globais da series
axes	Retorna lista de labels do eixo das linhas
dtype	Retorna o tipo (dtype) dos objetos armazenados
flags	Lista as propriedades do objeto
hasnans	Informa se existem NaNs
iat[n]	Acesso ao valor na posição n inteiro
iloc[n]	Acesso ao valor na posição n inteiro
index	Retorna lista de índices
index[n]	Retorna índice na n-ésima posição
is_monotonic	Booleano: True se valores crescem de forma monotônica
is_monotonic_decreasing	Booleano: True se valores decrescem de forma monotônica
is_unique	Booleano: True se valores na series são únicos
loc	Acessa linhas e colunas por labels em array booleano
name	O nome da Series
nbytes	Número de bytes nos dados armazenados
shape	Retorna uma tuple com forma (dimensões) dos dados
size	Número de elementos nos dados
values	Retorna series como ndarray

Alguns casos de acessos à essas propriedades. Os outputs são exibidos como comentários:

» import pandas as pd
» import numpy as np 
» serie = pd.Series([1,-1, 2, 2, 6, 63])
» serie.size              # 6, o mesmo que len(serie)
» serie.at[5]             # 63
» serie.iloc[0]           # 1
» serie.index             # RangeIndex(start=0, stop=6, step=1)
» serie.is_monotonic      # False
» serie.is_unique         # False
» serie.shape             # (6,) 

Métodos

Nas tabelas abaixo a expressão “elemento a elemento” é abreviada para “e/e”. Estas operações são repetidas a cada elemento da, ou das, séries envolvidas. Por exemplo, o método serie.add(s2) é feita “elemento a elemento” (e/e):

» import pd	
» serie_a = pd.Series([-1,9,0,2, 5, -8])
» serie_b = pd.Series([1,-9,0, -2,-5, 8])
» serie_a.add(serie_b)
» # é o mesmo que
» serie_a + serie_b
» # que resulta em serie nula 
» # pd.Series([0,0,0,0,0,0])

Manipulação e gerenciamento das Series

Método (sobre série s, outra s2)	Descrição
s.align(s2)	Alinha 2 objetos em seus eixos usando método especificado
s.append(to_append[, ignore_index, …])	Concatena 2 ou mais Series
s.asof(where[, subset])	Último elemento antes da ocorrência de NaNs após ‘where’
s.backfill([axis, inplace, limit, downcast])	Aliás para DataFrame.fillna() usando method=’bfill’
s.bfill([axis, inplace, limit, downcast])	Alias para DataFrame.fillna() usando method=’bfill’
s.clip([min, max, axis, inplace])	Inclui apenas valores no intervalo
s.combine(s2, func[, fill_value])	Combina a s com s2 ou escalar, usando func
s.copy([deep])	Cópia do objeto s, índices e valores
s.drop_duplicates([keep, inplace])	Remove elementos duplicados de s
s.dropna()	Remove valores faltantes de s
s.duplicated([keep])	Exibe valores duplicados na s
s.explode([ignore_index])	Transforma cada elemento de um objeto tipo lista em uma linha
s.fillna([value, method, axis, inplace, …])	Substitui valores NA/NaN usando método especificado
s.get(key)	Retorna item correspondente à key
s.groupby([by, axis, level, as_index, sort, …])	Agrupa a s
s.head([n])	Retorna os n primeiros valores
s.interpolate([method, axis, limit, inplace, …])	Preenche valores NaN usando metodo de interpolação
s.item()	Primeiro elemento dos dados como escalar do Python
s.items()	Iteração (lazy) sobre a tupla (index, value)
s.iteritems()	Iteração (lazy) sobre a tupla (index, value)
s.mask(cond[, s2, inplace, axis, level, …])	Substitui valores sob condição dada
s.max([axis, skipna, level, numeric_only])	Valor máximo
s.memory_usage([index, deep])	Memória usada pela s
s.min([axis, skipna, level, numeric_only])	Menor dos valores da s
s.nlargest([n, keep])	Retorna os n maiores elementos
s.nsmallest([n, keep])	Retorna os n menores elementos
s.nunique([dropna])	Retorna quantos elementos únicos existem na s
s.pad([axis, inplace, limit, downcast])	O mesmo que DataFrame.fillna() usando method=’ffill’
s.plot()	O mesmo que pandas.plotting._core.PlotAccessor
s.pop(i)	Remove s[i] de s e retorna s[i]
s.repeat(repeats[, axis])	Repete elementos da s
s.replace([to_replace, value, inplace, limit, …])	Substitui valores em to_replace por value
s.sort_values([axis, ascending, inplace, …])	Reorganiza s usando seus valores
s.str	Usa funções de string sobre s (se string). Ex. s.str.split(“-“)
s.tail([n])	Últimos n elementos
s.unique()	Retorna os valores da s, sem repetições
s.update(s2)	Modifica s usando valores de s2, usando índices iguais
s.view([dtype])	Cria uma nova “view” da s
s.where(cond[, serie, inplace, axis, level, …])	Substitui valores se a condição cond = True

Operações matemáticas básicas:

s.ewm([com, span, halflife, alpha, …])Calcula exponencial com peso

s.abs()	Retorna s com valor absoluto, e/e
s.add(s2)	Soma s com s2, e/e
s.agg([func, axis])	Agrega usando func sobre o eixo especificado
s.apply(func[, convert_dtype, args])	Aplica func sobre os valores de s, e/e
s.div(s2)	Divisão (float) de s por s2, e/e
s.divmod(s2)	Divisão inteira e módulo de s por s2, e/e
s.dot(s2)	Produto interno entre a s e s2
s.floordiv(s2)	Divisão inteira da s por s2, e/e
s.mod(s2[, level, fill_value, axis])	Módulo de s por s2, e/e
s.rfloordiv(s2[, level, fill_value, axis])	Divisão inteira de s por s2, e/e
s.rmod(s2[, level, fill_value, axis])	Modulo da divisão da s por s2, e/e
s.rmul(s2[, level, fill_value, axis])	Multiplicação de s por s2, e/e
s.round([n])	Arredonda valores da s para n casas decimais.
s.rpow(s2[, level, fill_value, axis])	Exponential de s por s2, e/e
s.rsub(s2[, level, fill_value, axis])	Subtração da s por s2, e/e
s.rtruediv(serie[, level, fill_value, axis])	Divisão (float) de s por s2, e/e
s.sub(s2)	Subtração de s por s2, e/e
s.subtract(serie)	Idem
s.sum([axis, skipna, level, numeric_only, …])	Soma dos valores da s
s.transform(func[, axis])	Executa func sobre elementos de s
s.truediv(s2)	Divisão (float) de s por s2, e/e
s.truncate([before, after, axis, copy])	Trunca a s antes e após índices dados
s.mul(s2[, level, fill_value, axis])	Multiplicação de s por s2, e/e
s.multiply(s2[, level, fill_value, axis])	Idem
s.pow(s2)	Exponential de s por s2, e/e
s.prod([axis, skipna, level, numeric_only, …])	Produto dos elementos da s
s.product([axis, skipna, level, numeric_only, …])	Idem
s.rdiv(s2[, level, fill_value, axis])	Divisão (float) de s por s2, e/e
s.rdivmod(s2)	Divisão inteira e módulo de s por s2, e/e

Operações estatísticas:

Método (sobre série s, outra s2)	Descrição
s.corr(s2)	Correlação de s com s2, excluindo NaNs
s.count([level])	Número de observações na s, excluindo NaN/nulls
s.cov(s2[, min_periods, ddof])	Covariância da s, excluindo NaN/nulls
s.cummax([axis, skipna])	Máximo cumulativo
s.cummin([axis, skipna])	Mínimo cumulativo
s.cumprod([axis, skipna])	Produto cumulativo
s.cumsum([axis, skipna])	Soma cumulativa
s.describe([percentiles, include, exclude, …])	Gera descrição estatística
s.kurt([axis, skipna, level, numeric_only])	Kurtosis imparcial
s.kurtosis([axis, skipna, level, numeric_only])	Idem
s.hist()	Plota histograma da s usando matplotlib.
s.mad([axis, skipna, level])	Desvio médio absoluto dos valores de s
s.mean([axis, skipna, level, numeric_only])	Média dos valores
s.median([axis, skipna, level, numeric_only])	Mediana dos valores
s.mode([dropna])	Moda da s
s.quantile([q, interpolation])	Valor no quantil dado
s.ravel([order])	Retorna dados como um ndarray
s.sample([n, frac, replace, weights, …])	Amostra randomizada de items da s
s.sem([axis, skipna, level, ddof, numeric_only])	Erro padrão imparcial da média
s.skew([axis, skipna, level, numeric_only])	Inclinação imparcial
s.std([axis, skipna, level, ddof, numeric_only])	Desvio padrão da amostra
s.value_counts([normalize, sort, ascending, …])	Retorna s com a contagem de valores únicos
s.var([axis, skipna, level, ddof, numeric_only])	Variância imparcial dos valores da s

Operações com índices:

s.add_prefix('prefixo')	Adiciona prefixo aos labels com string ‘prefixo’
s.add_suffix('sufixo')	Adiciona sufixo aos labels com string ‘sufixo’
s.argmax([axis, skipna])	Posição (índice inteiro) do valor mais alto de s
s.argmin([axis, skipna])	Posição (índice inteiro) do menor valor de s
s.argsort([axis, kind, order])	Índices inteiros que ordenam valores da s
s.drop([labels])	Retorna s com labels removidos
s.first_valid_index()	Índice do primeiro valor não NA/null
s.idxmax([axis, skipna])	Label do item de maior valor
s.idxmin([axis, skipna])	Label do item de menor valor
s.keys()	Alias de index
s.last_valid_index()	Índice do último valor não NA/null
s.reindex([index])	Ajusta a s ao novo índice
s.reindex_like(s2[, method, copy, limit, …])	Série com índices em acordo com s2
s.rename([index, axis, copy, inplace, level, …])	Altera o nome (labels) dos índices
s.reorder_levels(order)	Reajusta níveis de índices usando order
s.reset_index([level, drop, name, inplace])	Reinicializa índices
s.searchsorted(value[, side, sorter])	Índices onde elementos devem ser inseridos para manter ordem
s.sort_index([axis, level, ascending, …])	Reorganiza s usando os índices

Testes, com retorno booleanos e comparações:

Método (sobre série s, outra s2)	Descrição
s.all([axis, bool_only, skipna, level])	Booleano: se todos os elementos são True
s.any([axis, bool_only, skipna, level])	Booleano: se algum elemento é True
s.equals(s2)	Booleano: True se s contém os mesmos elementos que s2
s.between(min, max)	Booleano: satisfazendo min <= s <= max, e/e
s.compare(s2[, align_axis, keep_shape, …])	Compara s com s2 exibindo diferenças
s.eq(s2)	Boleano: igualdade entre s e s2, e/e
s.ge(s2)	Booleana: maior ou igual entre s e s2, e/e
s.gt(s2[, level, fill_value, axis])	Booleana: se s é maior que s2, e/e
s.isin(valores)	Booleano: se elementos da s estão contidos em valores
s.isna()	Booleano: se existem valores ausentes
s.isnull()	Booleano: se existem valores nulos
s.le(s2)	Booleana: se s é menor ou igual a s2, e/e
s.lt(s2[, level, fill_value, axis])	Booleana: se s é menor que s2, e/e
s.ne(s2[, level, fill_value, axis])	Booleana: se s é diferente de s2, e/e
s.notna()	Booleana: se existem valores não faltantes ou nulos
s.notnull()	Idem

Transformações para outros formatos e tipos:

s.astype(dtype[, copy, errors])	Transforma (cast) para dtype
s.to_clipboard([excel, sep])	Copia o object para o clipboard do sistema
s.to_csv([path_or_buf, sep, na_rep, …])	Grava a s como arquivo csv
s.to_dict()	Converte s para dict {label ⟶ value}
s.to_excel(excel_writer[, sheet_name, na_rep, …])	Grava s como uma planilha Excel
s.to_frame([name])	Converte s em DataFrame
s.to_hdf(path_or_buf, key[, mode, complevel, …])	Grava s em arquivo HDF5 usando HDFStore
s.to_json([path_or_buf, orient, date_format, …])	Converte s em string JSON
s.to_latex([buf, columns, col_space, header, …])	Renderiza objeto para LaTeX
s.to_markdown([buf, mode, index, storage_options])	Escreve a s em formato Markdown (leia)
s.to_numpy([dtype, copy, na_value])	Converte s em NumPy ndarray
s.to_pickle(path[, compression, protocol, …])	Grava objeto serializado em arquivo Pickle
s.to_sql(name, con[, schema, if_exists, …])	Grava elementos em forma de um database SQL
s.to_string([buf, na_rep, float_format, …])	Constroi uma representação string da s
s.tolist()	Retorna uma lista dos valores
s.to_list()	idem

Operações com séries temporais:

s.asfreq(freq)	Converte TimeSeries para frequência especificada.
s.at_time(time[, asof, axis])	Seleciona valores em determinada hora (ex., 9:30AM)
s.between_time(inicio, fim)	Seleciona valores com tempo entre inicio e fim
s.first(offset)	Seleciona período inicial de uma série temporal usando offset.
s.last(offset)	Seleciona período final de uma série temporal usando offset

Alguns exemplos de uso dos métodos de pandas.Series:

» import pandas as pd
» import numpy as np
» serie = pd.Series([1,-1, 2, 2, 6, 63])
» serie.abs()
» # retorna  pd.Series([1, 1, 2, 2, 6, 63])

» # Muitos métodos não alteram a series inplace.
» s2 = serie.rename('NovoNome')  # não altera nome de serie
» s2.name
↳ 'NovoNome'
» # para alterar o nome usamos
» serie.rename('NovoNome', inplace=True)  # altera nome de serie inplace
» serie.name
↳ 'NovoNome'

» # um resumo estatístico pode ser visto com describe
» serie.describe()
↳ count    15.000000
  mean      4.866667
  std       3.044120
  min       0.000000
  25%       3.500000
  50%       5.000000
  75%       7.000000
  max       9.000000
  dtype: float64

» # gerando outra series
» data = np.random.randint(0, 10,size=15)
» serie2 = pd.Series(data)
» data
↳ array([2, 2, 6, 3, 1, 4, 3, 4, 3, 0, 8, 3, 8, 2, 7])

» serie.div(serie2)
↳ 0     2.500000
  1     0.000000
  ...
  9          inf
  13    0.000000
  14    1.000000
  dtype: float64

Observe que a divisão por 0 não gera erro mas é representada por inf.

Alguma habilidade gráfica pode ser encontrada entre os métodos das series. Um exemplo é o serie.hist() que traça o histograma da series usando matplotlib. Veremos com mais detalhes as funcionalidades dessa biblioteca.

» data = np.random.randint(0, 10,size=15)
» data
array([5, 0, 7, 7, 0, 9, 6, 5, 6, 9, 5, 5, 2, 0, 7])
» serie = pd.Series(data)
» serie.hist()

Objetos do pandas possuem métodos poderosos e eficientes. O método serie.str() permite operações de strings sobre os elementos da serie, se esses forem strings.

» str = ['-mercado','-tensão','-plasia']
» serie = pd.Series(str)
» serie
↳ 0    -mercado
  1     -tensão
  2     -plasia

» serie = serie.str.replace('-','hiper-')
» serie
↳ 0    hiper-mercado
  1     hiper-tensão
  2     hiper-plasia

» serie.str.split('-')
↳ 0    [hiper, mercado]
  1     [hiper, tensão]
  2     [hiper, plasia]

» # elementos não strings resultam em NaN
» serie = pd.Series([123,'-tensão','-plasia'])
» serie.str.replace('-','hiper-')
↳ 0             NaN
  1    hiper-tensão
  2    hiper-plasia

Series podem ser usadas na construção de dataframes, que serão vistos a seguir. Em particular o método to_frame() transforma uma series em um dataframe com uma coluna, onde cada valor ocupa uma linha.

» # uma series pode ser transformada em um dataframe
» df = serie.to_frame()
» # um dataframe é gerado e armazenado em df

Como a maioria dos métodos de series são análogos àqueles de dataframes faremos uma exploração mais extensa desses na sessão referente aos dataframes.

Bibliografia

• Blair,Steve: Python Data Science, The Ultimate Handbook for Beginners on How to Explore NumPy for Numerical Data, Pandas for Data Analysis, IPython, Scikit-Learn and Tensorflow for Machine Learning and Business, edição do autor disponível na Amazon, 2019.
• Harrison, Matt: Learning Pandas, Python Tools for Data Munging, Data Analysis, and Visualization,
  edição do autor, 2016.
• McKinney, Wes: pandas: powerful Python data analysistoolkit, Release 1.2.1
  publicação do Pandas Development Team, revisado em 2021.
• McKinney, Wes: Python for Data Analysis, Data Wrangling with Pandas, NumPy,and IPython
  O’Reilly Media, 2018.
• Pandas: página oficial, acessada em janeiro de 2021.
• Pandas User Guide, acessada em fevereiro de 2021.
• Miller, Curtis: On Data Analysis with NumPy and pandas, Packt Publishing, Birmingham, 2018.