pandas模块和随堂笔记(1)

最新推荐文章于 2024-02-05 11:00:00 发布

零零后小白

最新推荐文章于 2024-02-05 11:00:00 发布

阅读量1k

点赞数

文章标签： python 数据分析数据挖掘

本文链接：https://blog.csdn.net/m0_51945364/article/details/121839860

版权

本文介绍了Pandas库的基础知识，包括Series和DataFrame数据结构的定义、特点、生成及操作方法。详细讲解了如何创建、访问、修改Series和DataFrame，以及它们的属性和方法，如数据类型、索引、添加和删除列、行操作等，适合初学者了解和掌握Pandas基础操作。

摘要由CSDN通过智能技术生成

Pandas简介

定义

一个开源的python类库，用于数据分析、数据处理、数据可视化

特点

高性能、容易使用的数据结构、容易使用的数据分析工具

pandas数据类型

Series是由相同数据类型组成的一维数组。

DataFrame：二维的表格型数据结构，数据帧(DataFrame)是大小可变的数据结构，每列可以是不同的数据类型（整型、字符串、布尔值等）

面板(Panel)可以由不同的数据类型构成的三维数据结构，Panel是DataFrame的容器

数据结构	维数	描述	数据	大小
Series	1	数据可变，一维数组，大小不可变，Series是由相同数据类型组成的一维数组。	数据可变	大小不可变
DataFrame	2	二维数组，大小可变的表格结构，它含有一组有序的列，每列可以是不同的数据类型（整型、字符串、布尔值等）	数据可变	大小可变
Panel	3	数据可变大小可变的三维数组	数据可变	大小可变

pandas安装

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)

利用列表创建

#利用单层listx = [1,2,3,4,5,6]df = pd.DataFrame(x，dtype=np.float32)print(df)

#利用双层listx = [    ["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'] = 100print(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，就会默认是nundf1 = 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和agex = {    '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，行索引是indexs1 = 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'])) #<class 'pandas.core.series.Series'>print("----------------------")print(df[['name','age']])print(type(df[['name','age']])) <class 'pandas.core.frame.DataFrame'>

列的添加

"""语法：df[columns] = 数据切记数据要是同类型的数据，"""x = [    ["tom",10],    ["jack",20],    ["mike",30]]df = pd.DataFrame(x,columns=['name','age'],index=['row1','row2','row3'])print(df)#依据list进行创建的，添加列的时候要是listx1 = ['nan','nv','nan']df["three"] = x1print("---------------------------------------------")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']=s3print (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']=s3print (df)del df['one']print (df)df_pop = df.pop('two')print("--------------------------")print (df_pop) """a    1b    2c    3d    4"""print (df)"""   threea   10.0b   20.0c   30.0d    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    tomage      10Name: row1, dtype: object"""print("---------------------------------------")#查询一个数据 ，精确到第一行。name那一列的数据print(df.loc["row1","name"])#tomprint("---------------------------------------")print(df.loc[['row1','row2'],"name"]) #查询第一行和第二行的name"""row1     tomrow2    jackName: name, dtype: object"""print("---------------------------------------")print(df.loc[['row1','row2'],['name','age']]) #查询第一行和第二行的name和age"""      name  agerow1   tom   10row2  jack   20"""print("---------------------------------------")print(df.loc['row1',['name','age']]) #第一行的name和age"""name    tomage      10Name: row1, dtype: object"""print("----------------------------------")print(df.loc['row1':'row3','name'])#查询第一行到第三行的name"""row1     tomrow2    jackrow3    mikeName: name, dtype: object"""print("----------------------------------")print(df.loc['row1','name':'age']) #第一行的name到age"""name    tomage      10Name: row1, dtype: object"""print("----------------------------------")print(df.loc['row1':'row3','name':'age'])"""      name  agerow1   tom   10row2  jack   20row3  mike   30"""print("----------------------------------")b = df['age']<20print(b)"""row1     Truerow2    Falserow3    False"""print(df.loc[b])  #获取age小于20的行，列是所有列"""     name  agerow1  tom   10"""print("----------------------------------")print(df.loc[b,'name'])  #获取age小于20的行，列是name"""row1    tomName: 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    mikeage       30Name: row3, dtype: object"""print("------------------------")print(df.iloc[0:2])"""      name  agerow1   tom   10row2  jack   20"""print("------------------------")print(df.iloc[[0,2]])"""      name  agerow1   tom   10row3  mike   30"""print("------------------------")print(df.iloc[2,0]) #mikeprint("------------------------")print(df.iloc[2,[0,1]]) """------------------------name    mikeage       30Name: row3, dtype: object"""print("------------------------")print(df.iloc[2,0:1]) """name    mikeName: 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  agerow1   tom   10row2  jack   20"""print("-----------------------------------------")print(df['row1':'row3'])"""-----------------------------------------      name  agerow1   tom   10row2  jack   20row3  mike   30"""

