一个开源的python类库，用于数据分析、数据处理、数据可视化
特点高性能、容易使用的数据结构、容易使用的数据分析工具
pandas数据类型Series是由相同数据类型组成的一维数组。
Dataframe：二维的表格型数据结构，数据帧(Dataframe)是大小可变的数据结构，每列可以是不同的数据类型（整型、字符串、布尔值等）
面板(Panel)可以由不同的数据类型构成的三维数据结构，Panel是Dataframe的容器
| 数据结构 | 维数 | 描述 | 数据 | 大小 |
|---|---|---|---|---|
| Series | 1 | 数据可变， 一维数组，大小不可变，Series是由相同数据类型组成的一维数组。 | 数据可变 | 大小不可变 |
| Dataframe | 2 | 二维数组，大小可变的表格结构，它含有一组有序的列，每列可以是不同的数据类型（整型、字符串、布尔值等） | 数据可变 | 大小可变 |
| Panel | 3 | 数据可变 大小可变的三维数组 | 数据可变 | 大小可变 |
pip install pandas pip list一维数据结构：Series对象
#查看列索引 print(d1.columns) #查看行索引 print(d1.index)Series对象的生成 使用Pandas.Series
""" pandas.Series( data, index, dtype, copy) data:数据,可以是序列类型，可以是int index:索引值必须是唯一的，与data的长度相同，默认为np.arange(n) dtype:数据类型 copy:是否复制数据，默认为false 打印左侧为索引，右侧为数据 """ #如果全部是int类型，那么打印s1会显示是int类型 s1 = pd.Series([1,2,3,4]) #dtype: int64 print(s1) #如果什么数据类型都存在，那么打印s1会显示object类型的 s1 = pd.Series([1,"a",0.5,["张三","李四"]])#dtype: object print(s1) s1 = pd.Series([1,"a",0.5,["张三","李四"]],index=['a','b','c','d']) s1 = pd.Series([1,2,3,4],index=['a','b','c','d'],dtype=np.float32) """ copy=True后，数据x不会改变，数据s1会改变 copy=False,数据x会改变，数据s1会改变 """ x=np.array([10,20,30,40]) s1 = pd.Series(x,index=['a','b','c','d'],copy=True) s1['a']=100 print(s1) print(x) 从ndarray创建一个Series
x=np.array([10,20,30,40]) s1 = pd.Series(x) s1 = pd.Series(x,index=['a','b','c','d']) print(s1) 从字典创建一个Series
"""
由于我们的Series有索引有数据，和我们的字典很像，字典是有key和vaule
"""
#a是索引 100数据
x={'a':100,'b':200,'c':300,'d':400}
s1 = pd.Series(x)
#设置索引
s1 = pd.Series(x,index=['a','b','c','d'])
#如果设置的索引位置换一下呢，数据也会跟着换
s1 = pd.Series(x,index=['a','c','d','b'])
#如果设置的索引，在字典中不存在呢，为nan
s1 = pd.Series(x,index=['a','b','e','f'])
print(s1)
访问Series数据
单个索引获取数据
""" 语法：s1[index] 获取单个数据 """ #可以使用默认索引，也可以使用自定义索引 s1 = pd.Series([1,"a",0.5,["张三","李四"]],index=['a','b','c','d']) print(s1[0]) print(s1['a']) 多个索引获取数据
""" 语法： s1[list] 获取索引中的数据 s1[index1:index2] 获取从第一个索引到第二个索引的数据，左开右闭 """ s1 = pd.Series([1,"a",0.5,["张三","李四"]],index=['a','b','c','d']) print(s1[0:4]) #左开右闭 print(s1[[0,1,2,3]]) print(s1[['a','b','c']]) print(s1['a':'b'])#获取两个数据 Series对象的使用
| 属性和方法 | 说明 |
|---|---|
| axes | 返回Series索引列表 |
| dtype | 返回Series的数据类型 |
| empty | 判断Series是否为空，如果为空，则返回True |
| ndim | 返回基础数据的位数，默认为：1 |
| size | 返回基础数据中的元素个数 |
| values | 将Series作为ndarray返回 |
| head() | 返回前n行 |
| tail() | 返回最后n行 |
"""
axes 返回Series索引列表
dtype 返回Series的数据类型
empty 判断Series是否为空，如果为空，则返回True
ndim 返回基础数据的维度数，默认为：1
size 返回基础数据中的元素个数
values 将Series作为ndarray返回
head() 返回前n行
tail() 返回最后n行
"""
"""
head()返回前n行(观察索引值)。默认数量为5，可以传递自定义数值。
tail()返回最后n行(观察索引值)。默认数量为5，可以传递自定义数值。
"""
s1 = pd.Series([1,"a",0.5,["张三","李四"]],index=['a','b','c','d'])
"""
print(s1.axes)
print(s1.dtype)
print(s1.empty)
print('ndim',s1.ndim)
print(s1.size)
print('type',type(s1))
print('type',type(s1.values))
"""
print('ndim',s1.ndim)
ss1 = s1.tail(3)
print(ss1)
print(type(ss1))
ss = s1.head(3)
print(ss)
print(type(ss))
二维数据结构：Dataframe对象
创建Dataframe对象
""" pandas.Dataframe( data, index, columns, dtype, copy) data 支持多种数据类型，如:ndarray，series，map，lists，dict，constant和另一个Dataframe。 index 行标签，如果没有传递索引值，默认值为0,1,2,3,4....... columns 列标签，如果没有传递索引值，默认值为0,1,2,3,4....... dtype 每列的数据类型 copy 是否复制数据，默认值为False """创建空Dataframe对象
df = pd.Dataframe() print (df)利用列表创建
#利用单层list x = [1,2,3,4,5,6] df = pd.Dataframe(x，dtype=np.float32) print(df)
#利用双层list
x = [
["tom",10],
["jack",20],
["mike",30]
]
#df = pd.Dataframe(x,columns=['name','age'])
#如果是True，那么x数据不改变
df = pd.Dataframe(x,columns=['name','age'，'sex'],copy=True)
df['age'] = 100
print(df)
print(x)
# 利用数据是字典的列表创建
x = [
{'a':1,'b':2},
{'a':10,'b':20,'c':30}
]
#index 行索引 columns列索引
df1 = pd.Dataframe(x)
print(df1)
df1 = pd.Dataframe(x,index=["first","second"])
print(df1)
#如果没有c，就会默认是nun
df1 = pd.Dataframe(x,index=["first","second"],columns=['a','c'])
print(df1)
利用字典创建
#利用字典创建Dataframe
#a、b是列索引，一定要设置行索引（index），否则报错
x = {'a':1,'b':2}
d1 = pd.Dataframe(x,index=['row1'])
print(d1)
# 字典里面的v是列表类型创建Dataframe
#那么默认列索引是name和age
x = {
'name':['zs','ls','ww','zl'],
'age':[14,15,16,17]
}
d1 = pd.Dataframe(x)
print(d1)
print(d1['age'])
利用Series和字典的结合来创建Dataframe
"""
#只有列索引，没有行索引
s1 = pd.Series([1,2,3,4,5,6])
s2 = pd.Series([100,200,300,400,500])
"""
#列索引是one，two，行索引是index
s1 = pd.Series([1,2,3,4,5,6],index=['a','b','c','d','e','f'])
s2 = pd.Series([100,200,300,400,500],index=['a','b','c','d','e'])
x = {
'one':s1,
'two':s2
}
d1 = pd.Dataframe(x)
print(d1)
列的读取
"""
语法：
df[columns] 查询单列
df[[columns] ] 查询多列
查询出一列和一列都会进行降维Dataframe-----》Series
"""
x = [
["tom",10],
["jack",20],
["mike",30]
]
df = pd.Dataframe(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
#根据columns获取列数据
print("----------------------")
print(df['name'])
print(type(df['name'])) #
print("----------------------")
print(df[['name','age']])
print(type(df[['name','age']]))
列的添加
"""
语法：df[columns] = 数据
切记数据要是同类型的数据，
"""
x = [
["tom",10],
["jack",20],
["mike",30]
]
df = pd.Dataframe(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
#依据list进行创建的，添加列的时候要是list
x1 = ['nan','nv','nan']
df["three"] = x1
print("---------------------------------------------")
print(df)
"""
语法：
df1[columns]=df1[columns]+df1[columns]
"""
x = [
{'a':1,'b':2},
{'a':10,'b':20,'c':30}
]
df1 = pd.Dataframe(x)
print(df1)
# df1['d'] = {'a':2,'b':3} 报错
#数据已经标明列了，不能使用上面的方法，我们可以使用Dataframe中的现有列添加新列
df1['d']=df1['a']+df1['b']
print("--------------------------------")
print(df1)
练习
#把以下数据添加'three'列
s1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s2 = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
s3 = pd.Series([10,20,30], index=['a','b','c'])
d = {'one' : s1,
'two' : s2}
df = pd.Dataframe(d)
print ("通过传递Series添加一个新列:")
df['three']=s3
print (df)
print ("使用Dataframe中的现有列添加新列:")
df['four']=df['one']+df['three']
print (df)
列的删除
"""
删除语法
del df[columns] 根据下标进行检索删除，没有返回值
df.pop(columns) 根据下标进行检索删除，并返回删除的那一列
"""
df = pd.Dataframe(d)
print ("通过传递Series添加一个新列:")
df['three']=s3
print (df)
del df['one']
print (df)
df_pop = df.pop('two')
print("--------------------------")
print (df_pop)
"""
a 1
b 2
c 3
d 4
"""
print (df)
"""
three
a 10.0
b 20.0
c 30.0
d NaN
"""
行的读取
使用loc方法
"""
语法：
loc[index] 查询一行数据
扩展
loc[index,columns] 精确到行和列，那就是一个数据
查询多行和多列（精确到第几行和第几列）
loc[[index1,index2,....],[columns1,columns12,.....]]
查询多行和多列（第几行到第几行,第几列到第几列）
不是左开右闭
loc[index1:index2,columns1：columns2]
使用布尔索引也可以查询多行多列
loc[行_布尔索引,列_布尔索引]
"""
x = [
["tom",10],
["jack",20],
["mike",30]
]
df = pd.Dataframe(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
print(df.loc["row1"])#查询一行数据
"""
name tom
age 10
Name: row1, dtype: object
"""
print("---------------------------------------")
#查询一个数据 ，精确到第一行。name那一列的数据
print(df.loc["row1","name"])#tom
print("---------------------------------------")
print(df.loc[['row1','row2'],"name"]) #查询第一行和第二行的name
"""
row1 tom
row2 jack
Name: name, dtype: object
"""
print("---------------------------------------")
print(df.loc[['row1','row2'],['name','age']]) #查询第一行和第二行的name和age
"""
name age
row1 tom 10
row2 jack 20
"""
print("---------------------------------------")
print(df.loc['row1',['name','age']]) #第一行的name和age
"""
name tom
age 10
Name: row1, dtype: object
"""
print("----------------------------------")
print(df.loc['row1':'row3','name'])#查询第一行到第三行的name
"""
row1 tom
row2 jack
row3 mike
Name: name, dtype: object
"""
print("----------------------------------")
print(df.loc['row1','name':'age']) #第一行的name到age
"""
name tom
age 10
Name: row1, dtype: object
"""
print("----------------------------------")
print(df.loc['row1':'row3','name':'age'])
"""
name age
row1 tom 10
row2 jack 20
row3 mike 30
"""
print("----------------------------------")
b = df['age']<20
print(b)
"""
row1 True
row2 False
row3 False
"""
print(df.loc[b]) #获取age小于20的行，列是所有列
"""
name age
row1 tom 10
"""
print("----------------------------------")
print(df.loc[b,'name']) #获取age小于20的行，列是name
"""
row1 tom
Name: name, dtype: object
"""
使用df.iloc方法
df.loc方法，根据行、列的标签值查询
df.iloc方法 根据行、列的数字位置查询
"""
语法：
iloc[num_index] 根据索引位置获取行
iloc[num_index1:num_index2] 第几行到第几行,左开右闭
iloc[[num_index1,num_index2,.....]] 第几行和第几行
iloc[num_index,num_columns] #第几行的第几列
iloc[num_index,[num_columns1,num_columns2,....]] 第几行，第几列和第几列
iloc[num_index,[num_columns1:num_columns2]] 第几行，第几列到第几列,左开右闭
"""
x = [
["tom",10],
["jack",20],
["mike",30]
]
df = pd.Dataframe(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
print("------------------------")
print(df.iloc[2]) #根据索引位置获取行
"""
name mike
age 30
Name: row3, dtype: object
"""
print("------------------------")
print(df.iloc[0:2])
"""
name age
row1 tom 10
row2 jack 20
"""
print("------------------------")
print(df.iloc[[0,2]])
"""
name age
row1 tom 10
row3 mike 30
"""
print("------------------------")
print(df.iloc[2,0]) #mike
print("------------------------")
print(df.iloc[2,[0,1]])
"""
------------------------
name mike
age 30
Name: row3, dtype: object
"""
print("------------------------")
print(df.iloc[2,0:1])
"""
name mike
Name: row3, dtype: object
"""
使用切片读取
"""
df[num_index1:num_index2] 第几行到第几行 左开右闭---切片
df[label_index1:label_index2] 第几行到第几行，左开右开
"""
x = [
["tom",10],
["jack",20],
["mike",30]
]
df = pd.Dataframe(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
print("-----------------------------------------")
print(df[0:2])
"""
-----------------------------------------
name age
row1 tom 10
row2 jack 20
"""
print("-----------------------------------------")
print(df['row1':'row3'])
"""
-----------------------------------------
name age
row1 tom 10
row2 jack 20
row3 mike 30
"""
行的添加
"""
在末尾追加一行，返回一个新对象
df.append(other,ignore_index= False,verify_integrity = False,
sort = False)
other：要附加的数据，Dataframe或者Series等类型
ignore_index：如果是True，则不使用索引标签，默认false
verify_integrity：如果是True，在创建于重复项的索引时，引发valueError，默认时false
sort：如果原数据和添加数据的列没有对齐，则对列进行排序，不建议排序
"""
x = [
["tom",10],
["jack",20],
["mike",30]
]
df = pd.Dataframe(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
print("-----------------------------------------")
y = [
["zs",10],
["ls",20],
["ww",30]
]
df1 = pd.Dataframe(y,columns=['name','age'],index=['row1','row2','row3'])
df2 = df.append(df1)
print(df2)
"""
-----------------------------------------
name age
row1 tom 10
row2 jack 20
row3 mike 30
row1 zs 10
row2 ls 20
row3 ww 30
"""
print("-------------ignore_index=True，则不使用索引标签----------------------------")
df1 = pd.Dataframe(y,columns=['name','age'],index=['row1','row2','row3'])
df2 = df.append(df1,ignore_index=True)
print(df2)
"""
-------------ignore_index=True，则不使用索引标签----------------------------
name age
0 tom 10
1 jack 20
2 mike 30
3 zs 10
4 ls 20
5 ww 30
"""
print("------verify_integrity=True，在创建于重复项的索引时，引发valueError-------")
df1 = pd.Dataframe(y,columns=['name','age'],index=['row1','row2','row3'])
df2 = df.append(df1,verify_integrity=True)
print(df2)
行的删除
"""
df1= df.drop(index) #删除某行，返回一个新数据
"""
x = [
["tom",10],
["jack",20],
["mike",30]
]
df = pd.Dataframe(x,columns=['name','age'],index=['row1','row2','row3'])
print(df)
print("--------------------------")
df1= df.drop('row1')
print(df1)
Dataframe的属性和方法
| 属性和方法 | 描述 |
|---|---|
| T | 转置行和列 |
| axes | 返回一个列，行轴标签和列轴标签作为唯一的成员 |
| dtypes | 返回此对象中的数据类型 |
| empty | 如果Dataframe为空，则返回为True，任何轴的长度都为0 |
| ndim | 数组维度大小，默认为2维 |
| shape | 返回表示Dataframe的维度的元组 |
| size | Dataframe中的元素个数 |
| values | 将Dataframe中的实际数据作为NDarray返回 |
| head() | 返回开头n行 |
| tail() | 返回最后n行 |
s1 =pd.Series(['Tom','James','Ricky','Vin','Steve','Minsu','Jack'])
s2 = pd.Series([25,26,25,23,30,29,23])
s3 = pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])
d = {'Name':s1,
'Age':s2,
'Rating':s3}
#生成一个Dataframe对象
df = pd.Dataframe(d)
print (df)
"""
Name Age Rating
0 Tom 25 4.23
1 James 26 3.24
2 Ricky 25 3.98
3 Vin 23 2.56
4 Steve 30 3.20
5 Minsu 29 4.60
6 Jack 23 3.80
"""
print("--------df.T返回Dataframe的转置，行和列将交换----------")
df_T = df.T
print(df_T)
"""
--------df.T返回Dataframe的转置，行和列将交换----------
0 1 2 3 4 5 6
Name Tom James Ricky Vin Steve Minsu Jack
Age 25 26 25 23 30 29 23
Rating 4.23 3.24 3.98 2.56 3.2 4.6 3.8
"""
print("--------df.axes返回行轴标签和列轴标签列表----------")
df_axes = df.axes
print(df_axes)
#[RangeIndex(start=0, stop=7, step=1), Index(['Name', 'Age', 'Rating'], dtype='object')]
print("--------df.dtypes返回每列的数据类型----------")
df_dtype = df.dtypes
print(df_dtype)
"""
--------df.dtypes返回每列的数据类型----------
Name object
Age int64
Rating float64
dtype: object
"""
print("--------df.empty返回布尔值，表示对象是否为空，返回True表示对象为空----------")
df_empty = df.empty
print(df_empty) #False
print("--------df.ndim返回对象的维数----------")
df_ndim = df.ndim
print(df_ndim ) #2
print("-----df.shape返回表示Dataframe的维度的元组。元组(a，b)，其中a表示行数，b表示列数----")
df_shape = df.shape
print(df_shape ) #(7, 3)
print("-----df.size返回Dataframe中的元素个数。----")
df_size = df.size
print(df_size ) #21
print("-----df.values将Dataframe中的实际数据作为NDarray返回。----")
df_values = df.values
print(df_values)
"""
-----df.values将Dataframe中的实际数据作为NDarray返回。----
[['Tom' 25 4.23]
['James' 26 3.24]
['Ricky' 25 3.98]
['Vin' 23 2.56]
['Steve' 30 3.2]
['Minsu' 29 4.6]
['Jack' 23 3.8]]
"""
print("-----df.head(n)返回前n行(观察索引值)。默认数量为5----")
df_head = df.head(2)
print(df_head)
"""
-----df.head(n)返回前n行(观察索引值)。默认数量为5----
Name Age Rating
0 Tom 25 4.23
1 James 26 3.24
"""
print("-----df.tail(n)返回后n行(观察索引值)。默认数量为5----")
df_tail = df.tail(2)
print(df_tail)
"""
-----df.tail(n)返回后n行(观察索引值)。默认数量为5----
Name Age Rating
5 Minsu 29 4.6
6 Jack 23 3.8
"""
"""
pandas.Dataframe(data,index,columns,dtype,copy)
data 支持多种数据类型，如：ndarray,series,map,lists,dict,constant和另一个Dataframe.
index 行标签，如果没有传递索引值，默认值为0，1，2，3，4......
columns 列标签， 如果没有传递索引值，默认值为0，1，2，3，4.....
dtype 每列的数据类型
copy 是否复制数据，默认值为False
np01=np.arange(20).reshape(4,5)
df1=pd.Dataframe(np01,index=['a','b','c','d'],columns=['name','age','sex','hobbit','address'],dtype=np.float32)
print(df1)
name age sex hobbit address
a 0.0 1.0 2.0 3.0 4.0
b 5.0 6.0 7.0 8.0 9.0
c 10.0 11.0 12.0 13.0 14.0
d 15.0 16.0 17.0 18.0 19.0
#利用数据是字典的列表创建
#1.K变成列标签
#2.没有数据的用NAN
x=[
{'a':20,'b':30},
{'a':100,'b':200,'c':400}
]
df4=pd.Dataframe(x)
print(df4)
"""
"""
#利用字典创建Dataframe
#a,b是列索引，一定要设置行索引(index),否则报错
x={'馒头':1,'包子':1.5,'豆浆':2,"倔强面":17}
df1=pd.Dataframe(x,index=['价格'])
print(df1)
x={
'食品':['馒头','大米','包子'],
'价格':[1,2,1.5]
}
df2=pd.Dataframe(x)
print(df2)
s1=pd.Series(['馒头','大米','包子'])
s2=pd.Series([1,2,1.5])
x={
'食品':s1,
'价格':s2
}
df3=pd.Dataframe(x)
print(df3)
"""
"""
df[columns_label] 查询单列
df[[columns_label]] 查询多列
查询出一列会进行降维Dataframe----->>Series
s1=pd.Series(['馒头','大米','包子'])
s2=pd.Series([1,2,1.5])
x={
'食品':s1,
'价格':s2
}
df3=pd.Dataframe(x)
print(df3)
s=df3['食品']
print(s)
print(type(s))
s1=pd.Series(['馒头','大米','包子'])
s2=pd.Series([1,2,1.5])
x={
'食品':s1,
'价格':s2
}
df3=pd.Dataframe(x)
print(df3)
s=df3['食品']#
print(s)
print(type(s))
s2=df3[['食品','价格']]#
print(s2)
print(type(s2))
"""
"""
添加列
语法：df[columns]=数据
切记数据要是同类型的数据，
df1[columns]=df1[columns]+df1[columns]
s1=pd.Series(['馒头','大米','包子'])
s2=pd.Series([1,2,1.5])
x={
'食品':s1,
'价格':s2
}
df3=pd.Dataframe(x)
a=['好吃','多','陷多']
df3['评价']=a
print(df3)
print("----------------------")
df3['详细评价']=df3['食品']+df3['评价']
print(df3)
"""
"""
删除语法
del df[columns] 根据下标进行检索删除，没有返回值
df.pop(columns)根据下标进行检索删除，并返回删除的那一列
s1=pd.Series(['馒头','大米','包子'])
s2=pd.Series([1,2,1.5])
x={
'食品':s1,
'价格':s2
}
df3=pd.Dataframe(x)
a=['好吃','多','陷多']
df3['评价']=a
print(df3)
print("----------------------")
df3['详细评价']=df3['食品']+df3['评价']
print(df3)
del df3['评价']
print(df3)
a=df3.pop('详细评价')
print('a',a)#要删除的那一列数据
print('df3',df3)
"""
"""
loc[自定义索引(标签索引)]
iloc[默认索引(数字索引)]
语法：
loc[index] 查询一行数据
扩展
loc[index,columns] 精确到行和列，那就是一个数据
查询多行和多列（精确到第几行和第几列）
loc[[index1,index2,....],[columns1,columns12,.....]]
查询多行和多列（第几行到第几行,第几列到第几列）
不是左开右闭
loc[index1:index2,columns1,columns2]
使用布尔索引也可以查询多行多列
loc[行_布尔索引,列_布尔索引]
"""
"""
s1=pd.Series(['馒头','大米','包子','大盘鸡','麻辣烫','鱼粉','热干面'],index=['row1','row2','row3','row4','row5','row6','row7'])
s2=pd.Series([1,2,1.5,12,16,10,8],index=['row1','row2','row3','row4','row5','row6','row7'])
s3=pd.Series(['Y','Y','Y','Y','Y','Y','Y'],index=['row1','row2','row3','row4','row5','row6','row7'])
x={
'食品':s1,
'价格':s2,
'评价':s3
}
df3=pd.Dataframe(x,index=['row1','row2','row3','row4','row5','row6','row7'])
print(df3)
"""
#print(df3.loc['row1'])
#print(df3.loc['row4','食品'])
#print(df3.loc[['row1','row3'],['食品','价格']])
#print(df3.loc[['row1','row3'],'食品'])
#print(df3.loc['row1',['食品','价格']])
#print(df3.loc['row1':'row4','食品':'价格'])
#print(df3.loc[['row1','row3'],'食品':'价格'])
#index_bool=[True,False,False,False,False,True,True]
#col_bool=[True,True,False]
#print(df3.loc[index_bool,col_bool])
#b=df3['价格'] >8
#print(df3.loc[b])#行
"""
查询行的，iloc[数字索引]
语法：
iloc[num_index] 根据索引位置获取行
iloc[num_index1:num_index2] 第几行到第几行,左开右闭
iloc[[num_index1,num_index2,.....]] 第几行和第几行
iloc[num_index,num_columns] #第几行的第几列
iloc[num_index,[num_columns1,num_columns2,....]] 第几行，第几列和第几列
iloc[num_index,[num_columns1:num_columns2]] 第几行，第几列到第几列,左开右闭
iloc[[num_index1,num_index2,.....],[num_columns1,num_columns2,....]]
iloc[num_index1:num_index2,[num_columns1:num_columns2]]
"""
#print(df3.iloc[0])
#print(df3.iloc[0:4])
#print(df3.iloc[[0,3]])
#print(df3.iloc[6,0])#热干面
#print(df3.iloc[6,0:2])
#print(df3.iloc[6,[0,2]])
#print(df3.iloc[[0,2,4],[0,2]])
"""
df[num_index1:num_index2] 第几行到第几行 左开右闭----切片
df[label_index1:label_index2]第二行到第几行，左开右开
"""
#df3[0:4]#第一行到第五行，但是第五行取不到
#df3['row1':'row4']#第一行到第四行，第四行能取到
"""
在末尾追加一行，返回一个新对象
df.append(other,ignore_index=False,verify_integrity=False,sort=False)
other:要附加的数据，Dataframe或者Series等类型
ignore_index：如果是True,则不使用索引标签，默认false
verify_integrity；如果是True,在创建于重复项的索引时，引发valueError,默认时false
sort:如果原数据和添加数据的列没有对齐，则对列进行排序，不建议排序
s1=pd.Series(['zs','ls','ww'],index=['row1','row2','row3'])
s2=pd.Series([10,20,30],index=['row1','row2','row3'])
x={
'name':s1,
'age':s2
}
df1=pd.Dataframe(x)
s3=pd.Series(['大黄','狗蛋','铁蛋','富贵'],index=['row1','row2','row3','row4'])
s4=pd.Series([10,10,10,10],index=['row1','row2','row3','row4'])
x1={
'name':s3,
'age':s4
}
df2=pd.Dataframe(x1)
print('------------------')
df3=df1.append(df2,verify_integrity=False)
print(df3)
print("---------------")
df3=df1.append(df2,ignore_index=True)
print(df3)
"""
"""
df1=df.drop(index)#删除某行，返回一个新数据
index只能是索引标签(自定义索引)
df3=df2.drop('row4')
print(df3)
"""
"""
| T | 转置行和列 |
| ------ | -------------------------------------------------- |
| axes | 返回一个列，行轴标签和列轴标签作为唯一的成员 |
| dtypes | 返回此对象中的数据类型 |
| empty | 如果Dataframe为空，则返回为True，任何轴的长度都为0 |
| ndim | 数组维度大小，默认为2维 |
| shape | 返回表示Dataframe的维度的元组 |
| size | Dataframe中的元素个数 |
| values | 将Dataframe中的实际数据作为NDarray返回 |
| head() | 返回开头n行 |
| tail() | 返回最后n行
s1=pd.Series(['zs','ls','ww'],index=['row1','row2','row3'])
s2=pd.Series([10,20,30],index=['row1','row2','row3'])
x={
'name':s1,
'age':s2
}
df1=pd.Dataframe(x)
s3=pd.Series(['大黄','狗蛋','铁蛋','富贵'],index=['row1','row2','row3','row4'])
s4=pd.Series([10,10,10,10],index=['row1','row2','row3','row4'])
x1={
'name':s3,
'age':s4
}
df2=pd.Dataframe(x1)
print(df2)
print("------T---转置----")
print(df2.T)
---axes---获取行和列的索引
[Index(['row1', 'row2', 'row3', 'row4'], dtype='object'), Index(['name', 'age'], dtype='object')]
print('---axes---获取行和列的索引')
print(df2.axes)
print("--dtypes--每一列的数据类型--")
print(df2.dtypes)
--dtypes--每一列的数据类型--
name object
age int64
dtype: object
print('---empty----')
print(df2.empty)
---empty----
False
print("--ndim--维度数")
print(df2.ndim)#2
--ndim--维度数
2
"""
"""
s1=pd.Series(['zs','ls','ww'],index=['row1','row2','row3'])
s2=pd.Series([10,20,30],index=['row1','row2','row3'])
x={
'name':s1,
'age':s2
}
df1=pd.Dataframe(x)
s3=pd.Series(['大黄','狗蛋','铁蛋','富贵'],index=['row1','row2','row3','row4'])
s4=pd.Series([10,10,10,10],index=['row1','row2','row3','row4'])
x1={
'name':s3,
'age':s4
}
df2=pd.Dataframe(x1)
print(df2)
print('--shape--(行，列)')
print(df2.shape)
--shape--(行，列)
(4, 2)
print('----size---元素个数--')
print(df2.size)
----size---元素个数--
8
print("---values-把真正的数据转换成ndarray的形式输出")
print(df2.values)
print(type(df2.values))
---values-把真正的数据转换成ndarray的形式输出
[['大黄' 10]
['狗蛋' 10]
['铁蛋' 10]
['富贵' 10]]
print(df2.head(2))
name age
row1 大黄 10
row2 狗蛋 10
print(df2.tail(2))
name age
row3 铁蛋 10
row4 富贵 10
"""
"""
| count() | 非空数据的数量 |
| --------- | ---------------- |
| sum() | 所有值之和 |
| mean() | 所有值的平均值 |
| median() | 所有值的中位数 |
| mod() | 值的模 |
| std() | 值的标准偏差 |
| min() | 所有值中的最小值 |
| max() | 所有值中的最大值 |
| abs() | 绝对值 |
| prod() | 数组元素的乘积 |
| cumsum() | 累积总和 |
| cumprod() | 累计乘积 |
"""
"""
s1=pd.Series(['zs','ls','ww'],index=['row1','row2','row3'])
s2=pd.Series([10,20,30],index=['row1','row2','row3'])
x={
'name':s1,
'age':s2
}
df1=pd.Dataframe(x)
s3=pd.Series(['大黄','狗蛋','铁蛋','富贵'],index=['row1','row2','row3','row4'])
s4=pd.Series([10,10,10,np.NaN],index=['row1','row2','row3','row4'])
x1={
'name':s3,
'age':s4
}
df2=pd.Dataframe(x1)
print(df2)
print('---count--非空计数--')
print(df2.count())
name 4
age 3
dtype: int64
print('--sum---求和--每一列的和--')
print(df2.sum())
--sum---求和--每一列的和--
name 大黄狗蛋铁蛋富贵
age 30.0
dtype: object
print('---mean--平均值--')
print(df2.mean())
---mean--平均值--
c:/Users/星/csv_read.py:539: FutureWarning: Dropping of nuisance columns in Dataframe reductions (with 'numeric_only=None') is deprecated; in a future version this will raise TypeError. Select only valid columns before calling the reduction.
print(df2.mean())
age 10.0
dtype: float64
print('---median--中位数---')
print(df2.median())
---median--中位数---
c:/Users/星/csv_read.py:554: FutureWarning: Dropping of nuisance columns in Dataframe reductions (with 'numeric_only=None') is deprecated; in a future version this will raise TypeError. Select only valid columns before calling the reduction.
print(df2.median())
age 10.0
dtype: float64
print("------mod(n)---取余--")
print(df2['age'].mod(2))
------mod(n)---取余--
row1 0.0
row2 0.0
row3 0.0
row4 NaN
Name: age, dtype: float64
print('--std--标准差--')
print(df2.std())
--std--标准差--
c:/Users/星/csv_read.py:575: FutureWarning: Dropping of nuisance columns in Dataframe reductions (with 'numeric_only=None') is deprecated; in a future version this will raise TypeError. Select only valid columns before calling the reduction.
print(df2.std())
age 0.0
dtype: float64
print('-----min---最小值--')
print(df2.min())
-----min---最小值--
name 大黄
age 10.0
dtype: object
print('-----max---最大值--')
print(df2.max())
-----max---最大值--
name 铁蛋
age 10.0
dtype: object
print("---prod-乘积-")
print(df2['age'].prod())
---prod-乘积-
1000.0
print("--cumsum---累计求和---")
print(df2.cumsum())
--cumsum---累计求和---
name age
row1 大黄 10.0
row2 大黄狗蛋 20.0
row3 大黄狗蛋铁蛋 30.0
row4 大黄狗蛋铁蛋富贵 NaN
print('----abs---绝对值---')
print(df2['age'].abs())
----abs---绝对值---
row1 10.0
row2 10.0
row3 10.0
row4 NaN
Name: age, dtype: float64
print('---cumprod--累计乘积--')
print(df2['age'].cumprod())
---cumprod--累计乘积--
row1 10.0
row2 100.0
row3 1000.0
row4 NaN
Name: age, dtype: float64
"""
"""
函数是用来计算有关Dataframe列的统计信息的摘要。
describe(percentiles=None,include=None,exclude=None,datatime_is_numeric=False)
percentiles:设置分位数，默认是[.25,.5,.75],也就是返回25%，50%，75%数据量时的数字
include:计算那些数据类型的统计量
object-汇总字符串列
number-汇总数字列
all-将所有列汇总在一起(不应将其作为列表值传递)
exclude:不计算那些数据类型的统计量，参数和上面一样，没有all
datatime_is_numeric:默认值为False。设置为True可将日期时间数据视为数字
s1=pd.Series(['zs','ls','ww'],index=['row1','row2','row3'])
s2=pd.Series([10,20,30],index=['row1','row2','row3'])
x={
'name':s1,
'age':s2
}
df1=pd.Dataframe(x)
s3=pd.Series(['大黄','狗蛋','铁蛋','富贵'],index=['row1','row2','row3','row4'])
s4=pd.Series([10,10,10,np.NaN],index=['row1','row2','row3','row4'])
x1={
'name':s3,
'age':s4
}
df2=pd.Dataframe(x1)
print(df2)
a=df2.describe(include='all')
print(a)
"""
"""
| lower() | 将Series/Index中的字符串转换为小写 |
| ------------------- | ------------------------------------------------------------ |
| upper() | 将Series/Index中的字符串转换为大写 |
| len() | 计算字符串长度 |
| strip() | 帮助从两侧的系列/索引中的每个字符串中删除空格(包括换行符) |
| split(' ') | 用给定的模式拆分每个字符串 |
| cat(sep=' ') | 使用给定的分隔符连接系列/索引元素 |
| get_dummies() | 返回具有单热编码值的数据帧(Dataframe) |
| contains(pattern) | 如果元素中包含子字符串，则返回每个元素的布尔值True，否则为False |
| replace(a,b) | 将值a替换为值b |
| repeat(value) | 重复每个元素指定的次数 |
| count(pattern) | 返回模式中每个元素的出现总数 |
| startswith(pattern) | 如果系列/索引中的元素以模式开始，则返回true |
| endswith(pattern) | 如果系列/索引中的元素以模式结束，则返回true |
| find(pattern) | 返回模式第一次出现的位置 |
| findall(pattern) | 返回模式的所有出现的列表 |
| swapcase() | 变换字母大小写 |
| islower() | 检查系列/索引中每个字符串中的所有字符是否小写，返回布尔值 |
| isupper() | 检查系列/索引中每个字符串中的所有字符是否大写，返回布尔值 |
| isnumeric() | 检查系列/索引中每个字符串中的所有字符是否为数字，返回布尔值 |
print('--len()---每一个名字的长度---')
df_name=df2['name']
print(df_name.str.len())
--len()---每一个名字的长度---
row1 5
row2 3
row3 2
row4 2
Name: name, dtype: int64
print("----去空----")
df_name=df2['name']
df_strip=df_name.str.strip()
print(df_strip)
df_len=df_strip.str.len()
print(df_len)
----去空----
row1 大黄,小黄
row2 狗蛋
row3 铁蛋
row4 富贵
Name: name, dtype: object
row1 5
row2 2
row3 2
row4 2
Name: name, dtype: int64
print('----拆分----')
df_name=df2['name']
df_split=df_name.str.split(',')
df_row1=df_split.loc['row1']
print(df_row1[1])
----拆分----
小黄
print("-----cat(sep)-----")
df_name=df2['name']
print(df_name.str.cat(sep="=="))
-----cat(sep)-----
大黄,小黄==狗蛋 ==铁蛋==富贵
#print('---replace()---替换--')
#df_name=df2['name']
#print(df_name.str.replace('富贵','栓柱'))
---replace()---替换--
row1 大黄,小黄
row2 狗蛋
row3 铁蛋
row4 栓柱
Name: name, dtype: object
#print('----contains(value)---是否包含--')
#df_name=df2['name']
#print(df_name.str.contains('蛋'))
----contains(value)---是否包含--
row1 False
row2 True
row3 True
row4 False
Name: name, dtype: bool
#print('---get_dummies()----寄存器编码----')
#df_name=df2['name']
#print(df_name.str.get_dummies())
---get_dummies()----寄存器编码----
富贵 铁蛋 大黄,小黄 狗蛋
row1 0 0 1 0
row2 0 0 0 1
row3 0 1 0 0
row4 1 0 0 0
"""
s3=pd.Series(['大黄,小黄','狗蛋 ','铁蛋','富贵'],index=['row1','row2','row3','row4'])
s4=pd.Series([10,10,10,np.NaN],index=['row1','row2','row3','row4'])
x1={
'name':s3,
'age':s4
}
df2=pd.Dataframe(x1)
#print(df2)
"""
pipe(func,*args,**kwargs)
func:函数
*args,**kwargs:意味着，我们自定义函数需要多个参数的时候可以进行传递
def chang_name(df):
df_name=df['name']#获取名字
df_re=df_name.str.repeat(3)#名字重复多少次
return df_re
df3=df2.pipe(chang_name)
print(df3)
row1 大黄,小黄大黄,小黄大黄,小黄
row2 狗蛋 狗蛋 狗蛋
row3 铁蛋铁蛋铁蛋
row4 富贵富贵富贵
Name: name, dtype: object
"""
"""
添加一列，score:[10,20,30,40]
修改成绩为10分制
df2['score']=[10,20,30,40]
print(df2)
def change_score(df2,i):
df2['score']=df2['score'] / i
return df2
df5=df2.pipe(change_score,10)
print(df5)
def chang_name(df):
df_name=df['name']#获取名字
df_re=df_name.str.repeat(3)#名字重复多少次
return df_re
df3=df2.pipe(chang_name)
#print(df3)
def add_age(df,i):
df_age=df['age']+i
return df
df4=df2.pipe(add_age,2)
print(df4)
"""
"""
自定义函数，把数据放到函数中进行应用/转换，成我们想要的数据
apply(func,axis= 0,raw= False,result_type=None,args=(),**kwargs)
func:作用于每一行和每一列
axis：所对应的轴，默认是0
0或者index:代表每一列
1或者columns:代表每一行
raw：布尔类型，默认是False
如果时False：将每一行和每一列作为Series传递给函数
如果时True：将数据作为ndarry传递给函数
result_type : {'expand', 'reduce', 'broadcast', None}，默认是none
expand：类似列表的结果转换成Dataframe的列
reduce：如果可能，返回一个Series或Dataframe，而不是类似列表的结果，和expand相反
broadcast:结果保留原始索引和列
def add(df):
a=df.sum()
return a
print(df2.apply(add))
name 大黄,小黄狗蛋 铁蛋富贵
age 30.0
score 10.0
dtype: object
"""
def add(df):
a=df.sum()
return a
print(df2.apply(add))
a=lambda df:[1,2]
df3=df2.apply(a,axis=1)
print(df3)
