Python Pandas - Краткое руководство

Pandas - это библиотека Python с открытым исходным кодом, предоставляющая высокопроизводительный инструмент для обработки и анализа данных с использованием мощных структур данных. Название Pandas происходит от слова Panel Data - эконометрика из многомерных данных.

В 2008 году разработчик Уэс МакКинни начал разрабатывать панд, когда ему требовался высокопроизводительный гибкий инструмент для анализа данных.

До Pandas Python в основном использовался для обработки и подготовки данных. Он внес очень небольшой вклад в анализ данных. Панды решили эту проблему. Используя Pandas, мы можем выполнить пять типичных шагов в обработке и анализе данных, независимо от их происхождения: загрузка, подготовка, управление, моделирование и анализ.

Python с Pandas используется в широком спектре областей, включая академические и коммерческие области, включая финансы, экономику, статистику, аналитику и т. Д.

Ключевые особенности Pandas

Быстрый и эффективный объект DataFrame со стандартной и индивидуальной индексацией.
Инструменты для загрузки данных в объекты данных в памяти из файлов разных форматов.
Согласование данных и интегрированная обработка недостающих данных.
Изменение формы и поворота наборов дат.
Нарезка на основе меток, индексация и разделение больших наборов данных.
Столбцы из структуры данных можно удалять или вставлять.
Группируйте данные для агрегирования и преобразования.
Высокопроизводительное слияние и соединение данных.
Функциональность временных рядов.

Стандартный дистрибутив Python не поставляется в комплекте с модулем Pandas. Легкая альтернатива - установить NumPy с помощью популярного установщика пакетов Python,pip.

pip install pandas

Если вы установите пакет Anaconda Python, Pandas будет установлен по умолчанию со следующим:

Windows

Anaconda (из https://www.continuum.io) - это бесплатный дистрибутив Python для стека SciPy. Он также доступен для Linux и Mac.
Canopy (https://www.enthought.com/products/canopy/) доступен как бесплатный, так и коммерческий дистрибутив с полным стеком SciPy для Windows, Linux и Mac.
Python(x, y) - это бесплатный дистрибутив Python со стеком SciPy и Spyder IDE для ОС Windows. (Можно загрузить сhttp://python-xy.github.io/)

Linux

Менеджеры пакетов соответствующих дистрибутивов Linux используются для установки одного или нескольких пакетов в стек SciPy.

For Ubuntu Users

sudo apt-get install python-numpy python-scipy python-matplotlibipythonipythonnotebook
python-pandas python-sympy python-nose

For Fedora Users

sudo yum install numpyscipy python-matplotlibipython python-pandas sympy
python-nose atlas-devel

Pandas имеет дело со следующими тремя структурами данных -

Series
DataFrame
Panel

Эти структуры данных построены на основе массива Numpy, что означает, что они быстрые.

Размер и описание

Лучший способ думать об этих структурах данных - это то, что структура данных более высокого измерения является контейнером структуры данных более низкого измерения. Например, DataFrame - это контейнер Series, Panel - контейнер DataFrame.

Структура данных	Габаритные размеры	Описание
Серии	1	Однородный массив, помеченный 1D, неизменяемый размер.
Фреймы данных	2	Общая двухмерная маркированная табличная структура с изменяемым размером и потенциально неоднородно типизированными столбцами.
Панель	3	Общий трехмерный помеченный массив с изменяемым размером.

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

Например, с табличными данными (DataFrame) семантически более полезно подумать о index (ряды) и columns вместо оси 0 и оси 1.

Изменчивость

Все структуры данных Pandas являются изменяемыми по значению (могут быть изменены), и, за исключением Series, все изменяются по размеру. Размер серии неизменен.

Note- DataFrame широко используется и является одной из самых важных структур данных. Панель используется гораздо реже.

Серии

Серия - это одномерный массив, подобный структуре с однородными данными. Например, следующая серия представляет собой набор целых чисел 10, 23, 56,…

10	23	56	17	52	61	73	90	26	72

Ключевые моменты

Однородные данные
Неизменяемый размер
Значения изменяемых данных

DataFrame

DataFrame - это двумерный массив с разнородными данными. Например,

имя	Возраст	Пол	Рейтинг
Стив	32	мужчина	3,45
Лия	28	женский	4.6
Вин	45	мужчина	3.9
Кэти	38	женский	2,78

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

Тип данных столбцов

Типы данных четырех столбцов следующие:

Столбец	Тип
имя	Строка
Возраст	Целое число
Пол	Строка
Рейтинг	Плавать

Ключевые моменты

Гетерогенные данные
Размер изменяемый
Изменяемые данные

Панель

Panel - это трехмерная структура данных с разнородными данными. Панель сложно представить в графическом виде. Но панель можно проиллюстрировать как контейнер DataFrame.

Ключевые моменты

Гетерогенные данные
Размер изменяемый
Изменяемые данные

Серия - это одномерный помеченный массив, способный хранить данные любого типа (целые, строковые, плавающие, объекты Python и т. Д.). Метки осей вместе называются индексами.

панды. серия

Серию панд можно создать с помощью следующего конструктора -

pandas.Series( data, index, dtype, copy)

Параметры конструктора следующие:

Старший Нет	Параметр и описание
1	data данные принимают различные формы, такие как ndarray, список, константы
2	index Значения индекса должны быть уникальными и хешируемыми, той же длины, что и данные. По умолчаниюnp.arange(n) если индекс не передан.
3	dtype dtype предназначен для типа данных. Если нет, будет выведен тип данных.
4	copy Скопируйте данные. По умолчанию False

Серия может быть создана с использованием различных входов, таких как -

Array
Dict
Скалярное значение или константа

Создать пустую серию

Базовая серия, которую можно создать, - это пустая серия.

пример

#import the pandas library and aliasing as pd
import pandas as pd
s = pd.Series()
print s

это output выглядит следующим образом -

Series([], dtype: float64)

Создать серию из ndarray

Если данные представляют собой массив ndarray, то переданный индекс должен иметь одинаковую длину. Если индекс не передан, то по умолчанию индекс будетrange(n) где n - длина массива, т.е. [0,1,2,3…. range(len(array))-1].

Пример 1

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data)
print s

это output выглядит следующим образом -

0   a
1   b
2   c
3   d
dtype: object

Мы не передавали никакого индекса, поэтому по умолчанию он присвоил индексы от 0 до len(data)-1, то есть от 0 до 3.

Пример 2

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data,index=[100,101,102,103])
print s

это output выглядит следующим образом -

100  a
101  b
102  c
103  d
dtype: object

Мы передали сюда значения индекса. Теперь мы можем видеть настроенные индексированные значения на выходе.

Создать серию из dict

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

Пример 1

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data)
print s

это output выглядит следующим образом -

a 0.0
b 1.0
c 2.0
dtype: float64

Observe - Ключи словаря используются для построения индекса.

Пример 2

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data,index=['b','c','d','a'])
print s

это output выглядит следующим образом -

b 1.0
c 2.0
d NaN
a 0.0
dtype: float64

Observe - Порядок индекса сохраняется, а отсутствующий элемент заполняется NaN (не числом).

Создать серию из скаляра

Если данные представляют собой скалярное значение, необходимо указать индекс. Значение будет повторяться, чтобы соответствовать длинеindex

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np
s = pd.Series(5, index=[0, 1, 2, 3])
print s

это output выглядит следующим образом -

0  5
1  5
2  5
3  5
dtype: int64

Доступ к данным из серии с позицией

Доступ к данным в серии можно получить так же, как в ndarray.

Пример 1

Получить первый элемент. Как мы уже знаем, что отсчет начинается с нуля для массива, что означает , что первый элемент сохраняется в нуле - ^е места и так далее.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve the first element
print s[0]

это output выглядит следующим образом -

Пример 2

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

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve the first three element
print s[:3]

это output выглядит следующим образом -

a  1
b  2
c  3
dtype: int64

Пример 3

Получите последние три элемента.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve the last three element
print s[-3:]

это output выглядит следующим образом -

c  3
d  4
e  5
dtype: int64

Получить данные с помощью метки (индекс)

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

Пример 1

Получить один элемент, используя значение метки индекса.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve a single element
print s['a']

это output выглядит следующим образом -

Пример 2

Получите несколько элементов, используя список значений метки индекса.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve multiple elements
print s[['a','c','d']]

это output выглядит следующим образом -

a  1
c  3
d  4
dtype: int64

Пример 3

Если метка отсутствует, возникает исключение.

import pandas as pd
s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])

#retrieve multiple elements
print s['f']

это output выглядит следующим образом -

…
KeyError: 'f'

Фрейм данных - это двумерная структура данных, т. Е. Данные выровнены в табличной форме по строкам и столбцам.

Особенности DataFrame

Потенциально столбцы бывают разных типов
Размер - изменяемый
Помеченные оси (строки и столбцы)
Может выполнять арифметические операции со строками и столбцами

Структура

Предположим, что мы создаем фрейм данных с данными студента.

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

pandas.DataFrame

DataFrame pandas можно создать с помощью следующего конструктора -

pandas.DataFrame( data, index, columns, dtype, copy)

Параметры конструктора следующие:

Старший Нет	Параметр и описание
1	data данные принимают различные формы, такие как ndarray, series, map, lists, dict, constants, а также другой DataFrame.
2	index Для меток строк индекс, который будет использоваться для результирующего кадра, является необязательным по умолчанию np.arange (n), если индекс не передан.
3	columns Для меток столбцов необязательный синтаксис по умолчанию - np.arange (n). Это верно только в том случае, если индекс не передан.
4	dtype Тип данных каждого столбца.
5	copy Эта команда (или что-то еще) используется для копирования данных, если по умолчанию установлено значение False.

Создать DataFrame

DataFrame pandas может быть создан с использованием различных входных данных, таких как -

Lists
dict
Series
Numpy ndarrays
Другой DataFrame

В следующих разделах этой главы мы увидим, как создать DataFrame, используя эти входные данные.

Создать пустой фрейм данных

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

пример

#import the pandas library and aliasing as pd
import pandas as pd
df = pd.DataFrame()
print df

это output выглядит следующим образом -

Empty DataFrame
Columns: []
Index: []

Создать DataFrame из списков

DataFrame может быть создан с использованием одного списка или списка списков.

Пример 1

import pandas as pd
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print df

это output выглядит следующим образом -

Пример 2

import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'])
print df

это output выглядит следующим образом -

Name      Age
0     Alex      10
1     Bob       12
2     Clarke    13

Пример 3

import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'],dtype=float)
print df

это output выглядит следующим образом -

Name     Age
0     Alex     10.0
1     Bob      12.0
2     Clarke   13.0

Note - Обратите внимание, dtype Параметр изменяет тип столбца Age на плавающую точку.

Создайте DataFrame из Dict из ndarrays / Lists

Все ndarraysдолжны быть одинаковой длины. Если передается index, то длина индекса должна быть равна длине массивов.

Если индекс не передан, то по умолчанию индекс будет диапазоном (n), где n - длина массива.

Пример 1

import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data)
print df

это output выглядит следующим образом -

Age      Name
0     28        Tom
1     34       Jack
2     29      Steve
3     42      Ricky

Note- Соблюдайте значения 0,1,2,3. Они являются индексом по умолчанию, назначаемым каждому с помощью диапазона функций (n).

Пример 2

Давайте теперь создадим индексированный DataFrame с использованием массивов.

import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4'])
print df

это output выглядит следующим образом -

Age    Name
rank1    28      Tom
rank2    34     Jack
rank3    29    Steve
rank4    42    Ricky

Note - Обратите внимание, index Параметр присваивает индекс каждой строке.

Создать DataFrame из списка Dicts

Список словарей можно передать в качестве входных данных для создания DataFrame. Ключи словаря по умолчанию используются как имена столбцов.

Пример 1

В следующем примере показано, как создать DataFrame, передав список словарей.

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print df

это output выглядит следующим образом -

a    b      c
0   1   2     NaN
1   5   10   20.0

Note - Обратите внимание, NaN (не число) добавляется в пропущенные области.

Пример 2

В следующем примере показано, как создать DataFrame, передав список словарей и индексы строк.

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data, index=['first', 'second'])
print df

это output выглядит следующим образом -

a   b       c
first   1   2     NaN
second  5   10   20.0

Пример 3

В следующем примере показано, как создать DataFrame со списком словарей, индексов строк и индексов столбцов.

import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]

#With two column indices, values same as dictionary keys
df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b'])

#With two column indices with one index with other name
df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1'])
print df1
print df2

это output выглядит следующим образом -

#df1 output
         a  b
first    1  2
second   5  10

#df2 output
         a  b1
first    1  NaN
second   5  NaN

Note- Заметьте, df2 DataFrame создается с индексом столбца, отличным от ключа словаря; таким образом, добавлены NaN на место. Принимая во внимание, что df1 создается с индексами столбцов, такими же, как ключи словаря, поэтому добавляется NaN.

Создайте DataFrame из Dict of Series

Dictionary of Series может быть передан для формирования DataFrame. Результирующий индекс - это объединение всех переданных индексов серии.

пример

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df

это output выглядит следующим образом -

one    two
a     1.0    1
b     2.0    2
c     3.0    3
d     NaN    4

Note - Обратите внимание, для серии один ярлык отсутствует ‘d’ прошло, но в результате для d метка, к NaN добавляется NaN.

Давайте теперь поймем column selection, addition, и deletion через примеры.

Выбор столбца

Мы поймем это, выбрав столбец из DataFrame.

пример

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df ['one']

это output выглядит следующим образом -

a     1.0
b     2.0
c     3.0
d     NaN
Name: one, dtype: float64

Добавление столбца

Мы поймем это, добавив новый столбец в существующий фрейм данных.

пример

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)

# Adding a new column to an existing DataFrame object with column label by passing new series

print ("Adding a new column by passing as Series:")
df['three']=pd.Series([10,20,30],index=['a','b','c'])
print df

print ("Adding a new column using the existing columns in DataFrame:")
df['four']=df['one']+df['three']

print df

это output выглядит следующим образом -

Adding a new column by passing as Series:
     one   two   three
a    1.0    1    10.0
b    2.0    2    20.0
c    3.0    3    30.0
d    NaN    4    NaN

Adding a new column using the existing columns in DataFrame:
      one   two   three    four
a     1.0    1    10.0     11.0
b     2.0    2    20.0     22.0
c     3.0    3    30.0     33.0
d     NaN    4     NaN     NaN

Удаление столбца

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

пример

# Using the previous DataFrame, we will delete a column
# using del function
import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd']), 
   'three' : pd.Series([10,20,30], index=['a','b','c'])}

df = pd.DataFrame(d)
print ("Our dataframe is:")
print df

# using del function
print ("Deleting the first column using DEL function:")
del df['one']
print df

# using pop function
print ("Deleting another column using POP function:")
df.pop('two')
print df

это output выглядит следующим образом -

Our dataframe is:
      one   three  two
a     1.0    10.0   1
b     2.0    20.0   2
c     3.0    30.0   3
d     NaN     NaN   4

Deleting the first column using DEL function:
      three    two
a     10.0     1
b     20.0     2
c     30.0     3
d     NaN      4

Deleting another column using POP function:
   three
a  10.0
b  20.0
c  30.0
d  NaN

Выбор, добавление и удаление строк

Теперь мы разберемся с выбором, добавлением и удалением строк на примерах. Начнем с концепции отбора.

Выбор по метке

Строки можно выбрать, передав метку строки в loc функция.

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df.loc['b']

это output выглядит следующим образом -

one 2.0
two 2.0
Name: b, dtype: float64

Результатом является серия с метками в качестве имен столбцов DataFrame. И имя серии - это метка, с которой она извлекается.

Выбор по целочисленному положению

Строки можно выбрать, передав целочисленное расположение в iloc функция.

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df.iloc[2]

это output выглядит следующим образом -

one   3.0
two   3.0
Name: c, dtype: float64

Нарезать строки

Несколько строк можно выбрать с помощью оператора ':'.

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']), 
   'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)
print df[2:4]

это output выглядит следующим образом -

one  two
c  3.0    3
d  NaN    4

Добавление строк

Добавьте новые строки в DataFrame, используя appendфункция. Эта функция добавит строки в конец.

import pandas as pd

df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])

df = df.append(df2)
print df

это output выглядит следующим образом -

Удаление строк