行的添加

"""在末尾追加一行，返回一个新对象 df.append(other,ignore_index= False,verify_integrity = False,        sort = False)other：要附加的数据，DataFrame或者Series等类型ignore_index：如果是True，则不使用索引标签，默认falseverify_integrity：如果是True，在创建于重复项的索引时，引发valueError，默认时falsesort：如果原数据和添加数据的列没有对齐，则对列进行排序，不建议排序"""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  agerow1   tom   10row2  jack   20row3  mike   30row1    zs   10row2    ls   20row3    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  age0   tom   101  jack   202  mike   303    zs   104    ls   205    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  Rating0    Tom   25    4.231  James   26    3.242  Ricky   25    3.983    Vin   23    2.564  Steve   30    3.205  Minsu   29    4.606   Jack   23    3.80"""print("--------df.T返回DataFrame的转置，行和列将交换----------")df_T = df.Tprint(df_T)"""--------df.T返回DataFrame的转置，行和列将交换----------           0      1      2     3      4      5     6Name     Tom  James  Ricky   Vin  Steve  Minsu  JackAge       25     26     25    23     30     29    23Rating  4.23   3.24   3.98  2.56    3.2    4.6   3.8"""print("--------df.axes返回行轴标签和列轴标签列表----------")df_axes = df.axesprint(df_axes)#[RangeIndex(start=0, stop=7, step=1), Index(['Name', 'Age', 'Rating'], dtype='object')]print("--------df.dtypes返回每列的数据类型----------")df_dtype = df.dtypesprint(df_dtype)"""--------df.dtypes返回每列的数据类型----------Name       objectAge         int64Rating    float64dtype: object"""print("--------df.empty返回布尔值，表示对象是否为空，返回True表示对象为空----------")df_empty = df.emptyprint(df_empty) #Falseprint("--------df.ndim返回对象的维数----------")df_ndim = df.ndimprint(df_ndim )  #2

print("-----df.shape返回表示DataFrame的维度的元组。元组(a，b)，其中a表示行数，b表示列数----")df_shape = df.shapeprint(df_shape  )  #(7, 3)print("-----df.size返回DataFrame中的元素个数。----")df_size = df.sizeprint(df_size  )  #21print("-----df.values将DataFrame中的实际数据作为NDarray返回。----")df_values = df.valuesprint(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  Rating0    Tom   25    4.231  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  Rating5  Minsu   29     4.66   Jack   23     3.8"""

随堂笔记

pandas.Series(data,index,dtype,copy)

“”"
data:数据，可以是序列类型，可以是int
index:索引值必须是唯一的，与data的长度相同，默认为np.arange(n)
dtype:数据类型
copy:是否复制数据，默认为False
打印左侧为索引，右侧为数据
“”"
import pandas as pd
import numpy as np
‘’’
a=np.array([1,2,3,4,5])
s1=pd.Series(a,index=[‘a’,‘b’,‘c’,‘d’,‘e’],copy=False)
print(s1)
print(a)

修改数据，把1----->100

print("---------------------")
s1[‘a’]=100
print(s1)
print(a) #[100 2 3 4 5]
‘’’
‘’’
a=[1,2,3,4,5]
s1=pd.Series(a)

np01=np.array([1,2,3])
s2=pd.Series(np01)
‘’’

字典={k:v}

“”"
k:在series中是index
“”"
‘’’
d1={‘zs’:18,‘ls’:20}
s3=pd.Series(d1)
print(s3)
print(s3[‘zs’]) #18

a=[18,20]
s4=pd.Series(a,index=[‘zs’,‘ls’])
‘’’

语法:s1[index] 获取单个数据

‘’’

可以使用默认索引，也可以使用自定义索引

d1={‘zs’:20,‘ls’:30,‘ww’:40,‘ch’:20,‘zl’:30}
s1=pd.Series(d1)
print(s1[‘zs’]) #使用自定义索引 20
print(s1[0]) #使用默认索引 20
‘’’

语法:

“”"
s1[list] 获取索引中的数据
s1[index1:index2] 获取从第一个索引到第二个索引的数据，左开右闭
数字索引是左开右闭，标签索引是左开右开
“”"
‘’’
print(s1[‘zs’:‘ch’]) #左开右开

print(s1[[‘zs’,‘ch’,‘ww’]])

