写在前面的话： 开始之前请确保已经配置好python环境，并安装好第三方库pandas和numpy。
1. pandas库介绍
什么是pandas？pandas是提供高性能易用数据类型和数据分析工具的第三方库。apple简单讲，pandpython下载安装教程as主要作用索引有两个：提供了简易高效的数据类型、提供了数据分析的工具。pandas基于numpy，常和numpy、matplotlib一起使用。 关于数据类型，python中自带的数据类型远远不能满足于数据分析。可以说在数据分析中numpy中的数据类型是基础数据类型，关注的是数据的结构表达，体数据分析师资格证书现在数据间的关系（维度）；pandas索引符号中的数据类型是基于numpy的数据分析培训扩展数据类型，关注的是数据的应用表达，体现在数据与索引之间的关系上。我们再学习pandas时最重要的是理解如何去操作索引，从某种程度上来说，操作索引就是操作数据。
2. pandas库的series类型
pandas主要有两种数据类型，一维度数据分析培训的Series数据类型，二维及高维的DataFrame类数组词型。我们先来看一下第一种，series类型索引失效。
2.1 什么是series类型？
series类型由一组数数据分析培训据及与之相关的数数据分析师工作内容据索引组成。我们来看几行代码：
import pandas as pd
a = pd.Series([7,8,9,10])
print(a)
输出如下：
0 7
1 8
2 9
3 10
dtype: int64
观察输出代码，我们可以发现Series对象一共由3部分组成：左侧自动索引部分，右侧数据部分，底部数据类型（numpy中的数据类型）部分。
除了自动添加索引外，我们还可以对其索引进行自定义：
import pandas as pd
a =pd.Series([7,8,9,10],index=["a","b","c","d"]) # index指定索引
print(a)
输出如下：
a 7
b 8
c 9
d 10
dtype: int64
可见，索引部分变为了我们自定义的abcdappstore。
2.2 如何创建series类型？
创建Series类型的方法有很多种，主要以 以下几种为主：
- 从标量创建
- 从字典创建
- 从ndarray类型创建
- 从列表application创建
下面进行具体数组排序讲解：
（1）从标量值创建
即指定一个标量生成一个series类型，如下：
import pandas as pd
a = pd.Series(5,index=["a","b","c","d","e","f"])
print(a)
输出如下：
a 5
b 5
c 5
d 5
e 5
f 5
dtype: int64
需要注意的是，此时索引页是哪一页的index参数不能省略（因为需要index来指定生成元素的个数和索引）。 （2）从字典类型创建 传入一个参数字典，字典的键为series类型的索引，字典的值为series类型的值：
import pandas as pd
my_dir={
"a":1,
"b":2,
"c":3
}
b = pd.Series(my_dir)
print(b)
输出如下：
a 1
b 2
c 3
dtype: int64
此外，利用字典构造series类型时，我们同样可以使用index来指定其索引或改变其结构，这个索引会覆盖字典中的“键索引”。
（3）从ndarray类型创建 ndarray类型是numpy中数组的数据类型appearance，python下载我们可以直接传入ndarpython123ray类型进行创建：
import pandas as pd
import numpy as np
c = np.arange(4)
d = pd.Series(c)
print(d)
输出如下：
0 0
1 1
2 2
3 3
dtype: int32
同样，也可以使用index参数自定义索引。
（4）也可以从python列表创建，见2.1中的小例。
2.3 series类型的基本使用
Series对象包括index和values两部分，所以主要是这两部分操作。我们先看一下下面appointment的案例：
- a.index:获取application索引
- a.values: 获取数据
- a索引失效的几种情况[‘a’]: 获取索引为a的元素
- a[0]：获取索引为0的元素，注意！自动数组和链表的区别索引和自定义索引并存但不能混合使用
因为series是基于ndarray类型的，所以对Series的操作类似于ndarray类型的操作：
- numpy中运算和操作可用于serie数组指针s类型
- 可以通过自动索引或自定义索引对其进行切片
import pandas as pd
a = pd.Series([1,2,3,4,5,6],index=["a","b","c","d","e","f"])
print("a的值：",a.values)
print("a的索引：",a.index)
print("a[0]：",a[0])
print("a['a']:",a["a"])
print("a切片：n",a[::-1])
输出如approach下：
a的值： [1 2 3 4 5 6]
a的索引： Index(['a', 'b', 'c', 'd', 'e', 'f'], dtype='object')
a[0]： 1
a['a']: 1
a切片：
f 6
e 5
d 4
c 3
b 2
a 1
dtype: int64
此外，series类型具备对齐操作。如下：
import pandas as pd
a = pd.Series([1,2,3],index=["c","d","e"])
b = pd.Series([4,5,6,7,8],index=["a","b","e","f","g"])
c = a+b
print(c)
输出如下：
a NaN
b NaN
c NaN
d NaN
e 9.0
f NaN
g NaN
dtype: float64
我们让两个series类型相加数组排序。观察输出结果可以数据分析观念发现，只有当a、b两者中有相同索引（包括位置）时，他们才会相加，而其余值则不会相加。这就对是series的对齐操作。这也同时验证了pandas是基于索数组排序引的运算。
Series类型还有一个name属性，即series对象和索引都可以被赋予一个名称。我们可以使用.name来获取或定义其名称。
import pandas as pd
a = pd.Series([1,2,3],index=["c","d","e"])
print(a.name) # 初始是没有名称的
a.name = "mySeries"
print(a.name)
print(a.index.name)
a.index.name = "索引列"
print(a.index.name)
print("*"*20)
print(a)
输出如下：
None
mySeries
None
索引列
********************
索引列
c 1
d 2
e 3
Name: mySeries, dtype: int64
3. pandas库的DataFrame类型
介绍完Series类型，再然我们来看一下二维及多维的DataFrame类型。
3.1 什么是DataFrame类型？索引下推
DataFrame类型是由共用相同索引的一组列数据组成的数据类型。数组和链表的区别即DataFrame类型数据分析软件是一数据分析软件个类似于表格型的数据类型，每列值类型索引是什么意思可以不同，同一行的多列数据都数组共用同一个索引。我们先看一个小例子：
import pandas as pd
import numpy as np
a = np.arange(10).reshape(2,5)
b = pd.DataFrame(a)
print(b)
通过python怎么读numpy生成一个二维的ndarray数组，并将其作为参数传给DataFrame，从而生成DataF索引页是哪一页rame类型的数据。输出如下：
从输出结果中，python培训可以发现数组长度，输出结果一共由三部分组成：左侧(纵向)行索引index(红色区,为轴axis=0) 、顶部(横向)列索引column(黄色区，为轴axis=1) 以及数据部分(蓝色区)。 DataFrame常用于表达二维数据，但也可以表达多维数据。
3.2 如何创建DataFrame类型？
dataFrame可以由以下4种方法创建：
- 二维ndarray对象
- 字典
- Series类型
- 其它DataFrame类型
接下来，我们进行详细介绍：
（1）由二维ndarray对象创建
import pandas as pd
import numpy as np
a = np.arange(16).reshape(4,4)
print('ndarray类型:n',a)
b = pd.DataFrame(a)
print('转换后的DataFrame类型：n',b)
通过numpy生成一个4*4的ndarray类型，然后作为参数转换成DataFrame类型，输出如下：
ndarray类型:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
转换后的DataFrame类型：
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
3 12 13 14 15
（2）由多个一维Series组成的字典生成 我们首先创建一个字典，并将其作为采数据分析培训参数传给DataFrame：
import pandas as pd
import numpy as np
a = {
"小明":pd.Series([100,99,98,100,95,99],index=["语文","数学","英语","物理","化学","生物"]),
"小红":pd.Series([100,99,98,100,95,99],index=["语文","数学","英语","物理","化学","生物"]),
"小蓝":pd.Series([100,99,98,100,95,99],index=["语文","数学","英语","物理","化学","生物"]),
"小黄":pd.Series([100,99,98,100,95,99],index=["语文","数学","英语","物理","化学","生物"]),
"小绿":pd.Series([100,99,98,100,95,99],index=["语文","数学","英语","物理","化学","生物"])}
b = pd.DataFrame(a)
print(b)
输出如下：
小明 小红 小蓝 小黄 小绿
语文 100 100 100 100 100
数学 99 99 99 99 99
英语 98 98 98 98 98
物理 100 100 100 100 100
化学 95 95 95 95 95
生物 99 99 99 99 99
可以看到，键名变成了列标签，键值索引变成了行标签。
3.3 DataFrame与Seripython123平台登录es的关系
可以发现当我们从DataFr索引超出了数组界限什么意思ame中取出一行或一列时，所得结果是Series类型。也就是说Dat数组的定义aFrame是Series类型的容器。
4. pandas库的数据操作
在上文中，我们提到pandas索引符号的两种数据类型是seriesappetite类型和DataF数据分析软件rame类型。接下来，我们主要针对这两种数据类型的操作进行讲解。
4.1 Dataframe的基本属性
-
df.shape：行数和列数
-
df.dtype：列数据类型
-
df.ndim：数据维度
-
df.index：行索引
-
df.columns：列索引
-
df.values：值
import pandas as pd import numpy as np df = pd.DataFrame(np.arange(16).reshape(4,4),index=list("abcd"),columns=list("ABCD")) print(df) print("行数和列数：",df.shape) print("列数据类型：n",df.dtypes) print("数据维度：",df.ndim) print("行索引：",df.index,"数据类型：",type(df.index)) print("列索引：",df.columns,"数据类型：",type(df.columns)) print("对象值：n",df.values,"数据类型：",type(df.values))
输出如下：
A B C D
a 0 1 2 3
b 4 5 6 7
c 8 9 10 11
d 12 13 14 15
行数和列数： (4, 4)
列数据类型：
A int32
B int32
C int32
D int32
dtype: object
数据维度： 2
行索引： Index(['a', 'b', 'c', 'd'], dtype='object') 数据类型： <class 'pandas.core.indexes.base.Index'>
列索引： Index(['A', 'B', 'C', 'D'], dtype='object') 数据类型： <class 'pandas.core.indexes.base.Index'>
对象值：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]] 数据类型： <class 'numpy.ndarray'>
4.2 dataFrame整体情况查询
-
df.head(n): 显示前n行，默认前五索引下推行
-
df.tail(n)：显示末尾n行，默认后五行
-
df.info()：基本信息：行列数，列索引，列非空值个数，列类型行类型，内存占用等
-
df.describe()： 统计信息：行数，列数，均值，标准差，最大值，最小值，四分位数等
-
df.sort_values(by=”索引类型列标签”，ascending=True)：升序排序
import pandas as pd import numpy as np df = pd.DataFrame(np.arange(16).reshape(4,4),index=list("abcd"),columns=list("ABCD")) print(df) print("前3行：n",df.head(3)) print("-"*50) print("后3行：n",df.tail(3)) print("-"*50) print("基本信息:") print(df.info()) print("-"*50) print("统计信息：",df.describe()) print("降序排序：") print(df.sort_values(by="B", ascending=False))
输出如下：
A B C D
a 0 1 2 3
b 4 5 6 7
c 8 9 10 11
d 12 13 14 15
前3行：
A B C D
a 0 1 2 3
b 4 5 6 7
c 8 9 10 11
--------------------------------------------------
后3行：
A B C D
b 4 5 6 7
c 8 9 10 11
d 12 13 14 15
--------------------------------------------------
基本信息:
<class 'pandas.core.frame.DataFrame'> # 数据类型
Index: 4 entries, a to d # 行数 4行
Data columns (total 4 columns): # 列数 4列
# Column Non-Null Count Dtype
--- ------ -------------- ----- # 列标签 列非空值个数 列数据类型
0 A 4 non-null int32
1 B 4 non-null int32
2 C 4 non-null int32
3 D 4 non-null int32
dtypes: int32(4)
memory usage: 96.0+ bytes # 内存占用大小
None
--------------------------------------------------
统计信息： # 以下结果也为DataFrame类型
A B C D
count 4.000000 4.000000 4.000000 4.000000 #包含的行数
mean 6.000000 7.000000 8.000000 9.000000 # 均值
std 5.163978 5.163978 5.163978 5.163978 # 标准差
min 0.000000 1.000000 2.000000 3.000000 # 最小值
25% 3.000000 4.000000 5.000000 6.000000 # 前25%中位数
50% 6.000000 7.000000 8.000000 9.000000 # 中位数
75% 9.000000 10.000000 11.000000 12.000000 # 前75%中位数
max 12.000000 13.000000 14.000000 15.000000 # 最大值
降序排序：
A B C D
d 12 13 14 15
c 8 9 10 11
b 4 5 6 7
a 0 1 2 3
4.3 取值操作
取值操作是pandas中的一个基本操作python基础教程，我们先生成一个100行3列的数据，用于下面操作：
import pandas as pd
import numpy as np
df = pd.DataFrame(np.arange(16).reshape(4,4),index=list("abcd"),columns=list("ABCD"))
print(df)
输出如下：
A B C D
a 0 1 2 3
b 4 5 6 7
c 8 9 10 11
d 12 13 14 15
pandas中有较多的取值方法数组词，但是最常用最好用的方法是以下两种，这里也将详细介绍这两种python怎么读方法：
-
df.loc[]: 通过标签索引python123平台登录获取行数据
-
df.iloc[]: 通过位置获取行数据
（1）先来看一下 df.loc[]:
print("取a行A列的数据：",df.loc["a","A"],"数据类型：",type(df.loc["a","A"])) print("取A B列的数据：n",df.loc[:,["A","B"]],"数据类型：",type(df.loc[:,["A","B"]]))
输出如下：
取a行A列的数据： 0 数据类型： <class 'numpy.int32'>
取A B列的数据：
A B
a 0 1
b 4 5
c 8 9
d 12 13 数据类型： <class 'pandas.core.frame.DataFrame'>
loc[]可以通过自定义的索引进行查找也可以通过位置索引进行查找数据分析是什么。值得注意的是，这里我们用到了 [ : ]，这里是前闭后闭的，即会选择冒号后面的数据。
（2）接着 来看一下df.iloc[]:
print("取前两行前两列：n",df.iloc[:2,:2])
输出：
取前两行前两列：
A B
a 0 1
b 4 5
（3）布尔索引
我们数据分析软件通过通常范围筛选数值，或通过判断进行筛选数值索引类型
print("选取df中数值大于7小于13的行：n",(df.loc[(df["B"]>7)&(df["B"]<13)]))
输出：
选取df中数值大于7小于13的行：
A B C D
c 8 9 10 11
这里选取多个条件时数据分析，需要用（）括起来。
4.4 改变数据类型
这里所谓的改变数据类型的结构就是对数据类型进行索引重排或增删 。主要操作如下：
（1） .reindex(index/columns):重排数据，通过改变数据的索引来对数据进行重新排序。索引失效 我们依旧拿上述的成绩单approach作为例子来进行讲解：
import pandas as pd
import numpy as np
a = {
"小明":pd.Series([100,99,91,90,85,69],index=["语文","数学","英语","物理","化学","生物"]),
"小红":pd.Series([100,93,92,100,65,93],index=["语文","数学","英语","物理","化学","生物"]),
"小蓝":pd.Series([100,94,93,70,55,92],index=["语文","数学","英语","物理","化学","生物"]),
"小黄":pd.Series([100,95,88,80,85,89],index=["语文","数学","英语","物理","化学","生物"]),
"小绿":pd.Series([100,92,78,89,75,79],index=["语文","数学","英语","物理","化学","生物"])}
b = pd.DataFrame(a)
print(b)
c = b.reindex(columns=["小红","小明","小蓝","小黄","小绿"])
print("对换小明和小红：n",c)
d = b.reindex(index=["数学","语文","英语","物理","化学","生物"])
print(d)
输入如下：
小明 小红 小蓝 小黄 小绿
语文 100 100 100 100 100
数学 99 93 94 95 92
英语 91 92 93 88 78
物理 90 100 70 80 89
化学 85 65 55 85 75
生物 69 93 92 89 79
对换小明和小红：
小红 小明 小蓝 小黄 小绿
语文 100 100 100 100 100
数学 93 99 94 95 92
英语 92 91 93 88 78
物理 100 90 70 80 89
化学 65 85 55 85 75
生物 93 69 92 89 79
对换数学和语文：
小明 小红 小蓝 小黄 小绿
数学 99 93 94 95 92
语文 100 100 100 100 100
英语 91 92 93 88 78
物理 90 100 70 80 89
化学 85 65 55 85 75
生物 69 93 92 89 79
可见，通过copython下载安装教程lumns调换了列数据，通过index调换了行数据。 下面补充一下.ind数组c语言ex()方法的其余参数：
- index,col数据分析是什么umns:新的行列自定义索引
- fill_value：重新索引中，用于填充缺失位置（NaN）的值
- limit： 最appearance大填充量
- method：填充方法 ffill向前填充，bfill向后填充
- copy：默认True，生成新的对象
(2)另外，索引的优缺点对于缺失值还有另一种处理方法:
-
pd.isnull(df): 是否为空值，空值标为True
-
pd.isnotnul数组去重l(df)：是否为非空值，非空值标为True
-
df.dropna(axis=0/1,how=”all/any”,inplace=True/False)： 删除nan所在的行/列
-
df.fiullan(n):将空值填充为n
import pandas as pd import numpy as np df = pd.DataFrame(np.arange(16).reshape(4,4),columns=list("ABCD")) df.loc[3,"C"] = None df.loc[2,"C"] = None print(df) print(df.isnull()) print(df.notnull()) print(df.dropna(axis=0,inplace=False)) print(df.fillna(df.mean()))
输出为：
A B C D
0 0 1 2.0 3
1 4 5 6.0 7
2 8 9 NaN 11
3 12 13 NaN 15
A B C D
0 False False False False
1 False False False False
2 False False True False
3 False False True False
A B C D
0 True True True True
1 True True True True
2 True True False True
3 True True False True
A B C D
0 0 1 2.0 3
1 4 5 6.0 7
A B C D
0 0 1 2.0 3
1 4 5 6.0 7
2 8 9 4.0 11
3 12 13 4.0 15
4.5 索引操作
对于索引，也有下常用的方法：
- .append()连接另一个index对python语言象，产生新的index对象
- .diff(id数组公式x):计算数据分析是什么差集，产生新的in数组的定义dex对象
- intersection(idx):计算交集appetite
- union（idx）：吉数组和链表的区别计算并集
- delete(loc): 删除loc位置处的元素
- insert(loc,c):在python语言loc位置增加一个元素c
4.6 删除指定索引对象
.drop()可数组的定义以删除series和DataFrame指定的行或列索引。
import pandas as pd
a = pd.Series([4,5,6,7],index=["a","b","c","d"])
print(a)
b = a.drop(["b","d"])
print(b)
输出如下：
a 4
b 5
c 6
d 7
dtype: int64
a 4
c 6
dtype: int64
对于DataFrame对象，.drop()默认操作0轴上的对象，当我们要操作1数据分析方法轴上的对象时，需要添加参数指定是1轴：axis数据分析观念=1。
5. pandas库的数据类型运算
5.1 算数运算
pandas的数据类型在进行算数运算时，根据行列索引，补齐后运算，即只有当索引相同时才进行运算，不同索引之间不进行运算而是补齐NaN。默认结果为浮点型。不同维度的数据类型之间的python123平台登录运算采用广播运算，即对应索引之间进行运算。 我们先来看一下相同维度的运算：
import pandas as pd
import numpy as np
a = np.arange(10).reshape(2,5)
b = np.arange(15).reshape(3,5)
a = pd.DataFrame(a)
b = pd.DataFrame(b)
print(a)
print(b)
print(a*b)
输出如下：
0 1 2 3 4
0 0 1 2 3 4
1 5 6 7 8 9
0 1 2 3 4
0 0 1 2 3 4
1 5 6 7 8 9
2 10 11 12 13 14
0 1 2 3 4
0 0.0 1.0 4.0 9.0 16.0
1 25.0 36.0 49.0 64.0 81.0
2 NaN NaN NaN NaN NaN
不同维度的运算如下：
import pandas as pd
import numpy as np
a = pd.Series([1,2,3,4,5])
b = np.arange(10).reshape(2,5)
b = pd.DataFrame(b)
print(a)
print(b)
print("________")
c = b-a
print(c)
我们生成一个一维series对象a，一个二DataFrame对象b,然后用b-a，得到的结果如下：
0 1
1 2
2 3
3 4
4 5
dtype: int64
0 1 2 3 4
0 0 1 2 3 4
1 5 6 7 8 9
________
0 1 2 3 4
0 -1 -1 -1 -1 -1
1 4 4 4 4 4
观察结果可以发现，b中的1轴都减去了a，即b中的每一行都对应减去了a中的元素。所以，对于不同维度的数据类型运算来说，默认的是高纬度的对series进行1轴运算。
5.2 比较运算
比较运算只能数组词比较相同索appointment引的元素，需要注意的是这里不进行补齐。二维和一维，一维和零维之间为广播运算，结果产生由布尔值组成的对象。
相同纬度：
import pandas as pd
import numpy as np
a = np.arange(16).reshape(4,4)
a = pd.DataFrame(a)
b = np.arange(4,20).reshape(4,4)
b = pd.DataFrame(b)
print(a,"n")
print(b,"n")
print(a == b)
输出如下：
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
3 12 13 14 15
0 1 2 3
0 4 5 6 7
1 8 9 10 11
2 12 13 14 15
3 16 17 18 19
0 1 2 3
0 False False False False
1 False False False False
2 False False False False
3 False False False False
相同维度进行比较时，要求两个数据的尺数组指针寸必须相同，否则会报错。那索引失效么不同维度的相比较会是怎样数据分析培训的结果呢？让我们来看一下：
import pandas as pd
import numpy as np
a = pd.Series([1,2,3,4])
b = np.arange(1,17).reshape(4,4)
b = pd.DataFrame(b)
print(a,"n")
print(b,"n")
print(a==b)
输出结果为：
0 1
1 2
2 3
3 4
dtype: int64
0 1 2 3
0 1 2 3 4
1 5 6 7 8
2 9 10 11 12
3 13 14 15 16
0 1 2 3
0 True True True True
1 False False False False
2 False False False False
3 False False False False
可以发现，不同维度相比较，进行广播运算，默认是1轴。 此外，数组去重方法除了直接利用运算符进行运算外，我们还可以利用函数进行运算。
- .add(d,**argws):加法
- .sub(d,**argws)：减法数组的定义
- .applemul(d,**argws)：乘法
- .div(d,**argws)：除法
通过这些函数我们不仅可以进行基本运算，application而且带有可选数据分析培训参数的它，为我们提供了更加强大的功能，如下：
import pandas as pd
import numpy as np
a = np.arange(16).reshape(4,4)
a = pd.DataFrame(a)
b = np.arange(20).reshape(5,4)
b = pd.DataFrame(b)
print(a)
print(b)
c = b.add(a,fill_value=100)
print(c)
输出如下：
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
3 12 13 14 15
0 1 2 3
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
3 12 13 14 15
4 16 17 18 19
0 1 2 3
0 0.0 2.0 4.0 6.0
1 8.0 10.0 12.0 14.0
2 16.0 18.0 20.0 22.0
3 24.0 26.0 28.0 30.0
4 116.0 117.0 118.0 119.0
可以发application现，ab是相同维度，但是尺寸不同，按照上文中直接使用加法运算程序会报错。但是在这里，我们传入了一个参数，在进行先进行补齐操作，然后进行运appstore算。
6. pandas操作CSV
6.1 pand数组去重as读取CSV文件
我们先创建一个15行4列的a.csv文件，用于下列案例数组的定义之用：
import pandas as pd
import numpy as np
# 创建一个csv文件
a = np.arange(60).reshape(15,4)
a = pd.DataFrame(a,columns=("a","b","c","d"))
print(a,"n")
a.to_csv("./a.csv",index=False)
文件内容如索引失效下：
pd.read_csv()的常用参数如下：
- filepath_or_buffer：— str 文件路径，可以是本地路径，也可以是url路径
- sep:指定分隔符，默认”,”
- header: –int 指定列名:header=0为默认值，表示数据第一行为列名；header=None表示数据没有列名python编程(为0，1，2，3，4……)，原列名变为第0行数据。
如案例1：
"""案例1：filepath_or_buffer、sep、header的使用 """
def demo01():
print("=== header=0时（默认）表示数据第一行为列名===")
path = "data.csv"
df = pd.read_csv(path, sep=",", header=0)
print(df.head(), "n") # 默认输出前5行
print("===header=none时 列名变为第0行数据===")
# header = None时
df = pd.read_csv(path, sep=",", header=None)
print(df.head(), "n")
输出如appreciate下：
=== header=0时（默认）===
a b c d
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
3 12 13 14 15
4 16 17 18 19
===header=none时 ===
0 1 2 3
0 a b c d
1 0 1 2 3
2 4 5 6 7
3 8 9 10 11
4 12 13 14 15
- names: –list 指定列名，当文件含有列名数组长度时会覆盖
如案例2：
"""通过names参数重新指定列名"""
def demo02():
df = pd.read_csv(path, names=["A", "B", "C", "D"])
print("重新指定列名:")
print(df.head(), "n")
输出如下：
重新指定列名:
A B C D
0 a b c d
1 0 1 2 3
2 4 5 6 7
3 8 9 10 11
4 12 13 14 15
- encodinpython培训g：指定编码格式，默认为utf-8。常用户解决乱码问题和平台编码不同的问题。
- index_col:–str/list 指定索引,将表中的某一列数据指定为索引。可以是单列也可以是多列。
如案例3数据分析：
"""通过index_col参数指定索引"""
def demo03():
print("指定b列为索引:")
df = pd.read_csv(path, index_col="b")
print(df.head(), "n")
df.to_csv("text.csv")
print("指定ab两列为索引:")
df = pd.read_csv(path, index_col=["a", "b"])
print(df.head())
输出如下：
指定b列为索引:
a c d
b
1 0 2 3
5 4 6 7
9 8 10 11
13 12 14 15
17 16 18 19
指定ab两列为索引:
c d
a b
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
16 17 18 19
- usecols: –str/list 指定读取的列,默认读取全部列
- nrows：—索引下推int 仅读取前多少行（不包括此行）
- skiprows：–int 跳过指定行数，开始读取（包括此行），注意必要时要指定列名，否则根据header=0当前行会为列名
如案例4：
"""usecols、nrows、skiprows的使用"""
def demo04():
print("只读取bc列:")
df = pd.read_csv(path, usecols=("b", "c"))
print(df.head(), "n")
print("读取前6行:")
df = pd.read_csv(path, nrows=6)
print(df, "n")
print("从第6行开始读取:")
df = pd.read_csv(path, skiprows=6, names=list("abcd"))
print(df.head(), "n")
输出如下：
只读取bc列:
b c
0 1 2
1 5 6
2 9 10
3 13 14
4 17 18
读取前6行:
a b c d
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
3 12 13 14 15
4 16 17 18 19
5 20 21 22 23
从第6行开始读取:
a b c d
0 20 21 22 23
1 24 25 26 27
2 28 29 30 31
3 32 33 34 35
4 36 37 38 39
6.2 pandas保存CSV文件
通过pandas保存csv实质上是调用DataFrame对象的to_csv方法。接下来我们就主要介绍一下to_csv方法的常用approve参数。
-
path_or_buf: 保存路径 -
sep：分隔符，默认为, -
na_repapproach：替换空格。将空格替换为指定的值 -
float_format： 格式化数值如保留两位小数%.2f -
hpython编程eader： 是否保留列名，默认保留。值数组去重方法为0则不保留。 -
index：是否保留索引（布尔值），默认保留。