Используйте метку индекса, чтобы удалить или отбросить строки из DataFrame. Если метка дублируется, то несколько строк будут отброшены.

Если вы заметили, в приведенном выше примере метки дублируются. Давайте сбросим метку и посмотрим, сколько строк будет отброшено.

import pandas as pd

df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])

df = df.append(df2)

# Drop rows with label 0
df = df.drop(0)

print df

это output выглядит следующим образом -

a b
1 3 4
1 7 8

В приведенном выше примере две строки были отброшены, потому что эти две содержат одинаковую метку 0.

А panelпредставляет собой трехмерный контейнер данных. СрокPanel data происходит от эконометрики и частично отвечает за название pandas - pan(el)-da(ta)-с.

Названия трех осей предназначены для придания некоторого семантического значения описанию операций с панельными данными. Они -

items - ось 0, каждый элемент соответствует содержащемуся внутри DataFrame.
major_axis - ось 1, это индекс (строки) каждого из DataFrames.
minor_axis - ось 2, это столбцы каждого из DataFrames.

pandas.Panel ()

Панель можно создать с помощью следующего конструктора -

pandas.Panel(data, items, major_axis, minor_axis, dtype, copy)

Параметры конструктора следующие:

Параметр	Описание
данные	Данные принимают различные формы, такие как ndarray, series, map, lists, dict, constants, а также другой DataFrame.
Предметы	ось = 0
major_axis	ось = 1
minor_axis	ось = 2
dtype	Тип данных каждого столбца
копировать	Скопируйте данные. По умолчанию,false

Создать панель

Панель можно создать несколькими способами, например:

Из ndarrays
Из dict DataFrames

Из 3D ndarray

# creating an empty panel
import pandas as pd
import numpy as np

data = np.random.rand(2,4,5)
p = pd.Panel(data)
print p

это output выглядит следующим образом -

<class 'pandas.core.panel.Panel'>
Dimensions: 2 (items) x 4 (major_axis) x 5 (minor_axis)
Items axis: 0 to 1
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 4

Note - Обратите внимание на размеры пустой панели и панели выше, все объекты разные.

Из dict объектов DataFrame

#creating an empty panel
import pandas as pd
import numpy as np

data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p

это output выглядит следующим образом -

Dimensions: 2 (items) x 4 (major_axis) x 3 (minor_axis)
Items axis: Item1 to Item2
Major_axis axis: 0 to 3
Minor_axis axis: 0 to 2

Создать пустую панель

Пустую панель можно создать с помощью конструктора Panel следующим образом:

#creating an empty panel
import pandas as pd
p = pd.Panel()
print p

это output выглядит следующим образом -

<class 'pandas.core.panel.Panel'>
Dimensions: 0 (items) x 0 (major_axis) x 0 (minor_axis)
Items axis: None
Major_axis axis: None
Minor_axis axis: None

Выбор данных из панели

Выберите данные на панели, используя -

Items
Major_axis
Minor_axis

Использование предметов

# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p['Item1']

это output выглядит следующим образом -

0          1          2
0    0.488224  -0.128637   0.930817
1    0.417497   0.896681   0.576657
2   -2.775266   0.571668   0.290082
3   -0.400538  -0.144234   1.110535

У нас есть два элемента, и мы получили item1. Результатом является DataFrame с 4 строками и 3 столбцами, которые являютсяMajor_axis и Minor_axis Габаритные размеры.

Использование major_axis

Доступ к данным можно получить с помощью метода panel.major_axis(index).

# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.major_xs(1)

это output выглядит следующим образом -

Item1       Item2
0   0.417497    0.748412
1   0.896681   -0.557322
2   0.576657       NaN

Использование minor_axis

Доступ к данным можно получить с помощью метода panel.minor_axis(index).

# creating an empty panel
import pandas as pd
import numpy as np
data = {'Item1' : pd.DataFrame(np.random.randn(4, 3)), 
   'Item2' : pd.DataFrame(np.random.randn(4, 2))}
p = pd.Panel(data)
print p.minor_xs(1)

это output выглядит следующим образом -

Item1       Item2
0   -0.128637   -1.047032
1    0.896681   -0.557322
2    0.571668    0.431953
3   -0.144234    1.302466

Note - Понаблюдайте за изменением размеров.

К настоящему времени мы узнали о трех структурах данных Pandas и о том, как их создавать. Мы в основном сосредоточимся на объектах DataFrame из-за их важности для обработки данных в реальном времени, а также обсудим несколько других структур данных.

Основные функции серии

Sr.No.	Атрибут или метод и описание
1	axes Возвращает список меток оси строк
2	dtype Возвращает dtype объекта.
3	empty Возвращает True, если серия пуста.
4	ndim Возвращает количество измерений базовых данных по определению 1.
5	size Возвращает количество элементов в базовых данных.
6	values Возвращает серию как ndarray.
7	head() Возвращает первые n строк.
8	tail() Возвращает последние n строк.

Давайте теперь создадим серию и посмотрим на все вышеупомянутые операции с табличными атрибутами.

пример

import pandas as pd
import numpy as np

#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print s

это output выглядит следующим образом -

0   0.967853
1  -0.148368
2  -1.395906
3  -1.758394
dtype: float64

топоры

Возвращает список меток серии.

import pandas as pd
import numpy as np

#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("The axes are:")
print s.axes

это output выглядит следующим образом -

The axes are:
[RangeIndex(start=0, stop=4, step=1)]

Результатом выше является компактный формат списка значений от 0 до 5, то есть [0,1,2,3,4].

пустой

Возвращает логическое значение, показывающее, является ли объект пустым или нет. Истина означает, что объект пуст.

import pandas as pd
import numpy as np

#Create a series with 100 random numbers
s = pd.Series(np.random.randn(4))
print ("Is the Object empty?")
print s.empty

это output выглядит следующим образом -

Is the Object empty?
False

ndim

Возвращает количество измерений объекта. По определению, серия - это одномерная структура данных, поэтому она возвращает

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s

print ("The dimensions of the object:")
print s.ndim

это output выглядит следующим образом -

0   0.175898
1   0.166197
2  -0.609712
3  -1.377000
dtype: float64

The dimensions of the object:
1

размер

Возвращает размер (длину) серии.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(2))
print s
print ("The size of the object:")
print s.size

это output выглядит следующим образом -

0   3.078058
1  -1.207803
dtype: float64

The size of the object:
2

значения

Возвращает фактические данные в серии в виде массива.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print s

print ("The actual data series is:")
print s.values

это output выглядит следующим образом -

0   1.787373
1  -0.605159
2   0.180477
3  -0.140922
dtype: float64

The actual data series is:
[ 1.78737302 -0.60515881 0.18047664 -0.1409218 ]

Голова и хвост

Чтобы просмотреть небольшой образец объекта Series или DataFrame, используйте методы head () и tail ().

head() возвращает первый nстрок (обратите внимание на значения индекса). По умолчанию количество отображаемых элементов равно пяти, но вы можете передать собственное число.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s

print ("The first two rows of the data series:")
print s.head(2)

это output выглядит следующим образом -

The original series is:
0   0.720876
1  -0.765898
2   0.479221
3  -0.139547
dtype: float64

The first two rows of the data series:
0   0.720876
1  -0.765898
dtype: float64

tail() возвращает последний nстрок (обратите внимание на значения индекса). По умолчанию количество отображаемых элементов равно пяти, но вы можете передать собственное число.

import pandas as pd
import numpy as np

#Create a series with 4 random numbers
s = pd.Series(np.random.randn(4))
print ("The original series is:")
print s

print ("The last two rows of the data series:")
print s.tail(2)

это output выглядит следующим образом -

The original series is:
0 -0.655091
1 -0.881407
2 -0.608592
3 -2.341413
dtype: float64

The last two rows of the data series:
2 -0.608592
3 -2.341413
dtype: float64

Базовые функции DataFrame

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

Sr.No.	Атрибут или метод и описание
1	T Переставляет строки и столбцы.
2	axes Возвращает список с метками оси строк и метками оси столбцов в качестве единственных членов.
3	dtypes Возвращает типы в этом объекте.
4	empty Истинно, если NDFrame полностью пуст [нет элементов]; если какая-либо из осей имеет длину 0.
5	ndim Количество осей / размеров массива.
6	shape Возвращает кортеж, представляющий размерность DataFrame.
7	size Количество элементов в NDFrame.
8	values Numpy представление NDFrame.
9	head() Возвращает первые n строк.
10	tail() Возвращает последние n строк.

Давайте теперь создадим DataFrame и посмотрим, как работают вышеупомянутые атрибуты.

пример

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data series is:")
print df

это output выглядит следующим образом -

Our data series is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

T (транспонировать)

Возвращает транспонированный DataFrame. Строки и столбцы поменяются местами.

import pandas as pd
import numpy as np
 
# Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

# Create a DataFrame
df = pd.DataFrame(d)
print ("The transpose of the data series is:")
print df.T

это output выглядит следующим образом -

The transpose of the data series is:
         0     1       2      3      4      5       6
Age      25    26      25     23     30     29      23
Name     Tom   James   Ricky  Vin    Steve  Smith   Jack
Rating   4.23  3.24    3.98   2.56   3.2    4.6     3.8

топоры

Возвращает список меток осей строк и меток осей столбцов.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Row axis labels and column axis labels are:")
print df.axes

это output выглядит следующим образом -

Row axis labels and column axis labels are:

[RangeIndex(start=0, stop=7, step=1), Index([u'Age', u'Name', u'Rating'],
dtype='object')]

dtypes

Возвращает тип данных каждого столбца.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("The data types of each column are:")
print df.dtypes

это output выглядит следующим образом -

The data types of each column are:
Age     int64
Name    object
Rating  float64
dtype: object

пустой

Возвращает логическое значение, показывающее, пуст объект или нет; Истина означает, что объект пуст.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Is the object empty?")
print df.empty

это output выглядит следующим образом -

Is the object empty?
False

ndim

Возвращает количество измерений объекта. По определению DataFrame - это 2D-объект.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The dimension of the object is:")
print df.ndim

это output выглядит следующим образом -

Our object is:
      Age    Name     Rating
0     25     Tom      4.23
1     26     James    3.24
2     25     Ricky    3.98
3     23     Vin      2.56
4     30     Steve    3.20
5     29     Smith    4.60
6     23     Jack     3.80

The dimension of the object is:
2

форма

Возвращает кортеж, представляющий размерность DataFrame. Кортеж (a, b), где a представляет количество строк, аb представляет количество столбцов.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The shape of the object is:")
print df.shape

это output выглядит следующим образом -

Our object is:
   Age   Name    Rating
0  25    Tom     4.23
1  26    James   3.24
2  25    Ricky   3.98
3  23    Vin     2.56
4  30    Steve   3.20
5  29    Smith   4.60
6  23    Jack    3.80

The shape of the object is:
(7, 3)

размер

Возвращает количество элементов в DataFrame.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The total number of elements in our object is:")
print df.size

это output выглядит следующим образом -

Our object is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

The total number of elements in our object is:
21

значения

Возвращает фактические данные в DataFrame в виде NDarray.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our object is:")
print df
print ("The actual data in our data frame is:")
print df.values

это output выглядит следующим образом -

Our object is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80
The actual data in our data frame is:
[[25 'Tom' 4.23]
[26 'James' 3.24]
[25 'Ricky' 3.98]
[23 'Vin' 2.56]
[30 'Steve' 3.2]
[29 'Smith' 4.6]
[23 'Jack' 3.8]]

Голова и хвост

Чтобы просмотреть небольшой образец объекта DataFrame, используйте head() и tail () методы. head() возвращает первый nстрок (обратите внимание на значения индекса). По умолчанию количество отображаемых элементов равно пяти, но вы можете передать собственное число.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The first two rows of the data frame is:")
print df.head(2)

это output выглядит следующим образом -

Our data frame is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

The first two rows of the data frame is:
   Age   Name   Rating
0  25    Tom    4.23
1  26    James  3.24

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack']),
   'Age':pd.Series([25,26,25,23,30,29,23]), 
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
 
#Create a DataFrame
df = pd.DataFrame(d)
print ("Our data frame is:")
print df
print ("The last two rows of the data frame is:")
print df.tail(2)

это output выглядит следующим образом -

Our data frame is:
    Age   Name    Rating
0   25    Tom     4.23
1   26    James   3.24
2   25    Ricky   3.98
3   23    Vin     2.56
4   30    Steve   3.20
5   29    Smith   4.60
6   23    Jack    3.80

The last two rows of the data frame is:
    Age   Name    Rating
5   29    Smith    4.6
6   23    Jack     3.8

Большое количество методов совместно вычисляют описательную статистику и другие связанные операции с DataFrame. Большинство из них представляют собой агрегаты типаsum(), mean(), но некоторые из них, как sumsum(), создайте объект того же размера. Вообще говоря, эти методы требуютaxisаргумент, как и ndarray. {sum, std, ...}, но ось может быть указана по имени или целому числу

DataFrame - «индекс» (ось = 0, по умолчанию), «столбцы» (ось = 1)

Давайте создадим DataFrame и будем использовать этот объект в этой главе для всех операций.

пример

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df

это output выглядит следующим образом -

Age  Name   Rating
0   25   Tom     4.23
1   26   James   3.24
2   25   Ricky   3.98
3   23   Vin     2.56
4   30   Steve   3.20
5   29   Smith   4.60
6   23   Jack    3.80
7   34   Lee     3.78
8   40   David   2.98
9   30   Gasper  4.80
10  51   Betina  4.10
11  46   Andres  3.65

sum()

Returns the sum of the values for the requested axis. By default, axis is index (axis=0).

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.sum()

Its output is as follows −

Age                                                    382
Name     TomJamesRickyVinSteveSmithJackLeeDavidGasperBe...
Rating                                               44.92
dtype: object

Each individual column is added individually (Strings are appended).

axis=1

This syntax will give the output as shown below.

import pandas as pd
import numpy as np
 
#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}
 
#Create a DataFrame
df = pd.DataFrame(d)
print df.sum(1)

это output выглядит следующим образом -

0    29.23
1    29.24
2    28.98
3    25.56
4    33.20
5    33.60
6    26.80
7    37.78
8    42.98
9    34.80
10   55.10
11   49.65
dtype: float64

значить()

Возвращает среднее значение.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.mean()

это output выглядит следующим образом -

Age       31.833333
Rating     3.743333
dtype: float64

std ()

Возвращает стандартное отклонение Бресселя числовых столбцов.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.std()

это output выглядит следующим образом -

Age       9.232682
Rating    0.661628
dtype: float64

Функции и описание

Давайте теперь разберемся с функциями описательной статистики в Python Pandas. В следующей таблице перечислены важные функции -

Sr.No.	Функция	Описание
1	count ()	Количество ненулевых наблюдений
2	сумма ()	Сумма значений
3	значить()	Среднее значение
4	медиана ()	Медиана значений
5	Режим()	Режим ценностей
6	std ()	Стандартное отклонение значений
7	мин ()	Минимальное значение
8	Максимум()	Максимальное значение
9	абс ()	Абсолютная величина
10	prod ()	Продукт ценностей
11	кончает ()	Накопительная сумма
12	cumprod ()	Совокупный продукт

Note- Поскольку DataFrame - это гетерогенная структура данных. Общие операции работают не со всеми функциями.

Функции вроде sum(), cumsum()работать как с числовыми, так и с символьными (или) строковыми элементами данных без ошибок. Хотяn На практике агрегаты символов обычно никогда не используются, эти функции не вызывают никаких исключений.
Функции вроде abs(), cumprod() генерировать исключение, когда DataFrame содержит символьные или строковые данные, поскольку такие операции не могут быть выполнены.

Обобщение данных

В describe() Функция вычисляет сводку статистики, относящуюся к столбцам DataFrame.

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.describe()

это output выглядит следующим образом -

Age         Rating
count    12.000000      12.000000
mean     31.833333       3.743333
std       9.232682       0.661628
min      23.000000       2.560000
25%      25.000000       3.230000
50%      29.500000       3.790000
75%      35.500000       4.132500
max      51.000000       4.800000

Эта функция дает mean, std и IQRзначения. И функция исключает символьные столбцы и дает сводку о числовых столбцах.'include'- это аргумент, который используется для передачи необходимой информации о том, какие столбцы необходимо учитывать при подведении итогов. Принимает список значений; по умолчанию "число".