print(s1[0:3]) #左开右闭

print(s1[[0,3,4]])
‘’’

语法:

“”"
axes 返回Series索引列表
dtype 返回Series的数据类型
empty 判断Series是否为空，如果为空，则返回True
ndim 返回基础数据的维度数，默认为:1
size 返回基础数据中的元素个数
values 将Series作为ndarray返回
head() 返回前n行
tail() 返回最后n行
“”"
“”"
head() 返回前n行(观察索引值)。默认数量为5，可以传递自定义数值
tail() 返回最后n行(观察索引值)。默认数量为5，可以传递自定义数值
“”"

可以使用默认索引，也可以使用自定义索引

d1={‘zs’:20,‘ls’:30,‘ww’:40,‘ch’:20,‘zl’:30}
s1=pd.Series(d1)
#print(s1.axes) #[Index([‘zs’, ‘ls’, ‘ww’, ‘ch’, ‘zl’], dtype=‘object’)]
#print(s1.dtype) #int64
#print(s1.empty) #False
#print(s1.ndim) #1
#print(s1.size) #5
#print(s1.values) #[20 30 40 20 30]
#print(type(s1.values)) #<class ‘numpy.ndarray’>
#print(s1.head(3))
#print(s1.tail(2))

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)
‘’’

利用单层list

#数据变成行数据
‘’’
x=[1,2,3,4,5]
df2=pd.DataFrame(x)
#print(df2)
‘’’

利用双层list

‘’’
x=[
[‘zs’,20],
[‘ls’,30],
[‘ch’,40]
]
df3=pd.DataFrame(x,columns=[‘name’,‘age’])
#print(df3)
‘’’

利用数据是字典的列表创建

“”"
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)
‘’’
df1=pd.DataFrame(x)
print(df1) #ValueError: If using all scalar values, you must pass an index
‘’’
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
查询多列不会进行降维
“”"
s=df3[‘食品’]
#print(s)
#print(type(s)) #<class ‘pandas.core.series.Series’>

s2=df3[[‘食品’,‘价格’]]
#print(s2)
#print(type(s2)) #<class ‘pandas.core.frame.DataFrame’>
#字典里面的v是列表

添加列

“”"
语法: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)
#print(df3)

a=[‘好吃’,‘多’,‘馅多’]
df3[‘评价’]=a
#print(df3)
#print("-------------------------------")
df3[‘详细评价’]=df3[‘食品’]+df3[‘评价’]
#print(df3)

删除语法

“”"
del df[columns] 根据下标进行检索删除，没有返回值
df.pop(columns) 根据下标进行检索删除，并返回删除的那一列
“”"
‘’’
del df3[‘评价’]
print(df3)

a=df3.pop(‘详细评价’)
print(‘a’,a) #要删除的那一列数据
print(‘df3’,df3) #删除后的数据
‘’’

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)
#print(df3)

索引语法:

“”"
loc[自定义索引(标签索引)]
iloc[默认索引(数字索引)]
语法:
loc[index] 查询一行数据
扩展
loc[index,columns] 精确到行和列，那就是一个数据
查询多行和多列（精确到第几行和第几列）
loc[[index1,index2,…],[columns1,columns12,…]]
查询多行和多列（第几行到第几行,第几列到第几列）
不是左开右闭
loc[index1:index2,columns1:columns2]
使用布尔索引也可以查询多行多列
loc[行_布尔索引,列_布尔索引]
“”"
#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[ ]语法:

“”"
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,np.NaN],index=[‘row1’,‘row2’,‘row3’,‘row4’])
x1={
‘name’:s3,
‘age’:s4
}
df2=pd.DataFrame(x1)
#print(df2)
“”"

T	转置行和列
axes	返回一个列，行轴标签和列轴标签作为唯一的成员
dtypes	返回此对象中的数据类型
empty	如果DataFrame为空，则返回为True，任何轴的长度都为0
ndim	数组维度大小，默认为2维
shape	返回表示DataFrame的维度的元组
size	DataFrame中的元素个数
values	将DataFrame中的实际数据作为NDarray返回
head()	返回开头n行
tail()	返回最后n行

