#!/usr/bin/env python

# coding: utf-8

# # pandas--Python Data Analysis Library

# 官网：https://pandas.pydata.org/

#

# Pandas中文网：https://www.pypandas.cn/

#

# Pandas 精选资源：https://www.pypandas.cn/

#

# Pandas 生态圈：https://www.pypandas.cn/

#

# Pandas教程：http://www.ysir308.com/archives/category/tutorial/pandas-tutorial

#

# 附录：

# - pandas中的index对象详解.ipynb

# - joyful-pandas-master文件夹

# In[1]:

#忽略级别 3 及以下的消息（级别 1 是提示，级别 2 是警告，级别 3 是错误）

import os

os.environ['TF_CPP_MIN_LOG_LEVEL']='3'

# In[97]:

from pandas import Series #联系下一句，思考这样写的用意

import pandas as pd

import numpy as np

# ## Pandas 中的数据类型 ####

#

# Pandas的名称来自于面板数据（panel data）和python数据分析（data analysis）。panel data是经济学中关于多维数据集的一个术语，在Pandas中也提供了panel的数据类型。

#

# Pandas 基于两种数据类型，series 和 dataframe。

#

# - series 是一种一维的数据类型，其中的每个元素都有各自的索引，可以把它当作一个由带索引的元素组成的 numpy 一维数组。索引(index)可以是**数字或者字符**。

#

# - dataframe 是一个二维的、表格型的数据结构。dataframe 可以储存许多**不同类型的数据**，并且**每个轴都有索引。**

# ### Series构建和引用

# In[98]:

s = Series([4, 7, -5, 3]) #可以用list构建

s

# In[99]:

s = Series((4, 7, -5, 3)) #可以用tuple构建

s

# In[100]:

s.index #默认的index

# In[101]:

type(s.index)

# In[102]:

s.index = ['Bob', 'Steve', 'Jeff', 'Ryan'] #重新设置index

s

# In[103]:

s.index

# In[104]:

s2 = Series([4, 7, -5, 3], index=['d', 'b', 'a', 'a']) #index的值可以相同

s2

# In[105]:

s2['a'] #index值索引

# In[106]:

sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}

s3 = Series(sdata) #用字典创建Series

s3

# In[107]:

states = ['California', 'Ohio', 'Oregon', 'Texas']

s4 = Series(sdata, index=states) #用字典创建Series，另外给出index（可能与字典中的key值不完全符合）

s4

# In[108]:

s = Series(np.arange(4.), index=['a', 'b', 'c', 'd'])

s

# In[109]:

s['b'] #index值索引

# In[110]:

s[1] #行号索引

# In[111]:

s[2:4] #行号索引--切片不包括末尾

# In[112]:

s[['b', 'a', 'd']] #index值索引

# In[113]:

s[[1, 3]] #行号索引

# In[114]:

s

# In[115]:

s[s < 2] #找出值<2的

# In[116]:

s < 2

# In[117]:

s

# In[118]:

s['a':'c'] #Series索引的切片运算和普通的切片运算不同--包含末端

# In[119]:

s['b':'c'] = 5 #切片赋值

s

# ### DataFrame构建与引用

# #### 构建一个空的DataFrame

# In[120]:

import pandas as pd

import numpy as np

df = pd.DataFrame()

df

# In[121]:

type(df)

# In[122]:

pd.DataFrame(columns=['b','a', 'c', 'd', 'e']) #指定列名

# #### 构建一个字符串DataFrame

# In[123]:

pd.DataFrame(np.array(list('abcdefgh')).reshape((4,2))) #默认，按行排列

# #### 读取文件构建DataFrame

# In[124]:

DATA=pd.read_csv(r'd:\foo.csv') #假定foo.csv文件放置在d:\

DATA

# In[125]:

DATA.index

# #### 创建日期索引的DataFrame

# In[126]:

dates = pd.date_range('20000226',periods=6) #2000年是闰年

df_d = pd.DataFrame(np.random.randn(6,4),index=dates,columns=list('ABCD'))

df_d

# In[127]:

df_d.index

# #### 用字典创建DataFrame，注意各项的value值个数要相同

# In[128]:

dic = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],

'year': [2000, 2001, 2002, 2001, 2002],

'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}

DF = pd.DataFrame(dic)

DF

# In[129]:

DF.index

# In[130]:

pd.DataFrame(dic, columns=['year', 'state', 'pop']) #改变字段的顺序

# In[131]:

pd.DataFrame(dic, columns=['year', 'state', 'pp']) #如果columns的值与data的key值不符

# In[132]:

DF1 = pd.DataFrame(dic, columns=['year', 'state', 'pop', 'debt'],

index=['one', 'two', 'three', 'four', 'five']) #指定列名和index

DF1

# In[133]:

DF1.columns #注意，columns也是Index

# In[134]:

a=DF1.year #也可以用“.”的方式引用列

a

# In[135]:

type(a)

# In[136]:

DF1['year'] #也可以[ ]引用列

# In[137]:

DF1[['year','pop']] #引用多列--使用list

# ### 快速查看整体信息

# In[2]:

import numpy as np

import pandas as pd

# .info()是DataFrame才可用的API，快捷查看多种信息：总行数和列数、每列元素类型和non-NaN的个数，总内存。

#

# DataFrame.info(verbose=None, memory_usage=True, null_counts=True)

# - verbose：True or False，字面意思是冗长的，也就说如果DataFrame有很多列，是否显示所有列的信息，如果为否，那么会省略一部分；

# - memory_usage：True or False，默认为True，是否查看DataFrame的内存使用情况；

# - null_counts：True or False，默认为True，是否统计NaN值的个数。

# In[6]:

df = pd.read_csv('golf.csv',sep=";")

df

# In[7]:

df.info() # 直接默认设置即可

# In[8]:

df.shape # (行数，列数)

# In[9]:

df.size # 元素个数，rows×cols

# In[10]:

df.describe() # 默认只对数值列进行统计

# In[ ]:

# #### DataFrame 数据索引与选取，从这三个层次考虑：行列、区域、单元格。

# 其对应使用的方法如下：

# ##### 一. 行，列 --> df[ ]

# ##### 二. 区域 --> df.loc[ ], df.iloc[ ]

# ##### 三. 单元格 --> df.at[ ], df.iat[ ]

# In[ ]:

# In[ ]:

# In[ ]:

# ### index的用途总结：

#

# 更方便的数据查询；

# - 使用index可以获得性能提升；

# - 自动的数据对齐功能；

# - 更多更强大的数据结构支持；

#

# 使用index会提升查询性能

# - 如果index是唯一的，Pandas会使用哈希表优化，查询性能为O(1);

# - 如果index不是唯一的，但是有序，Pandas会使用二分查找算法，查询性能为O(logN);

# - 如果index是完全随机的，那么每次查询都要扫描全表，查询性能为O(N);

# In[67]:

df.index

# ### 一. df[ ]:一维,只能单独地针对行或列，不能合起来使用

# ##### 行维度： 数字索引切片、索引切片、布尔列表、布尔Series

# - 即：如果 df[ ]中是切片、布尔，pandas认为是针对“行”---有整体感的

# - 简记为：[ ]--切片、布尔（有整体感的）针对“行”，字符、列表（没有整体感的）针对“列”

# In[144]:

import numpy as np

import pandas as pd

rng = np.random.RandomState(10) # 设置随机局部种子

df = pd.DataFrame(rng.randn(6,4), index=list('abcdef'), columns=list('ABCD'))

df

# In[145]:

df.index

# In[ ]:

# In[146]:

df[:3] #行号切片不包括尾

# In[147]:

df[2:3] #行号切片不包括尾--单独一行

# In[148]:

df['a':'c'] #index切片包括尾

# In[149]:

df['a':'a'] #index切片包括尾--单独一行

# In[150]:

df[['a','c']] #× 不能用行索引list

# In[151]:

df[[True,True,True,False,False,False]] # 前三行（布尔数组长度等于行数）

# In[152]:

df[df['A']>0] # A列值大于0的行

# In[153]:

df['A']>0

# In[154]:

type(df['A']>0)

# In[155]:

df[(df['A']>0) | (df['B']>0)] # A列值大于0，或者B列大于0的行,注意“df”外边的“()”

# In[156]:

df[(df['A']>0) & (df['B']>0)] # A列值大于0，并且B列大于0的行,注意“df”外边的“()”

# ##### 列维度：索引索引、索引列表

# ##### 即：如果 df[ ]中是索引索引或索引列表，pandas识别为针对“列”

# - 简记为：[ ]--切片、布尔（有整体感的）针对“行”，字符、列表（没有整体感的）针对“列”

# In[157]:

df['A']

# In[158]:

df['A':'C'] #× 列维度不能用切片,行维度可以

# In[159]:

df[['A','B']] #列维度用索引列表

# In[160]:

df['A','B'] #里面要写成列表--加上[ ]

# In[161]:

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

# In[162]:

import numpy as np

import pandas as pd

rng = np.random.RandomState(10) # 设置随机局部种子

df = pd.DataFrame(rng.randn(6,4), index=list('abcdef'), columns=list('ABCD'))

df

# ### 二. df.loc[ ] ：引用区域，二维，先行后列

# - 行维度：单个索引及切片、索引list、布尔list、布尔Series

# - 列维度：单个索引及切片、索引list、布尔list、布尔Series

# - 简记为：loc--索引所有及布尔

# In[186]:

import numpy as np

import pandas as pd

rng = np.random.RandomState(10) # 设置随机局部种子

df = pd.DataFrame(rng.randn(6,4), index=list('abcdef'), columns=list('ABCD'))

df

# In[187]:

df

# In[188]:

df.loc['a', :]

# In[189]:

df.loc['a'] #引用行可以省略后边的“：”

# In[190]:

df.loc['a':'d', :] #索引切片包括终值,索引的取值可能无规律，不便知道下一个取值