object - Суммирует строковые столбцы
number - Суммирует числовые столбцы
all - Суммирует все столбцы вместе (не следует передавать как значение списка)

Теперь используйте в программе следующий оператор и проверьте вывод -

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df.describe(include=['object'])

это output выглядит следующим образом -

Name
count       12
unique      12
top      Ricky
freq         1

Теперь используйте следующий оператор и проверьте вывод -

import pandas as pd
import numpy as np

#Create a Dictionary of series
d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Smith','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])
}

#Create a DataFrame
df = pd.DataFrame(d)
print df. describe(include='all')

это output выглядит следующим образом -

Age          Name       Rating
count   12.000000        12    12.000000
unique        NaN        12          NaN
top           NaN     Ricky          NaN
freq          NaN         1          NaN
mean    31.833333       NaN     3.743333
std      9.232682       NaN     0.661628
min     23.000000       NaN     2.560000
25%     25.000000       NaN     3.230000
50%     29.500000       NaN     3.790000
75%     35.500000       NaN     4.132500
max     51.000000       NaN     4.800000

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

Табличное применение функции: pipe ()
Применение мудрой функции строки или столбца: apply ()
Элементарное применение функции: applymap ()

Табличное приложение функции

Пользовательские операции можно выполнять, передав функцию и соответствующее количество параметров в качестве аргументов канала. Таким образом, операция выполняется над всем DataFrame.

Например, добавьте значение 2 ко всем элементам в DataFrame. Потом,

функция сумматора

Функция сумматора складывает два числовых значения в качестве параметров и возвращает сумму.

def adder(ele1,ele2):
   return ele1+ele2

Теперь мы будем использовать настраиваемую функцию для выполнения операции с DataFrame.

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)

Посмотрим полную программу -

import pandas as pd
import numpy as np

def adder(ele1,ele2):
   return ele1+ele2

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.pipe(adder,2)
print df.apply(np.mean)

это output выглядит следующим образом -

col1       col2       col3
0   2.176704   2.219691   1.509360
1   2.222378   2.422167   3.953921
2   2.241096   1.135424   2.696432
3   2.355763   0.376672   1.182570
4   2.308743   2.714767   2.130288

Применение мудрой функции строки или столбца

Произвольные функции могут применяться по осям DataFrame или Panel с помощью apply(), который, как и методы описательной статистики, принимает необязательный аргумент оси. По умолчанию операция выполняется по столбцам, принимая каждый столбец как массив.

Пример 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean)
print df.apply(np.mean)

это output выглядит следующим образом -

col1   -0.288022
col2    1.044839
col3   -0.187009
dtype: float64

Мимо axis параметра, операции могут выполняться построчно.

Пример 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(np.mean,axis=1)
print df.apply(np.mean)

это output выглядит следующим образом -

col1    0.034093
col2   -0.152672
col3   -0.229728
dtype: float64

Пример 3

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.apply(lambda x: x.max() - x.min())
print df.apply(np.mean)

это output выглядит следующим образом -

col1   -0.167413
col2   -0.370495
col3   -0.707631
dtype: float64

Приложение Element Wise Function

Не все функции могут быть векторизованы (ни массивы NumPy, которые возвращают другой массив, ни какое-либо значение), методы applymap() на DataFrame и analogously map() on Series принимают любую функцию Python, принимающую одно значение и возвращающую одно значение.

Пример 1

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])

# My custom function
df['col1'].map(lambda x:x*100)
print df.apply(np.mean)

это output выглядит следующим образом -

col1    0.480742
col2    0.454185
col3    0.266563
dtype: float64

Пример 2

import pandas as pd
import numpy as np

# My custom function
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
df.applymap(lambda x:x*100)
print df.apply(np.mean)

это output выглядит следующим образом -

col1    0.395263
col2    0.204418
col3   -0.795188
dtype: float64

Reindexingизменяет метки строк и столбцов в DataFrame. Чтобы проиндексировать средства для согласования данных в соответствии с заданным набором меток вдоль определенной оси.

Несколько операций могут быть выполнены с помощью индексации, например:

Измените порядок существующих данных, чтобы они соответствовали новому набору меток.
Вставьте маркеры отсутствующего значения (NA) в те места метки, где не было данных для метки.

пример

import pandas as pd
import numpy as np

N=20

df = pd.DataFrame({
   'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
   'x': np.linspace(0,stop=N-1,num=N),
   'y': np.random.rand(N),
   'C': np.random.choice(['Low','Medium','High'],N).tolist(),
   'D': np.random.normal(100, 10, size=(N)).tolist()
})

#reindex the DataFrame
df_reindexed = df.reindex(index=[0,2,5], columns=['A', 'C', 'B'])

print df_reindexed

это output выглядит следующим образом -

A    C     B
0  2016-01-01  Low   NaN
2  2016-01-03  High  NaN
5  2016-01-06  Low   NaN

Переиндексировать, чтобы выровнять с другими объектами

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

пример

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randn(10,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(7,3),columns=['col1','col2','col3'])

df1 = df1.reindex_like(df2)
print df1

это output выглядит следующим образом -

col1         col2         col3
0    -2.467652    -1.211687    -0.391761
1    -0.287396     0.522350     0.562512
2    -0.255409    -0.483250     1.866258
3    -1.150467    -0.646493    -0.222462
4     0.152768    -2.056643     1.877233
5    -1.155997     1.528719    -1.343719
6    -1.015606    -1.245936    -0.295275

Note - Здесь df1 DataFrame изменен и переиндексирован как df2. Имена столбцов должны совпадать, иначе NAN будет добавлен для всей метки столбца.

Заполнение при переиндексировании

reindex() принимает необязательный метод параметра, который является методом заполнения следующими значениями:

pad/ffill - Заполнить значения вперед
bfill/backfill - Заполнить значения назад
nearest - Заполнение от ближайших значений индекса

пример

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])

# Padding NAN's
print df2.reindex_like(df1)

# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill:")
print df2.reindex_like(df1,method='ffill')

это output выглядит следующим образом -

col1        col2       col3
0    1.311620   -0.707176   0.599863
1   -0.423455   -0.700265   1.133371
2         NaN         NaN        NaN
3         NaN         NaN        NaN
4         NaN         NaN        NaN
5         NaN         NaN        NaN

Data Frame with Forward Fill:
         col1        col2        col3
0    1.311620   -0.707176    0.599863
1   -0.423455   -0.700265    1.133371
2   -0.423455   -0.700265    1.133371
3   -0.423455   -0.700265    1.133371
4   -0.423455   -0.700265    1.133371
5   -0.423455   -0.700265    1.133371

Note - Последние четыре ряда заполнены.

Ограничения на заполнение при переиндексировании

Аргумент limit обеспечивает дополнительный контроль над заполнением при переиндексации. Лимит определяет максимальное количество последовательных совпадений. Давайте рассмотрим следующий пример, чтобы понять то же самое -

пример

import pandas as pd
import numpy as np
 
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])

# Padding NAN's
print df2.reindex_like(df1)

# Now Fill the NAN's with preceding Values
print ("Data Frame with Forward Fill limiting to 1:")
print df2.reindex_like(df1,method='ffill',limit=1)

это output выглядит следующим образом -

col1        col2        col3
0    0.247784    2.128727    0.702576
1   -0.055713   -0.021732   -0.174577
2         NaN         NaN         NaN
3         NaN         NaN         NaN
4         NaN         NaN         NaN
5         NaN         NaN         NaN

Data Frame with Forward Fill limiting to 1:
         col1        col2        col3
0    0.247784    2.128727    0.702576
1   -0.055713   -0.021732   -0.174577
2   -0.055713   -0.021732   -0.174577
3         NaN         NaN         NaN
4         NaN         NaN         NaN
5         NaN         NaN         NaN

Note- Обратите внимание, только 7-я строка заполняется предыдущей 6-й строкой. Затем строки остаются как есть.

Переименование

Метод rename () позволяет вам изменить метку оси на основе некоторого сопоставления (dict или Series) или произвольной функции.

Давайте рассмотрим следующий пример, чтобы понять это -

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
print df1

print ("After renaming the rows and columns:")
print df1.rename(columns={'col1' : 'c1', 'col2' : 'c2'},
index = {0 : 'apple', 1 : 'banana', 2 : 'durian'})

это output выглядит следующим образом -

col1        col2        col3
0    0.486791    0.105759    1.540122
1   -0.990237    1.007885   -0.217896
2   -0.483855   -1.645027   -1.194113
3   -0.122316    0.566277   -0.366028
4   -0.231524   -0.721172   -0.112007
5    0.438810    0.000225    0.435479

After renaming the rows and columns:
                c1          c2        col3
apple     0.486791    0.105759    1.540122
banana   -0.990237    1.007885   -0.217896
durian   -0.483855   -1.645027   -1.194113
3        -0.122316    0.566277   -0.366028
4        -0.231524   -0.721172   -0.112007
5         0.438810    0.000225    0.435479

Метод rename () предоставляет inplaceименованный параметр, который по умолчанию имеет значение False и копирует базовые данные. Проходитьinplace=True чтобы переименовать данные на месте.

Поведение базовой итерации по объектам Pandas зависит от типа. При итерации по Серии она рассматривается как массив, и базовая итерация производит значения. Другие структуры данных, такие как DataFrame и Panel, соответствуютdict-like соглашение об итерации по keys объектов.

Короче говоря, базовая итерация (для i в объекте) производит -

Series - ценности
DataFrame - подписи столбцов
Panel - ярлыки предметов

Итерация DataFrame

Итерация DataFrame дает имена столбцов. Давайте рассмотрим следующий пример, чтобы понять то же самое.

import pandas as pd
import numpy as np
 
N=20
df = pd.DataFrame({
   'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
   'x': np.linspace(0,stop=N-1,num=N),
   'y': np.random.rand(N),
   'C': np.random.choice(['Low','Medium','High'],N).tolist(),
   'D': np.random.normal(100, 10, size=(N)).tolist()
   })

for col in df:
   print col

это output выглядит следующим образом -

A
C
D
x
y

Чтобы перебирать строки DataFrame, мы можем использовать следующие функции:

iteritems() - перебирать пары (ключ, значение)
iterrows() - перебирать строки как пары (индекс, серия)
itertuples() - перебирать строки как именованные кортежи

iteritems ()

Итерации по каждому столбцу как пара ключ, значение с меткой как ключ и значение столбца как объект серии.

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(4,3),columns=['col1','col2','col3'])
for key,value in df.iteritems():
   print key,value

это output выглядит следующим образом -

col1 0    0.802390
1    0.324060
2    0.256811
3    0.839186
Name: col1, dtype: float64

col2 0    1.624313
1   -1.033582
2    1.796663
3    1.856277
Name: col2, dtype: float64

col3 0   -0.022142
1   -0.230820
2    1.160691
3   -0.830279
Name: col3, dtype: float64

Обратите внимание, каждый столбец повторяется отдельно как пара ключ-значение в серии.

iterrows ()

iterrows () возвращает итератор, дающий каждое значение индекса вместе с серией, содержащей данные в каждой строке.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row_index,row in df.iterrows():
   print row_index,row

это output выглядит следующим образом -

0  col1    1.529759
   col2    0.762811
   col3   -0.634691
Name: 0, dtype: float64

1  col1   -0.944087
   col2    1.420919
   col3   -0.507895
Name: 1, dtype: float64
 
2  col1   -0.077287
   col2   -0.858556
   col3   -0.663385
Name: 2, dtype: float64
3  col1    -1.638578
   col2     0.059866
   col3     0.493482
Name: 3, dtype: float64

Note - Потому что iterrows()перебирать строки, он не сохраняет тип данных по строке. 0,1,2 - это индексы строк, а col1, col2, col3 - индексы столбцов.

itertuples ()

Метод itertuples () вернет итератор, дающий именованный кортеж для каждой строки в DataFrame. Первый элемент кортежа будет соответствующим значением индекса строки, а остальные значения - значениями строки.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])
for row in df.itertuples():
    print row

это output выглядит следующим образом -

Pandas(Index=0, col1=1.5297586201375899, col2=0.76281127433814944, col3=-
0.6346908238310438)

Pandas(Index=1, col1=-0.94408735763808649, col2=1.4209186418359423, col3=-
0.50789517967096232)

Pandas(Index=2, col1=-0.07728664756791935, col2=-0.85855574139699076, col3=-
0.6633852507207626)

Pandas(Index=3, col1=0.65734942534106289, col2=-0.95057710432604969,
col3=0.80344487462316527)

Note- Не пытайтесь изменить какой-либо объект во время итерации. Итерация предназначена для чтения, и итератор возвращает копию исходного объекта (представления), поэтому изменения не отразятся на исходном объекте.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(4,3),columns = ['col1','col2','col3'])

for index, row in df.iterrows():
   row['a'] = 10
print df

это output выглядит следующим образом -

col1       col2       col3
0  -1.739815   0.735595  -0.295589
1   0.635485   0.106803   1.527922
2  -0.939064   0.547095   0.038585
3  -1.016509  -0.116580  -0.523158

Наблюдайте, никаких изменений не отражено.

В Pandas есть два вида сортировки. Они -

По этикетке
По фактической стоимости

Рассмотрим пример с выходом.

import pandas as pd
import numpy as np

unsorted_df=pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
mns=['col2','col1'])
print unsorted_df

это output выглядит следующим образом -

col2       col1
1  -2.063177   0.537527
4   0.142932  -0.684884
6   0.012667  -0.389340
2  -0.548797   1.848743
3  -1.044160   0.837381
5   0.385605   1.300185
9   1.031425  -1.002967
8  -0.407374  -0.435142
0   2.237453  -1.067139
7  -1.445831  -1.701035

В unsorted_df, то labels и valuesнесортированы. Давайте посмотрим, как их можно отсортировать.

По этикетке

Используя sort_index()DataFrame можно отсортировать, передав аргументы оси и порядок сортировки. По умолчанию сортировка выполняется по меткам строк в порядке возрастания.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
   mns = ['col2','col1'])

sorted_df=unsorted_df.sort_index()
print sorted_df

это output выглядит следующим образом -

col2       col1
0   0.208464   0.627037
1   0.641004   0.331352
2  -0.038067  -0.464730
3  -0.638456  -0.021466
4   0.014646  -0.737438
5  -0.290761  -1.669827
6  -0.797303  -0.018737
7   0.525753   1.628921
8  -0.567031   0.775951
9   0.060724  -0.322425

Порядок сортировки

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

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
   mns = ['col2','col1'])

sorted_df = unsorted_df.sort_index(ascending=False)
print sorted_df

это output выглядит следующим образом -

col2        col1
9    0.825697    0.374463
8   -1.699509    0.510373
7   -0.581378    0.622958
6   -0.202951    0.954300
5   -1.289321   -1.551250
4    1.302561    0.851385
3   -0.157915   -0.388659
2   -1.222295    0.166609
1    0.584890   -0.291048
0    0.668444   -0.061294

Сортировать столбцы

Передав аргументу оси значение 0 или 1, можно выполнить сортировку меток столбцов. По умолчанию ось = 0, сортировка по строке. Давайте рассмотрим следующий пример, чтобы понять то же самое.

import pandas as pd
import numpy as np
 
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],colu
   mns = ['col2','col1'])
 
sorted_df=unsorted_df.sort_index(axis=1)

print sorted_df

это output выглядит следующим образом -

col1        col2
1   -0.291048    0.584890
4    0.851385    1.302561
6    0.954300   -0.202951
2    0.166609   -1.222295
3   -0.388659   -0.157915
5   -1.551250   -1.289321
9    0.374463    0.825697
8    0.510373   -1.699509
0   -0.061294    0.668444
7    0.622958   -0.581378

По значению

Как и сортировка по индексу, sort_values()это метод сортировки по значениям. Он принимает аргумент «by», который будет использовать имя столбца DataFrame, с которым должны быть отсортированы значения.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
   sorted_df = unsorted_df.sort_values(by='col1')

print sorted_df

это output выглядит следующим образом -

col1  col2
1    1    3
2    1    2
3    1    4
0    2    1

Обратите внимание, значения col1 сортируются, и соответствующее значение col2 и индекс строки изменятся вместе с col1. Таким образом, они выглядят несортированными.

'by' Аргумент принимает список значений столбца.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
   sorted_df = unsorted_df.sort_values(by=['col1','col2'])

