阅读路线:
import numpy as np
import pandas as pd
在进行下面的题目操作时,一定要先导入上面的两个数据分析包pandas、numpy
s = pd.Series([1, 3, 5, np.nan, 6, 8])
输出:
series是一个一维的标记数组,可以容纳任何数据类型(整数、字符串、浮点数、Python对象等)。必须记住,与Python列表不同,一个series总是包含相同类型的数据。
#导入pandas
import pandas as pd
#字符串列表
lst = ["Gamer47", "Shox", "Simple"]
#在列表中调用DataFrame构造函数
df = pd.DataFrame(lst)
df2 = pd.DataFrame({'A': 1.,
'B': pd.Timestamp('20130102'),
'C': pd.Series(1, index = list(range(4)), dtype='float32'),
'D': np.array([3] * 4, dtype = 'int32'),
'E': pd.Categorical(["test", "train", "test", "train"]),
'F': 'foo'})
要创建一个完全空的pandas dataframe,我们使用以下操作:
import pandas as pd
df = pd.DataFrame()
已知有这样的数据,如何进行查看
dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index = dates, columns = list('ABCD'))
在pandas中建立索引意味着简单地从DataFrame中选择特定地数据行和列。
pandas支持四种类型的多轴索引,它们是:
它们统称为索引器。这些是迄今为止索引数据最常见的方法。这四个函数有助于从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']),
'D': np.random.normal(100, 10, size=(N)).tolist()
})
df_reindexed = df.reindex(index=[0, 2, 5], columns=['A', 'C', 'B'])
print(df_reindexed)
输出:
panda set_index()是一种将列表、序列或dataframe设置为dataframe索引的方法。
语法:
DataFrame.set_index(keys, inplace=False)
参数:
改变索引列
在本例中,名称列被用作DataFrame的索引列
import pandas as pd
#读取csv文本文件到DataFrame变量中
data = pd.read_csv("employees.csv")
data.set_index("first_name", inplace=True)
#观察数据
data.head()
输出:
如输出图像所示,以前索引列是一系列数字
改变索引列后,索引列是给定的索引列
Pandas Series.reset_index()
函数的作用是:生成一个新的DataFrame或带有重置索引的Series。
例1:使用Series.reset_index()函数重置给定Series对象的索引
#导入pandas包
import pandas as pd
#创建Series
sr = pd.Series([10, 25, 3, 11, 24, 6])
#创建索引
index_ = ['Coca Cola', 'Sprite', 'Coke', 'Fanta', 'Dew', 'ThumbsUp']
#设置索引
sr.index = index_
#打印series
print(sr)
输出:
现在,我们将使用Series.reset_index()函数来重置给定的series对象的索引
#重置索引
result = sr.reset_index()
#打印
print(result)
输出:
从输出中可以看到,该Series.reset_index()函数已将给定Series对象的索引重置为默认值。它保留了索引,并将其转换为列。
dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
import pandas as pd
import numpy as np
from numpy import percentile
p = pd.Series(np.random.normal(14, 6, 22))
state = np.random.RandomState(120)
p = pd.Series(state.normal(14, 6, 22))
print(percentile(p, q=[0, 25, 50, 75, 100]))
Pandas dataframe.mean(axis=None)函数返回所请求(axis = 0代表对列进行求平均值,axis=1代表对行进行求平均值)的值的平均值。
示例:使用mean()函数查找索引轴上所有观测值的平均值
import pandas as pd
df = pd.DataFrame({
"A": [12, 4, 5, 44, 1],
"B": [5, 2, 54, 3, 2],
"C": [20, 16, 7, 3, 8],
"D": [14, 3, 17, 2, 6]
})
df
输出:
让我们使用dataframe.mean()函数来查找索引轴上的平均值。
可以使用apply()函数以便将函数应用于给定dataframe中的每一行。让我们来看看我们完成这项任务的方式。
实例:
import pandas as pd
def add(a, b, c):
return a + b + c
def main():
data = {
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]
}
df = pd.DataFrame(data)
print("Original DataFrame:\n", df)
df['add'] = df.apply(lambda row: add(row['A'], row['B'], row['C']), axis = 1)
print('\nAfter Applying Function:')
print(df)
if __name__ == '__main__':
main()
import numpy as np
raw_data = {'name': ['Willard Morris', 'Al Jennings', 'Omar Mullins', 'Spencer McDaniel'],
'age': [20, 19, 22, 21],
'favorite_color': ['blue', 'red', 'yellow', 'green'],
'grade': [88, 92, 95, 70]}
df = pd.DataFrame(raw_data, columns=['name', 'age', 'favorite_color', 'grade'])
df.shape
Pandas dataframe.sum()函数返回所请求轴的值的和
语法: DataFrame.sum(axis=None,skipna=None)
参数:
**示例1:**使用sum()函数查找索引轴上所有值的总和
#导入数据
import pandas as pd
df = pd.read_csv("NBAPlayers.txt", delimiter="\t")
现在求出沿索引轴的所有值的和。我们将跳过计算和时的NaN值。
#查找索引轴的和,默认情况下,轴设置为0
df.sum(axis = 0, skipna = True)
如何将新行追加到pandas DataFrame
Pandas dataframe.append() 函数的作用是:将其他dataframe的行追加到给定的dataframe的末尾,返回一个新的dataframe对象。
语法: DataFrame.append(ignore_index=False)
参数:
示例1: 创建两个数据框,然后将第二个附加到第一个。
import pandas as pd
#使用dictionary创建第一个DataFrame
df1 = pd.DataFrame({
"a":[1, 2, 3, 4],
"b":[5, 6, 7, 8]
})
#使用dictionary创建第二个DataFrame
df2 = pd.DataFrame({
"a": [1, 2, 3],
"b": [5, 6, 7]
})
现在将df2附加到df1的末尾
df1.append(df2)
输出:
请注意,第二个DataFrame的索引值保留在附加的DataFrame中。如果我们不希望发生这种情况,则可以设置ignore_index = True
df.append(df2, ignore_index = True)
pandas.merge根据一个键或多个键将行进行连接。对于SQL或其他关系型数据库的用户来说,这种方式是比较熟悉的,它实现的是数据库的连接操作。
df1 = pd.DataFrame({
'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
'data1': range(7)
})
df2 = pd.DataFrame({
'key': ['a', 'b', 'd'],
'data2': range(3)
})
pd.merge(df1, df2)
输出:
请注意,我并没有指定在哪一列上进行连接。如果连接的键信息没有指定,merge会自动将重叠列名作为连接的键。但是,显示地指定连接键才是最好的实现:
如果每个对象的列名是不同的,你可以分别为它们指定列名:
df3 = pd.DataFrame({
'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
'data1': range(7)
})
df4 = pd.DataFrame({
'rkey': ['a', 'b', 'd'],
'data2': range(3)
})
pd.merge(df3, df4, left_on='lkey', right_on='rkey')
输出:
默认情况下,merge做的是内连接(“inner” join),结果中的键是两张表的交集。
其他可选的选项有’left’、“right”和“outer”。外连接(outer join)是键的并集,联合了左连接和右连接的效果:
尽管不是很直观,但多对多的合并有明确的行为。下面是一个例子:
df1 = pd.DataFrame({
'key': ['b', 'b', 'a', 'c', 'a', 'b'],
'data1': range(6)
})
df2 = pd.DataFrame({
'key': ['a', 'b', 'a', 'b', 'd'],
'data2': range(5)
})
pd.merge(df1, df2, on='key', how='left')
输出:
多对多连接时行的笛卡尔积。由于左边的DataFrame中有三个‘b’行,而在右边有两行,因此在结果中有六个’b’ 行。连接方法仅影响结果中显示的不同键值:
使用多个键进行合并时,传入一个列名的列表:
left = pd.DataFrame({
'key1': ['foo', 'foo', 'bar'],
'key2': ['one', 'two', 'one'],
'lval': [1, 2, 3]
})
right = pd.DataFrame({
'key1': ['foo', 'foo', 'bar', 'bar'],
'key2': ['one', 'one', 'one', 'two'],
'rval': [4, 5, 6, 7]
})
pd.merge(left, right, on=['key1', 'key2'], how='outer')
输出:
决定哪些键联合出现在结果中,取决于合并方法的选择,把多个键看作一个元组数据来作为单个连接键使用(尽管实际上并不是以这种方法来实现的)。
合并操作中最后一个要考虑的问题时如何处理重叠的列名。虽然你可以手动解决重叠问题,但是merge有一个suffixes后缀选项,用于左右两边DataFrame对象的重叠列名后指定需要添加的字符串:
在某些情况下,DataFrame中用于合并的键是它的索引。在这种情况下,你可以传递left_index=True或right_index=True(或者都传)来表示索引需要用来作为合并的键:
left1 = pd.DataFrame({
'key': ['a', 'b', 'a', 'a', 'b', 'c'],
'value': range(6)
})
right1 = pd.DataFrame({
'group_val': [3.5, 7]},
index=['a', 'b']
)
pd.merge(left1, right1, left_on='key', right_index=True)
输出:
由于默认的合并方法是连接键相交,你可以使用外连接来进行合并:
在多层索引数据的情况下,事情会更复杂,在索引上连接时一个隐式的多键合并:
lefth = pd.DataFrame({
'key1': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
'key2': [2000, 2001, 2002, 2001, 2002],
'data': np.arange(5.)
})
righth = pd.DataFrame(np.arange(12).reshape((6, 2)),
index=[['Nevada', 'Nevada', 'Ohio', 'Ohio', 'Ohio', 'Ohio'],
[2001, 2000, 2000, 2000, 2001, 2002]],
columns=['event1', 'event2'])
pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)
这种情况下,你必须以列表的方式指明合并所需多个列(请注意使用how = ‘outer’处理重复的索引值):
使用两边的索引进行合并也是可以的:
left2 = pd.DataFrame([[1., 2.,], [3., 4.,], [5., 6.]],
index=['a', 'c', 'e'],
columns=['Ohio', 'Nevada'])
right2 = pd.DataFrame([[7., 8.], [9., 10.], [11., 12.], [13., 14.]],
index=['b', 'c', 'd', 'e'],
columns=['Missouri', 'Alabama'])
pd.merge(left2, right2, how='outer', left_index=True, right_index=True)
DataFrame有一个方便的join示例方法,用于按照索引合并。该方法也可以用于合并多个索引相同或相似但没有重叠列的DataFrame对象。在之前的例子中,我们可以这样写:
由于一些历史原因(例如,一些非常早期版本的pandas),DataFrame的join方法进行连接键上的左连接,完全保留左边DataFrame的行索引。它还支持在调用DataFrame的某一列上连接传递的DataFrame的索引:
最后对于一些简单索引-索引合并,你可以向join方法传入一个DataFrame列表,这个方法可以替代下一节将要介绍的使用更为通用的concat函数的方法:
另一种数据组合操作可互换地称为拼接、绑定或堆叠。NumPy的concatenate函数可以在NumPy数组上实现该功能:
在Series和DataFrame等pandas对象的上下文中,使用标记的轴可以进一步泛化数组连接。尤其是你还有许多需要考虑的事情:
pandas的concat函数提供了一种一致性的方式来解决以上问题。我将给出一些例子来表明它的工作机制。假设我们有三个索引不存在重叠的Series:
用列表中的这些对象调用concat方法会将值和索引粘在一起:
默认情况下,concat方法是沿着axis=0的轴向生效的,生成另一个Series。如果你传递axis=1,返回的结果则是一个DataFrame(axis=1时是列):
在这个案例中另一个轴向上并没有重叠,你可以看到排序后的索引合集(’outer‘ join 外连接)。你也可以传入join=’inner’:
你甚至可以使用join_axes来指定用于连接其他轴向的轴:
拼接在一起的各部分无法在结果中区分是一个潜在的问题。假设你想在连接轴向上创建一个多层索引,可以使用keys参数来实现:
沿着轴向axis=1连接Series的时候,keys则成为DataFrame的列头:
将相同的逻辑拓展到DataFrame对象:
如果你传递的是对象的字典而不是列表的话,则字典的键会用于keys选项:
还有一些额外的参数负责多层索引生成。例如,我们可以使用names参数命名生成的轴层级:
最后需要考虑的是行索引中不包括任何相关数据的DataFrame:
在这个示例中,我们传入ignore_index=True:
还有另一个数据联合场景,既不是合并操作,也不是连接操作。你可能有两个数据集,这两个数据集的索引全部或部分重叠。作为一个示例,考虑NumPy的where函数,这个函数可以进行面向数组的if-else等价操作:
Series有一个combine_first方法,该方法可以等价于下面这种使用pandas常见数据对齐逻辑的轴向操作:
在DataFrame中,combine_first逐列做相同的操作,因此你可以认为它是根据你传入的对象来“修补"调用对象的缺失值:
“group by” 指的是涵盖下列一项或多项步骤的处理流程:
df = pd.DataFrame({
'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
'C': np.random.randn(8),
'D': np.random.randn(8)
})
df.groupby('A').sum()
df.groupby(['A', 'B']).sum()
如何将numpy数组转换为给定形状的DataFrame?
import pandas as pd
import numpy as np
p = pd.Series(np.random.randint(1, 7, 8))
输出:
将Series p重新组合成一个2行4列的dataframe
info = pd.DataFrame(p.values.reshape(2,4))
透视表是一种可以对数据动态排布并且分类汇总的表格格式,在pandas中它被称作pivot_table。
pivot_table(data, values=None, index=None, columns=None)
参数:
import pandas as pd
import numpy as np
df = pd.DataFrame({
'A': ['one', 'one', 'two', 'three'] * 3,
'B': ['A', 'B', 'C'] * 4,
'C': ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'] *2,
'D': np.random.randn(12),
'E': np.random.randn(12)
})
pd.pivot_table(df, values='D', index=['A', 'B'], columns=['C'])
源数据:
#导入pandas
import pandas as pd
#定义一个包含学生数据的字典
data = {'Name': ['Jai', 'Princi', 'Gaurav', 'Anuj'],
'Height': [5.1, 6.2, 5.1, 5.2],
'Qualification': ['Msc', 'Ma', 'Msc', 'Msc']}
#将字典转换成DataFrame
df = pd.DataFrame(data)
#声明要转换为列的列表
address = ['Delhi', 'Bangalore', 'Chennai', 'Patna']
#使用”address“作为列名
df['address'] = address
#观察结果
df
向DataFrame添加索引
如果您创建了一个DataFrame,pandas允许将输入添加到索引参数中。它将确保您拥有所需的索引。否则,在默认情况下,DataFrame包含一个数值索引,该索引从0开始,在DataFrame的最后一行结束。
向DataFrame添加行、列
我们可以使用.loc、iloc和ix将行、列插入到DataFrame中。
添加具有特定索引名的行:
import pandas as pd
employees = pd.DataFrame(data={'Name': ['John Doe', 'William Spark'],
'Occupation': ['Chemist', 'Statistician'],
'Date Of Join': ['2018-01-25', '2018-01-26'],
'Age': [23, 24]},
index=['Emp001', 'Emp002'],
columns=['Name', 'Occupation', 'Date Of Join', 'Age'])
print("\n----------------- BEFORE -------------------\n")
print(employees)
employees.loc['Emp003'] = ['Sunny', 'Programmer', '2018-01-25', 45]
print("\n----------------- AFTER -------------------\n")
print(employees)
您可以通过结合使用for循环和对DataFrame的iterrows()调用来遍历DataFrame的行。
import pandas as pd
import numpy as np
df = pd.DataFrame([{'c1': 10, 'c2': 100}, {'c1': 11, 'c2': 110}, {'c1': 12, 'c2': 120}])
for index, row in df.iterrows():
print(row['c1'], row['c2'])
df
我们可以通过以下几种有效地在DataFrame中执行排序:
(1)可以使用sort_index()方法对数据dataframe进行排序。可以通过传递axis参数和排序顺序来实现。默认情况下,按升序对行标签进行排序。
import numpy as np
import pandas as pd
unsorted_df = pd.DataFrame(np.random.randn(10, 2), index=[1, 4, 6, 2, 3, 5, 9, 8, 0, 7],
columns=['col2', 'col1'])
sorted_df = unsorted_df.sort_index()
print(sorted_df)
输出:
排序顺序
通过将布尔值传递给升序参数,可以控制排序的顺序。让我们考虑下面的例子来理解这个问题
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],
columns=['col2', 'col1'])
sorted_df = unsorted_df.sort_index(ascending=False)
print(sorted_df)
输出:
对列进行排序
通过传递值1的axis参数,可以对列标签进行排序,让我们考虑下面的例子来理解这个问题。
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],
columns=['col2', 'col1'])
sorted_df = unsorted_df.sort_index(axis=1)
print(sorted_df)
输出:
(2)按照实际值
DataFrame.sort_values(by,axis=0,ascending=True,inplace=False)
sort_values提供了一个功能,我们可以在其中指定要排序的值的DataFrame列名。他是通过传递“by”参数来完成的。
参数解析:
import numpy as np
import pandas as pd
from pandas import DataFrame
data = [['a', 2, 301], ['b', 1, 201], ['c', 2, 201], ['d', 1, 301], ['e', 2, 301]]
df = pd.DataFrame(data, columns=['A', 'B', 'C'])
df.sort_values(by=['C', 'B'], ascending=[False, True], inplace=True)
data_1 = [[300, 2, 301], [2, 1, 201], [3, 300, 201], [100, 1, 301], [500, 2, 301]]
df_1 = pd.DataFrame(data_1, columns=['A', 'B', 'C'])
df_1.sort_values(by=0, axis=1, inplace=True)
import pandas as pd
data = {'name': ['Jason', 'Molly', 'Tina', 'Jake', 'Amy'],
'year': [2012, 2013, 2013, 2014, 2014],
'reports': [4, 24, 31, 2, 3]}
df = pd.DataFrame(data, index=['Cochice', 'Pima', 'Santa Cruz', 'Maricopa', 'Yuma'])
df
df.drop(['Cochice', 'Pima'])
创建源数据
test_dict = {'id':[1, 2, 3, 4, 5, 6],
'name': ['Alice', 'Bob', 'Cindy', 'Eric', 'Helen', 'Grace'],
'math': [90, 89, 99, 78, 97, 93],
'english': [89, 94, 80, 94, 94, 90]}
#直接写入参数test_dict
test_dict_df = pd.DataFrame(test_dict)
#字典型赋值
test_dict_df = pd.DataFrame(data=test_dict)
输出:
删除列
删除列,我们使用drop()函数,则要增加参数axis=1
test_dict_df.drop(['id'], axis=1)