티스토리 뷰
Table of Contents
- Opening
- Data loading manually and from CSV files to Pandas DataFrame
- Loading, editing, and viewing data from Pandas DataFrame
- Renaming colmnns, exporting and saving Pandas DataFrames
- Summarising, grouping, and aggregating data in Pandas
- Merge and join DataFrames with Pandas
- Basic Plotting Pandas DataFrames
Opening¶
CSV (쉼표로 구분 된 값) 파일은 일반적인 데이터 파일 형식입니다.
Python을 사용하여 CSV 파일에서 날짜를 읽고, 조작하고, 날짜를 쓰는 기능은 데이터 과학자 또는 비즈니스 분석을 마스터하는 핵심 기술입니다.
1) what CSV files are,
2) how to read CSV files into "Pandas DataFrames",
3) how to write DataFrames back to CSV files.
What is "Pandas DataFrame"? : Pandas는 Python에서 가장 널리 사용되는 데이터 조작 패키지이며 DataFrames는 테이블 형식 2D 데이터를 저장하기위한 Pandas 데이터 타입입니다. : Pandas 개발은 2008 년에 주요 개발자 인 Wes McKinney와 함께 시작되었으며 라이브러리는 Python을 사용한 데이터 분석 및 관리의 표준이되었습니다. : Pandas 유창성은 모든 Python 기반 데이터 전문가, Kaggle 과제에 관심이 있거나 데이터 프로세스를 자동화하려는 모든 사람에게 필수적입니다. : Pandas 라이브러리 설명서는 DataFrame을“축과 행이 레이블이 지정된 2 차원 크기 변경 가능 이종 테이블 형식 데이터 구조”로 정의합니다.
- There can be multiple rows and columns in the data.
- Each row represents a sample of data,
- Each column contains a different variable that describes the samples (rows).
- The data in every column is usually the same type of data – e.g. numbers, strings, dates.
- Usually, unlike an excel data set, DataFrames avoid having missing values, and there are no gaps and empty values between rows or columns.
In [1]:
# Manually generate data
import pandas as pd
pd.options.display.max_columns = 20
pd.options.display.max_rows = 10
data = {'column1':[1,2,3,4,5],
'anatoeh_column':['this', 'column', 'has', 'strings', 'indise!'],
'float_column':[0.1, 0.5, 33, 48, 42.5555],
'binary_column':[True, False, True, True, False]}
print(data)
print(data['column1'])
display(pd.DataFrame(data))
display(pd.DataFrame(data['column1']))
Data loading manually and from CSV files to Pandas DataFrame¶
(https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.html)
There are 3 fundamantal conceps to grasp and debug the operation of the data loading procedure.
1) Understanding file extensions and file types – what do the letters CSV actually mean? what’s the difference between a .csv file and a .txt file?
2) Understanding how data is represented inside CSV files – if you open a CSV file, what does the data actually look like?
3) Understanding the Python path and how to reference a file – what is the absolute and relative path to the file you are loading? What directory are you working in?
4) CSV file loading errors
- FileNotFoundError: File b'filename.csv' does not exist
=> A File Not Found error is typically an issue with path setup, current directory, or file name confusion (file extension can play a part here!) - UnicodeDecodeError: 'utf-8' codec can't decode byte in position : invalid continuation byte
=> A Unicode Decode Error is typically caused by not specifying the encoding of the file, and happens when you have a file with non-standard characters. For a quick fix, try opening the file in Sublime Text, and re-saving with encoding ‘UTF-8’. - pandas.parser.CParserError: Error tokenizing data.
=> Parse Errors can be caused in unusual circumstances to do with your data format – try to add the parameter “engine=’python'” to the read_csv function call; this changes the data reading function internally to a slower but more stable method.
In [2]:
# Finding your Python path
# The "OS module" is for operating system dependent functionality into Python
import os
print(os.getcwd())
print(os.listdir())
# os.chdir("path")
In [3]:
# File Loading from "Absolute" and "Relative" paths
# Relative paths are directions to the file starting at your current working directory, where absolute paths always start at the base of your file system.
# direct_path : 'https://s3-eu-west-1.amazonaws.com/shanebucket/downloads/FAO+database.csv' from 'https://www.kaggle.com/dorbicycle/world-foodfeed-production'
absolute_path = '../Data/FoodAgricultureOrganization/Food_Agriculture_Organization_UN_Full.csv'
pd.read_csv(absolute_path, sep=',')
Out[3]:
In [5]:
relative_path = '../Data/FoodAgricultureOrganization/Food_Agriculture_Organization_UN_Full.csv'
pd.read_csv(relative_path, sep=',')
Out[5]:
In [6]:
pd.options.display.max_columns = 20
relative_path = '../Data/FoodAgricultureOrganization/Food_Agriculture_Organization_UN_Full.csv'
raw_data = pd.read_csv(relative_path, sep=',')
raw_data
Out[6]:
Loading, editing, and viewing data from Pandas DataFrame¶
팬더는 넓은 데이터 데이터 프레임의 경우 기본적으로 20 개의 열만 표시하고 중간 섹션은 잘리는 60 개 정도의 행만 표시합니다. 이 한도를 변경하려면 Pandas 디스플레이의 일부 내부 옵션을 사용하여 기본값을 편집 할 수 있습니다 (simple use pd.display.options.XX = value to set these) (https://pandas.pydata.org/pandas-docs/stable/options.html)
- pd.options.display.width – the width of the display in characters – use this if your display is wrapping rows over more than one line.
- pd.options.display.max_rows – maximum number of rows displayed.
- pd.options.display.max_columns – maximum number of columns displayed.
마지막으로 특정 열에 대한 핵심 통계를 보려면 'describe'기능을 사용하십시오.
- For numeric columns, describe() returns basic statistics: the value count, mean, standard deviation, minimum, maximum, and 25th, 50th, and 75th quantiles for the data in a column.
- For string columns, describe() returns the value count, the number of unique entries, the most frequently occurring value (‘top’), and the number of times the top value occurs (‘freq’)
Pandas에서 선택 및 색인 생성 활동을 수행하기위한 두 가지 주요 옵션이 있습니다. .loc 또는 .iloc을 사용하는 경우, 당신은 목록 또는 단일 값을 selector에 전달하여 출력 형식을 제어 할 수 있습니다. (http://pandas.pydata.org/pandas-docs/stable/indexing.html#selection-by-label)
- iloc
- .iloc은 한 row을 선택하면 Pandas Series를, 여러 row을 선택하거나 전체 column을 선택하면 Pandas DataFrame을 반환합니다. 이를 방지하려면 DataFrame 출력이 필요한 경우 single-valued list을 전달하십시오.
- 이러한 방식으로 여러 column 또는 여러 row을 선택할 때 선택 (예 : [1:5])에서 선택한 행 / 열은 첫 번째 숫자에서 두 번째 숫자에서 1을 뺀 숫자로 실행됩니다. 예 : [1:5]는 1,2,3,4.가되고, [x,y]는 x에서 y-1이됩니다.
- loc
- Label-based / Index-based indexing
- Boolean / Logical indexing
- array 또는 True / False 값 Series를 .loc 인덱서에 전달하여 Series에 True 값이있는 행을 선택합니다.
Selecting rows and columns
- using a dot notation, e.g. data.column_name,
- using square braces and the name of the column as a string, e.g. data['column_name']
- using numeric indexing and the iloc selector data.iloc[:,
]
When a column is selected using any of these methodologies, a pandas.Series is the resulting datatype. A pandas series is a one-dimensional set of data.
- square-brace selection with a list of column names, e.g. data[['column_name_1', 'column_name_2']]
- using numeric indexing with the iloc selector and a list of column numbers, e.g. data.iloc[:, [0,1,20,22]]
Rows in a DataFrame are selected, typically, using the iloc/loc selection methods, or using logical selectors
- numeric row selection using the iloc selector, e.g. data.iloc[0:10, :] – select the first 10 rows.
- label-based row selection using the loc selector (this is only applicably if you have set an “index” on your dataframe. e.g. data.loc[44, :]
- logical-based row selection using evaluated statements, e.g. data[data["Area"] == "Ireland"] – select the rows where Area value is ‘Ireland’.
To delete rows and columns from DataFrames, Pandas uses the “drop” function.
- column 또는 여러 column을 삭제하려면 column 이름을 사용하고 “axis”을 1로 지정하십시오.
- 또는 아래 예와 같이 'columns'매개 변수가 pandas에 추가되어 'axis'이 필요하지 않습니다.
- drop 함수는 열이 제거 된 새 DataFrame을 반환합니다. 원래 DataFrame을 실제로 편집하기 위해 "inplace"매개 변수를 True로 설정할 수 있으며 반환 된 값이 없습니다.
- axis = 0을 지정하여 “drop”기능을 사용하여 행을 제거 할 수도 있습니다. Drop ()은 숫자 색인 대신 "labels"을 기준으로 행을 제거합니다. 숫자 position / index를 기준으로 행을 삭제하려면 iloc을 사용하여 데이터 프레임 값을 다시 지정하십시오.
In [7]:
# Examine data in a Pandas DataFrame
raw_data.shape
Out[7]:
In [8]:
raw_data.ndim
Out[8]:
In [9]:
raw_data.head(5)
Out[9]:
In [10]:
raw_data.tail(5)
Out[10]:
In [13]:
raw_data.dtypes
Out[13]:
In [11]:
raw_data['Item Code'] = raw_data['Item Code'].astype(str)
raw_data.dtypes
Out[11]:
In [12]:
raw_data['Y2013'].describe()
Out[12]:
In [13]:
raw_data['Area'].describe()
Out[13]:
In [14]:
raw_data.describe()
Out[14]:
In [15]:
# Selecting and manipulating data
raw_data.iloc[0]
Out[15]:
In [16]:
raw_data.iloc[[1]]
Out[16]:
In [17]:
raw_data.iloc[[-1]]
Out[17]:
In [18]:
raw_data.iloc[:,0]
Out[18]:
In [19]:
raw_data.iloc[:,[1]]
Out[19]:
In [20]:
raw_data.iloc[:,[-1]]
Out[20]:
In [21]:
raw_data.iloc[0:5]
Out[21]:
In [22]:
raw_data.iloc[:,0:2]
Out[22]:
In [23]:
raw_data.iloc[[0,3,6,24],[0,5,6]]
Out[23]:
In [24]:
raw_data.iloc[0:5, 5:8]
Out[24]:
In [25]:
raw_data.loc[0]
Out[25]:
In [26]:
raw_data.loc[[1]]
Out[26]:
In [27]:
raw_data.loc[[1,3]]
Out[27]:
In [28]:
raw_data.loc[[1,3],['Item','Y2013']]
Out[28]:
In [29]:
raw_data.loc[[1,3],'Item':'Y2013']
Out[29]:
In [30]:
raw_data.loc[1:3,'Item':'Y2013']
Out[30]:
In [31]:
raw_data_test = raw_data.loc[10:,'Item':'Y2013']
raw_data_test.iloc[[0]]
Out[31]:
In [32]:
raw_data_test.loc[[10]]
Out[32]:
In [33]:
raw_data.loc[raw_data['Item'] == 'Sugar beet']
Out[33]:
In [34]:
# is same as
raw_data[raw_data['Item'] == 'Sugar beet']
Out[34]:
In [35]:
raw_data.loc[raw_data['Item'] == 'Sugar beet', 'Area']
Out[35]:
In [36]:
raw_data.loc[raw_data['Item'] == 'Sugar beet', ['Area']]
Out[36]:
In [37]:
# is not same as
raw_data[raw_data['Item'] == 'Sugar beet', ['Area']]
In [38]:
raw_data.loc[raw_data['Item'] == 'Sugar beet', ['Area', 'Item', 'latitude']]
Out[38]:
In [42]:
raw_data.loc[raw_data['Item'] == 'Sugar beet', 'Area':'latitude']
Out[42]:
In [43]:
raw_data.loc[raw_data['Area'].str.endswith('many')]
Out[43]:
In [44]:
# is same as
raw_data.loc[raw_data['Area'].isin(['Germany'])]
Out[44]:
In [45]:
raw_data.loc[raw_data['Area'].isin(['Germany', 'France'])]
Out[45]:
In [46]:
raw_data.loc[(raw_data['Area'].str.endswith('many')) & (raw_data['Element'] == 'Feed')]
Out[46]:
In [47]:
raw_data.loc[(raw_data['Y2004'] < 1000) & (raw_data['Y2004'] > 990)]
Out[47]:
In [48]:
raw_data.loc[(raw_data['Y2004'] < 1000) & (raw_data['Y2004'] > 990), ['Area', 'Item', 'latitude']]
Out[48]:
In [49]:
raw_data.loc[raw_data['Item'].apply(lambda x: len(x.split(' ')) == 5)]
Out[49]:
In [50]:
# is same as
TF_indexing = raw_data['Item'].apply(lambda x: len(x.split(' ')) == 5)
raw_data.loc[TF_indexing]
Out[50]:
In [51]:
raw_data.loc[TF_indexing, ['Area', 'Item', 'latitude']]
Out[51]:
In [52]:
raw_data_test = raw_data.copy()
raw_data_test.loc[(raw_data_test['Y2004'] < 1000) & (raw_data_test['Y2004'] > 990), ['Area']]
Out[52]:
In [53]:
raw_data_test.loc[(raw_data_test['Y2004'] < 1000) & (raw_data_test['Y2004'] > 990), ['Area']] = 'Company'
raw_data_test.loc[(raw_data_test['Y2004'] < 1000) & (raw_data_test['Y2004'] > 980), ['Area']]
Out[53]:
In [54]:
raw_data['Y2007'].sum(), raw_data['Y2007'].mean(), raw_data['Y2007'].median(), raw_data['Y2007'].nunique(), raw_data['Y2007'].count(), raw_data['Y2007'].max(), raw_data['Y2007'].min()
Out[54]:
In [55]:
[raw_data['Y2007'].sum(),
raw_data['Y2007'].mean(),
raw_data['Y2007'].median(),
raw_data['Y2007'].nunique(),
raw_data['Y2007'].count(),
raw_data['Y2007'].max(),
raw_data['Y2007'].min(),
raw_data['Y2007'].isna().sum(),
raw_data['Y2007'].fillna(0)]
Out[55]:
In [56]:
# Delete the "Area" column from the dataframe
raw_data.drop("Area", axis=1)
Out[56]:
In [57]:
# alternatively, delete columns using the columns parameter of drop
raw_data.drop(columns="Area")
Out[57]:
In [58]:
# Delete the Area column from the dataframe and the original 'data' object is changed when inplace=True
raw_data.drop("Area", axis=1, inplace=False)
Out[58]:
In [59]:
# Delete multiple columns from the dataframe
raw_data.drop(["Y2011", "Y2012", "Y2013"], axis=1)
Out[59]:
In [60]:
# Delete the rows with labels 0,1,5
raw_data.drop([0,1,5], axis=0)
Out[60]:
In [61]:
# Delete the rows with label "Afghanistan". For label-based deletion, set the index first on the dataframe
raw_data.set_index("Area")
raw_data.set_index("Area").drop("Afghanistan", axis=0)
Out[61]:
In [62]:
# Delete the first five rows using iloc selector
raw_data.iloc[5:,]
Out[62]:
Renaming colmnns, exporting and saving Pandas DataFrames¶
DataFrame 이름 바꾸기 기능을 사용하면 Pandas에서 열 이름을 쉽게 바꿀 수 있습니다. 이름 바꾸기 기능은 사용하기 쉽고 매우 유연합니다.
- Rename by mapping old names to new names using a dictionary, with form {“old_column_name”: “new_column_name”, …}
- Rename by providing a function to change the column names with. Functions are applied to every column name.
조작 또는 계산 후 데이터를 CSV로 다시 저장하는 것이 다음 단계입니다.
- to_csv to write a DataFrame to a CSV file,
- to_excel to write DataFrame information to a Microsoft Excel file.
In [63]:
# Renaming of columns
raw_data.rename(columns={'Area':'New_Area'})
Out[63]:
In [64]:
display(raw_data)
raw_data.rename(columns={'Area':'New_Area'}, inplace=False)
Out[64]:
In [65]:
raw_data.rename(columns={'Area':'New_Area',
'Y2013':'Year_2013'}, inplace=False)
Out[65]:
In [66]:
raw_data.rename(columns=lambda x: x.upper().replace(' ', '_'), inplace=False)
Out[66]:
In [67]:
# Exporting and saving
# Output data to a CSV file
# If you don't want row numbers in my output file, hence index=False, and to avoid character issues, you typically use utf8 encoding for input/output.
raw_data.to_csv("Tutorial_Pandas_Output_Filename.csv", index=False, encoding='utf8')
# Output data to an Excel file.
# For the excel output to work, you may need to install the "xlsxwriter" package.
raw_data.to_excel("Tutorial_Pandas_Output_Filename.xlsx", sheet_name="Sheet 1", index=False)
Summarising, grouping, and aggregating data in Pandas¶
.describe () 함수는 적용되는 모든 변수 또는 그룹에 대한 통계를 빠르게 표시하는 유용한 요약 도구입니다. describe () 출력은 숫자 또는 문자 열에 적용하는지에 따라 달라집니다.
| Function | Description |
|---|---|
| count | Number of non-null observations |
| sum | Sum of values |
| mean | Mean of values |
| mad | Mean absolute deviation |
| median | Arithmetic median of values |
| min | Minimum |
| max | Maximum |
| mode | Mode |
| abs | Absolute Value |
| prod | Product of values |
| std | Unbiased standard deviation |
| var | Unbiased variance |
| sem | Unbiased standard error of the mean |
| skew | Unbiased skewness (3rd moment) |
| kurt | Unbiased kurtosis (4th moment) |
| quantile | Sample quantile (value at %) |
| cumsum | Cumulative sum |
| cumprod | Cumulative product |
| cummax | Cumulative maximum |
| cummin | Cumulative minimum |
우리는 다양한 변수로 큰 데이터 프레임을 그룹화하고 각 그룹에 summary functions를 적용 할 것입니다. 이는 Pandas DataFrame 객체의 "groupby()"및 "agg()"함수를 사용하여 Pandas에서 수행됩니다. (http://pandas.pydata.org/pandas-docs/stable/groupby.html)
- groupby() 는 기본적으로 선택한 변수에 따라 데이터를 여러 그룹으로 나눕니다.
- groupby () 함수는 GroupBy 오브젝트를 리턴하지만 원래 데이터 세트의 행이 분할 된 방식을 본질적으로 설명합니다.
- GroupBy object.groups 변수는 키가 계산 된 unique 그룹이고 해당 값이 각 그룹에 속하는 axis label 인 dictionary입니다.
- max(), min(), mean(), first(), last()와 같은 함수를 GroupBy 객체에 빠르게 적용하여 각 그룹에 대한 요약 통계를 얻을 수 있습니다.
- 결과 열을 두 개 이상 계산하면 결과가 DataFrame이됩니다. 단일 결과 열의 경우 agg function는 기본적으로 Series를 생성합니다. 작업 열을 다르게 선택하여 이를 변경할 수 있습니다 (예 : [[]])
- groupby 출력에는 선택한 그룹화 변수에 해당하는 행에 대한 색인 또는 다중 색인이 있습니다. 이 인덱스를 설정하지 않으려면 "as_index = False"를 groupby 작업에 전달하십시오.
agg () 함수가 제공하는 집계 기능을 사용하면 그룹당 여러 통계를 한 번의 계산으로 계산할 수 있습니다.
- When multiple statistics are calculated on columns, the resulting dataframe will have a multi-index set on the column axis. This can be difficult to work with, and be better to rename columns after a groupby operation.
- 여러 통계가 열에 대해 계산되면 결과 dataframe에 column axis에 multi-index set이 설정됩니다. 이는 작업하기 어려울 수 있으며 그룹 별 작업 후에 열 이름을 바꾸는 것이 좋습니다.
- 깔끔한 접근 방식은 그룹화 된 열에서 ravel() 메서드를 사용하고 있습니다. Ravel ()은 Pandas multi-index을 더 간단한 배열로 바꾸어 현명한 열 이름으로 결합 할 수 있습니다.
In [68]:
# Summarising
url_path = 'https://shanelynnwebsite-mid9n9g1q9y8tt.netdna-ssl.com/wp-content/uploads/2015/06/phone_data.csv'
raw_phone = pd.read_csv(url_path)
raw_phone
Out[68]:
In [69]:
if 'date' in raw_phone.columns:
raw_phone['date'] = pd.to_datetime(raw_phone['date'])
raw_phone
Out[69]:
In [70]:
raw_phone['duration'].max()
Out[70]:
In [71]:
raw_phone['item'].unique()
Out[71]:
In [72]:
raw_phone['duration'][raw_phone['item'] == 'data'].max()
Out[72]:
In [73]:
raw_phone['network'].unique()
Out[73]:
In [74]:
raw_phone['month'].value_counts()
Out[74]:
In [75]:
# Grouping
raw_phone.groupby(['month']).groups
Out[75]:
In [76]:
raw_phone.groupby(['month']).groups.keys()
Out[76]:
In [77]:
raw_phone.groupby(['month']).first()
Out[77]:
In [78]:
raw_phone.groupby(['month'])['duration'].sum()
Out[78]:
In [79]:
raw_phone.groupby(['month'], as_index=False)[['duration']].sum()
Out[79]:
In [80]:
raw_phone.groupby(['month'])['date'].count()
Out[80]:
In [81]:
raw_phone[raw_phone['item'] == 'call'].groupby('network')['duration'].sum()
Out[81]:
In [82]:
raw_phone.groupby(['month', 'item']).groups
Out[82]:
In [83]:
raw_phone.groupby(['month', 'item']).groups.keys()
Out[83]:
In [84]:
raw_phone.groupby(['month', 'item']).first()
Out[84]:
In [85]:
raw_phone.groupby(['month', 'item'])['duration'].sum()
Out[85]:
In [86]:
raw_phone.groupby(['month', 'item'])['date'].count()
Out[86]:
In [87]:
raw_phone.groupby(['month', 'network_type'])['date'].count()
Out[87]:
In [88]:
raw_phone.groupby(['month', 'network_type'])[['date']].count()
Out[88]:
In [89]:
raw_phone.groupby(['month', 'network_type'], as_index=False)[['date']].count()
Out[89]:
In [90]:
raw_phone.groupby(['month', 'network_type'])[['date']].count().shape
Out[90]:
In [91]:
raw_phone.groupby(['month', 'network_type'], as_index=False)[['date']].count().shape
Out[91]:
In [92]:
# Aggregating
raw_phone.groupby(['month'], as_index=False)[['duration']].sum()
Out[92]:
In [93]:
# is same as
raw_phone.groupby(['month'], as_index=False).agg({'duration':'sum'})
Out[93]:
In [94]:
raw_phone.groupby(['month', 'item']).agg({'duration':'sum',
'network_type':'count',
'date':'first'})
Out[94]:
In [95]:
# is same as
aggregation_logic = {'duration':'sum',
'network_type':'count',
'date':'first'}
raw_phone.groupby(['month', 'item']).agg(aggregation_logic)
Out[95]:
In [96]:
aggregation_logic = {'duration':[min, max, sum],
'network_type':'count',
'date':[min, 'first', 'nunique']}
raw_phone.groupby(['month', 'item']).agg(aggregation_logic)
Out[96]:
In [97]:
aggregation_logic = {'duration':[min, max, sum],
'network_type':'count',
'date':['first', lambda x: max(x)-min(x)]}
raw_phone.groupby(['month', 'item']).agg(aggregation_logic)
Out[97]:
In [98]:
raw_phone_test = raw_phone.groupby(['month', 'item']).agg(aggregation_logic)
raw_phone_test
Out[98]:
In [99]:
raw_phone_test.columns = raw_phone_test.columns.droplevel(level=0)
raw_phone_test
Out[99]:
In [100]:
raw_phone_test.rename(columns={'min':'min_duration',
'max':'max_duration',
'sum':'sum_duration',
'<lambda>':'date_difference'})
raw_phone_test = raw_phone.groupby(['month', 'item']).agg(aggregation_logic)
raw_phone_test
Out[100]:
In [101]:
raw_phone_test.columns = ['_'.join(x) for x in raw_phone_test.columns.ravel()]
raw_phone_test
Out[101]:
Merge and join DataFrames with Pandas¶
(http://pandas.pydata.org/pandas-docs/stable/merging.html)
Python을 사용하는 실제 데이터 과학 상황의 경우 분석 데이터 세트를 구성하기 위해 Pandas Dataframes를 merge하거나 join해야하는 시간은 약 10 분입니다. 데이터 프레임 병합 및 결합은 모든 주목받는 데이터 분석가가 마스터해야하는 핵심 프로세스입니다.
- 두 데이터 세트를 "merge"하는 것은 두 데이터 세트를 하나로 모으고 공통 속성 또는 열을 기준으로 각 행을 정렬하는 프로세스입니다.
- 가장 간단한 병합 작업은 왼쪽 dataframe (첫 번째 인수), 오른쪽 dataframe (두 번째 인수), merge column name 또는 "on"을 병합 할 열을 사용합니다.
- 출력/결과에서 "on"으로 지정된 병합 열의 공통 값이있는 경우 왼쪽 및 오른쪽 dataframe의 행이 일치됩니다.
- 기본적으로 Pandas 병합 작업은 "inner" merge으로 작동합니다.
Pandas에는 세 가지 유형의 병합이 있습니다. 이러한 병합 유형은 대부분의 데이터베이스 및 데이터 지향 언어 (SQL, R, SAS)에서 일반적이며 "join"이라고합니다
- inner merge / inner jon – 기본 팬더 동작은 병합 "on"값이 왼쪽 및 오른쪽 dataframe 모두에 존재하는 행만 유지합니다.
- left merge / left outer join – (일명 왼쪽 병합 또는 왼쪽 조인) 왼쪽 dataframe의 모든 행을 유지합니다. 오른쪽 dataframe에 "on" 변수의 결 측값이있는 경우 결과에 empty/NaN 값을 추가하십시오.
- Right merge / Right outer join – (일명 오른쪽 병합 또는 오른쪽 조인) 모든 행을 올바른 dataframe에 유지합니다. 왼쪽 열에 "on" 변수의 결 측값이 있으면 결과에 empty / NaN 값을 추가하십시오.
- outer merge / full outer join – full outer join은 왼쪽 dateframe의 모든 행과 오른쪽 dataframe의 모든 행을 반환하고 가능한 경우 NaN과 다른 행을 일치시킵니다.
In [102]:
# Merge and join od dataframes
user_usage = pd.read_csv('https://raw.githubusercontent.com/shanealynn/Pandas-Merge-Tutorial/master/user_usage.csv')
user_device = pd.read_csv('https://raw.githubusercontent.com/shanealynn/Pandas-Merge-Tutorial/master/user_device.csv')
device_info = pd.read_csv('https://raw.githubusercontent.com/shanealynn/Pandas-Merge-Tutorial/master/android_devices.csv')
display(user_usage.head())
display(user_device.head())
display(device_info.head())
In [103]:
# Q: if the usage patterns for users differ between different devices
result = pd.merge(left=user_usage, right=user_device, on='use_id')
result.head()
Out[103]:
In [104]:
print(user_usage.shape, user_device.shape, device_info.shape, result.shape)
In [105]:
user_usage['use_id'].isin(user_device['use_id']).value_counts()
Out[105]:
In [106]:
result = pd.merge(left=user_usage, right=user_device, on='use_id', how='left')
print(user_usage.shape, result.shape, result['device'].isnull().sum())
In [107]:
display(result.head(), result.tail())
In [108]:
result = pd.merge(left=user_usage, right=user_device, on='use_id', how='right')
print(user_device.shape, result.shape, result['device'].isnull().sum(), result['monthly_mb'].isnull().sum())
In [109]:
display(result.head(), result.tail())
In [110]:
print(user_usage['use_id'].unique().shape[0], user_device['use_id'].unique().shape[0], pd.concat([user_usage['use_id'], user_device['use_id']]).unique().shape[0])
In [111]:
result = pd.merge(left=user_usage, right=user_device, on='use_id', how='outer')
print(result.shape)
In [112]:
print((result.apply(lambda x: x.isnull().sum(), axis=1) == 0).sum())
In [113]:
# Note that all rows from left and right merge dataframes are included, but NaNs will be in different columns depending if the data originated in the left or right dataframe.
result = pd.merge(left=user_usage, right=user_device, on='use_id', how='outer', indicator=True)
result.iloc[[0, 1, 200, 201, 350, 351]]
Out[113]:
In [114]:
# For the question,
result1 = pd.merge(left=user_usage, right=user_device, on='use_id', how='left')
result1.head()
Out[114]:
In [115]:
device_info.head()
Out[115]:
In [116]:
result_final = pd.merge(left=result1, right=device_info[['Retail Branding', 'Marketing Name', 'Model']],
left_on='device', right_on='Model', how='left')
result_final[result_final['Retail Branding'] == 'Samsung'].head()
Out[116]:
In [117]:
result_final[result_final['Retail Branding'] == 'LGE'].head()
Out[117]:
In [118]:
group1 = result_final[result_final['Retail Branding'] == 'Samsung']
group2 = result_final[result_final['Retail Branding'] == 'LGE']
display(group1.describe())
display(group2.describe())
In [119]:
result_final.groupby('Retail Branding').agg({'outgoing_mins_per_month':'mean',
'outgoing_sms_per_month':'mean',
'monthly_mb':'mean',
'user_id':'count'})
Out[119]:
Basic Plotting Pandas DataFrames¶
(https://pandas.pydata.org/pandas-docs/stable/visualization.html)
그래픽을 생성하려면 matplotlib 플로팅 패키지가 설치되어 있어야하며 인라인 플롯에 대해 "% matplotlib 인라인"노트북 'magic'이 활성화되어 있어야합니다.
다이어그램에 그림 레이블과 축 레이블을 추가하려면 "import matplotlib.pyplot as plt"도 필요합니다.
Pandas가 기본적으로 .plot () 명령으로 많은 기능을 제공합니다.
In [120]:
# Plotting DataFrames
import matplotlib.pyplot as plt
raw_data['latitude'].plot(kind='hist', bins=100)
plt.xlabel('Latitude Value')
plt.show()
In [121]:
raw_data.loc[raw_data['Element'] == 'Food']
Out[121]:
In [122]:
raw_data_test = raw_data.loc[raw_data['Element'] == 'Food']
pd.DataFrame(raw_data_test.groupby('Area')['Y2013'].sum())
Out[122]:
In [123]:
pd.DataFrame(raw_data_test.groupby('Area')['Y2013'].sum().sort_values(ascending=False))
Out[123]:
In [124]:
pd.DataFrame(raw_data_test.groupby('Area')['Y2013'].sum().sort_values(ascending=False)[:10])
Out[124]:
In [125]:
raw_data_test.groupby('Area')['Y2013'].sum().sort_values(ascending=False)[:10].plot(kind='bar')
plt.title('Top Ten Food Producers')
plt.ylabel('Food Produced (tonnes)')
Out[125]:
In [ ]:
'Kafka & Elasticsearch' 카테고리의 다른 글
| Text and Keyword 타입 (0) | 2020.04.29 |
|---|---|
| Elasticsearch scaling down (0) | 2019.08.04 |
| Kafka Streams (Stateful, Aggregating) (0) | 2019.03.17 |
| Kafka Fail-over (cluster) (0) | 2019.01.07 |
| 토픽 삭제 (Topic delete) (0) | 2019.01.06 |
댓글