“”"
#print(df2.head(2))
#print(df2.tail(2))
“”"
name age
row1 大黄 10
row2 狗蛋 10
name age
row3 铁蛋 10
row4 富贵 10
“”"
#print("-----values–把真正的数据转换成ndarray的形式输出")
#print(df2.values)
#print(type(df2.values))
“”"
-----values–把真正的数据转换成ndarray的形式输出
[[‘大黄’ 10]
[‘狗蛋’ 10]
[‘铁蛋’ 10]
[‘富贵’ 10]]
<class ‘numpy.ndarray’>
“”"
#print(’----size—元素个数–’)
#print(df2.size)
“”"
----size—元素个数–
8
“”"
#print(’—shape—(行,列)’)
#print(df2.shape)
“”"
—shape—(行,列)
(4, 2)
“”"
#print("—ndim—维度数")
#print(df2.ndim) #2
“”"
—ndim—维度数
2
“”"
#print("----empty–")
#print(df2.empty)
“”"
----empty–
False
“”"
#print("----dtypes----每一列的数据类型–")
#print(df2.dtypes)
“”"
----dtypes----每一列的数据类型–
name object
age int64
dtype: object
“”"
#print(’------axes—获取行和列的索引’)
#print(df2.axes)
“”"
----axes----获取行和列的索引
[Index([‘row1’, ‘row2’, ‘row3’, ‘row4’], dtype=‘object’),
Index([‘name’, ‘age’], dtype=‘object’)]
“”"

语法:

“”"

count()	非空数据的数量
sum()	所有值之和
mean()	所有值的平均值
median()	所有值的中位数
mod()	值的模
std()	值的标准偏差
min()	所有值中的最小值
max()	所有值中的最大值
abs()	绝对值
prod()	数组元素的乘积
cumsum()	累积总和
cumprod()	累计乘积

cumprod—累计求积

“”"
#print(’—cumprod—累计求积–’)
#print(df2[‘age’].cumprod())
“”"
—cumprod—累计求积–
row1 10.0
row2 100.0
row3 1000.0
row4 NaN
Name: age, dtype: float64
“”"

cumsum–累计求和

#print(’-----cumsum–累计求和–’)
#print(df2.cumsum())
“”"
-----cumsum–累计求和–
name age
row1 大黄 10.0
row2 大黄狗蛋 20.0
row3 大黄狗蛋铁蛋 30.0
row4 大黄狗蛋铁蛋富贵 NaN
“”"

prod----乘积

#print(’----prod----乘积–’)
#print(df2[‘age’].prod())
“”"
----prod----乘积–
1000.0
“”"

abs—绝对值

#print(’----abs—绝对值—’)
#print(df2[‘age’].abs())
“”"
----abs—绝对值—
row1 10.0
row2 10.0
row3 10.0
row4 NaN
Name: age, dtype: float64
“”"

max—最大值

#print(’----max—最大值–’)
#print(df2.max())
“”"
----max—最大值–
name 铁蛋
age 10.0
dtype: object
“”"

min----最小值

#print(’—min----最小值—’)
#print(df2.min())
“”"
—min----最小值—
name 大黄
age 10.0
dtype: object
“”"

std—标准差

#print(’----std—标准差—’)
#print(df2.std())
“”"
age 0.0
dtype: float64
“”"

mod(n)—取余

#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
“”"

median—中位数

#print(’—median—中位数–’)
#print(df2.median())
“”"
age 10.0
dtype: float64
“”"

mean----平均值

#print(’—mean----平均值—’)
#print(df2.mean())
“”"
age 10.0
dtype: float64
“”"

sum—求和—每一列的和

#print(’—sum—求和—每一列的和’)
#print(df2.sum())
“”"
—sum—求和—每一列的和
name 大黄狗蛋铁蛋富贵
age 30.0
dtype: object
“”"

count—非空计数

#print(’—count—非空计数’)
#print(df2.count())
“”"
—count—非空计数
name 4
age 3
dtype: int64
“”"

append(ignore_index)

‘’’
print("---------------------------")
df3=df1.append(df2,verify_integrity=False)
print(df3)
print("------------append(ignore_index)---------------")
df3=df1.append(df2,ignore_index=True)
print(df3)
‘’’

删除某行，返回一个新数据

“”"
df1=df.drop(index) #删除某行，返回一个新数据
index只能是索引标签(自定义索引)
“”"
df3=df2.drop(‘row4’)
#print(df3)

函数是用来计算有关DataFrame 列的统计信息的摘要

“”"
describe(percentiles=None,include=None,exclude=None,datetime_is_numeric=False,)

percentiles:设置分位数，默认是[.25,.5,.75],
也就是返回 25%，50%，75%数据量时的数字
include:计算那些数据类型的统计量
object -汇总字符串列
number -汇总数字列
all -将所有列汇总在一起(不应将其作为列表值传递)
exclude:不计算那些数据类型的统计量，参数和上面一样，没有all
datetime_is_numeric:默认值为False。设置为True 可将日期时间数据视为数字
“”"
a=df2.describe(exclude=‘number’)
#print(a)