导语:
随着人工智能的普及,越来越多人开始接触机器学习,而机器学习算法通常需要对数据进行预处理、特征工程和模型训练等操作，而NumPy和Pandas提供了强大的工具和函数，可以简化这些操作。机器学习的数据通常以NumPy数组或Pandas数据框的形式呈现，NumPy和Pandas是机器学习中常用的库，用于数据的处理、清洗、特征工程等操作，为机器学习算法的实现和应用提供了便捷和高效的工具。
一.Numpy
1.1 Numpy简介
NumPy（Numerical Python）是Python数据分析必不可少的第三方库
NumPy的出现一定程度上解决了Python运算性能不佳的问题，同时提供了更加精确的数据类型，使其具备了构造复杂数据类型的能力。Numpy本身是由C语言开发，是个很基础的扩展，NumPy被Python其它科学计算包作为基础包，NumPy重在数值计算，主要用于多维数组（矩阵）处理的库。用来存储和处理大型矩阵，比Python自身的嵌套列表结构要高效的多
1.2 Numpy属性
NumPy的数组类被称作ndarray，通常被称作数组。ndarray对象属性如下：
这里我们先创建了一个3行5列的数组,然后通过ndarray,获得了数组的一些属性
import numpy as np
a = np.arange(15).reshape(3, 5)
print('数组的维度:', a.shape)
print('数组轴的个数:', a.ndim)
print('数组的元素类型:', a.dtype)
print('数组总每个元素的字节大小:', a.itemsize)
print('数组元素的总个数:',a.size)
print('类型查询:',type(a))
# 创建一个数组
b=np.array([4,5,6])
print('数组b:',b)
print('数组b类型',type(b))
# -------------------------------运行结果-----------------------------------
数组的维度: (3, 5)
数组轴的个数: 2
数组的元素类型: int32
数组总每个元素的字节大小: 4
数组元素的总个数: 15
类型查询:
数组b: [4 5 6]
数组b类型
1.3 Numpy中创建矩阵ndarray的方法
Numpy中创建矩阵的方法有很多种,:
创建一维矩阵的方法有:通过array()直接创建,通过arange()方式创建;
创建二维矩阵的方法有:通过zeros() /ones()/empty()方式创建,通过mat()和matrix()方式创建,
创建随机数矩阵的方法有:random.rand(),random.randint()和random.uniform()这三种方法,
创建等比数列的方法为np.logspace(),创建等差数列的方法为np.linspace(),
实现代码如下:
import numpy as np
a = np.array([1, 2, 3])
print('a:', a)
b = np.zeros((3, 3))
print('b:', b)
c = np.ones((2, 3))
print('c:', c)
d = np.empty((2, 3))
print('d:', d)
e = np.arange(10, 20, 2) # 这里10是起步参数,20是终止参数,且包前不包后,2是步长
print('e:', e)
f = np.mat('1 2;3 4')
print('f:', f)
g = np.matrix('5 6;7 8')
print('g:', g)
h = np.random.rand(3, 4) #random.rand(3,4)的意思是生成一个0-1的3行4列矩阵
print('h:', h)
i = np.random.randint(-1, 5, size=(3, 4)) # random.randint(-1,5,size=(3,4))的意思是生成一个-1-5的3行4列整数矩阵
print('i:', i)
j = np.random.uniform(-1, 5, size=(3, 4)) # random.uniform(-1,5,size=(3,4))的意思是生成一个-1-5的3行4列浮点数矩阵
print('j', j)
k = np.logspace(1, 9, 9, base=2)
# logspace(1,9,9,base=2)的意思是,一维矩阵第一个数是2的1次幂,最后一个数是2的9次幂,一维矩阵一共有9个数
#矩阵中的数两两之间都是等比的
print('k:', k)
l=np.linspace(1,9,3)
# linspace(1,9,3)的意思是一维矩阵的第一个数是1,最后一个数是9,一维矩阵中一共有3个数,
#矩阵中的数两两之间都是等差的
print('l:',l)
a: [1 2 3]
b: [[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
c: [[1. 1. 1.]
[1. 1. 1.]]
d: [[1. 1. 1.]
[1. 1. 1.]]
e: [10 12 14 16 18]
f: [[1 2]
[3 4]]
g: [[5 6]
[7 8]]
h: [[0.19904864 0.13460017 0.30577181 0.48653778]
[0.16910918 0.89322476 0.99818593 0.22763371]
[0.3554963 0.09866053 0.79378095 0.09418235]]
i: [[-1 4 3 0]
[-1 0 4 2]
[-1 1 -1 0]]
j [[ 4.94195639 0.73269461 2.65636449 3.61839477]
[-0.53709465 0.79258678 -0.72499458 3.87578745]
[ 0.37288844 4.06036813 3.91141886 -0.47682978]]
k: [ 2. 4. 8. 16. 32. 64. 128. 256. 512.]
l: [1. 5. 9.]
1.4 Numpy的内置函数
1.41 基本函数:
np.ceil(): 向上最接近的整数，参数是 number 或 array
np.floor(): 向下最接近的整数，参数是 number 或 array
np.rint(): 四舍五入，参数是 number 或 array
np.isnan(): 判断元素是否为 NaN(Not a Number)，参数是 number 或 array
np.multiply(): 元素相乘，参数是 number 或 array
np.divide(): 元素相除，参数是 number 或 array
np.abs()：元素的绝对值，参数是 number 或 array
np.where(condition, x, y): 三元运算符，x if condition else y
代码如下:
import numpy as np
arr=np.random.randn(2,3)
print(arr)
print('ceil:',np.ceil(arr))
print('floor:',np.floor(arr))
print('rint:',np.rint(arr))
print('isnan:',np.isnan(arr))
print('multiply:',np.multiply(arr,arr))
print('divide:',np.divide(arr,arr))
print('abs:',np.abs(arr))
print('where:',np.where(arr>0,1,-1))
[[-0.03682608 0.5946285 0.05805796]
[ 0.2122641 -0.06633258 1.01911833]]
ceil: [[-0. 1. 1.]
[ 1. -0. 2.]]
floor: [[-1. 0. 0.]
[ 0. -1. 1.]]
rint: [[-0. 1. 0.]
[ 0. -0. 1.]]
isnan: [[False False False]
[False False False]]
multiply: [[0.00135616 0.35358305 0.00337073]
[0.04505605 0.00440001 1.03860217]]
divide: [[1. 1. 1.]
[1. 1. 1.]]
abs: [[0.03682608 0.5946285 0.05805796]
[0.2122641 0.06633258 1.01911833]]
where: [[-1 1 1]
[ 1 -1 1]]
1.42 统计函数
np.mean(), np.sum()：所有元素的平均值，所有元素的和，参数是 number 或 array
np.max(), np.min()：所有元素的最大值，所有元素的最小值，参数是 number 或 array
np.std(), np.var()：所有元素的标准差，所有元素的方差，参数是 number 或 array
np.argmax(), np.argmin()：最大值的下标索引值，最小值的下标索引值，参数是 number 或 array
np.cumsum(), np.cumprod()：返回一个一维数组，每个元素都是之前所有元素的 累加和 和 累乘积，参数是 number 或 array
多维数组默认统计全部维度，axis参数可以按指定轴心统计，值为0则按列统计，值为1则按行统计。
代码如下:
import numpy as np
arr = np.arange(12).reshape(3, 4)
print('arr:\n', arr)
print('cumsum:\n', np.cumsum(arr)) #返回一个一维数组,每个元素都是之前所有元素的累加和
print('sum:\n', np.sum(arr)) # 所有元素的和
print('sum(arr,axis=0):\n', np.sum(arr, axis=0)) # 数组的按列统计和
print('sum(arr,axis=1):\n', np.sum(arr, axis=1)) # 数组的按行统计和
arr:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
cumsum:
[ 0 1 3 6 10 15 21 28 36 45 55 66]
sum:
66
sum(arr,axis=0):
[12 15 18 21]
sum(arr,axis=1):
[ 6 22 38]
1.43 比较函数、去重函数、排序函数
假如我们想要知道矩阵a和矩阵b中所有对应元素是否相等，我们需要使用all方法，假如我们想要知道矩阵a和矩阵b中对应元素是否有一个相等，我们需要使用any方法。
np.any(): 至少有一个元素满足指定条件，返回True
np.all(): 所有的元素满足指定条件，返回True
np.unique():找到唯一值并返回排序结果，类似于Python的set集合
np.sort():对数组元素进行排序
代码如下:
import numpy as np
# 比较函数
arr = np.random.randn(2, 3)
print('arr:\n', arr)
print('np.any(arr>0):\n', np.any(arr > 0))
print('np.all(arr>0):\n', np.all(arr > 0))
# 去重函数
arr = np.array([[1, 2, 1], [2, 3, 4]])
print('arr:\n', arr)
print('unique(arr):\n', np.unique(arr))
# 排序函数
arr = np.array([1, 2, 43, 5])
print('arr:\n', arr)
print('np.sort(arr):\n', np.sort(arr))
arr.sort()
print('arr.sort():\n', arr)
arr:
[[-1.12424333 0.58601603 -1.02848931]
[-1.63602081 -0.61012182 -1.32713442]]
np.any(arr>0):
True
np.all(arr>0):
False
arr:
[[1 2 1]
[2 3 4]]
unique(arr):
[1 2 3 4]
arr:
[ 1 2 43 5]
np.sort(arr):
[ 1 2 5 43]
arr.sort():
[ 1 2 5 43]
1.44 矩阵基本运算
矩阵的算数运算是按照元素的。新的矩阵被创建并且被结果填充。代码如下:
import numpy as np
a=np.array([20,30,40,50])
b=np.arange(4)
c=a-b
print('数组a:\n',a)
print('数组b:\n',b)
print('数组c:\n',c)
数组a:
[20 30 40 50]
数组b:
[0 1 2 3]
数组c:
[20 29 38 47]
1.45 矩阵乘法运算
矩阵乘法的规则如图所示,看不明白的同学可以去复习一下<<线性代数>>:
这里需要注意的是: a和b都是矩阵,a*b和a.dot(b)的区别
a*b 和 a.dot(b) 是在 NumPy 中对矩阵乘法运算的不同表示方式。
a*b表示逐元素的乘法运算，即对应位置元素相乘形成新的矩阵。两个矩阵的形状必须相同才能进行逐元素乘法运算。这种乘法运算也称为哈达玛积（Hadamard product）。如下图所示:
代码如下:
# a*b 哈达玛积
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([[1, 2, 3], [4, 5, 6]])
c = a * b
d = np.multiply(a, b)
print('数组a:\n', a)
print('数组b:\n', b)
print('数组c=a*b:\n', c)
print('数组d=np.multiply(a,b):\n', d)
数组a:
[[1 2 3]
[4 5 6]]
数组b:
[[1 2 3]
[4 5 6]]
数组c=a*b:
[[ 1 4 9]
[16 25 36]]
数组d=np.multiply(a,b):
[[ 1 4 9]
[16 25 36]]
a.dot(b) 表示矩阵的点积运算，即按照矩阵乘法规则进行运算。对于矩阵乘法运算，要求被乘矩阵的列数与乘矩阵的行数相同。点积运算会对两个矩阵进行正确的矩阵乘法运算，生成一个新的矩阵。如下图所示:
代码如下:
# a.dot(b) 点积
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([[6, 23], [-1, 7], [8, 9]])
c=a.dot(b)
d=np.dot(a,b)
print('数组a:\n', a)
print('数组b:\n', b)
print('数组c=a.dot(b):\n', c)
print('数组d=np.dot(a,b):\n', d)
数组a:
[[1 2 3]
[4 5 6]]
数组b:
[[ 6 23]
[-1 7]
[ 8 9]]
数组c=a.dot(b):
[[ 28 64]
[ 67 181]]
数组d=np.dot(a,b):
[[ 28 64]
[ 67 181]]
二.Pandas 数据结构
2.1 Pandas简介
Pandas是建立在NumPy之上的强大数据分析工具，提供了丰富的数据结构和灵活的数据处理功能，使数据清洗、整理和分析变得轻松简单。Pandas与机器学习密切相关，可在数据预处理、特征工程和数据清洗方面提供便利，同时与NumPy紧密集成，为处理大规模数据提供高效灵活的解决方案。其无缝整合NumPy和Matplotlib等工具，使Python成为强大的数据分析利器，并为机器学习模型的训练和评估提供重要支持，使数据转换和准备工作更高效便捷。而Series和DataFrame是Pandas中最基本的两种数据结构。
2.2 Series 和 DataFrame的创建
在Pandas中，Series是一维容器，Series表示DataFrame的每一列,可以把DataFrame看作由Series对象组成的字典，其中key是列名，值是Series,Series和Python中的列表非常相似。
创建Series的最简单方法是传入一个Python列表:
import pandas as pd
s=pd.Series(['banana',42])
print(s)
0 banana
1 42
dtype: object
也可以通过index参数来指定行索引,如果不指定,就如上面那个代码所示,默认用阿拉伯数字从0开始表示索引:
import pandas as pd
s=pd.Series(['banana',42],index=['kind','quantity'])
print(s)
kind banana
quantity 42
dtype: object
而DataFrame通常可以用字典来创建:
import pandas as pd
name_list = pd.DataFrame(
{'Name': ['Tom', 'Bob'],
'Occupation': ['Teacher', 'IT Engineer'],
'age': [28, 36]
}
)
print(name_list)
Name Occupation age
0 Tom Teacher 28
1 Bob IT Engineer 36
在创建DataFrame的时候还可以指定列的顺序和行索引,代码如下:
import pandas as pd
name_list = pd.DataFrame(
{'Occupation': ['Teacher', 'IT Engineer'],
'Age': [28, 36]
},
columns=['Age','Occupation'],index=['Tom','Bob']
)
print(name_list)
Age Occupation
Tom 28 Teacher
Bob 36 IT Engineer
2.3 Series的常用属性
可以使用DataFrame的loc属性获取数聚集的第一行,就会得到一个Series对象
可以通过index和values属性获取行索引和值,
代码如下:
import pandas as pd
name_list = pd.DataFrame(
{'Occupation': ['Teacher', 'IT Engineer'],
'Age': [28, 36],
'Name':['Tom','Bob']
},
columns=['Name','Age','Occupation']
)
print('name_list:\n',name_list)
print()
first_row=name_list.loc[1]
print('type(name_list):\n',type(name_list))
print()
print('type(first_row):\n',type(first_row))
print()
print('first_row:\n',first_row)
print()
print('first_row.index:\n',first_row.index)
print()
print('first_row.values:\n',first_row.values)
name_list:
Name Age Occupation
0 Tom 28 Teacher
1 Bob 36 IT Engineer
type(name_list):
type(first_row):
first_row:
Name Bob
Age 36
Occupation IT Engineer
Name: 1, dtype: object
first_row.index:
Index(['Name', 'Age', 'Occupation'], dtype='object')
first_row.values:
['Bob' 36 'IT Engineer']
2.3 Series的常用方法
对于数值型的Series，可以进行常见计算,计算平均值mean(),计算最大值max(),计算最小值min(),计算标准差std(),计算方差var(),这里标准差是方差的开根号,代码如下:
import pandas as pd
data=pd.Series([1,3,5,7,9])
print('数据:\n',data)
print('平均数:\n',data.mean())
print('最大值:\n',data.max())
print('最小值:\n',data.min())
print('标准差:\n',data.std())
print('方差:\n',data.var())
数据:
0 1
1 3
2 5
3 7
4 9
dtype: int64
平均数:
5.0
最大值:
9
最小值:
1
标准差:
3.1622776601683795
方差:
10.0
Series的value_counts()方法，可以返回不同值的条目数量,count()方法可以返回有多少非空值,通过describe()方法可以打印描述信息,描述性统计信息里通常会包括以下统计量：
Count（非空值的数量）Mean（均值）Standard Deviation（标准差）Minimum（最小值）25th Percentile（第 25 百分位数）Median（中位数）75th Percentile（第 75 百分位数）Maximum（最大值）
举例代码如下:
import pandas as pd
# value_counts()
data = pd.Series(['北京', '上海', '北京', '广州', '上海', '深圳', '北京', '上海'])
city_counts = data.value_counts()
print(city_counts)
print()
北京 3
上海 3
广州 1
深圳 1
dtype: int64
import pandas as pd
# count()
data = pd.Series([1, 2, None, 4, 5])
count_result = data.count()
print('非空元素数量为:\n',count_result)
4
import pandas as pd
# describe()
data = pd.Series([1, 2, 2, 3, 3, 3, 4])
describe_result = data.describe()
print(describe_result)
count 7.000000
mean 2.571429
std 0.975900
min 1.000000
25% 2.000000
50% 3.000000
75% 3.000000
max 4.000000
dtype: float64
Series也有一些其他的方法如图所示:
2.4 Series的布尔索引
从Series中获取满足某些条件的数据，可以使用布尔索引:
import pandas as pd
data = pd.Series([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) # 创建一个包含整数的 Series 对象 data
print('data:\n', data) # 输出 data 的值
print()
print('[data>5]:\n', [data > 5]) # 输出条件表达式 data>5 对应的布尔 Series
print()
# 获取大于5的值
result = data[data > 5] # 使用布尔索引，获取 Series 中大于5的值，并赋值给 result
print('result:\n', result) # 输出 result 的值
data:
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
dtype: int64
[data>5]:
[0 False
1 False
2 False
3 False
4 False
5 True
6 True
7 True
8 True
9 True
dtype: bool]
result:
5 6
6 7
7 8
8 9
9 10
dtype: int64
2.5 Series的运算
Series和数值型遍历进行计算时,变量会与Series中的每个元素逐一进行计算,元素个数不同的Series之间进行计算,会根据索引进行计算,缺失的位置会用NaN填充,代码如下:
import pandas as pd
data = pd.Series([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) # 创建一个包含整数的 Series 对象 data
print('data:\n', data) # 输出 data 的值
print()
print('data+data:\n',data+data)
a=pd.Series([1,100])
print()
print('a:\n',a)
print(data+a)
print()
print('data+a:\n',data+a)
data:
0 1
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
dtype: int64
data+data:
0 2
1 4
2 6
3 8
4 10
5 12
6 14
7 16
8 18
9 20
dtype: int64
a:
0 1
1 100
dtype: int64
0 2.0
1 102.0
2 NaN
3 NaN
4 NaN
5 NaN
6 NaN
7 NaN
8 NaN
9 NaN
dtype: float64
data+a:
0 2.0
1 102.0
2 NaN
3 NaN
4 NaN
5 NaN
6 NaN
7 NaN
8 NaN
9 NaN
dtype: float64
2.6 DataFrame的常用属性和方法
DataFrame是Pandas中最常见的对象,Series数据结构的很多属性和方法在DataFrame中也一样适用。
import pandas as pd
data = pd.DataFrame(
{'Name': ['Tom', 'Bob'],
'Occupation': ['Teacher', 'IT Engineer'],
'age': [28, 36]
}
)
print('data:\n',data) # 打印整个 DataFrame 对象
print('type(data):\n',type(data)) # 打印 data 的类型
print('data.shape:\n',data.shape) # 打印 data 的形状
print('data.size:\n',data.size) # 打印 data 的元素数量
print('data.ndim:\n',data.ndim) # 打印 data 的维度数量
print('len(data):\n',len(data)) # 打印 data 的长度（行数）
print('data.count():\n',data.count()) # 打印每列非缺失值的数量
data:
Name Occupation age
0 Tom Teacher 28
1 Bob IT Engineer 36
type(data):
data.shape:
(2, 3)
data.size:
6
data.ndim:
2
len(data):
2
data.count():
Name 2
Occupation 2
age 2
dtype: int64
2.7 DataFrame的布尔索引
同Series一样,DataFrame也可以使用布尔索引获取数据子集,示例代码如下:
import pandas as pd
data = pd.DataFrame(
{'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]
}
)
print('data:\n',data)
print()
print('布尔索引为:\n',[data['B']>4])
print()
print('数据子集为:\n',data[data['B']>4])
data:
A B C
0 1 4 7
1 2 5 8
2 3 6 9
布尔索引为:
[0 False
1 True
2 True
Name: B, dtype: bool]
数据子集为:
A B C
1 2 5 8
2 3 6 9
2.8 DataFrame的运算
与Series类似,当DataFrame和数值进行运算时,DataFrame中的每一个元素会分别和数值进行运算,当两个DataFrame之间进行计算时,会根据索引进行对应计算,两个DataFrame数据条目数不同时,会根据索引进行计算,索引不匹配的会返回NaN,代码如下:
import pandas as pd
data1 = pd.DataFrame({
'A': [1, 2, 3], 'B': [4, 5, 6]
})
data2 = pd.DataFrame({
'A': [1, 2, 3, 4], 'B': [4, 5, 6, 7]
})
print("data1 :\n",data1)
print()
print("data2 :\n",data2)
print()
# 和数值进行运算
result1=data1+10
print("data1 + 10:\n", result1)
print()
# 两个DataFrame之间进行计算
result2 = data1 + data2
print("data1 + data2:\n", result2)
data1 :
A B
0 1 4
1 2 5
2 3 6
data2 :
A B
0 1 4
1 2 5
2 3 6
3 4 7
data1 + 10:
A B
0 11 14
1 12 15
2 13 16
data1 + data2:
A B
0 2.0 8.0
1 4.0 10.0
2 6.0 12.0
3 NaN NaN
在上述代码中，由于存在不匹配的列名和索引，结果 DataFrame 的数据类型会变为浮点数。因此，当两个 DataFrame 进行加法运算时，如果存在列名或索引不匹配的情况，会导致数据类型的变化。如果想保持整数数据类型，需要确保两个 DataFrame 的列名和索引完全匹配。
2.9 给索引命名
在加载数据文件时,如果不指定行索引,Pandas会自动加上从0开始的索引,可以通过index_col参数,指定使用某一列数据作为行索引,如pd.read_csv('a.csv',index_col='movie_title'),也可以通过reset_index()的方法重置索引,还可以通过rename()的方法对原有的行索引和列名进行修改,
示例代码如下:
import pandas as pd
data1 = pd.DataFrame({
'A': [1, 2, 3], 'B': [4, 5, 6]
})
print("修改列名前的data1 :\n",data1)
print()
data1.rename(columns={'A':'SSS'},inplace=True)
print("把列名A改为SSS之后的data1 :\n",data1)
print()
data1.rename(index={1:999},inplace=True)
print("把索引2改为999之后的data1 :\n",data1)
修改列名前的data1 :
A B
0 1 4
1 2 5
2 3 6
把列名A改为SSS之后的data1 :
SSS B
0 1 4
1 2 5
2 3 6
把索引2改为999之后的data1 :
SSS B
0 1 4
999 2 5
2 3 6
2.10 添加、删除和插入列
pandas中可以通过dataframe[列名]的方式添加新列,也可以用drop的方法删除列,可以用insert的方法插入列,示例代码如下:
import pandas as pd
data1 = pd.DataFrame({
'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [88, 99, 77]
})
print("初始data1 :\n", data1)
print()
data1['D'] = [0, 9, 8]
print("添加D列之后的data1 :\n", data1)
print()
data1.drop(columns=['B'], inplace=True)
print("删除B列之后的data1 :\n", data1)
print()
data1.insert(loc=1, column='F', value=[32, 43, 31])
print('插入F列之后的data1:\n', data1)
初始data1 :
A B C
0 1 4 88
1 2 5 99
2 3 6 77
添加D列之后的data1 :
A B C D
0 1 4 88 0
1 2 5 99 9
2 3 6 77 8
删除B列之后的data1 :
A C D
0 1 88 0
1 2 99 9
2 3 77 8
插入F列之后的data1:
A F C D
0 1 32 88 0
1 2 43 99 9
2 3 31 77 8
2.11 导入和导出数据
如要保存的对象是计算的中间结果，或者保存的对象以后会在Python中复用，可把对象保存为.pickle文件,如果保存成pickle文件，只能在python中使用,文件的扩展名可以是.p，.pkl，.pickle
import pandas as pd
data = pd.read_csv('data/a.csv')
names = data['Name']
names.to_pickle('output/names.pickle')
data.to_pickle('output/data.pickle')
也可以使用csv文件,CSV(逗号分隔值)是很灵活的一种数据存储格式,在CSV文件中，对于每一行，各列采用逗号分隔,除了逗号，还可以使用其他类型的分隔符，比如TSV文件，使用制表符作为分隔符,CSV是数据协作和共享的首选格式
也可以保存为Excel文件,但是Series不支持to_excel方法,如果想保存Excel文件,需要把Series转换为DataFrame。
三.总结
Pandas和Numpy的基本用法本篇博客已经详细的聊过了,Pandas和Numpy是机器学习的基础,同学们需要仔细学习,打好基础,下一篇博客,我们来聊Pandas的进阶部分,包括Pandas的DataFrame部分和数据分析部分等。
参考链接
您阅读本篇文章共花了：
发表评论