# In[191]:

df.loc['a':'d'] #引用行可以省略后边的“：”

# In[192]:

df.loc[['a','b','d'], :]

# In[193]:

df.loc[['a','b','d']] #引用行可以省略后边的“：”

# In[194]:

df.loc[[True,True,True,False,False,False], :] # 前三行（布尔数组长度等于行数）

# In[195]:

df.loc[df['A']>0, :]

# In[196]:

df['A']>0

# In[197]:

type(df['A']>0)

# In[198]:

df.loc[:, 'A']

# In[199]:

df['A'] #与上句等效

# In[200]:

df.loc[:, 'A':'C']

# In[201]:

df.loc[,'A':'C'] #引用列不能省略前边的“：”

# In[202]:

df.loc[:, ['A','C']]

# In[203]:

df.loc[:, [True,True,True,False]] # 前三列（布尔列表长度等于列数）

# In[204]:

type([True,True,True,False])

# In[205]:

df.loc[:, df.loc['a']>0] # a行大于0的列

# In[206]:

df.loc['a']>0

# In[207]:

type(df.loc['a']>0)

# In[208]:

df.loc[df['A']>0, :] # A列大于0的行

# In[209]:

df['A']>0

# In[210]:

type(df['A']>0)

# In[211]:

df.loc[['a','c','f'], df.columns[2]] #loc中使用列号

# In[212]:

df.columns[2]

# In[213]:

df

# In[214]:

df.loc[['a','c','f'], df.columns[:2]] #loc中使用列号列表

# In[215]:

df.columns[:2]

# In[216]:

df.loc[['a','c','f'], ['A','C','D']] #用loc索引列表取某些行中的某些列-不连续

# In[217]:

df.loc['c':'f', 'B':'D'] #用loc索引切片取某些行中的某些列--连续

# 数字索引

# In[220]:

import numpy as np

import pandas as pd

df = pd.read_csv('data/table.csv',index_col='ID')

df

# In[221]:

df.index

# In[222]:

df.loc[1103]

# In[223]:

df.loc[[1102,2304]]

# In[224]:

df.loc[1304:2103]

# In[225]:

df.loc[2402::-1]

# In[227]:

df.loc[[1101,1102,1105]]

# In[ ]:

# ### 三、 df.iloc[ ]---i(int)表示行号：二维，先行后列

# - 行维度：行号索引、行号切片、行号list、（行号）布尔list

# - 列维度：列号索引、列号切片、列号list、（列号）布尔list

# - 简记为：iloc--行列号所有及布列

# In[230]:

import numpy as np

import pandas as pd

rng = np.random.RandomState(10) # 设置随机局部种子

df = pd.DataFrame(rng.randn(6,4), index=list('abcdef'), columns=list('ABCD'))

df

# In[232]:

df.iloc[3, :]

# In[74]:

df.iloc[3]

# In[75]:

df.iloc[:3, :]

# In[76]:

df.iloc[[0,2,4], :]

# In[233]:

df.iloc[[True,True,True,False,False,False], :] # 前三行（布尔数组长度等于行数）

# In[234]:

df.iloc[df['A']>0, :] # × 本意是取出A列中>0的所有行

# In[81]:

df['A']>0

# In[236]:

type(df['A']>0) #不是单纯的布尔list

# In[237]:

df.iloc[df.loc[:,'A']>0, :] # × 本意是取出A列中>0的行

# In[238]:

df.loc[:,'A']>0

# In[239]:

type(df.loc[:,'A']>0) #不是单纯的布尔list

# In[240]:

df.loc[df.loc[:,'A']>0, :] #改用本句即可

# In[241]:

df.iloc[:, df.loc['a']>0] # × 本意是取出a行中>0的列

# In[242]:

df.loc['a']>0

# In[243]:

type(df.loc['a']>0)

# In[244]:

df.loc[:, df.loc['a']>0] #改用本句即可

# In[245]:

df

# In[246]:

df.iloc[:, 1] #记住是从“0”列开始

# In[247]:

df.iloc[:, 0:3]

# In[248]:

df.iloc[:, [0,2]]

# In[249]:

df.iloc[:, [True,True,True,False]] # 前三列（布尔数组长度等于行数）

# In[250]:

df.iloc[[0,2], [0,2]] #用iloc序号列表取某些行中的某些列-不连续

# In[251]:

df.iloc[0:2, 0:2] #用iloc序号切片取某些行中的某些列-连续

# In[252]:

df.loc[df.iloc[:,0]>0, :] #第0列>0的行

# In[253]:

df.iloc[:,0]>0

# In[254]:

df.loc[:,df.iloc[0,:]>0] #第0行>0的列

# In[255]:

df.iloc[0,:]>0

# In[256]:

df.loc[:, df.iloc[0]>0] # 0行大于0的列,iloc中只有一个数字，是行

# ### 四、 df.at[ ]:用索引精确定位单元格

# - 行维度：索引索引

# - 列维度：索引索引

# In[257]:

df