print sorted_df

это output выглядит следующим образом -

Алгоритм сортировки

sort_values()предоставляет возможность выбора алгоритма из сортировки слиянием, сортировки в кучах и быстрой сортировки. Mergesort - единственный стабильный алгоритм.

import pandas as pd
import numpy as np

unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1' ,kind='mergesort')

print sorted_df

это output выглядит следующим образом -

col1 col2
1    1    3
2    1    2
3    1    4
0    2    1

В этой главе мы обсудим строковые операции с нашим базовым Series / Index. В следующих главах мы узнаем, как применять эти строковые функции к DataFrame.

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

Почти все эти методы работают со строковыми функциями Python (см .: https://docs.python.org/3/library/stdtypes.html#string-methods). Итак, преобразуйте объект серии в объект String, а затем выполните операцию.

Давайте теперь посмотрим, как работает каждая операция.

Старший Нет	Описание функции
1	lower() Преобразует строки в серии / указателе в нижний регистр.
2	upper() Преобразует строки в серии / указателе в верхний регистр.
3	len() Вычисляет длину строки ().
4	strip() Помогает удалить пробелы (включая новую строку) из каждой строки в серии / индексе с обеих сторон.
5	split(' ') Разбивает каждую строку заданным шаблоном.
6	cat(sep=' ') Объединяет элементы серии / индекса с заданным разделителем.
7	get_dummies() Возвращает DataFrame со значениями One-Hot Encoded.
8	contains(pattern) Возвращает логическое значение True для каждого элемента, если подстрока содержится в элементе, иначе False.
9	replace(a,b) Заменяет значение a со значением b.
10	repeat(value) Повторяет каждый элемент с указанным числом раз.
11	count(pattern) Возвращает количество появлений узора в каждом элементе.
12	startswith(pattern) Возвращает true, если элемент в серии / индексе начинается с шаблона.
13	endswith(pattern) Возвращает истину, если элемент в серии / индексе заканчивается шаблоном.
14	find(pattern) Возвращает первую позицию первого вхождения шаблона.
15	findall(pattern) Возвращает список всех вхождений шаблона.
16	swapcase Меняет местами регистр нижний / верхний.
17	islower() Проверяет, все ли символы в каждой строке в Серии / Индексе в нижнем регистре или нет. Возвращает логическое значение
18	isupper() Проверяет, все ли символы в каждой строке в Серии / Индексе в верхнем регистре или нет. Возвращает логическое значение.
19	isnumeric() Проверяет, все ли символы в каждой строке в Серии / Индексе являются числовыми. Возвращает логическое значение.

Давайте теперь создадим серию и посмотрим, как работают все вышеперечисленные функции.

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])

print s

это output выглядит следующим образом -

0            Tom
1   William Rick
2           John
3        Alber@t
4            NaN
5           1234
6    Steve Smith
dtype: object

нижний ()

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])

print s.str.lower()

это output выглядит следующим образом -

0            tom
1   william rick
2           john
3        alber@t
4            NaN
5           1234
6    steve smith
dtype: object

верхний ()

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])

print s.str.upper()

это output выглядит следующим образом -

0            TOM
1   WILLIAM RICK
2           JOHN
3        ALBER@T
4            NaN
5           1234
6    STEVE SMITH
dtype: object

len ()

import pandas as pd
import numpy as np

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t', np.nan, '1234','SteveSmith'])
print s.str.len()

это output выглядит следующим образом -

0    3.0
1   12.0
2    4.0
3    7.0
4    NaN
5    4.0
6   10.0
dtype: float64

полоса ()

import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After Stripping:")
print s.str.strip()

это output выглядит следующим образом -

0            Tom
1   William Rick
2           John
3        Alber@t
dtype: object

After Stripping:
0            Tom
1   William Rick
2           John
3        Alber@t
dtype: object

сплит (узор)

import pandas as pd
import numpy as np
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("Split Pattern:")
print s.str.split(' ')

это output выглядит следующим образом -

0            Tom
1   William Rick
2           John
3        Alber@t
dtype: object

Split Pattern:
0   [Tom, , , , , , , , , , ]
1   [, , , , , William, Rick]
2   [John]
3   [Alber@t]
dtype: object

кошка (sep = шаблон)

import pandas as pd
import numpy as np

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.cat(sep='_')

это output выглядит следующим образом -

Tom _ William Rick_John_Alber@t

get_dummies ()

import pandas as pd
import numpy as np

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.get_dummies()

это output выглядит следующим образом -

William Rick   Alber@t   John   Tom
0             0         0      0     1
1             1         0      0     0
2             0         0      1     0
3             0         1      0     0

содержит ()

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.contains(' ')

это output выглядит следующим образом -

0   True
1   True
2   False
3   False
dtype: bool

заменить (а, б)

import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print s
print ("After replacing @ with $:") print s.str.replace('@','$')

это output выглядит следующим образом -

0   Tom
1   William Rick
2   John
3   Alber@t
dtype: object

After replacing @ with $: 0 Tom 1 William Rick 2 John 3 Alber$t
dtype: object

повторить (значение)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.repeat(2)

это output выглядит следующим образом -

0   Tom            Tom
1   William Rick   William Rick
2                  JohnJohn
3                  Alber@tAlber@t
dtype: object

количество (узор)

import pandas as pd
 
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print ("The number of 'm's in each string:")
print s.str.count('m')

это output выглядит следующим образом -

The number of 'm's in each string:
0    1
1    1
2    0
3    0

начинается с (шаблон)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print ("Strings that start with 'T':")
print s.str. startswith ('T')

это output выглядит следующим образом -

0  True
1  False
2  False
3  False
dtype: bool

заканчивается (узор)

import pandas as pd
s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])
print ("Strings that end with 't':")
print s.str.endswith('t')

это output выглядит следующим образом -

Strings that end with 't':
0  False
1  False
2  False
3  True
dtype: bool

найти (шаблон)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.find('e')

это output выглядит следующим образом -

0  -1
1  -1
2  -1
3   3
dtype: int64

«-1» означает, что в элементе нет такого шаблона.

findall (шаблон)

import pandas as pd

s = pd.Series(['Tom ', ' William Rick', 'John', 'Alber@t'])

print s.str.findall('e')

это output выглядит следующим образом -

0 []
1 []
2 []
3 [e]
dtype: object

Нулевой список ([]) означает, что в элементе нет такого шаблона.

swapcase ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.swapcase()

это output выглядит следующим образом -

0  tOM
1  wILLIAM rICK
2  jOHN
3  aLBER@T
dtype: object

islower ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])
print s.str.islower()

это output выглядит следующим образом -

0  False
1  False
2  False
3  False
dtype: bool

isupper ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])

print s.str.isupper()

это output выглядит следующим образом -

0  False
1  False
2  False
3  False
dtype: bool

isnumeric ()

import pandas as pd

s = pd.Series(['Tom', 'William Rick', 'John', 'Alber@t'])

print s.str.isnumeric()

это output выглядит следующим образом -

0  False
1  False
2  False
3  False
dtype: bool

Pandas предоставляет API для настройки некоторых аспектов его поведения, в основном используется отображение.

API состоит из пяти соответствующих функций. Они -

get_option()
set_option()
reset_option()
describe_option()
option_context()

Давайте теперь поймем, как работают функции.

get_option (параметр)

get_option принимает единственный параметр и возвращает значение, как указано в выводе ниже -

display.max_rows

Отображает количество значений по умолчанию. Интерпретатор считывает это значение и отображает строки с этим значением в качестве верхнего предела для отображения.

import pandas as pd
print pd.get_option("display.max_rows")

это output выглядит следующим образом -

display.max_columns

import pandas as pd
print pd.get_option("display.max_columns")

это output выглядит следующим образом -

Здесь 60 и 20 - значения параметров конфигурации по умолчанию.

set_option (параметр, значение)

set_option принимает два аргумента и устанавливает значение параметра, как показано ниже -

display.max_rows

С помощью set_option(), мы можем изменить количество отображаемых строк по умолчанию.

import pandas as pd

pd.set_option("display.max_rows",80)

print pd.get_option("display.max_rows")

это output выглядит следующим образом -

display.max_columns

С помощью set_option(), мы можем изменить количество отображаемых строк по умолчанию.

import pandas as pd

pd.set_option("display.max_columns",30)

print pd.get_option("display.max_columns")

это output выглядит следующим образом -

reset_option (параметр)

reset_option принимает аргумент и возвращает значение по умолчанию.

display.max_rows

Используя reset_option (), мы можем изменить значение обратно на количество отображаемых строк по умолчанию.

import pandas as pd

pd.reset_option("display.max_rows")
print pd.get_option("display.max_rows")

это output выглядит следующим образом -

description_option (параметр)

describe_option печатает описание аргумента.

display.max_rows

Используя reset_option (), мы можем изменить значение обратно на количество отображаемых строк по умолчанию.

import pandas as pd
pd.describe_option("display.max_rows")

это output выглядит следующим образом -

display.max_rows : int
   If max_rows is exceeded, switch to truncate view. Depending on
   'large_repr', objects are either centrally truncated or printed as
   a summary view. 'None' value means unlimited.

   In case python/IPython is running in a terminal and `large_repr`
   equals 'truncate' this can be set to 0 and pandas will auto-detect
   the height of the terminal and print a truncated object which fits
   the screen height. The IPython notebook, IPython qtconsole, or
   IDLE do not run in a terminal and hence it is not possible to do
   correct auto-detection.
   [default: 60] [currently: 60]

option_context ()

option_context менеджер контекста используется для установки параметра в with statementвременно. Значения опций восстанавливаются автоматически при выходе изwith block -

display.max_rows

Используя option_context (), мы можем временно установить значение.

import pandas as pd
with pd.option_context("display.max_rows",10):
   print(pd.get_option("display.max_rows"))
   print(pd.get_option("display.max_rows"))

это output выглядит следующим образом -

10
10

Видите разницу между первым и вторым операторами печати. Первый оператор печатает значение, установленноеoption_context() что временно в пределах with contextсам. Послеwith context, второй оператор печати выводит настроенное значение.

Часто используемые параметры

Старший Нет	Параметр и описание
1	display.max_rows Отображает максимальное количество строк для отображения
2	2 display.max_columns Отображает максимальное количество отображаемых столбцов
3	display.expand_frame_repr Отображает фреймы данных для растягивания страниц
4	display.max_colwidth Отображает максимальную ширину столбца
5	display.precision Отображает точность десятичных чисел

В этой главе мы обсудим, как разрезать дату и в целом получить подмножество объекта pandas.

Операторы индексирования Python и NumPy "[]" и оператор атрибута "." обеспечивают быстрый и легкий доступ к структурам данных Pandas в широком диапазоне вариантов использования. Однако, поскольку тип данных, к которым необходимо получить доступ, заранее неизвестен, прямое использование стандартных операторов имеет некоторые ограничения оптимизации. Для производственного кода мы рекомендуем вам воспользоваться оптимизированными методами доступа к данным pandas, описанными в этой главе.

Pandas теперь поддерживает три типа многоосной индексации; три типа упомянуты в следующей таблице -

Старший Нет	Индексирование и описание
1	.loc() Этикетка на основе
2	.iloc() Целочисленный
3	.ix() На основе меток и целых чисел

.loc ()

Панды предоставляют различные методы чисто label based indexing. При нарезке также включается начальная граница. Целые числа являются допустимыми метками, но они относятся к метке, а не к позиции.

.loc() имеет несколько методов доступа, таких как -

Одна скалярная метка
Список этикеток
Объект-срез
Логический массив

locпринимает два оператора single / list / range, разделенных ','. Первый указывает строку, а второй - столбцы.

Пример 1

#import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

#select all rows for a specific column
print df.loc[:,'A']

это output выглядит следующим образом -

a   0.391548
b  -0.070649
c  -0.317212
d  -2.162406
e   2.202797
f   0.613709
g   1.050559
h   1.122680
Name: A, dtype: float64

Пример 2

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# Select all rows for multiple columns, say list[]
print df.loc[:,['A','C']]

это output выглядит следующим образом -

A           C
a    0.391548    0.745623
b   -0.070649    1.620406
c   -0.317212    1.448365
d   -2.162406   -0.873557
e    2.202797    0.528067
f    0.613709    0.286414
g    1.050559    0.216526
h    1.122680   -1.621420

Пример 3

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# Select few rows for multiple columns, say list[]
print df.loc[['a','b','f','h'],['A','C']]

это output выглядит следующим образом -

A          C
a   0.391548   0.745623
b  -0.070649   1.620406
f   0.613709   0.286414
h   1.122680  -1.621420

Пример 4

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# Select range of rows for all columns
print df.loc['a':'h']

это output выглядит следующим образом -

A           B          C          D
a    0.391548   -0.224297   0.745623   0.054301
b   -0.070649   -0.880130   1.620406   1.419743
c   -0.317212   -1.929698   1.448365   0.616899
d   -2.162406    0.614256  -0.873557   1.093958
e    2.202797   -2.315915   0.528067   0.612482
f    0.613709   -0.157674   0.286414  -0.500517
g    1.050559   -2.272099   0.216526   0.928449
h    1.122680    0.324368  -1.621420  -0.741470

Пример 5

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4),
index = ['a','b','c','d','e','f','g','h'], columns = ['A', 'B', 'C', 'D'])

# for getting values with a boolean array
print df.loc['a']>0

это output выглядит следующим образом -

A  False
B  True
C  False
D  False
Name: a, dtype: bool

.iloc ()

Pandas предоставляет различные методы для получения полностью целочисленной индексации. Как и python и numpy, это0-based индексация.

Различные методы доступа следующие:

Целое число
Список целых чисел
Диапазон значений

Пример 1

# import the pandas library and aliasing as pd
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# select all rows for a specific column
print df.iloc[:4]

это output выглядит следующим образом -

A          B           C           D
0   0.699435   0.256239   -1.270702   -0.645195
1  -0.685354   0.890791   -0.813012    0.631615
2  -0.783192  -0.531378    0.025070    0.230806
3   0.539042  -1.284314    0.826977   -0.026251

Пример 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# Integer slicing
print df.iloc[:4]
print df.iloc[1:5, 2:4]

это output выглядит следующим образом -

A          B           C           D
0   0.699435   0.256239   -1.270702   -0.645195
1  -0.685354   0.890791   -0.813012    0.631615
2  -0.783192  -0.531378    0.025070    0.230806
3   0.539042  -1.284314    0.826977   -0.026251

           C          D
1  -0.813012   0.631615
2   0.025070   0.230806
3   0.826977  -0.026251
4   1.423332   1.130568

Пример 3

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# Slicing through list of values
print df.iloc[[1, 3, 5], [1, 3]]
print df.iloc[1:3, :]
print df.iloc[:,1:3]

это output выглядит следующим образом -

B           D
1   0.890791    0.631615
3  -1.284314   -0.026251
5  -0.512888   -0.518930

           A           B           C           D
1  -0.685354    0.890791   -0.813012    0.631615
2  -0.783192   -0.531378    0.025070    0.230806

           B           C
0   0.256239   -1.270702
1   0.890791   -0.813012
2  -0.531378    0.025070
3  -1.284314    0.826977
4  -0.460729    1.423332
5  -0.512888    0.581409
6  -1.204853    0.098060
7  -0.947857    0.641358

.ix ()

Помимо чистых меток и целых чисел, Pandas предоставляет гибридный метод для выбора и подмножества объекта с помощью оператора .ix ().

Пример 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

# Integer slicing
print df.ix[:4]

это output выглядит следующим образом -

A          B           C           D
0   0.699435   0.256239   -1.270702   -0.645195
1  -0.685354   0.890791   -0.813012    0.631615
2  -0.783192  -0.531378    0.025070    0.230806
3   0.539042  -1.284314    0.826977   -0.026251

Пример 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
# Index slicing
print df.ix[:,'A']

это output выглядит следующим образом -

0   0.699435
1  -0.685354
2  -0.783192
3   0.539042
4  -1.044209
5  -1.415411
6   1.062095
7   0.994204
Name: A, dtype: float64

Использование обозначений

Получение значений из объекта Pandas с многоосной индексацией использует следующие обозначения:

Объект	Индексаторы	Тип возврата
Серии	s.loc [индексатор]	Скалярное значение
DataFrame	df.loc [row_index, col_index]	Объект серии
Панель	p.loc [item_index, major_index, minor_index]	p.loc [item_index, major_index, minor_index]

