使用列表创建DataframePandas优点：
-
处理浮点与非浮点数据里的缺失数据，表示为
NaN； -
大小可变：插入或删除 DataFrame 等多维对象的列；
-
自动、显式数据对齐：显式地将对象与一组标签对齐，也可以忽略标签，在 Series、DataFrame 计算时自动与数据对齐；
-
强大、灵活的**分组（group by）**功能：拆分-应用-组合数据集，聚合、转换数据；
-
把 Python 和 NumPy 数据结构里不规则、不同索引的数据轻松地转换为 DataFrame 对象；
-
基于智能标签，对大型数据集进行切片、花式索引、子集分解等操作；
-
直观地合并（merge）、**连接（join）**数据集；
-
灵活地重塑（reshape）、**透视（pivot）**数据集；
-
轴支持结构化标签：一个刻度支持多个标签；
-
成熟的 IO 工具：读取文本文件（CSV 等支持分隔符的文件）、Excel 文件、数据库等来源的数据，利用超快的 HDF5 格式保存 / 加载数据；
-
时间序列：支持日期范围生成、频率转换、移动窗口统计、移动窗口线性回归、日期位移等时间序列功能。
创建Dataframe的方法
pandas.DataFrame( data, index, columns, dtype, copy) 构造方法
data：一组数据(ndarray、series, map, lists, dict 等类型)
index：索引值，或者可以称为行标签。
columns：列标签，默认为 RangeIndex (0, 1, 2, …, n) 。
dtype：数据类型。
copy：拷贝数据，默认为 False。#使用list列表创建DataFrame
data1 = [['a',1.0],['b',2.0],['c',3.0],]
df1 = pd.DataFrame(data1,columns=['key','value'])
print(df1)
print('----------------------------')
print(df1.dtypes)key value 0 a 1.0 1 b 2.0 2 c 3.0 ---------------------------- key object value float64 dtype: object
#使用List创建DataFrame
list1=["class1",'class2','class3','class4','class5']
list2=list('abcdef')
list3 = [[3,4,5,6,8,10],[2,3,5,1,9,11],[4,2,9,0,2,3],[14,12,19,10,12,13],[24,22,292,20,22,23]]
df = pd.DataFrame(list3,index=list1,columns=list2)
print(df)a b c d e f class1 3 4 5 6 8 10 class2 2 3 5 1 9 11 class3 4 2 9 0 2 3 class4 14 12 19 10 12 13 class5 24 22 292 20 22 23
#使用字典创建Dataframe
data2 = {'name':['a1','a2','a3'],'age':[12,20,18]}
df= pd.DataFrame(data2,index =["class1",'class2','class3'])
print(df2)
print('----------------------------')
print(df2.dtypes)name age class1 a1 12 class2 a2 20 class3 a3 18 ---------------------------- name object age int64 dtype: object
#使用字典创建 Dataframe
data1 = {'a':1,'b':2,'c':3},{'a':3,'b':5,'c':3},{'a':3,'b':2,}
df3 = pd.DataFrame(data1,dtype=int)
print(df3)
print('----------------------------')
print(df3.dtypes)a b c 0 1 2 3.0 1 3 5 3.0 2 3 2 NaN ---------------------------- a int32 b int32 c float64 dtype: object
#创建一组日期DataFrame
index = pd.date_range('1/1/2000', periods=8)
print(index)DatetimeIndex(['2000-01-01', '2000-01-02', '2000-01-03', '2000-01-04',
'2000-01-05', '2000-01-06', '2000-01-07', '2000-01-08'],
dtype='datetime64[ns]', freq='D')
#numpy创建DataFrame
import numpy as np
list1=['a1','a2','a3','a4','a5','a6']
list2=['A','B','C']
df = pd.DataFrame(np.random.randn(6, 3), index=list1,columns=list2)
print(df)A B C a1 -0.342545 -1.714921 -0.006376 a2 3.010536 0.198070 -0.360081 a3 1.416659 0.803343 -0.917506 a4 0.007565 1.076642 -1.037496 a5 0.428244 -0.953278 -0.265666 a6 -1.558382 1.002403 0.226359
#numpy创建DataFrame
df1 = pd.DataFrame(np.arange(12).reshape((4, 3)), columns=list('abc'), index=['1', '2', '3','4'])a b c 1 0 1 2 2 3 4 5 3 6 7 8 4 9 10 11
Pandas设置数据显示格式
display.max_rows 最大显示行数，超过该值用省略号代替，为None时显示所有行。
display.max_columns 最大显示列数，超过该值用省略号代替，为None时显示所有列。
display.expand_frame_repr 输出数据宽度超过设置宽度时，表示是否对其要折叠，False不折叠，True要折叠。
display.max_colwidth 单列数据宽度，以字符个数计算，超过时用省略号表示。
display.precision 设置输出数据的小数点位数。
display.width 数据显示区域的宽度，以总字符数计算。
display.show_dimensions 当数据量大需要以truncate（带引号的省略方式）显示时，该参数表示是否在最后显示数据的维数，默认 True 显示，False 不显示。# 显示最大列宽pd.set_option('max_colwidth',200)
# 显示所有列 pd.set_option('display.max_columns', None)
# 显示所有行 pd.set_option('display.max_rows', None)
查找及选取数据
list1=list('12345')
list2=list('abcdef')
list3 = [[3,4,5,6,8,10],[2,3,5,1,9,11],[4,2,9,0,2,3],[14,12,19,10,12,13],[24,22,292,20,22,23]]
df1 = pd.DataFrame(list3,index=list1,columns=list2) #索引为字符‘12345’
df2 = pd.DataFrame(list3,columns=list2) #索引为数值12345
print("--------索引为字符‘12345’--------------")
print(df1)
print("----------索引为数值12345---------------")
print(df2)
print("------loc['1']获取索引为字符'1'的行-----")
print(df1.loc['1'])
print("-------loc[1]获取索引为数字的行---------")
print(df2.loc[1])
print("---iloc[1]获取df1/2第2行(从0行算起)-----")
print(df1.iloc[1])
print("---------iloc[1]按列索引选取------------")
print(df2.iloc[1])
print("-------------df['c']按行范围选----------")
print(df1.b)
print(df['c'])
print("-------------df[0:2]按行切片------------")
print(df[0:2])--------索引为字符‘12345’-------------
a b c d e f
1 3 4 5 6 8 10
2 2 3 5 1 9 11
3 4 2 9 0 2 3
4 14 12 19 10 12 13
5 24 22 292 20 22 23
----------索引为数值12345---------------
a b c d e f
0 3 4 5 6 8 10
1 2 3 5 1 9 11
2 4 2 9 0 2 3
3 14 12 19 10 12 13
4 24 22 292 20 22 23
------loc['1']获取索引为字符'1'的行-----
a 3
b 4
c 5
d 6
e 8
f 10
Name: 1, dtype: int64
-------loc[1]获取索引为数字的行---------
a 2
b 3
c 5
d 1
e 9
f 11
Name: 1, dtype: int64
---iloc[1]获取df1/2第2行(从0行算起)-----
a 2
b 3
c 5
d 1
e 9
f 11
Name: 2, dtype: int64
a 2
b 3
c 5
d 1
e 9
f 11
Name: 1, dtype: int64
-------------按列索引选取---------------
1 4
2 3
3 2
4 12
5 22
Name: b, dtype: int64
0 5
1 5
2 9
3 19
4 292
Name: c, dtype: int64
-------------按行范围选对---------------
a b c d e f
0 3 4 5 6 8 10
1 2 3 5 1 9 11
list1=list('12345')
list2=list('abcdef')
list3 = [[3,4,5,6,8,10],[2,3,5,1,9,11],[4,2,9,0,2,3],[14,12,19,10,12,13],[24,22,292,20,22,23]]
df1 = pd.DataFrame(list3,index=list1,columns=list2) #索引为字符‘12345’
df2 = pd.DataFrame(list3,columns=list2) #索引为数值12345
print("--------索引为字符‘12345’-------------")
print(df1)
print("----------索引为数值12345---------------")
print(df2)
print(df1.shape)
print(df1.index)
print(df2.index)
print(df1.columns)
print('----------------')
print(df1.to_numpy())
print("----------------")
df2.values--------索引为字符‘12345’-------------
a b c d e f
1 3 4 5 6 8 10
2 2 3 5 1 9 11
3 4 2 9 0 2 3
4 14 12 19 10 12 13
5 24 22 292 20 22 23
----------索引为数值12345---------------
a b c d e f
0 3 4 5 6 8 10
1 2 3 5 1 9 11
2 4 2 9 0 2 3
3 14 12 19 10 12 13
4 24 22 292 20 22 23
(5, 6)
Index(['1', '2', '3', '4', '5'], dtype='object')
RangeIndex(start=0, stop=5, step=1)
Index(['a', 'b', 'c', 'd', 'e', 'f'], dtype='object')
----------------
[[ 3 4 5 6 8 10]
[ 2 3 5 1 9 11]
[ 4 2 9 0 2 3]
[ 14 12 19 10 12 13]
[ 24 22 292 20 22 23]]
----------------
array([[ 3, 4, 5, 6, 8, 10],
[ 2, 3, 5, 1, 9, 11],
[ 4, 2, 9, 0, 2, 3],
[ 14, 12, 19, 10, 12, 13],
[ 24, 22, 292, 20, 22, 23]], dtype=int64)
插入数据
# 采用insert方式插入列数据
a1 =[['john',2,5],['web',3,5],['fan',8,9]]
d1 =pd.DataFrame(a1,index=list('abc'),columns=['name','u1','u2'])
a2 =[['mary',9,3],['hanson',6,7],['jonson',18,2]]
d2 =pd.DataFrame(a2,index=list('def'),columns=['name','u1','u2'])
add =[23,8,10]
print(d1)
print('----------------------------')
print(d2)
print('----------------------------')
d1.insert(3,column='u3',value=add) # 第一个参数表示插入在第3列
print(d1)
print('----------------------------')
# append 合并二个数据 其column需相同
d3 = d1._append(d2)
print(d3) name u1 u2
a john 2 5
b web 3 5
c fan 8 9
----------------------------
name u1 u2
d mary 9 3
e hanson 6 7
f jonson 18 2
----------------------------
name u1 u2 u3
a john 2 5 23
b web 3 5 8
c fan 8 9 10
----------------------------
name u1 u2 u3
a john 2 5 23.0
b web 3 5 8.0
c fan 8 9 10.0
d mary 9 3 NaN
e hanson 6 7 NaN
f jonson 18 2 NaN
删除数据
# 删除列数据
a1 =({'john':[2,3,5,10],'smith':[3,3,2,5],'tom':[8,7,2,2]})
df = pd.DataFrame(a1,index =list('abcd'))
print(df)
df.pop('tom')
print(df)
del df['john']
print(df)
print('----------------------------')
#删除行数据
print(df.drop('a')) john smith tom a 2 3 8 b 3 3 7 c 5 2 2 d 10 5 2 john smith a 2 3 b 3 3 c 5 2 d 10 5 smith a 3 b 3 c 2 d 5 ---------------------------- smith b 3 c 2 d 5
常用属性和方法汇总
a1 =({'john':[2,3,5,10],'smith':[3,3,2,5],'tom':[8,7,2,2]})
df = pd.DataFrame(a1,index =list('abcd'))
print(df)
print('----------------------------')
print(df.T) #行和列进行交换,行和列转置
print('---------------------------行和列转置-')
print(df.axes) #返回一个行标签、列标签组成的列表
print('----------------------------行标签、列标签')
print(df.index)
print(df.columns)
print(df.values)
print(df.to_numpy)
print(df.dtypes) #返回每一列的数据类型
print('----------------------------数据对象是否为空')
print(df.empty) #返回一个布尔值，判断输出的数据对象是否为空，若为 True 表示对象为空
print('----------------------------数据对象的维数')
print(df.ndim) #返回数据对象的维数。DataFrame 是一个二维数据结构。
print('---------------------------DataFrame 维度-')
print(df.shape) #返回一个代表 DataFrame 维度的元组。返回值元组 (a,b)，其中 a 表示行数，b 表示列数。
print('---------------------------元素数量')
print(df.size) #返回 DataFrame 中的元素数量
print('----------------------------DataFrame 中的数据')
print(df.values) #以 ndarray 数组的形式返回 DataFrame 中的数据
print('---------------------------显示前2行的数据-')
print(df.head(2)) #head()&tail()查看数据
print('----------------------------')
print(df.shift(periods=2,axis=0))
print('----------------------------')
print(df.shift(periods=2,axis=1,fill_value= 10))
# shift()移动行或列 DataFrame.shift(periods=1, freq=None, axis=0)
# peroids 类型为int，表示移动的幅度，可以是正数，也可以是负数，默认值为1。
# freq 日期偏移量，默认值为None，适用于时间序。取值为符合时间规则的字符串。
# axis 如果是 0 或者 "index" 表示上下移动，如果是 1 或者 "columns" 则会左右移动。
# fill_value 该参数用来填充缺失值。
john smith tom
a 2 3 8
b 3 3 7
c 5 2 2
d 10 5 2
----------------------------
a b c d
john 2 3 5 10
smith 3 3 2 5
tom 8 7 2 2
---------------------------行和列转置-
[Index(['a', 'b', 'c', 'd'], dtype='object'), Index(['john', 'smith', 'tom'], dtype='object')]
----------------------------行标签、列标签
john int64
smith int64
tom int64
dtype: object
----------------------------数据对象是否为空
False
----------------------------数据对象的维数
2
---------------------------DataFrame 维度-
(4, 3)
---------------------------元素数量
12
----------------------------DataFrame 中的数据
[[ 2 3 8]
[ 3 3 7]
[ 5 2 2]
[10 5 2]]
---------------------------显示前2行的数据-
john smith tom
a 2 3 8
b 3 3 7
----------------------------
john smith tom
a NaN NaN NaN
b NaN NaN NaN
c 2.0 3.0 8.0
d 3.0 3.0 7.0
----------------------------
john smith tom
a 10 10 2
b 10 10 3
c 10 10 5
d 10 10 10
内置迭代方法
#遍历 DataFrame 的每一行
a1 =({'john':[2,3,5,10],'smith':[3,3,2,5],'tom':[8,7,2,2]})
df = pd.DataFrame(a1,index =list('abcd'))
print(df)
print('\n')
#1) iteritems()：以键值对 (key,value) 的形式遍历；
for key,value in df.iteritems():
print(key,value)
print('----------------------------')
#2) iterrows()：以 (row_index,row) 的形式遍历行;
for row_index,row in df.iterrows():
print (row_index,row)
print('----------------------------')
#3) itertuples()：使用已命名元组的方式对行遍历
for row in df.itertuples():
print(row)
john smith tom a 2 3 8 b 3 3 7 c 5 2 2 d 10 5 2 john a 2 b 3 c 5 d 10 Name: john, dtype: int64 smith a 3 b 3 c 2 d 5 Name: smith, dtype: int64 tom a 8 b 7 c 2 d 2 Name: tom, dtype: int64 ---------------------------- a john 2 smith 3 tom 8 Name: a, dtype: int64 b john 3 smith 3 tom 7 Name: b, dtype: int64 c john 5 smith 2 tom 2 Name: c, dtype: int64 d john 10 smith 5 tom 2 Name: d, dtype: int64 ---------------------------- Pandas(Index='a', john=2, smith=3, tom=8) Pandas(Index='b', john=3, smith=3, tom=7) Pandas(Index='c', john=5, smith=2, tom=2) Pandas(Index='d', john=10, smith=5, tom=2)
#各种遍历方式用时对比：
def df_sample():
a1 = np.random.uniform(1,1000,30000)
a2 = np.random.uniform(1,1000,30000)
a3 = np.random.uniform(1,1000,30000)
a4 = np.random.uniform(1,1000,30000)
df = pd.DataFrame({'s1':a1,'s2':a2, 's3': a3, 's4': a4, 's5': None})
return df
def iterate_1(dataframe):
for i in range(len(dataframe)):
dataframe.iloc[i,4] = dataframe.iloc[i,0] + dataframe.iloc[i,1]
def iterate_2(dataframe):
for i in range(len(dataframe)):
dataframe.iat[i,4] = dataframe.iat[i,0] + dataframe.iat[i,1]
def iterate_3(dataframe):
for index,rows in dataframe.iterrows():
rows['s5'] = rows['s1'] + rows['s2']
def iterate_4(dataframe):
dataframe['s5'] = dataframe.apply(lambda x:x.s1 +ｘ.s2, axis = 1)
def iterate_5(dataframe):
dataframe['s5'] = dataframe[['s1','s2']].apply(lambda x:x.s1 +ｘ.s2, axis = 1)
def iterate_6(dataframe):
dataframe['s5'] = [a + b for a,b in zip(dataframe['s1'],dataframe['s2'])]
def iterate_7(dataframe):
dataframe['s5'] = dataframe['s1'] + dataframe['s2']
def iterate_8(dataframe):
dataframe['s5'] = dataframe['s1'].values + dataframe['s2'].values
df = df_sample()
%timeit iterate_1(df)
df = df_sample()
%timeit iterate_2(df)
df = df_sample()
%timeit iterate_3(df)
df = df_sample()
%timeit iterate_4(df)
df = df_sample()
%timeit iterate_5(df)
df = df_sample()
%timeit iterate_6(df)
df = df_sample()
%timeit iterate_7(df)
df = df_sample()
%timeit iterate_8(df)1.6 s ± 20.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) 684 ms ± 24.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) 960 ms ± 12.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) 255 ms ± 5.02 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) 258 ms ± 5.54 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) 4.81 ms ± 146 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) 142 µs ± 9.94 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each) 74.4 µs ± 7.81 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)
索引及排序
按标签排序和按数值排序
#标签排序
#使用 sort_index() 方法对行标签排序，指定轴参数（axis）或者排序顺序。或者可以对 DataFrame 进行排序
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)col2 col1 9 0.444369 -1.697888 8 0.070220 0.390137 7 -0.583545 0.919181 6 0.422157 -1.009720 5 -1.790309 -0.826443 4 1.230016 0.196717 3 0.416548 0.784816 2 0.946949 -0.676896 1 -0.648799 0.688239 0 -1.166974 0.420939
#sort_values() 表示按值排序。它接受一个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')
print (sorted_df)col1 col2 1 1 3 2 1 2 3 1 4 0 2 1
重置行列标签
#重置行、列索引标签
#重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配
#通过重置索引操作，您可以完成对现有数据的重新排序
#如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN
a1 =({'john':[2,3,5,10],'smith':[3,3,2,5],'tom':[8,7,2,2]})
df = pd.DataFrame(a1,index =list('abcd'))
print(df)
print('\n')
df1 = df.reindex(index=['c','a'],columns=['tom','smith','tony'])
print(df1)john smith tom a 2 3 8 b 3 3 7 c 5 2 2 d 10 5 2 tom smith tony c 2.0 2.0 NaN a 8.0 3.0 NaN
重命名标签_rename
# rename() 方法允许使用某些映射(dict或Series)或任意函数来对行、列标签重新命名
a1 =({'john':[2,3,5,10],'smith':[3,3,2,5],'tom':[8,7,2,2]})
df = pd.DataFrame(a1,index =list('abcd'))
print(df)
print('\n')
df1 = df.rename(columns={'john':'john_ren','smith':'smith_ren'},index={'b':"b_ren"})
print(df1) john smith tom
a 2 3 8
b 3 3 7
c 5 2 2
d 10 5 2
john_ren smith_ren tom
a 2 3 8
b_ren 3 3 7
c 5 2 2
d 10 5 2
重置索引_reset_index
#reset_index()在获得新的index，使用参数 drop=True不保留原来的index，默认 False原来的index变成数据列，保留下来
a1 =[['john',2,5],['web',3,5],['fan',8,9]]
d1 =pd.DataFrame(a1,columns=['name','u1','u2'])
a2 =[['mary',9,3],['hanson',6,7],['jonson',18,2]]
d2 =pd.DataFrame(a2,columns=['name','u1','u2'])
print(d1)
print(d2)
print('\n')
d3 =d2.append(d1)
print(d3)
print('----------------------------')
d3 = d3.reset_index(drop=True)
print(d3) name u1 u2
0 john 2 5
1 web 3 5
2 fan 8 9
name u1 u2
0 mary 9 3
1 hanson 6 7
2 jonson 18 2
name u1 u2
0 mary 9 3
1 hanson 6 7
2 jonson 18 2
0 john 2 5
1 web 3 5
2 fan 8 9
----------------------------
name u1 u2
0 mary 9 3
1 hanson 6 7
2 jonson 18 2
3 john 2 5
4 web 3 5
5 fan 8 9
设置索引
#set_index() 将已存在的列标签设置为 DataFrame 行索引、替换已经存在的索引
a1 =({'john':[2,3,5,10],'smith':[3,3,2,5],'tom':[8,7,2,2]})
df = pd.DataFrame(a1,index =list('abcd'))
print(df)
print('\n')
df.set_index('john')john smith tom a 2 3 8 b 3 3 7 c 5 2 2 d 10 5 2 Out[157]:
| smith | tom | |
|---|---|---|
| john | ||
| 2 | 3 | 8 |
| 3 | 3 | 7 |
| 5 | 2 | 2 |
| 10 | 5 | 2 |
merge合并操作
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,left_index=False, right_index=False, sort=True,suffixes=('_x', '_y'), copy=True)
left/right 两个不同的 DataFrame 对象。
on 指定用于连接的键（即列标签的名字），该键必须同时存在于左右两个 DataFrame 中，如果没有指定，并且其他参数也未指定， 那么将会以
两个 DataFrame 的列名交集做为连接键。
left_on 指定左侧 DataFrame 中作连接键的列名。该参数在左、右列标签名不相同，但表达的含义相同时非常有用。
right_on 指定左侧 DataFrame 中作连接键的列名。
left_index 布尔参数，默认为 False。如果为 True 则使用左侧 DataFrame 的行索引作为连接键，若 DataFrame 具有多层
索引(MultiIndex)，则层的数量必须与连接键的数量相等。
right_index 布尔参数，默认为 False。如果为 True 则使用左侧 DataFrame 的行索引作为连接键。
how 要执行的合并类型，从 {'left', 'right', 'outer', 'inner'} 中取值，默认为“inner”内连接。
sort 布尔值参数，默认为True，它会将合并后的数据进行排序；若设置为 False，则按照 how 给定的参数值进行排序。
suffixes 字符串组成的元组。当左右 DataFrame 存在相同列名时，通过该参数可以在相同的列名后附加后缀名，默认为('_x','_y')。
copy 默认为 True，表示对数据进行复制。concat连接操作
pd.concat(objs,axis=0,join='outer',join_axes=None,ignore_index=False)
objs 一个序列或者是Series、DataFrame对象。
axis 表示在哪个轴方向上（行或者列）进行连接操作，默认 axis=0 表示行方向。
join 指定连接方式，取值为{"inner","outer"}，默认为 outer 表示取并集，inner代表取交集。
ignore_index 布尔值参数，默认为 False，如果为 True，表示不在连接的轴上使用索引。
join_axes 表示索引对象的列表。a1 =[['john',2,5],['web',3,5],['fan',8,9]]
d1 =pd.DataFrame(a1,columns=['name','u1','u2'],index=[1,2,3,])
a2 =[['mary',9,3],['hanson',6,7],['jonson',18,2]]
d2 =pd.DataFrame(a2,columns=['name','u1','u2'],index =[2,3,4])
a3 =[['mary',2],['hanson',7],['jonson',1]]
d3 =pd.DataFrame(a3,columns=(['name','u3']),index=[2,3,4])
print(d1)
print(d2)
print(d3)
print('\n')
print(pd.concat([d1,d2]).reset_index(drop=True))
print(pd.concat([d1,d2],ignore_index=True))
print('\n')
print(pd.concat([d2,d3],axis=1,join='inner',ignore_index=False))
name u1 u2
1 john 2 5
2 web 3 5
3 fan 8 9
name u1 u2
2 mary 9 3
3 hanson 6 7
4 jonson 18 2
name u3
2 mary 2
3 hanson 7
4 jonson 1
name u1 u2
0 john 2 5
1 web 3 5
2 fan 8 9
3 mary 9 3
4 hanson 6 7
5 jonson 18 2
name u1 u2
0 john 2 5
1 web 3 5
2 fan 8 9
3 mary 9 3
4 hanson 6 7
5 jonson 18 2
name u1 u2 name u3
2 mary 9 3 mary 2
3 hanson 6 7 hanson 7
4 jonson 18 2 jonson 1
join合并
d1=pd.DataFrame({'A':['A0','A1'],'B':['B0','B1']},index=['a','b'])
d2=pd.DataFrame({'C':['C0','C1'],'D':['D0','D1']},index=['c','d'])
d3=pd.DataFrame({'E':['E0','E1','E2'],'F':['F0','F1','F2'],'G':['G0','G1','G2']},index=list('abc'))
d4=pd.DataFrame({'G':['C0','C1'],'D':['D0','D1']},index=['c','d'])
print('---d1--------------------')
print(d1)
print('---d2--------------------')
print(d2)
print('---d3--------------------')
print(d3)
print('---d4--------------------')
print(d4)
print("")
print("-------d1.join(d2,how='left')-------------------")
print(d1.join(d2,how='left'))
print("-------d1.join(d2,how='right')-------------------")
print(d1.join(d2,how='right'))
print("-------d1.join(d3,how='right')-------------------")
print(d1.join(d3,how='left'))
print("-------d3.join(d1,how='outer)-------------------")
print(d3.join(d1,how='outer'))
print("-------d3.join(d1,how='inner)-------------------")
print(d3.join(d1,how='inner'))
print("-------d3.join(d1,how='outer)-------------------")
print(d3.join(d1['B'],how='outer'))
print("-------d3.join(d1,how='outer)-------------------")
print(d3.join(d4['D'],how='outer'))
print("-------d3.join(d1,how='left)-------------------")
print(d4.join(d3['E'],how='left'))---d1--------------------
A B
a A0 B0
b A1 B1
---d2--------------------
C D
c C0 D0
d C1 D1
---d3--------------------
E F G
a E0 F0 G0
b E1 F1 G1
c E2 F2 G2
---d4--------------------
G D
c C0 D0
d C1 D1
-------d1.join(d2,how='left')-------------------
A B C D
a A0 B0 NaN NaN
b A1 B1 NaN NaN
-------d1.join(d2,how='right')-------------------
A B C D
c NaN NaN C0 D0
d NaN NaN C1 D1
-------d1.join(d3,how='right')-------------------
A B E F G
a A0 B0 E0 F0 G0
b A1 B1 E1 F1 G1
-------d3.join(d1,how='outer)-------------------
E F G A B
a E0 F0 G0 A0 B0
b E1 F1 G1 A1 B1
c E2 F2 G2 NaN NaN
-------d3.join(d1,how='inner)-------------------
E F G A B
a E0 F0 G0 A0 B0
b E1 F1 G1 A1 B1
-------d3.join(d1,how='outer)-------------------
E F G B
a E0 F0 G0 B0
b E1 F1 G1 B1
c E2 F2 G2 NaN
-------d3.join(d1,how='outer)-------------------
E F G D
a E0 F0 G0 NaN
b E1 F1 G1 NaN
c E2 F2 G2 D0
d NaN NaN NaN D1
-------d3.join(d1,how='left)-------------------
G D E
c C0 D0 E2
d C1 D1 NaN
统计性描述
frame = pd.DataFrame(np.random.randn(1000, 5),
....: columns=['a', 'b', 'c', 'd', 'e'])
print(frame)
frame.describe()| a | b | c | d | e | |
|---|---|---|---|---|---|
| count | 1000.000000 | 1000.000000 | 1000.000000 | 1000.000000 | 1000.000000 |
| mean | -0.012433 | 0.017818 | -0.002237 | 0.045592 | 0.004731 |
| std | 0.956565 | 0.985582 | 1.012973 | 1.004513 | 0.985172 |
| min | -2.512181 | -3.011423 | -3.082391 | -3.350117 | -3.276499 |
| 25% | -0.711675 | -0.666165 | -0.675890 | -0.633904 | -0.679420 |
| 50% | -0.073087 | 0.044573 | -0.018296 | 0.067337 | -0.047563 |
| 75% | 0.604105 | 0.724816 | 0.691015 | 0.704870 | 0.703942 |
| max | 3.250821 | 2.845904 | 3.625596 | 3.351248 | 2.620156 |
data = {'name' : pd.Series(['Alice', 'Bob', 'Cathy', 'Dany', 'Ella', 'Ford', 'Gary', 'Ham', 'Ico', 'Jack']),
'Math_A' : pd.Series([1.1, 2.2, 3.3, 4.4, 5, 3.2, 2.4, 1.5, 4.3, 4.5]),
'English_A' : pd.Series([3, 2.6, 2, 1.7, 3, 3.3, 4.4, 5, 3.2, 2.4]),
'Math_B' : pd.Series([1.7, 2.5, 3.6, 2.4, 5, 2.2, 3.3, 4.4, 1.5, 4.3]),
'English_B' : pd.Series([5, 2.6, 2.4, 1.3, 3, 3.6, 2.4, 5, 2.2, 3.1]),
'Project_num' : pd.Series([2, 3, 0, 1, 7, 2, 1, 5, 3, 4]),
'Sex' : pd.Series(['F', 'M', 'M', 'F', 'M', 'F', 'M', 'M', 'F', 'M'])
}
df = pd.DataFrame(data)
print(df)
print('-------------------统计行数---------------------')
print(len(df))
print('-------------统计有多少种不同的值---------------')
print(df['Sex'].nunique())
print('------------列中每种不同的值进行计数 -----------')
print(df['Sex'].value_counts())
print('---------------整体统计描述 --------------------')
print(df.describe())
print(df.describe(include='all'))
print('---------------对指定的列整体统计 --------------')
print(df.Math_A.describe())
print('---------------------指定求合 ------------------')
print(df.Project_num.sum())
print('---------------------指定计数 ------------------')
print(df.count())
print('---------------------指定中位数 ----------------')
print(df.median())
print('---------------------指定分位数 ----------------')
print(df.quantile([0.25,0.75]))
print('-------------------最大值/最小值 ---------------')
print(df.max())
print(df.min())
print('---------------------均值 ----------------------')
print(df.mean())
print('----------------方差 / 标准差 ------------------')
print(df.var())
print(df.std()) name Math_A English_A Math_B English_B Project_num Sex
0 Alice 1.1 3.0 1.7 5.0 2 F
1 Bob 2.2 2.6 2.5 2.6 3 M
2 Cathy 3.3 2.0 3.6 2.4 0 M
3 Dany 4.4 1.7 2.4 1.3 1 F
4 Ella 5.0 3.0 5.0 3.0 7 M
5 Ford 3.2 3.3 2.2 3.6 2 F
6 Gary 2.4 4.4 3.3 2.4 1 M
7 Ham 1.5 5.0 4.4 5.0 5 M
8 Ico 4.3 3.2 1.5 2.2 3 F
9 Jack 4.5 2.4 4.3 3.1 4 M
-------------------统计行数---------------------
10
-------------统计有多少种不同的值---------------
2
------------列中每种不同的值进行计数 -----------
M 6
F 4
Name: Sex, dtype: int64
---------------整体统计描述 --------------------
Math_A English_A Math_B English_B Project_num
count 10.000000 10.000000 10.000000 10.000000 10.000000
mean 3.190000 3.060000 3.090000 3.060000 2.800000
std 1.355196 1.014561 1.211473 1.189958 2.097618
min 1.100000 1.700000 1.500000 1.300000 0.000000
25% 2.250000 2.450000 2.250000 2.400000 1.250000
50% 3.250000 3.000000 2.900000 2.800000 2.500000
75% 4.375000 3.275000 4.125000 3.475000 3.750000
max 5.000000 5.000000 5.000000 5.000000 7.000000
name Math_A English_A Math_B English_B Project_num Sex
count 10 10.000000 10.000000 10.000000 10.000000 10.000000 10
unique 10 NaN NaN NaN NaN NaN 2
top Alice NaN NaN NaN NaN NaN M
freq 1 NaN NaN NaN NaN NaN 6
mean NaN 3.190000 3.060000 3.090000 3.060000 2.800000 NaN
std NaN 1.355196 1.014561 1.211473 1.189958 2.097618 NaN
min NaN 1.100000 1.700000 1.500000 1.300000 0.000000 NaN
25% NaN 2.250000 2.450000 2.250000 2.400000 1.250000 NaN
50% NaN 3.250000 3.000000 2.900000 2.800000 2.500000 NaN
75% NaN 4.375000 3.275000 4.125000 3.475000 3.750000 NaN
max NaN 5.000000 5.000000 5.000000 5.000000 7.000000 NaN
---------------对指定的列整体统计 --------------
count 10.000000
mean 3.190000
std 1.355196
min 1.100000
25% 2.250000
50% 3.250000
75% 4.375000
max 5.000000
Name: Math_A, dtype: float64
---------------------指定求合 ------------------
28
---------------------指定计数 ------------------
name 10
Math_A 10
English_A 10
Math_B 10
English_B 10
Project_num 10
Sex 10
dtype: int64
---------------------指定中位数 ----------------
Math_A 3.25
English_A 3.00
Math_B 2.90
English_B 2.80
Project_num 2.50
dtype: float64
---------------------指定分位数 ----------------
Math_A English_A Math_B English_B Project_num
0.25 2.250 2.450 2.250 2.400 1.25
0.75 4.375 3.275 4.125 3.475 3.75
-------------------最大值/最小值 ---------------
name Jack
Math_A 5.0
English_A 5.0
Math_B 5.0
English_B 5.0
Project_num 7
Sex M
dtype: object
name Alice
Math_A 1.1
English_A 1.7
Math_B 1.5
English_B 1.3
Project_num 0
Sex F
dtype: object
---------------------均值 ----------------------
Math_A 3.19
English_A 3.06
Math_B 3.09
English_B 3.06
Project_num 2.80
dtype: float64
----------------方差 / 标准差 ------------------
Math_A 1.836556
English_A 1.029333
Math_B 1.467667
English_B 1.416000
Project_num 4.400000
dtype: float64
Math_A 1.355196
English_A 1.014561
Math_B 1.211473
English_B 1.189958
Project_num 2.097618
dtype: float64
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
