Pandas简介
定义
一个开源的python类库，用于数据分析、数据处理、数据可视化
特点
高性能、容易使用的数据结构、容易使用的数据分析工具
pandas数据类型
Series是由相同数据类型组成的一维数组。
DataFrame：二维的表格型数据结构，数据帧(DataFrame)是大小可变的数据结构，每列可以是不同的数据类型（整型、字符串、布尔值等）
面板(Panel)可以由不同的数据类型构成的三维数据结构，Panel是DataFrame的容器
| 数据结构 | 维数 | 描述 | 数据 | 大小 |
|---|
| Series | 1 | 数据可变， 一维数组，大小不可变，Series是由相同数据类型组成的一维数组。 | 数据可变 | 大小不可变 | | DataFrame | 2 | 二维数组，大小可变的表格结构，它含有一组有序的列，每列可以是不同的数据类型（整型、字符串、布尔值等） | 数据可变 | 大小可变 | | Panel | 3 | 数据可变 大小可变的三维数组 | 数据可变 | 大小可变 |
pandas安装
<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#000000">pip</span> <span style="color:#000000">install</span> <span style="color:#000000">pandas</span>
<span style="color:#000000">pip</span> <span style="color:#3300aa">list</span></span></span>
一维数据结构：Series对象
<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#aa5500">#查看列索引</span>
<span style="color:#3300aa">print</span>(<span style="color:#000000">d1</span>.<span style="color:#000000">columns</span>)
<span style="color:#aa5500">#查看行索引</span>
<span style="color:#3300aa">print</span>(<span style="color:#000000">d1</span>.<span style="color:#000000">index</span>)</span></span>
Series对象的生成
使用Pandas.Series
<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#aa1111">"""</span>
<span style="color:#aa1111">pandas.Series( data, index, dtype, copy)</span>
<span style="color:#aa1111">data:数据,可以是序列类型，可以是int</span>
<span style="color:#aa1111">index:索引值必须是唯一的，与data的长度相同，默认为np.arange(n)</span>
<span style="color:#aa1111">dtype:数据类型</span>
<span style="color:#aa1111">copy:是否复制数据，默认为false</span>
<span style="color:#aa1111">打印左侧为索引，右侧为数据</span>
<span style="color:#aa1111">"""</span>
<span style="color:#aa5500">#如果全部是int类型，那么打印s1会显示是int类型</span>
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>([<span style="color:#116644">1</span>,<span style="color:#116644">2</span>,<span style="color:#116644">3</span>,<span style="color:#116644">4</span>]) <span style="color:#aa5500">#dtype: int64</span>
<span style="color:#3300aa">print</span>(<span style="color:#000000">s1</span>)
<span style="color:#aa5500">#如果什么数据类型都存在，那么打印s1会显示object类型的</span>
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>([<span style="color:#116644">1</span>,<span style="color:#aa1111">"a"</span>,<span style="color:#116644">0.5</span>,[<span style="color:#aa1111">"张三"</span>,<span style="color:#aa1111">"李四"</span>]])<span style="color:#aa5500">#dtype: object</span>
<span style="color:#3300aa">print</span>(<span style="color:#000000">s1</span>)
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>([<span style="color:#116644">1</span>,<span style="color:#aa1111">"a"</span>,<span style="color:#116644">0.5</span>,[<span style="color:#aa1111">"张三"</span>,<span style="color:#aa1111">"李四"</span>]],<span style="color:#000000">index</span>=[<span style="color:#aa1111">'a'</span>,<span style="color:#aa1111">'b'</span>,<span style="color:#aa1111">'c'</span>,<span style="color:#aa1111">'d'</span>])
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>([<span style="color:#116644">1</span>,<span style="color:#116644">2</span>,<span style="color:#116644">3</span>,<span style="color:#116644">4</span>],<span style="color:#000000">index</span>=[<span style="color:#aa1111">'a'</span>,<span style="color:#aa1111">'b'</span>,<span style="color:#aa1111">'c'</span>,<span style="color:#aa1111">'d'</span>],<span style="color:#000000">dtype</span>=<span style="color:#000000">np</span>.<span style="color:#000000">float32</span>)
<span style="color:#aa1111">"""</span>
<span style="color:#aa1111">copy=True后，数据x不会改变，数据s1会改变</span>
<span style="color:#aa1111">copy=False,数据x会改变，数据s1会改变</span>
<span style="color:#aa1111">"""</span>
<span style="color:#000000">x</span>=<span style="color:#000000">np</span>.<span style="color:#000000">array</span>([<span style="color:#116644">10</span>,<span style="color:#116644">20</span>,<span style="color:#116644">30</span>,<span style="color:#116644">40</span>])
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>(<span style="color:#000000">x</span>,<span style="color:#000000">index</span>=[<span style="color:#aa1111">'a'</span>,<span style="color:#aa1111">'b'</span>,<span style="color:#aa1111">'c'</span>,<span style="color:#aa1111">'d'</span>],<span style="color:#000000">copy</span>=<span style="color:#770088">True</span>)
<span style="color:#000000">s1</span>[<span style="color:#aa1111">'a'</span>]=<span style="color:#116644">100</span>
<span style="color:#3300aa">print</span>(<span style="color:#000000">s1</span>)
<span style="color:#3300aa">print</span>(<span style="color:#000000">x</span>)
?</span></span>
从ndarray创建一个Series
<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#000000">x</span>=<span style="color:#000000">np</span>.<span style="color:#000000">array</span>([<span style="color:#116644">10</span>,<span style="color:#116644">20</span>,<span style="color:#116644">30</span>,<span style="color:#116644">40</span>])
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>(<span style="color:#000000">x</span>)
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>(<span style="color:#000000">x</span>,<span style="color:#000000">index</span>=[<span style="color:#aa1111">'a'</span>,<span style="color:#aa1111">'b'</span>,<span style="color:#aa1111">'c'</span>,<span style="color:#aa1111">'d'</span>])
<span style="color:#3300aa">print</span>(<span style="color:#000000">s1</span>)
?</span></span>
从字典创建一个Series
<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#aa1111">"""</span>
<span style="color:#aa1111">由于我们的Series有索引有数据，和我们的字典很像，字典是有key和vaule</span>
<span style="color:#aa1111">"""</span>
<span style="color:#aa5500">#a是索引 100数据</span>
<span style="color:#000000">x</span>={<span style="color:#aa1111">'a'</span>:<span style="color:#116644">100</span>,<span style="color:#aa1111">'b'</span>:<span style="color:#116644">200</span>,<span style="color:#aa1111">'c'</span>:<span style="color:#116644">300</span>,<span style="color:#aa1111">'d'</span>:<span style="color:#116644">400</span>}
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>(<span style="color:#000000">x</span>)
<span style="color:#aa5500">#设置索引</span>
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>(<span style="color:#000000">x</span>,<span style="color:#000000">index</span>=[<span style="color:#aa1111">'a'</span>,<span style="color:#aa1111">'b'</span>,<span style="color:#aa1111">'c'</span>,<span style="color:#aa1111">'d'</span>])
<span style="color:#aa5500">#如果设置的索引位置换一下呢，数据也会跟着换</span>
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>(<span style="color:#000000">x</span>,<span style="color:#000000">index</span>=[<span style="color:#aa1111">'a'</span>,<span style="color:#aa1111">'c'</span>,<span style="color:#aa1111">'d'</span>,<span style="color:#aa1111">'b'</span>])
<span style="color:#aa5500">#如果设置的索引，在字典中不存在呢，为nan</span>
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>(<span style="color:#000000">x</span>,<span style="color:#000000">index</span>=[<span style="color:#aa1111">'a'</span>,<span style="color:#aa1111">'b'</span>,<span style="color:#aa1111">'e'</span>,<span style="color:#aa1111">'f'</span>])
<span style="color:#3300aa">print</span>(<span style="color:#000000">s1</span>)</span></span>
访问Series数据
单个索引获取数据
<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#aa1111">"""</span>
<span style="color:#aa1111">语法：s1[index] 获取单个数据 </span>
<span style="color:#aa1111">"""</span>
<span style="color:#aa5500">#可以使用默认索引，也可以使用自定义索引</span>
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>([<span style="color:#116644">1</span>,<span style="color:#aa1111">"a"</span>,<span style="color:#116644">0.5</span>,[<span style="color:#aa1111">"张三"</span>,<span style="color:#aa1111">"李四"</span>]],<span style="color:#000000">index</span>=[<span style="color:#aa1111">'a'</span>,<span style="color:#aa1111">'b'</span>,<span style="color:#aa1111">'c'</span>,<span style="color:#aa1111">'d'</span>])
<span style="color:#3300aa">print</span>(<span style="color:#000000">s1</span>[<span style="color:#116644">0</span>])
<span style="color:#3300aa">print</span>(<span style="color:#000000">s1</span>[<span style="color:#aa1111">'a'</span>])
?</span></span>
多个索引获取数据
<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#aa1111">"""</span>
<span style="color:#aa1111">语法：</span>
<span style="color:#aa1111">s1[list] 获取索引中的数据</span>
<span style="color:#aa1111">s1[index1:index2] 获取从第一个索引到第二个索引的数据，左开右闭</span>
<span style="color:#aa1111">"""</span>
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>([<span style="color:#116644">1</span>,<span style="color:#aa1111">"a"</span>,<span style="color:#116644">0.5</span>,[<span style="color:#aa1111">"张三"</span>,<span style="color:#aa1111">"李四"</span>]],<span style="color:#000000">index</span>=[<span style="color:#aa1111">'a'</span>,<span style="color:#aa1111">'b'</span>,<span style="color:#aa1111">'c'</span>,<span style="color:#aa1111">'d'</span>])
<span style="color:#3300aa">print</span>(<span style="color:#000000">s1</span>[<span style="color:#116644">0</span>:<span style="color:#116644">4</span>]) <span style="color:#aa5500">#左开右闭</span>
<span style="color:#3300aa">print</span>(<span style="color:#000000">s1</span>[[<span style="color:#116644">0</span>,<span style="color:#116644">1</span>,<span style="color:#116644">2</span>,<span style="color:#116644">3</span>]])
<span style="color:#3300aa">print</span>(<span style="color:#000000">s1</span>[[<span style="color:#aa1111">'a'</span>,<span style="color:#aa1111">'b'</span>,<span style="color:#aa1111">'c'</span>]])
<span style="color:#3300aa">print</span>(<span style="color:#000000">s1</span>[<span style="color:#aa1111">'a'</span>:<span style="color:#aa1111">'b'</span>])<span style="color:#aa5500">#获取两个数据</span>
?</span></span>
Series对象的使用
| 属性和方法 | 说明 |
|---|
| axes | 返回Series索引列表 | | dtype | 返回Series的数据类型 | | empty | 判断Series是否为空，如果为空，则返回True | | ndim | 返回基础数据的位数，默认为：1 | | size | 返回基础数据中的元素个数 | | values | 将Series作为ndarray返回 | | head() | 返回前n行 | | tail() | 返回最后n行 |
<span style="background-color:#f8f8f8"><span style="color:#333333"><span style="color:#aa1111">"""</span>
<span style="color:#aa1111">axes ? 返回Series索引列表 ? ? ? ? ? ? ? ? ? ? ? </span>
<span style="color:#aa1111">dtype ? 返回Series的数据类型 ? ? ? ? ? ? ? ? ? ? </span>
<span style="color:#aa1111">empty ? 判断Series是否为空，如果为空，则返回True </span>
<span style="color:#aa1111">ndim ? 返回基础数据的维度数，默认为：1 ? ? ? ? ? ?</span>
<span style="color:#aa1111">size ? 返回基础数据中的元素个数 ? ? ? ? ? ? ? ? </span>
<span style="color:#aa1111">values 将Series作为ndarray返回 ? ? ? ? ? ? ? ? ?</span>
<span style="color:#aa1111">head() 返回前n行 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?</span>
<span style="color:#aa1111">tail() 返回最后n行 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?</span>
<span style="color:#aa1111">"""</span>
<span style="color:#aa1111">"""</span>
<span style="color:#aa1111">head()返回前n行(观察索引值)。默认数量为5，可以传递自定义数值。</span>
<span style="color:#aa1111">tail()返回最后n行(观察索引值)。默认数量为5，可以传递自定义数值。</span>
<span style="color:#aa1111">"""</span>
<span style="color:#000000">s1</span> = <span style="color:#000000">pd</span>.<span style="color:#000000">Series</span>([<span style="color:#116644">1</span>,<span style="color:#aa1111">"a"</span>,<span style="color:#116644">0.5</span>,[<span style="color:#aa1111">"张三"</span>,<span style="color:#aa1111">"李四"</span>]],<span style="color:#000000">index</span>=[<span style="color:#aa1111">'a'</span>,<span style="color:#aa1111">'b'</span>,<span style="color:#aa1111">'c'</span>,<span style="color:#aa1111">'d'</span>])
<span style="color:#aa1111">"""</span>
<span style="color:#aa1111">print(s1.axes)</span>
<span style="color:#aa1111">print(s1.dtype)</span>
<span style="color:#aa1111">print(s1.empty)</span>
<span style="color:#aa1111">print('ndim',s1.ndim)</span>
<span style="color:#aa1111">print(s1.size)</span>
<span style="color:#aa1111">print('type',type(s1))</span>
<span style="color:#aa1111">print('type',type(s1.values))</span>
<span style="color:#aa1111">"""</span>
<span style="color:#3300aa">print</span>(<span style="color:#aa1111">'ndim'</span>,<span style="color:#000000">s1</span>.<span style="color:#000000">ndim</span>)
<span style="color:#000000">ss1</span> = <span style="color:#000000">s1</span>.<span style="color:#000000">tail</span>(<span style="color:#116644">3</span>)
<span style="color:#3300aa">print</span>(<span style="color:#000000">ss1</span>)
<span style="color:#3300aa">print</span>(<span style="color:#3300aa">type</span>(<span style="color:#000000">ss1</span>))
<span style="color:#000000">ss</span> = <span style="color:#000000">s1</span>.<span style="color:#000000">head</span>(<span style="color:#116644">3</span>)
<span style="color:#3300aa">print</span>(<span style="color:#000000">ss</span>)
<span style="color:#3300aa">print</span>(<span style="color:#3300aa">type</span>(<span style="color:#000000">ss</span>))</span></span>
二维数据结构：DataFrame对象
创建DataFrame对象
<span style="background-color:#f8f8f8"><span style="color:#333333">"""
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
"""</span></span>
创建空DataFrame对象
<span style="background-color:#f8f8f8"><span style="color:#333333">df = pd.DataFrame()
print (df)
</span></span>
利用列表创建
<span style="background-color:#f8f8f8"><span style="color:#333333">#利用单层list
x = [1,2,3,4,5,6]
df = pd.DataFrame(x，dtype=np.float32)
print(df)</span></span>
<span style="background-color:#f8f8f8"><span style="color:#333333">#利用双层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)
</span></span>
<span style="background-color:#f8f8f8"><span style="color:#333333"># 利用数据是字典的列表创建
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)
</span></span>
利用字典创建
<span style="background-color:#f8f8f8"><span style="color:#333333">#利用字典创建DataFrame
#a、b是列索引，一定要设置行索引（index），否则报错
x = {'a':1,'b':2}
d1 = pd.DataFrame(x,index=['row1'])
print(d1)</span></span>
<span style="background-color:#f8f8f8"><span style="color:#333333"># 字典里面的v是列表类型创建DataFrame
#那么默认列索引是name和age
x = {
'name':['zs','ls','ww','zl'],
'age':[14,15,16,17]
}
d1 = pd.DataFrame(x)
print(d1)
print(d1['age'])</span></span>
利用Series和字典的结合来创建DataFrame
<span style="background-color:#f8f8f8"><span style="color:#333333">"""
#只有列索引，没有行索引
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)</span></span>
列的读取
<span style="background-color:#f8f8f8"><span style="color:#333333">"""
语法：
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'>
</span></span>
列的添加
<span style="background-color:#f8f8f8"><span style="color:#333333">
"""
语法：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)
</span></span>
<span style="background-color:#f8f8f8"><span style="color:#333333">"""
语法：
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)</span></span>
练习
<span style="background-color:#f8f8f8"><span style="color:#333333">#把以下数据添加'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)</span></span>
列的删除
<span style="background-color:#f8f8f8"><span style="color:#333333">"""
删除语法
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
"""</span></span>
行的读取
使用loc方法
<span style="background-color:#f8f8f8"><span style="color:#333333">"""
语法：
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
"""</span></span>
使用df.iloc方法
df.loc方法，根据行、列的标签值查询
df.iloc方法 根据行、列的数字位置查询
<span style="background-color:#f8f8f8"><span style="color:#333333">"""
语法：
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
"""</span></span>
使用切片读取
<span style="background-color:#f8f8f8"><span style="color:#333333">"""
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
"""</span></span>
行的添加
<span style="background-color:#f8f8f8"><span style="color:#333333">"""
在末尾追加一行，返回一个新对象
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)</span></span>
行的删除
<span style="background-color:#f8f8f8"><span style="color:#333333">"""
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)</span></span>
DataFrame的属性和方法
| 属性和方法 | 描述 |
|---|
| T | 转置行和列 | | axes | 返回一个列，行轴标签和列轴标签作为唯一的成员 | | dtypes | 返回此对象中的数据类型 | | empty | 如果DataFrame为空，则返回为True，任何轴的长度都为0 | | ndim | 数组维度大小，默认为2维 | | shape | 返回表示DataFrame的维度的元组 | | size | DataFrame中的元素个数 | | values | 将DataFrame中的实际数据作为NDarray返回 | | head() | 返回开头n行 | | tail() | 返回最后n行 |
<span style="background-color:#f8f8f8"><span style="color:#333333">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</span></span>
<span style="background-color:#f8f8f8"><span style="color:#333333">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
"""</span></span>
?
"""
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['食品']#<class 'pandas.core.series.Series'>
print(s)
print(type(s))
s2=df3[['食品','价格']]#<class 'pandas.core.frame.DataFrame'>
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]]
<class 'numpy.ndarray'>
?
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)
?
|