Note − .iloc() & .ix() применяет те же параметры индексации и возвращаемое значение.

Давайте теперь посмотрим, как каждая операция может быть выполнена с объектом DataFrame. Мы будем использовать основной оператор индексации '[]' -

Пример 1

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df['A']

это output выглядит следующим образом -

0  -0.478893
1   0.391931
2   0.336825
3  -1.055102
4  -0.165218
5  -0.328641
6   0.567721
7  -0.759399
Name: A, dtype: float64

Note - Мы можем передать список значений в [], чтобы выбрать эти столбцы.

Пример 2

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

print df[['A','B']]

это output выглядит следующим образом -

A           B
0  -0.478893   -0.606311
1   0.391931   -0.949025
2   0.336825    0.093717
3  -1.055102   -0.012944
4  -0.165218    1.550310
5  -0.328641   -0.226363
6   0.567721   -0.312585
7  -0.759399   -0.372696

Пример 3

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])
print df[2:2]

это output выглядит следующим образом -

Columns: [A, B, C, D]
Index: []

Доступ к атрибутам

Столбцы можно выбрать с помощью оператора атрибута '.'.

пример

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(8, 4), columns = ['A', 'B', 'C', 'D'])

print df.A

это output выглядит следующим образом -

0   -0.478893
1    0.391931
2    0.336825
3   -1.055102
4   -0.165218
5   -0.328641
6    0.567721
7   -0.759399
Name: A, dtype: float64

Статистические методы помогают понять и проанализировать поведение данных. Теперь мы изучим несколько статистических функций, которые мы можем применить к объектам Pandas.

Percent_change

Series, DatFrames и Panel - все имеют функцию pct_change(). Эта функция сравнивает каждый элемент с его предыдущим элементом и вычисляет процент изменения.

import pandas as pd
import numpy as np
s = pd.Series([1,2,3,4,5,4])
print s.pct_change()

df = pd.DataFrame(np.random.randn(5, 2))
print df.pct_change()

это output выглядит следующим образом -

0        NaN
1   1.000000
2   0.500000
3   0.333333
4   0.250000
5  -0.200000
dtype: float64

            0          1
0         NaN        NaN
1  -15.151902   0.174730
2  -0.746374   -1.449088
3  -3.582229   -3.165836
4   15.601150  -1.860434

По умолчанию pct_change()действует на колонны; если вы хотите применить одну и ту же строку, используйтеaxis=1() аргумент.

Ковариация

Ковариация применяется к данным ряда. Объект Series имеет метод cov для вычисления ковариации между объектами серии. NA будет исключен автоматически.

Cov серии

import pandas as pd
import numpy as np
s1 = pd.Series(np.random.randn(10))
s2 = pd.Series(np.random.randn(10))
print s1.cov(s2)

это output выглядит следующим образом -

-0.12978405324

Метод ковариации при применении к DataFrame вычисляет cov между всеми столбцами.

import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])
print frame['a'].cov(frame['b'])
print frame.cov()

это output выглядит следующим образом -

-0.58312921152741437

           a           b           c           d            e
a   1.780628   -0.583129   -0.185575    0.003679    -0.136558
b  -0.583129    1.297011    0.136530   -0.523719     0.251064
c  -0.185575    0.136530    0.915227   -0.053881    -0.058926
d   0.003679   -0.523719   -0.053881    1.521426    -0.487694
e  -0.136558    0.251064   -0.058926   -0.487694     0.960761

Note - Соблюдайте cov между a и b столбец в первом операторе, и это значение, возвращаемое cov в DataFrame.

Корреляция

Корреляция показывает линейную зависимость между любыми двумя массивами значений (сериями). Есть несколько методов для вычисления корреляции, например, pearson (по умолчанию), spearman и kendall.

import pandas as pd
import numpy as np
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])

print frame['a'].corr(frame['b'])
print frame.corr()

это output выглядит следующим образом -

-0.383712785514

           a          b          c          d           e
a   1.000000  -0.383713  -0.145368   0.002235   -0.104405
b  -0.383713   1.000000   0.125311  -0.372821    0.224908
c  -0.145368   0.125311   1.000000  -0.045661   -0.062840
d   0.002235  -0.372821  -0.045661   1.000000   -0.403380
e  -0.104405   0.224908  -0.062840  -0.403380    1.000000

Если в DataFrame присутствует какой-либо нечисловой столбец, он автоматически исключается.

Ранжирование данных

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

import pandas as pd
import numpy as np

s = pd.Series(np.random.np.random.randn(5), index=list('abcde'))
s['d'] = s['b'] # so there's a tie
print s.rank()

это output выглядит следующим образом -

a  1.0
b  3.5
c  2.0
d  3.5
e  5.0
dtype: float64

Ранг необязательно принимает параметр по возрастанию, который по умолчанию равен true; если false, данные ранжируются в обратном порядке, при этом большим значениям присваивается меньший ранг.

Rank поддерживает различные методы разрешения конфликтов, указанные с помощью параметра метода -

average - средний рейтинг равной группы
min - самый низкий рейтинг в группе
max - высшее место в группе
first - ранги присваиваются в порядке их появления в массиве

Для работы с числовыми данными Pandas предоставляет несколько вариантов, таких как вращение, расширение и экспоненциальное перемещение весов для оконной статистики. Среди нихsum, mean, median, variance, covariance, correlation, и т.п.

Теперь мы узнаем, как каждый из них можно применить к объектам DataFrame.

.rolling () Функция

Эта функция может применяться к серии данных. Укажитеwindow=n аргумент и примените к нему соответствующую статистическую функцию.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df.rolling(window=3).mean()

это output выглядит следующим образом -

A           B           C           D
2000-01-01        NaN         NaN         NaN         NaN
2000-01-02        NaN         NaN         NaN         NaN
2000-01-03   0.434553   -0.667940   -1.051718   -0.826452
2000-01-04   0.628267   -0.047040   -0.287467   -0.161110
2000-01-05   0.398233    0.003517    0.099126   -0.405565
2000-01-06   0.641798    0.656184   -0.322728    0.428015
2000-01-07   0.188403    0.010913   -0.708645    0.160932
2000-01-08   0.188043   -0.253039   -0.818125   -0.108485
2000-01-09   0.682819   -0.606846   -0.178411   -0.404127
2000-01-10   0.688583    0.127786    0.513832   -1.067156

Note - Поскольку размер окна равен 3, для первых двух элементов есть нули, а с третьего значения будет средним значением n, n-1 и n-2элементы. Таким образом, мы также можем применять различные функции, упомянутые выше.

.expanding () Функция

Эта функция может применяться к серии данных. Укажитеmin_periods=n аргумент и примените к нему соответствующую статистическую функцию.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df.expanding(min_periods=3).mean()

это output выглядит следующим образом -

A           B           C           D
2000-01-01        NaN         NaN         NaN         NaN
2000-01-02        NaN         NaN         NaN         NaN
2000-01-03   0.434553   -0.667940   -1.051718   -0.826452
2000-01-04   0.743328   -0.198015   -0.852462   -0.262547
2000-01-05   0.614776   -0.205649   -0.583641   -0.303254
2000-01-06   0.538175   -0.005878   -0.687223   -0.199219
2000-01-07   0.505503   -0.108475   -0.790826   -0.081056
2000-01-08   0.454751   -0.223420   -0.671572   -0.230215
2000-01-09   0.586390   -0.206201   -0.517619   -0.267521
2000-01-10   0.560427   -0.037597   -0.399429   -0.376886

.ewm () Функция

ewmприменяется к серии данных. Укажите любое из com, span,halflifeаргумент и примените к нему соответствующую статистическую функцию. Он присваивает веса экспоненциально.

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df.ewm(com=0.5).mean()

это output выглядит следующим образом -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   0.865131   -0.453626   -1.137961    0.058747
2000-01-03  -0.132245   -0.807671   -0.308308   -1.491002
2000-01-04   1.084036    0.555444   -0.272119    0.480111
2000-01-05   0.425682    0.025511    0.239162   -0.153290
2000-01-06   0.245094    0.671373   -0.725025    0.163310
2000-01-07   0.288030   -0.259337   -1.183515    0.473191
2000-01-08   0.162317   -0.771884   -0.285564   -0.692001
2000-01-09   1.147156   -0.302900    0.380851   -0.607976
2000-01-10   0.600216    0.885614    0.569808   -1.110113

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

Как только катится, расширяется и ewm создаются объекты, доступно несколько методов для агрегирования данных.

Применение агрегатов к DataFrame

Давайте создадим DataFrame и применим к нему агрегаты.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])

print df
r = df.rolling(window=3,min_periods=1)
print r

это output выглядит следующим образом -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   0.790670   -0.387854   -0.668132    0.267283
2000-01-03  -0.575523   -0.965025    0.060427   -2.179780
2000-01-04   1.669653    1.211759   -0.254695    1.429166
2000-01-05   0.100568   -0.236184    0.491646   -0.466081
2000-01-06   0.155172    0.992975   -1.205134    0.320958
2000-01-07   0.309468   -0.724053   -1.412446    0.627919
2000-01-08   0.099489   -1.028040    0.163206   -1.274331
2000-01-09   1.639500   -0.068443    0.714008   -0.565969
2000-01-10   0.326761    1.479841    0.664282   -1.361169

Rolling [window=3,min_periods=1,center=False,axis=0]

Мы можем агрегировать, передав функцию всему DataFrame или выбирая столбец с помощью стандартного get item метод.

Применение агрегирования ко всему фрейму данных

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate(np.sum)

это output выглядит следующим образом -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469

                    A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469

Применение агрегирования к одному столбцу фрейма данных

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate(np.sum)

это output выглядит следующим образом -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
2000-01-01   1.088512
2000-01-02   1.879182
2000-01-03   1.303660
2000-01-04   1.884801
2000-01-05   1.194699
2000-01-06   1.925393
2000-01-07   0.565208
2000-01-08   0.564129
2000-01-09   2.048458
2000-01-10   2.065750
Freq: D, Name: A, dtype: float64

Применение агрегирования к нескольким столбцам фрейма данных

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate(np.sum)

это output выглядит следующим образом -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
                    A           B
2000-01-01   1.088512   -0.650942
2000-01-02   1.879182   -1.038796
2000-01-03   1.303660   -2.003821
2000-01-04   1.884801   -0.141119
2000-01-05   1.194699    0.010551
2000-01-06   1.925393    1.968551
2000-01-07   0.565208    0.032738
2000-01-08   0.564129   -0.759118
2000-01-09   2.048458   -1.820537
2000-01-10   2.065750    0.383357

Применение нескольких функций к одному столбцу фрейма данных

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r['A'].aggregate([np.sum,np.mean])

это output выглядит следующим образом -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
                  sum       mean
2000-01-01   1.088512   1.088512
2000-01-02   1.879182   0.939591
2000-01-03   1.303660   0.434553
2000-01-04   1.884801   0.628267
2000-01-05   1.194699   0.398233
2000-01-06   1.925393   0.641798
2000-01-07   0.565208   0.188403
2000-01-08   0.564129   0.188043
2000-01-09   2.048458   0.682819
2000-01-10   2.065750   0.688583

Применение нескольких функций к нескольким столбцам фрейма данных

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10, 4),
   index = pd.date_range('1/1/2000', periods=10),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r[['A','B']].aggregate([np.sum,np.mean])

это output выглядит следующим образом -

A           B           C           D
2000-01-01   1.088512   -0.650942   -2.547450   -0.566858
2000-01-02   1.879182   -1.038796   -3.215581   -0.299575
2000-01-03   1.303660   -2.003821   -3.155154   -2.479355
2000-01-04   1.884801   -0.141119   -0.862400   -0.483331
2000-01-05   1.194699    0.010551    0.297378   -1.216695
2000-01-06   1.925393    1.968551   -0.968183    1.284044
2000-01-07   0.565208    0.032738   -2.125934    0.482797
2000-01-08   0.564129   -0.759118   -2.454374   -0.325454
2000-01-09   2.048458   -1.820537   -0.535232   -1.212381
2000-01-10   2.065750    0.383357    1.541496   -3.201469
                    A                      B
                  sum       mean         sum        mean
2000-01-01   1.088512   1.088512   -0.650942   -0.650942
2000-01-02   1.879182   0.939591   -1.038796   -0.519398
2000-01-03   1.303660   0.434553   -2.003821   -0.667940
2000-01-04   1.884801   0.628267   -0.141119   -0.047040
2000-01-05   1.194699   0.398233    0.010551    0.003517
2000-01-06   1.925393   0.641798    1.968551    0.656184
2000-01-07   0.565208   0.188403    0.032738    0.010913
2000-01-08   0.564129   0.188043   -0.759118   -0.253039
2000-01-09   2.048458   0.682819   -1.820537   -0.606846
2000-01-10   2.065750   0.688583    0.383357    0.127786

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

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(3, 4),
   index = pd.date_range('1/1/2000', periods=3),
   columns = ['A', 'B', 'C', 'D'])
print df
r = df.rolling(window=3,min_periods=1)
print r.aggregate({'A' : np.sum,'B' : np.mean})

это output выглядит следующим образом -

A          B          C         D
2000-01-01  -1.575749  -1.018105   0.317797  0.545081
2000-01-02  -0.164917  -1.361068   0.258240  1.113091
2000-01-03   1.258111   1.037941  -0.047487  0.867371
                    A          B
2000-01-01  -1.575749  -1.018105
2000-01-02  -1.740666  -1.189587
2000-01-03  -0.482555  -0.447078

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

Когда и почему данные отсутствуют?

Давайте рассмотрим онлайн-опрос по продукту. Часто люди не делятся всей связанной с ними информацией. Мало кто делится своим опытом, но не тем, как долго они пользуются продуктом; немногие люди рассказывают, как долго они используют продукт, своим опытом, но не своей контактной информацией. Таким образом, так или иначе часть данных всегда отсутствует, и это очень часто встречается в режиме реального времени.

Давайте теперь посмотрим, как мы можем обрабатывать отсутствующие значения (скажем, NA или NaN) с помощью Pandas.

# import the pandas library
import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df

это output выглядит следующим образом -

one        two      three
a   0.077988   0.476149   0.965836
b        NaN        NaN        NaN
c  -0.390208  -0.551605  -2.301950
d        NaN        NaN        NaN
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
g        NaN        NaN        NaN
h   0.085100   0.532791   0.887415

Используя переиндексирование, мы создали DataFrame с пропущенными значениями. На выходеNaN средства Not a Number.

Проверьте отсутствующие значения

Чтобы упростить обнаружение отсутствующих значений (и для разных типов массивов), Pandas предоставляет isnull() и notnull() функции, которые также являются методами для объектов Series и DataFrame -

Пример 1

import pandas as pd
import numpy as np
 
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df['one'].isnull()

это output выглядит следующим образом -

a  False
b  True
c  False
d  True
e  False
f  False
g  True
h  False
Name: one, dtype: bool

Пример 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df['one'].notnull()

это output выглядит следующим образом -

a  True
b  False
c  True
d  False
e  True
f  True
g  False
h  True
Name: one, dtype: bool

Расчеты с отсутствующими данными

При суммировании данных NA будет рассматриваться как ноль.
Если все данные NA, то результатом будет NA.

Пример 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df['one'].sum()

это output выглядит следующим образом -

2.02357685917

Пример 2

import pandas as pd
import numpy as np

df = pd.DataFrame(index=[0,1,2,3,4,5],columns=['one','two'])
print df['one'].sum()

это output выглядит следующим образом -

nan

Очистка / заполнение недостающих данных

Pandas предоставляет различные методы для очистки недостающих значений. Функция fillna может «заполнять» значения NA ненулевыми данными двумя способами, которые мы проиллюстрировали в следующих разделах.

Заменить NaN скалярным значением

Следующая программа показывает, как можно заменить «NaN» на «0».

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(3, 3), index=['a', 'c', 'e'],columns=['one',
'two', 'three'])

df = df.reindex(['a', 'b', 'c'])

print df
print ("NaN replaced with '0':")
print df.fillna(0)

это output выглядит следующим образом -

one        two     three
a  -0.576991  -0.741695  0.553172
b        NaN        NaN       NaN
c   0.744328  -1.735166  1.749580

NaN replaced with '0':
         one        two     three
a  -0.576991  -0.741695  0.553172
b   0.000000   0.000000  0.000000
c   0.744328  -1.735166  1.749580

Здесь мы заполняем нулевым значением; вместо этого мы также можем заполнить любое другое значение.

Заполнить NA вперед и назад

Используя концепции заполнения, обсуждаемые в главе «Переиндексирование», мы заполним недостающие значения.

Старший Нет	Метод и действие
1	pad/fill Методы заливки Вперед
2	bfill/backfill Методы заливки Назад

Пример 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df.fillna(method='pad')

это output выглядит следующим образом -

one        two      three
a   0.077988   0.476149   0.965836
b   0.077988   0.476149   0.965836
c  -0.390208  -0.551605  -2.301950
d  -0.390208  -0.551605  -2.301950
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
g  -0.930230  -0.670473   1.146615
h   0.085100   0.532791   0.887415

Пример 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print df.fillna(method='backfill')

это output выглядит следующим образом -

one        two      three
a   0.077988   0.476149   0.965836
b  -0.390208  -0.551605  -2.301950
c  -0.390208  -0.551605  -2.301950
d  -2.000303  -0.788201   1.510072
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
g   0.085100   0.532791   0.887415
h   0.085100   0.532791   0.887415

Отбросьте отсутствующие значения

Если вы хотите просто исключить отсутствующие значения, используйте dropna функции вместе с axisаргумент. По умолчанию ось = 0, т. Е. Вдоль строки, что означает, что если какое-либо значение в строке имеет значение NA, то вся строка исключается.

Пример 1

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna()

это output выглядит следующим образом -

one        two      three
a   0.077988   0.476149   0.965836
c  -0.390208  -0.551605  -2.301950
e  -2.000303  -0.788201   1.510072
f  -0.930230  -0.670473   1.146615
h   0.085100   0.532791   0.887415

Пример 2

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])

df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.dropna(axis=1)

это output выглядит следующим образом -

Empty DataFrame
Columns: [ ]
Index: [a, b, c, d, e, f, g, h]

Заменить отсутствующие (или) общие значения

Часто нам приходится заменять общее значение некоторым конкретным значением. Мы можем добиться этого, применив метод замены.

Замена NA на скалярное значение эквивалентно поведению fillna() функция.

Пример 1

import pandas as pd
import numpy as np

df = pd.DataFrame({'one':[10,20,30,40,50,2000], 'two':[1000,0,30,40,50,60]})

print df.replace({1000:10,2000:60})

это output выглядит следующим образом -

one  two
0   10   10
1   20    0
2   30   30
3   40   40
4   50   50
5   60   60

Пример 2

import pandas as pd
import numpy as np

df = pd.DataFrame({'one':[10,20,30,40,50,2000], 'two':[1000,0,30,40,50,60]})
print df.replace({1000:10,2000:60})

это output выглядит следующим образом -

one  two
0   10   10
1   20    0
2   30   30
3   40   40
4   50   50
5   60   60

Любые groupbyоперация включает в себя одну из следующих операций над исходным объектом. Они -

Splitting предмет
Applying функция
Combining результаты

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

Aggregation - вычисление сводной статистики
Transformation - выполнить некоторую групповую операцию
Filtration - отбрасывание данных с некоторым условием

Давайте теперь создадим объект DataFrame и выполним с ним все операции -

#import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df

это output выглядит следующим образом -

Points   Rank     Team   Year
0      876      1   Riders   2014
1      789      2   Riders   2015
2      863      2   Devils   2014
3      673      3   Devils   2015
4      741      3    Kings   2014
5      812      4    kings   2015
6      756      1    Kings   2016
7      788      1    Kings   2017
8      694      2   Riders   2016
9      701      4   Royals   2014
10     804      1   Royals   2015
11     690      2   Riders   2017

Разделить данные на группы

Объект Pandas можно разделить на любой из своих объектов. Есть несколько способов разделить объект, например -

obj.groupby('key')
obj.groupby(['key1','key2'])
obj.groupby(key,axis=1)

Давайте теперь посмотрим, как группирующие объекты могут быть применены к объекту DataFrame.

пример

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby('Team')

это output выглядит следующим образом -

<pandas.core.groupby.DataFrameGroupBy object at 0x7fa46a977e50>

Просмотр групп

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby('Team').groups

это output выглядит следующим образом -

{'Kings': Int64Index([4, 6, 7],      dtype='int64'),
'Devils': Int64Index([2, 3],         dtype='int64'),
'Riders': Int64Index([0, 1, 8, 11],  dtype='int64'),
'Royals': Int64Index([9, 10],        dtype='int64'),
'kings' : Int64Index([5],            dtype='int64')}

пример

Group by с несколькими столбцами -

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby(['Team','Year']).groups

это output выглядит следующим образом -

{('Kings', 2014): Int64Index([4], dtype='int64'),
 ('Royals', 2014): Int64Index([9], dtype='int64'),
 ('Riders', 2014): Int64Index([0], dtype='int64'),
 ('Riders', 2015): Int64Index([1], dtype='int64'),
 ('Kings', 2016): Int64Index([6], dtype='int64'),
 ('Riders', 2016): Int64Index([8], dtype='int64'),
 ('Riders', 2017): Int64Index([11], dtype='int64'),
 ('Devils', 2014): Int64Index([2], dtype='int64'),
 ('Devils', 2015): Int64Index([3], dtype='int64'),
 ('kings', 2015): Int64Index([5], dtype='int64'),
 ('Royals', 2015): Int64Index([10], dtype='int64'),
 ('Kings', 2017): Int64Index([7], dtype='int64')}

Итерация по группам

С groupby объект в руке, мы можем перебирать объект, аналогично itertools.obj.

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Year')

for name,group in grouped:
   print name
   print group

это output выглядит следующим образом -

2014
   Points  Rank     Team   Year
0     876     1   Riders   2014
2     863     2   Devils   2014
4     741     3   Kings    2014
9     701     4   Royals   2014

2015
   Points  Rank     Team   Year
1     789     2   Riders   2015
3     673     3   Devils   2015
5     812     4    kings   2015
10    804     1   Royals   2015

2016
   Points  Rank     Team   Year
6     756     1    Kings   2016
8     694     2   Riders   2016

2017
   Points  Rank    Team   Year
7     788     1   Kings   2017
11    690     2  Riders   2017

По умолчанию groupby объект имеет то же имя метки, что и имя группы.

Выберите группу

Используя get_group() метод, мы можем выбрать одну группу.

# import the pandas library
import pandas as pd

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Year')
print grouped.get_group(2014)

это output выглядит следующим образом -

Points  Rank     Team    Year
0     876     1   Riders    2014
2     863     2   Devils    2014
4     741     3   Kings     2014
9     701     4   Royals    2014

Агрегаты

Агрегированная функция возвращает единое агрегированное значение для каждой группы. Однаждыgroup by создается объект, можно выполнить несколько операций агрегирования с сгруппированными данными.

Очевидным является агрегирование через агрегат или эквивалент agg метод -

# import the pandas library
import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Year')
print grouped['Points'].agg(np.mean)

это output выглядит следующим образом -

Year
2014   795.25
2015   769.50
2016   725.00
2017   739.00
Name: Points, dtype: float64

Другой способ узнать размер каждой группы - применить функцию size () -

import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

Attribute Access in Python Pandas
grouped = df.groupby('Team')
print grouped.agg(np.size)

это output выглядит следующим образом -

Points   Rank   Year
Team
Devils        2      2      2
Kings         3      3      3
Riders        4      4      4
Royals        2      2      2
kings         1      1      1

Одновременное применение нескольких функций агрегирования

С сгруппированными сериями вы также можете пройти list или же dict of functions для агрегации и создания DataFrame в качестве вывода -

# import the pandas library
import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Team')
print grouped['Points'].agg([np.sum, np.mean, np.std])

это output выглядит следующим образом -

Team      sum      mean          std
Devils   1536   768.000000   134.350288
Kings    2285   761.666667    24.006943
Riders   3049   762.250000    88.567771
Royals   1505   752.500000    72.831998
kings     812   812.000000          NaN

Трансформации

Преобразование группы или столбца возвращает индексированный объект того же размера, что и группируемый. Таким образом, преобразование должно возвращать результат того же размера, что и у группового фрагмента.

# import the pandas library
import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

grouped = df.groupby('Team')
score = lambda x: (x - x.mean()) / x.std()*10
print grouped.transform(score)

это output выглядит следующим образом -

Points        Rank        Year
0   12.843272  -15.000000  -11.618950
1   3.020286     5.000000   -3.872983
2   7.071068    -7.071068   -7.071068
3  -7.071068     7.071068    7.071068
4  -8.608621    11.547005  -10.910895
5        NaN          NaN         NaN
6  -2.360428    -5.773503    2.182179
7  10.969049    -5.773503    8.728716
8  -7.705963     5.000000    3.872983
9  -7.071068     7.071068   -7.071068
10  7.071068    -7.071068    7.071068
11 -8.157595     5.000000   11.618950

Фильтрация

Фильтрация фильтрует данные по определенным критериям и возвращает подмножество данных. Вfilter() функция используется для фильтрации данных.

import pandas as pd
import numpy as np

ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)

print df.groupby('Team').filter(lambda x: len(x) >= 3)

это output выглядит следующим образом -

Points  Rank     Team   Year
0      876     1   Riders   2014
1      789     2   Riders   2015
4      741     3   Kings    2014
6      756     1   Kings    2016
7      788     1   Kings    2017
8      694     2   Riders   2016
11     690     2   Riders   2017

В приведенном выше условии фильтра мы просим вернуть команды, которые участвовали в IPL три или более раз.

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

Pandas предоставляет единственную функцию, merge, в качестве точки входа для всех стандартных операций соединения базы данных между объектами DataFrame -

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True)

Здесь мы использовали следующие параметры -

left - Объект DataFrame.
right - Другой объект DataFrame.
on- Столбцы (имена) для присоединения. Должен находиться как в левом, так и в правом объекте DataFrame.
left_on- Столбцы из левого DataFrame для использования в качестве ключей. Могут быть имена столбцов или массивы с длиной, равной длине DataFrame.
right_on- Столбцы из правого DataFrame для использования в качестве ключей. Могут быть имена столбцов или массивы с длиной, равной длине DataFrame.
left_index - Если True,используйте индекс (метки строк) из левого DataFrame в качестве ключа (ключей) соединения. В случае DataFrame с MultiIndex (иерархическим) количество уровней должно соответствовать количеству ключей соединения из правого DataFrame.
right_index - То же использование, что и left_index для правильного DataFrame.
how- Один из «левый», «правый», «внешний», «внутренний». По умолчанию внутренний. Каждый метод описан ниже.
sort- Отсортируйте результат DataFrame по ключам соединения в лексикографическом порядке. По умолчанию установлено значение True, значение False во многих случаях существенно улучшает производительность.

Давайте теперь создадим два разных DataFrames и выполним с ними операции слияния.

# import the pandas library
import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame(
   {'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print left
print right

это output выглядит следующим образом -

Name  id   subject_id
0   Alex   1         sub1
1    Amy   2         sub2
2  Allen   3         sub4
3  Alice   4         sub6
4  Ayoung  5         sub5

    Name  id   subject_id
0  Billy   1         sub2
1  Brian   2         sub4
2  Bran    3         sub3
3  Bryce   4         sub6
4  Betty   5         sub5

Слияние двух фреймов данных на ключе

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
	'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on='id')

это output выглядит следующим образом -

Name_x   id  subject_id_x   Name_y   subject_id_y
0  Alex      1          sub1    Billy           sub2
1  Amy       2          sub2    Brian           sub4
2  Allen     3          sub4     Bran           sub3
3  Alice     4          sub6    Bryce           sub6
4  Ayoung    5          sub5    Betty           sub5

Слияние двух фреймов данных на нескольких ключах

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
	'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left,right,on=['id','subject_id'])

это output выглядит следующим образом -

Name_x   id   subject_id   Name_y
0    Alice    4         sub6    Bryce
1   Ayoung    5         sub5    Betty

Слияние с использованием аргумента "как"

В howаргумент для слияния указывает, как определить, какие ключи должны быть включены в результирующую таблицу. Если комбинация клавиш не отображается ни в левой, ни в правой таблицах, значения в объединенной таблице будут Н / Д.

Вот краткое изложение how параметры и их эквивалентные имена в SQL -

Метод слияния	Эквивалент SQL	Описание
слева	ЛЕВОЕ ВНЕШНЕЕ СОЕДИНЕНИЕ	Используйте ключи от левого объекта
правильно	ПРАВО НАРУЖНОЕ СОЕДИНЕНИЕ	Используйте ключи от правого объекта
внешний	ПОЛНОЕ ВНЕШНЕЕ СОЕДИНЕНИЕ	Используйте объединение ключей
внутренний	ВНУТРЕННЕЕ СОЕДИНЕНИЕ	Используйте пересечение ключей

Левое соединение

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='left')

это output выглядит следующим образом -

Name_x   id_x   subject_id   Name_y   id_y
0     Alex      1         sub1      NaN    NaN
1      Amy      2         sub2    Billy    1.0
2    Allen      3         sub4    Brian    2.0
3    Alice      4         sub6    Bryce    4.0
4   Ayoung      5         sub5    Betty    5.0

Правое соединение

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='right')

это output выглядит следующим образом -

Name_x  id_x   subject_id   Name_y   id_y
0      Amy   2.0         sub2    Billy      1
1    Allen   3.0         sub4    Brian      2
2    Alice   4.0         sub6    Bryce      4
3   Ayoung   5.0         sub5    Betty      5
4      NaN   NaN         sub3     Bran      3

Внешнее соединение

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, how='outer', on='subject_id')

это output выглядит следующим образом -

Name_x  id_x   subject_id   Name_y   id_y
0     Alex   1.0         sub1      NaN    NaN
1      Amy   2.0         sub2    Billy    1.0
2    Allen   3.0         sub4    Brian    2.0
3    Alice   4.0         sub6    Bryce    4.0
4   Ayoung   5.0         sub5    Betty    5.0
5      NaN   NaN         sub3     Bran    3.0

Внутреннее соединение

Присоединение будет производиться по индексу. Операция соединения учитывает объект, для которого она вызывается. Так,a.join(b) не равно b.join(a).

import pandas as pd
left = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5']})
right = pd.DataFrame({
   'id':[1,2,3,4,5],
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5']})
print pd.merge(left, right, on='subject_id', how='inner')

это output выглядит следующим образом -

Name_x   id_x   subject_id   Name_y   id_y
0      Amy      2         sub2    Billy      1
1    Allen      3         sub4    Brian      2
2    Alice      4         sub6    Bryce      4
3   Ayoung      5         sub5    Betty      5

Pandas предоставляет различные возможности для простого комбинирования Series, DataFrame, и Panel объекты.

pd.concat(objs,axis=0,join='outer',join_axes=None,
ignore_index=False)

objs - Это последовательность или отображение объектов Series, DataFrame или Panel.
axis - {0, 1, ...}, по умолчанию 0. Это ось для объединения.
join- {'внутренний', 'внешний'}, по умолчанию 'внешний'. Как обрабатывать индексы на других осях. Внешний для соединения и внутренний для пересечения.
ignore_index- логическое значение, по умолчанию False. Если True, не используйте значения индекса на оси конкатенации. Результирующая ось будет помечена 0, ..., n - 1.
join_axes- Это список объектов индекса. Конкретные индексы для использования для других (n-1) осей вместо выполнения логики внутреннего / внешнего набора.

Объединение объектов

В concatФункция выполняет всю тяжелую работу по выполнению операций конкатенации вдоль оси. Давайте создадим разные объекты и сделаем конкатенацию.

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two])

это output выглядит следующим образом -

Marks_scored     Name   subject_id
1             98     Alex         sub1
2             90      Amy         sub2
3             87    Allen         sub4
4             69    Alice         sub6
5             78   Ayoung         sub5
1             89    Billy         sub2
2             80    Brian         sub4
3             79     Bran         sub3
4             97    Bryce         sub6
5             88    Betty         sub5

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

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'])

это output выглядит следующим образом -

x  1  98    Alex    sub1
   2  90    Amy     sub2
   3  87    Allen   sub4
   4  69    Alice   sub6
   5  78    Ayoung  sub5
y  1  89    Billy   sub2
   2  80    Brian   sub4
   3  79    Bran    sub3
   4  97    Bryce   sub6
   5  88    Betty   sub5

Индекс результирующего дублируется; каждый указатель повторяется.

Если результирующий объект должен следовать своей собственной индексации, установите ignore_index к True.

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two],keys=['x','y'],ignore_index=True)

это output выглядит следующим образом -

Marks_scored     Name    subject_id
0             98     Alex          sub1
1             90      Amy          sub2
2             87    Allen          sub4
3             69    Alice          sub6
4             78   Ayoung          sub5
5             89    Billy          sub2
6             80    Brian          sub4
7             79     Bran          sub3
8             97    Bryce          sub6
9             88    Betty          sub5

Обратите внимание, индекс полностью изменяется, и ключи также переопределяются.

Если нужно добавить два объекта axis=1, затем будут добавлены новые столбцы.

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print pd.concat([one,two],axis=1)

это output выглядит следующим образом -

Marks_scored    Name  subject_id   Marks_scored    Name   subject_id
1           98      Alex      sub1         89         Billy         sub2
2           90       Amy      sub2         80         Brian         sub4
3           87     Allen      sub4         79          Bran         sub3
4           69     Alice      sub6         97         Bryce         sub6
5           78    Ayoung      sub5         88         Betty         sub5

Объединение с использованием добавления

Полезным ярлыком для concat являются методы добавления экземпляра в Series и DataFrame. Эти методы фактически предшествовали concat. Они соединяются вместеaxis=0, а именно индекс -

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print one.append(two)

это output выглядит следующим образом -

Marks_scored    Name  subject_id
1           98      Alex      sub1
2           90       Amy      sub2
3           87     Allen      sub4
4           69     Alice      sub6
5           78    Ayoung      sub5
1           89     Billy      sub2
2           80     Brian      sub4
3           79      Bran      sub3
4           97     Bryce      sub6
5           88     Betty      sub5

В append функция также может принимать несколько объектов -

import pandas as pd

one = pd.DataFrame({
   'Name': ['Alex', 'Amy', 'Allen', 'Alice', 'Ayoung'],
   'subject_id':['sub1','sub2','sub4','sub6','sub5'],
   'Marks_scored':[98,90,87,69,78]},
   index=[1,2,3,4,5])

two = pd.DataFrame({
   'Name': ['Billy', 'Brian', 'Bran', 'Bryce', 'Betty'],
   'subject_id':['sub2','sub4','sub3','sub6','sub5'],
   'Marks_scored':[89,80,79,97,88]},
   index=[1,2,3,4,5])
print one.append([two,one,two])

это output выглядит следующим образом -

Marks_scored   Name    subject_id
1           98     Alex          sub1
2           90      Amy          sub2
3           87    Allen          sub4
4           69    Alice          sub6
5           78   Ayoung          sub5
1           89    Billy          sub2
2           80    Brian          sub4
3           79     Bran          sub3
4           97    Bryce          sub6
5           88    Betty          sub5
1           98     Alex          sub1
2           90      Amy          sub2
3           87    Allen          sub4
4           69    Alice          sub6
5           78   Ayoung          sub5
1           89    Billy          sub2
2           80    Brian          sub4
3           79     Bran          sub3
4           97    Bryce          sub6
5           88    Betty          sub5

Временные ряды

Pandas предоставляет надежный инструмент для работы с данными временных рядов, особенно в финансовом секторе. При работе с данными временных рядов мы часто сталкиваемся со следующим:

Генерация последовательности времени
Преобразование временных рядов в разные частоты

Pandas предоставляет относительно компактный и автономный набор инструментов для выполнения вышеуказанных задач.

Получить текущее время

datetime.now() дает вам текущую дату и время.

import pandas as pd

print pd.datetime.now()

это output выглядит следующим образом -

2017-05-11 06:10:13.393147

Создать отметку времени

Данные с отметкой времени - это самый основной тип данных временного ряда, который связывает значения с моментами времени. Для объектов pandas это означает использование точек во времени. Возьмем пример -

import pandas as pd

print pd.Timestamp('2017-03-01')

это output выглядит следующим образом -

2017-03-01 00:00:00

Также возможно преобразовать целое или плавающее время эпох. Единицей измерения по умолчанию являются наносекунды (поскольку именно так хранятся метки времени). Однако часто эпохи сохраняются в другом модуле, который можно указать. Возьмем другой пример

import pandas as pd

print pd.Timestamp(1587687255,unit='s')

это output выглядит следующим образом -

2020-04-24 00:14:15

Создайте диапазон времени

import pandas as pd

print pd.date_range("11:00", "13:30", freq="30min").time

это output выглядит следующим образом -

[datetime.time(11, 0) datetime.time(11, 30) datetime.time(12, 0)
datetime.time(12, 30) datetime.time(13, 0) datetime.time(13, 30)]

Измените частоту времени

import pandas as pd

print pd.date_range("11:00", "13:30", freq="H").time

это output выглядит следующим образом -

[datetime.time(11, 0) datetime.time(12, 0) datetime.time(13, 0)]

Преобразование в метки времени

Чтобы преобразовать объект типа Series или списка из объектов типа даты, например строк, эпох или их смеси, вы можете использовать to_datetimeфункция. При передаче возвращается серия (с тем же индексом), аlist-like преобразуется в DatetimeIndex. Взгляните на следующий пример -

import pandas as pd

print pd.to_datetime(pd.Series(['Jul 31, 2009','2010-01-10', None]))

это output выглядит следующим образом -

0  2009-07-31
1  2010-01-10
2         NaT
dtype: datetime64[ns]

NaT средства Not a Time (эквивалент NaN)

Возьмем другой пример.

import pandas as pd

print pd.to_datetime(['2005/11/23', '2010.12.31', None])

это output выглядит следующим образом -

DatetimeIndex(['2005-11-23', '2010-12-31', 'NaT'], dtype='datetime64[ns]', freq=None)

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

Генерация последовательности дат
Преобразуйте ряд дат в разные частоты

Создайте диапазон дат

Используя date.range()функцию, указав периоды и частоту, мы можем создать ряд дат. По умолчанию частота диапазона - Дни.

import pandas as pd

print pd.date_range('1/1/2011', periods=5)

это output выглядит следующим образом -

DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
   dtype='datetime64[ns]', freq='D')

Изменить частоту даты

import pandas as pd

print pd.date_range('1/1/2011', periods=5,freq='M')

это output выглядит следующим образом -

DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31', '2011-04-30', '2011-05-31'],
   dtype='datetime64[ns]', freq='M')

bdate_range

bdate_range () обозначает диапазоны рабочих дат. В отличие от date_range (), он исключает субботу и воскресенье.

import pandas as pd

print pd.date_range('1/1/2011', periods=5)

это output выглядит следующим образом -

DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
   dtype='datetime64[ns]', freq='D')

Обратите внимание, что после 3 марта дата переходит на 6 марта, за исключением 4 и 5. Просто проверьте свой календарь на дни.

Функции удобства вроде date_range и bdate_rangeиспользовать различные частотные псевдонимы. Частота по умолчанию для date_range - календарный день, а для bdate_range по умолчанию - рабочий день.

import pandas as pd
start = pd.datetime(2011, 1, 1)
end = pd.datetime(2011, 1, 5)

print pd.date_range(start, end)

это output выглядит следующим образом -

DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04', '2011-01-05'],
   dtype='datetime64[ns]', freq='D')

Смещение псевдонимов

Для полезных общих частот временных рядов дается ряд псевдонимов строк. Мы будем называть эти псевдонимы псевдонимами смещения.

Псевдоним	Описание	Псевдоним	Описание
B	частота рабочих дней	BQS	частота начала бизнес-квартала
D	частота календарных дней	А	годовая (год) конечная частота
W	еженедельная частота	BA	частота окончания финансового года
M	частота окончания месяца	BAS	частота начала финансового года
SM	частота окончания полумесяца	BH	частота рабочих часов
BM	частота окончания рабочего месяца	ЧАС	почасовая частота
РС	частота начала месяца	Т, мин	поминутная частота
SMS	Частота начала полумесяца SMS	S	во-вторых частота
BMS	частота начала рабочего месяца	L, мс	миллисекунды
Q	частота конца четверти	U, нас	микросекунды
BQ	частота окончания финансового квартала	N	наносекунды
QS	частота начала четверти

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

Мы можем создавать объекты Timedelta, используя различные аргументы, как показано ниже -

Строка

Передав строковый литерал, мы можем создать объект timedelta.

import pandas as pd

print pd.Timedelta('2 days 2 hours 15 minutes 30 seconds')

это output выглядит следующим образом -

2 days 02:15:30

Целое число

Передавая целочисленное значение с единицей измерения, аргумент создает объект Timedelta.

import pandas as pd

print pd.Timedelta(6,unit='h')

это output выглядит следующим образом -

0 days 06:00:00

Смещения данных

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

import pandas as pd

print pd.Timedelta(days=2)

это output выглядит следующим образом -

2 days 00:00:00

to_timedelta ()

Использование верхнего уровня pd.to_timedelta, вы можете преобразовать скаляр, массив, список или ряд из распознанного формата / значения timedelta в тип Timedelta. Он построит Series, если вход является Series, скаляр, если вход подобен скаляру, иначе будет выводитьTimedeltaIndex.

import pandas as pd

print pd.Timedelta(days=2)

это output выглядит следующим образом -

2 days 00:00:00

Операции

Вы можете работать с Series / DataFrames и создавать timedelta64[ns] Последовательность операций вычитания на datetime64[ns] Серии или отметки времени.

Давайте теперь создадим DataFrame с объектами Timedelta и datetime и выполним с ним некоторые арифметические операции -

import pandas as pd

s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))

print df

это output выглядит следующим образом -

A      B
0  2012-01-01 0 days
1  2012-01-02 1 days
2  2012-01-03 2 days

Дополнительные операции

import pandas as pd

s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']

print df

это output выглядит следующим образом -

A      B          C
0 2012-01-01 0 days 2012-01-01
1 2012-01-02 1 days 2012-01-03
2 2012-01-03 2 days 2012-01-05

Операция вычитания

import pandas as pd

s = pd.Series(pd.date_range('2012-1-1', periods=3, freq='D'))
td = pd.Series([ pd.Timedelta(days=i) for i in range(3) ])
df = pd.DataFrame(dict(A = s, B = td))
df['C']=df['A']+df['B']
df['D']=df['C']+df['B']

print df

это output выглядит следующим образом -

A      B          C          D
0 2012-01-01 0 days 2012-01-01 2012-01-01
1 2012-01-02 1 days 2012-01-03 2012-01-04
2 2012-01-03 2 days 2012-01-05 2012-01-07

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

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

Категориальный тип данных полезен в следующих случаях:

Строковая переменная, состоящая всего из нескольких разных значений. Преобразование такой строковой переменной в категориальную позволяет сэкономить память.
Лексический порядок переменной отличается от логического порядка («один», «два», «три»). При преобразовании в категориальный и указании порядка в категориях, сортировка и мин. / Макс. Будут использовать логический порядок вместо лексического.
Как сигнал другим библиотекам Python о том, что этот столбец следует рассматривать как категориальную переменную (например, для использования подходящих статистических методов или типов графиков).

Создание объекта

Категориальный объект можно создать несколькими способами. Различные способы были описаны ниже -

категория

Указав dtype как «категорию» при создании объекта pandas.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
print s

это output выглядит следующим образом -

0  a
1  b
2  c
3  a
dtype: category
Categories (3, object): [a, b, c]

Количество элементов, переданных объекту серии, равно четырем, но категорий всего три. То же самое и с выходными категориями.

pd.Categorical

Используя стандартный конструктор категорий pandas, мы можем создать объект категории.

pandas.Categorical(values, categories, ordered)

Возьмем пример -

import pandas as pd

cat = pd.Categorical(['a', 'b', 'c', 'a', 'b', 'c'])
print cat

это output выглядит следующим образом -

[a, b, c, a, b, c]
Categories (3, object): [a, b, c]

Приведем еще один пример -

import pandas as pd

cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'])
print cat

это output выглядит следующим образом -

[a, b, c, a, b, c, NaN]
Categories (3, object): [c, b, a]

Здесь второй аргумент обозначает категории. Таким образом, любое значение, не представленное в категориях, будет рассматриваться какNaN.

Теперь взгляните на следующий пример -

import pandas as pd

cat = cat=pd.Categorical(['a','b','c','a','b','c','d'], ['c', 'b', 'a'],ordered=True)
print cat

это output выглядит следующим образом -

[a, b, c, a, b, c, NaN]
Categories (3, object): [c < b < a]

Логически порядок означает, что, a больше, чем b и b больше, чем c.

Описание

Используя .describe() для категориальных данных, мы получаем аналогичный результат Series или же DataFrame из type строка.

import pandas as pd
import numpy as np

cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
df = pd.DataFrame({"cat":cat, "s":["a", "c", "c", np.nan]})

print df.describe()
print df["cat"].describe()

это output выглядит следующим образом -

cat s
count    3 3
unique   2 2
top      c c
freq     2 2
count     3
unique    2
top       c
freq      2
Name: cat, dtype: object

Получить свойства категории

obj.cat.categories команда используется для получения categories of the object.

import pandas as pd
import numpy as np

s = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print s.categories

это output выглядит следующим образом -

Index([u'b', u'a', u'c'], dtype='object')

obj.ordered команда используется для получения порядка объекта.

import pandas as pd
import numpy as np

cat = pd.Categorical(["a", "c", "c", np.nan], categories=["b", "a", "c"])
print cat.ordered

это output выглядит следующим образом -

False

Функция вернула false потому что мы не указали заказ.

Переименование категорий

Переименование категорий осуществляется путем присвоения новых значений параметрам series.cat.categoriesseries.cat.categories свойство.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
s.cat.categories = ["Group %s" % g for g in s.cat.categories]
print s.cat.categories

это output выглядит следующим образом -

Index([u'Group a', u'Group b', u'Group c'], dtype='object')

Начальные категории [a,b,c] обновляются s.cat.categories свойство объекта.

Добавление новых категорий

С помощью метода Categories.add.categories () можно добавлять новые категории.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
s = s.cat.add_categories([4])
print s.cat.categories

это output выглядит следующим образом -

Index([u'a', u'b', u'c', 4], dtype='object')

Удаление категорий

Используя Categorical.remove_categories() метод, нежелательные категории могут быть удалены.

import pandas as pd

s = pd.Series(["a","b","c","a"], dtype="category")
print ("Original object:")
print s

print ("After removal:")
print s.cat.remove_categories("a")

это output выглядит следующим образом -

Original object:
0  a
1  b
2  c
3  a
dtype: category
Categories (3, object): [a, b, c]

After removal:
0  NaN
1  b
2  c
3  NaN
dtype: category
Categories (2, object): [b, c]

Сравнение категориальных данных

Сравнение категориальных данных с другими объектами возможно в трех случаях:

сравнение равенства (== и! =) со списковым объектом (список, серия, массив, ...) той же длины, что и категориальные данные.
все сравнения (==,! =,>,> =, <и <=) категориальных данных с другой категориальной серией, если они упорядочены == True и категории совпадают.
все сравнения категориальных данных со скаляром.

Взгляните на следующий пример -

import pandas as pd

cat = pd.Series([1,2,3]).astype("category", categories=[1,2,3], ordered=True)
cat1 = pd.Series([2,2,2]).astype("category", categories=[1,2,3], ordered=True)

print cat>cat1

это output выглядит следующим образом -

0  False
1  False
2  True
dtype: bool

Основной сюжет: сюжет

Эта функция в Series и DataFrame представляет собой простую оболочку для matplotlib libraries plot() метод.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10,4),index=pd.date_range('1/1/2000',
   periods=10), columns=list('ABCD'))

df.plot()

это output выглядит следующим образом -

Если индекс состоит из дат, он вызывает gct().autofmt_xdate() , чтобы отформатировать ось x, как показано на иллюстрации выше.

Мы можем построить график зависимости одного столбца от другого, используя x и y ключевые слова.

Методы печати позволяют использовать несколько стилей печати, кроме линейного графика по умолчанию. Эти методы могут быть предоставлены как аргумент ключевого слова kind дляplot(). К ним относятся -

бар или бар для участков
hist для гистограммы
ящик для ящичного участка
'area' для участков
'scatter' для диаграмм рассеяния

Барный участок

Давайте теперь посмотрим, что такое гистограмма, создав ее. Барную диаграмму можно создать следующим образом -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar()

это output выглядит следующим образом -

Чтобы создать диаграмму столбцов с накоплением, pass stacked=True -

import pandas as pd
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')
df.plot.bar(stacked=True)

это output выглядит следующим образом -

Чтобы получить графики горизонтальной полосы, используйте barh метод -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d')

df.plot.barh(stacked=True)

это output выглядит следующим образом -

Гистограммы

Гистограммы можно построить с помощью plot.hist()метод. Мы можем указать количество ящиков.

import pandas as pd
import numpy as np

df = pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])

df.plot.hist(bins=20)

это output выглядит следующим образом -

Чтобы построить разные гистограммы для каждого столбца, используйте следующий код -

import pandas as pd
import numpy as np

df=pd.DataFrame({'a':np.random.randn(1000)+1,'b':np.random.randn(1000),'c':
np.random.randn(1000) - 1}, columns=['a', 'b', 'c'])

df.diff.hist(bins=20)

это output выглядит следующим образом -

Коробчатые графики

Коробчатый график можно нарисовать, позвонив Series.box.plot() и DataFrame.box.plot(), или же DataFrame.boxplot() для визуализации распределения значений в каждом столбце.

Например, вот диаграмма, представляющая пять испытаний из 10 наблюдений однородной случайной величины на [0,1).

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10, 5), columns=['A', 'B', 'C', 'D', 'E'])
df.plot.box()

это output выглядит следующим образом -

Площадь участка

График площади можно создать с помощью Series.plot.area() или DataFrame.plot.area() методы.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.rand(10, 4), columns=['a', 'b', 'c', 'd'])
df.plot.area()

это output выглядит следующим образом -

Точечная диаграмма

График рассеяния можно создать с помощью DataFrame.plot.scatter() методы.

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(50, 4), columns=['a', 'b', 'c', 'd'])
df.plot.scatter(x='a', y='b')

это output выглядит следующим образом -

Круговая диаграмма

Круговую диаграмму можно создать с помощью DataFrame.plot.pie() метод.

import pandas as pd
import numpy as np

df = pd.DataFrame(3 * np.random.rand(4), index=['a', 'b', 'c', 'd'], columns=['x'])
df.plot.pie(subplots=True)

это output выглядит следующим образом -

В Pandas I/O API это набор функций чтения верхнего уровня, доступ к которым осуществляется как pd.read_csv() которые обычно возвращают объект Pandas.

Две основные функции для чтения текстовых файлов (или плоских файлов): read_csv() и read_table(). Оба они используют один и тот же код синтаксического анализа для интеллектуального преобразования табличных данных вDataFrame объект -

pandas.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer',
names=None, index_col=None, usecols=None

pandas.read_csv(filepath_or_buffer, sep='\t', delimiter=None, header='infer',
names=None, index_col=None, usecols=None

Вот как csv данные файла выглядят так -

S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900

Сохраните эти данные как temp.csv и проводить на нем операции.

S.No,Name,Age,City,Salary
1,Tom,28,Toronto,20000
2,Lee,32,HongKong,3000
3,Steven,43,Bay Area,8300
4,Ram,38,Hyderabad,3900

Сохраните эти данные как temp.csv и проводить на нем операции.

read.csv

read.csv читает данные из файлов csv и создает объект DataFrame.

import pandas as pd

df=pd.read_csv("temp.csv")
print df

это output выглядит следующим образом -

S.No     Name   Age       City   Salary
0     1      Tom    28    Toronto    20000
1     2      Lee    32   HongKong     3000
2     3   Steven    43   Bay Area     8300
3     4      Ram    38  Hyderabad     3900

специальный индекс

Это указывает столбец в файле csv для настройки индекса с помощью index_col.

import pandas as pd

df=pd.read_csv("temp.csv",index_col=['S.No'])
print df

это output выглядит следующим образом -

S.No   Name   Age       City   Salary
1       Tom    28    Toronto    20000
2       Lee    32   HongKong     3000
3    Steven    43   Bay Area     8300
4       Ram    38  Hyderabad     3900

Конвертеры

dtype столбцов можно передать как dict.

import pandas as pd

df = pd.read_csv("temp.csv", dtype={'Salary': np.float64})
print df.dtypes

это output выглядит следующим образом -

S.No       int64
Name      object
Age        int64
City      object
Salary   float64
dtype: object

По умолчанию dtype столбца "Зарплата" int, но результат показывает это как float потому что мы явно привели тип.

Таким образом, данные выглядят как float -

S.No   Name   Age      City    Salary
0   1     Tom   28    Toronto   20000.0
1   2     Lee   32   HongKong    3000.0
2   3  Steven   43   Bay Area    8300.0
3   4     Ram   38  Hyderabad    3900.0

header_names

Укажите имена заголовка, используя аргумент names.

import pandas as pd
 
df=pd.read_csv("temp.csv", names=['a', 'b', 'c','d','e'])
print df

это output выглядит следующим образом -

a        b    c           d        e
0   S.No     Name   Age       City   Salary
1      1      Tom   28     Toronto    20000
2      2      Lee   32    HongKong     3000
3      3   Steven   43    Bay Area     8300
4      4      Ram   38   Hyderabad     3900

Обратите внимание, к именам заголовков добавляются пользовательские имена, но заголовок в файле не был удален. Теперь мы используем аргумент заголовка, чтобы удалить это.

Если заголовок находится в строке, отличной от первой, передайте номер строки в заголовок. Это пропустит предыдущие строки.

import pandas as pd 

df=pd.read_csv("temp.csv",names=['a','b','c','d','e'],header=0)
print df

это output выглядит следующим образом -

a        b    c           d        e
0  S.No     Name   Age       City   Salary
1     1      Tom   28     Toronto    20000
2     2      Lee   32    HongKong     3000
3     3   Steven   43    Bay Area     8300
4     4      Ram   38   Hyderabad     3900

скипроу

skiprows пропускает указанное количество строк.

import pandas as pd

df=pd.read_csv("temp.csv", skiprows=2)
print df

это output выглядит следующим образом -

2      Lee   32    HongKong   3000
0   3   Steven   43    Bay Area   8300
1   4      Ram   38   Hyderabad   3900

Разреженные объекты «сжимаются», когда любые данные, соответствующие определенному значению (NaN / отсутствующее значение, хотя можно выбрать любое значение), опущены. Специальный объект SparseIndex отслеживает, где данные были «разрежены». Это будет иметь больше смысла в примере. Все стандартные структуры данных Pandas применяютto_sparse метод -

import pandas as pd
import numpy as np

ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts

это output выглядит следующим образом -

0   -0.810497
1   -1.419954
2         NaN
3         NaN
4         NaN
5         NaN
6         NaN
7         NaN
8    0.439240
9   -1.095910
dtype: float64
BlockIndex
Block locations: array([0, 8], dtype=int32)
Block lengths: array([2, 2], dtype=int32)

Редкие объекты существуют по причинам эффективности памяти.

Давайте теперь предположим, что у вас есть большой фрейм данных NA, и выполните следующий код -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(10000, 4))
df.ix[:9998] = np.nan
sdf = df.to_sparse()

print sdf.density

это output выглядит следующим образом -

0.0001

Любой разреженный объект можно преобразовать обратно в стандартную плотную форму, вызвав to_dense -

import pandas as pd
import numpy as np
ts = pd.Series(np.random.randn(10))
ts[2:-2] = np.nan
sts = ts.to_sparse()
print sts.to_dense()

это output выглядит следующим образом -

0   -0.810497
1   -1.419954
2         NaN
3         NaN
4         NaN
5         NaN
6         NaN
7         NaN
8    0.439240
9   -1.095910
dtype: float64

Редкие типы Dtypes

Разреженные данные должны иметь тот же dtype, что и их плотное представление. В настоящее время,float64, int64 и booldtypesподдерживаются. В зависимости от оригиналаdtype, fill_value default изменения -

float64 - нп.нан
int64 - 0
bool - ложь

Давайте выполним следующий код, чтобы понять то же самое -

import pandas as pd
import numpy as np

s = pd.Series([1, np.nan, np.nan])
print s

s.to_sparse()
print s

это output выглядит следующим образом -

0   1.0
1   NaN
2   NaN
dtype: float64

0   1.0
1   NaN
2   NaN
dtype: float64

Caveats означает предупреждение, а gotcha означает невидимую проблему.

Использование оператора If / Truth с пандами

Pandas следует соглашению numpy о выдаче ошибки при попытке преобразовать что-либо в bool. Это происходит вif или же when используя логические операции, и or, или же not. Непонятно, каким должен быть результат. Должно ли это быть Истина, потому что это не нулевая длина? Ложь, потому что есть Ложные значения? Это неясно, поэтому вместо этого Pandas поднимаетValueError -

import pandas as pd

if pd.Series([False, True, False]):
   print 'I am True'

это output выглядит следующим образом -

ValueError: The truth value of a Series is ambiguous. 
Use a.empty, a.bool() a.item(),a.any() or a.all().

В ifсостояние, непонятно что с ним делать. Ошибка указывает на то, следует ли использоватьNone или же any of those.

import pandas as pd

if pd.Series([False, True, False]).any():
   print("I am any")

это output выглядит следующим образом -

I am any

Чтобы оценить одноэлементные объекты pandas в логическом контексте, используйте метод .bool() -

import pandas as pd

print pd.Series([True]).bool()

это output выглядит следующим образом -

True

Побитовое логическое значение

Побитовые логические операторы, такие как == и != вернет логический ряд, который в любом случае почти всегда требуется.

import pandas as pd

s = pd.Series(range(5))
print s==4

это output выглядит следующим образом -

0 False
1 False
2 False
3 False
4 True
dtype: bool

isin Operation

Это возвращает логическую серию, показывающую, содержится ли каждый элемент в серии точно в переданной последовательности значений.

import pandas as pd

s = pd.Series(list('abc'))
s = s.isin(['a', 'c', 'e'])
print s

это output выглядит следующим образом -

0 True
1 False
2 True
dtype: bool

Переиндексирование против ix Gotcha

Многие пользователи обнаружат, что используют ix indexing capabilities как краткое средство выбора данных из объекта Pandas -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))

print df
print df.ix[['b', 'c', 'e']]

это output выглядит следующим образом -

one        two      three       four
a   -1.582025   1.335773   0.961417  -1.272084
b    1.461512   0.111372  -0.072225   0.553058
c   -1.240671   0.762185   1.511936  -0.630920
d   -2.380648  -0.029981   0.196489   0.531714
e    1.846746   0.148149   0.275398  -0.244559
f   -1.842662  -0.933195   2.303949   0.677641

          one        two      three       four
b    1.461512   0.111372  -0.072225   0.553058
c   -1.240671   0.762185   1.511936  -0.630920
e    1.846746   0.148149   0.275398  -0.244559

В данном случае это, конечно, полностью эквивалентно использованию reindex метод -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))

print df
print df.reindex(['b', 'c', 'e'])

это output выглядит следующим образом -

one        two      three       four
a    1.639081   1.369838   0.261287  -1.662003
b   -0.173359   0.242447  -0.494384   0.346882
c   -0.106411   0.623568   0.282401  -0.916361
d   -1.078791  -0.612607  -0.897289  -1.146893
e    0.465215   1.552873  -1.841959   0.329404
f    0.966022  -0.190077   1.324247   0.678064

          one        two      three       four
b   -0.173359   0.242447  -0.494384   0.346882
c   -0.106411   0.623568   0.282401  -0.916361
e    0.465215   1.552873  -1.841959   0.329404

Некоторые могут сделать вывод, что ix и reindexна 100% эквивалентны. Это верно, кроме случая целочисленной индексации. Например, указанная выше операция может быть выражена как -

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three',
'four'],index=list('abcdef'))

print df
print df.ix[[1, 2, 4]]
print df.reindex([1, 2, 4])

это output выглядит следующим образом -

one        two      three       four
a   -1.015695  -0.553847   1.106235  -0.784460
b   -0.527398  -0.518198  -0.710546  -0.512036
c   -0.842803  -1.050374   0.787146   0.205147
d   -1.238016  -0.749554  -0.547470  -0.029045
e   -0.056788   1.063999  -0.767220   0.212476
f    1.139714   0.036159   0.201912   0.710119

          one        two      three       four
b   -0.527398  -0.518198  -0.710546  -0.512036
c   -0.842803  -1.050374   0.787146   0.205147
e   -0.056788   1.063999  -0.767220   0.212476

    one  two  three  four
1   NaN  NaN    NaN   NaN
2   NaN  NaN    NaN   NaN
4   NaN  NaN    NaN   NaN

Важно помнить, что reindex is strict label indexing only. Это может привести к некоторым потенциально неожиданным результатам в патологических случаях, когда индекс содержит, скажем, как целые числа, так и строки.

Поскольку многие потенциальные пользователи Pandas в некоторой степени знакомы с SQL, эта страница предназначена для предоставления некоторых примеров того, как различные операции SQL могут выполняться с использованием pandas.

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
print tips.head()

это output выглядит следующим образом -

total_bill   tip      sex  smoker  day     time  size
0        16.99  1.01   Female      No  Sun  Dinner      2
1        10.34  1.66     Male      No  Sun  Dinner      3
2        21.01  3.50     Male      No  Sun  Dinner      3
3        23.68  3.31     Male      No  Sun  Dinner      2
4        24.59  3.61   Female      No  Sun  Dinner      4

ВЫБРАТЬ

В SQL выбор выполняется с использованием списка столбцов, разделенных запятыми, которые вы выбираете (или * для выбора всех столбцов) -

SELECT total_bill, tip, smoker, time
FROM tips
LIMIT 5;

В Pandas выбор столбца выполняется путем передачи списка имен столбцов в ваш DataFrame -

tips[['total_bill', 'tip', 'smoker', 'time']].head(5)

Проверим полную программу -

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'
 
tips=pd.read_csv(url)
print tips[['total_bill', 'tip', 'smoker', 'time']].head(5)

это output выглядит следующим образом -

total_bill   tip  smoker     time
0       16.99  1.01      No   Dinner
1       10.34  1.66      No   Dinner
2       21.01  3.50      No   Dinner
3       23.68  3.31      No   Dinner
4       24.59  3.61      No   Dinner

Вызов DataFrame без списка имен столбцов отобразит все столбцы (аналогично SQL *).

ГДЕ

Фильтрация в SQL выполняется с помощью предложения WHERE.

SELECT * FROM tips WHERE time = 'Dinner' LIMIT 5;

DataFrames можно фильтровать несколькими способами; наиболее интуитивно понятным из них является использование логической индексации.

tips[tips['time'] == 'Dinner'].head(5)

Проверим полную программу -

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
print tips[tips['time'] == 'Dinner'].head(5)

это output выглядит следующим образом -

total_bill   tip      sex  smoker  day    time  size
0       16.99  1.01   Female     No   Sun  Dinner    2
1       10.34  1.66     Male     No   Sun  Dinner    3
2       21.01  3.50     Male     No   Sun  Dinner    3
3       23.68  3.31     Male     No   Sun  Dinner    2
4       24.59  3.61   Female     No   Sun  Dinner    4

Приведенный выше оператор передает серию объектов True / False в DataFrame, возвращая все строки с True.

Группа по

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

SELECT sex, count(*)
FROM tips
GROUP BY sex;

Эквивалент Pandas будет -

tips.groupby('sex').size()

Проверим полную программу -

import pandas as pd

url = 'https://raw.github.com/pandasdev/
pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
print tips.groupby('sex').size()

это output выглядит следующим образом -

sex
Female   87
Male    157
dtype: int64

Верхние N строк

SQL возвращает top n rows с помощью LIMIT -

SELECT * FROM tips
LIMIT 5 ;

Эквивалент Pandas будет -

tips.head(5)

Давайте проверим полный пример -

import pandas as pd

url = 'https://raw.github.com/pandas-dev/pandas/master/pandas/tests/data/tips.csv'

tips=pd.read_csv(url)
tips = tips[['smoker', 'day', 'time']].head(5)
print tips

это output выглядит следующим образом -

smoker   day     time
0      No   Sun   Dinner
1      No   Sun   Dinner
2      No   Sun   Dinner
3      No   Sun   Dinner
4      No   Sun   Dinner

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