Numpy和Pandas学习笔记

记录学习的内容，方便今后查阅

Numpy

Numpy的安装

​ 直接使用pip3 install numpy即可，可以在终端使用python3 -c "import numpy"判断是否安装成功，如果在终端里直接输入这个语句没有任何反应，那么说明numpy是安装成功可以使用了的

Numpy array 和 Python的List的差别

Numpy array的定义

import numpy as np
#定义numpy array
np.array([1,2,3])

List 和 Numpy array 共同点

  • 它们都可以用来存储、提取以及修改
import numpy as np
my_list = [1,2,3]
my_array = np.array([1,2,3])
print(my_list[0])
print(my_array[0])
#都可以正常打印噢
my_list[0] = -1
my_array[0] = -1
print(my_list)
print(my_array)

Numpy array的优势何在？

​ Numpy的运算速度快，numpy array在内存中使用连续地址，并不像List使用不连续的地址块，因此速度上就有差异，而且Numpy对于批量数据的存储的数据格式也更有效率

总结

​ Numpy Array 和 Python List 在很多使用场景上是可以互换的，不过在大数据处理的场景下，而且你的数据类型又高度统一， 那么 Numpy 绝对是你不二的人选，能提升的运算速度也是杠杠的~

Numpy的基本操作

Numpy中的维度

​ Numpy在多维数据的计算上速度很快！！！我们来学一下怎么用numpy创建并处理多维数据

创建多维数据
import numpy as np
#创建一维
cars = np.array([5,10,2,6])
print("数据：",cars,"维度：",cars.ndim)
#创建二维
cars = np.array([
  [5,10,12,6],
  [5.1,8.2,11,6.3],
  [4.4,9.1,10,6.6]
])
print("数据：",cars,"维度：",cars.ndim)
#创建三维
cars = np.array([
  [
    [5,10,12,6],
    [5.1,8.2,11,6.3],
    [4.4,9.1,10,6.6]
  ],[
    [6,11,13,7],
    [6.1,9.2,12,7.3],
    [5.4,10.1,11,7.6]
  ]
])
print("数据：",cars,"维度：",cars.ndim)
print("场地1 数据：\n",cars[0],"\n场地1 维度:"，cars[0].ndim)
print("场地2 数据：\n",cars[1],"\n场地2 维度:"，cars[1].ndim)
添加数据
  • 把两个一维数组变成一个二维数组
cars1 = np.array([5,10,12,6])
cars2 = np.array([5.2,4.2])
cars = np.concatenate([cars1,cars2])
#concatenate的意思是连接
print(cars)
  • 数据换成二维数组之后想要添加数据
test1 = np.array([5, 10, 12, 6])
test2 = np.array([5.1, 8.2, 11, 6.3])

# 首先需要把它们都变成二维，下面这两种方法都可以加维度
test1 = np.expand_dims(test1, 0)
test2 = test2[np.newaxis, :]

print("test1加维度后 ", test1)
print("test2加维度后 ", test2)

# 然后再在第一个维度上叠加
all_tests = np.concatenate([test1, test2])
print("括展后\n", all_tests)

运行结果：

test1加维度后  [[ 5 10 12  6]]
test2加维度后  [[ 5.1  8.2 11.   6.3]]
括展后
 [[ 5.  10.  12.   6. ]
 [ 5.1  8.2 11.   6.3]]
合并数据
  • 只要维度能够对齐，你可以在任意维度上进行合并操作
print("第一维度叠加：\n", np.concatenate([all_tests, all_tests], axis=0))
print("第二维度叠加：\n", np.concatenate([all_tests, all_tests], axis=1))

​ 运行结果：

第一维度叠加：
 [[ 5.  10.  12.   6. ]
 [ 5.1  8.2 11.   6.3]
 [ 5.  10.  12.   6. ]
 [ 5.1  8.2 11.   6.3]]
第二维度叠加：
 [[ 5.  10.  12.   6.   5.  10.  12.   6. ]
 [ 5.1  8.2 11.   6.3  5.1  8.2 11.   6.3]]

​ 看来axis为0的时候，就是把二维数组和二维数组直接合并，而axis为1的时候就是把相对应的数据合并成一个数组，两个数组的原有位置关系不变

  • 转载一个好的理解axis方法：axis这个参数实际上就是表示的你要修改哪一维度的数据。举个栗子：
    有两组数据，它们的维度都是（2，3），即都是两行三列的数据。有小伙伴可能会发愁，当这两组数据合并时，axis参数设为0到底是横向操作还是竖向操作，肯定有小伙伴要在这里思考一下，实际上不用这么麻烦哒~
    当axis设为0时，表示我们要修改第一个维度的数据，两组数据的第一个维度都是2，当它们合并时就变成了4，所以合并后的数据的维度就是（4，3），即变成了四行三列。通过这样子思考，就再也不用努力回想到底是横向合并还是竖向合并啦hh
    同理，axis设为1，合并后的数据维度就变成了（2，6），即两行六列~
    同理，axis参数在其他方法里也可以用同样的方法思考，比如求均值的mean方法，当axis设为0时，对第一个维度的数据进行求均值，维度为（2，3）的数据计算完后就变成了维度为（1，3）的数据，是不是很好理解~

​ 而且除了np.concatenate()之外，还有``np.vstack(), np.hstack().这两个方法在二维数组上可以将数据进行横向合并和纵向合并：

横向合并

纵向合并

a = np.array([
[1,2],
[3,4]
])
b = np.array([
[5,6],
[7,8]
])
print("竖直合并\n", np.vstack([a, b]))
print("水平合并\n", np.hstack([a, b]))

​ 运行结果

竖直合并
 [[1 2]
 [3 4]
 [5 6]
 [7 8]]
水平合并
 [[1 2 5 6]
 [3 4 7 8]]
观察形态

​ 除了 np.ndim 来查看数据的形态，其实我们有时候还想更加了解数据的细节问题，比如这个数据的大小，规格。方便我们管理这些数据。

  • 当我想知道到底有多少车辆测试数据时，你可能会通过遍历的方法来计数。
cars = np.array([
[5, 10, 12, 6],
[5.1, 8.2, 11, 6.3],
[4.4, 9.1, 10, 6.6]
])

count = 0
for i in range(len(cars)):
    for j in range(len(cars[i])):
        count += 1
print("总共多少测试数据：", count)

​ 但以下代码与上面代码等价：

print("总共多少测试数据：", cars.size)
  • 想知道数组有几行（第一维度）几列（第二维度）
cars = np.array([
[5, 10, 12, 6],
[5.1, 8.2, 11, 6.3],
[4.4, 9.1, 10, 6.6]
])
print("第一个维度：", cars.shape[0])
print("第二个维度：", cars.shape[1])
print("所有维度：", cars.shape)

​ 运行结果：

第一个维度： 3
第二个维度： 4
所有维度： (3, 4)

​ 要好好理解维度噢，这很重要

用numpy进行数据选择

​ 可以使用numpy进行对数据的选择，不管是批量划分，还是按条件筛选，都可以哦qwq

单个选取
  • array[1]
import numpy as np
a = np.array([1,2,3])
#一个一个选qwq！
print("a[0]:",a[0])
print("a[1]:",a[1])

array[1]

  • array[1,2,3]
#一次选择多个
print("a[[0,1]]:\n",a[[0,1]])
print("a[[1,1,0]]:\n",a[[1,1,0]])
  • array[1][1]
#对二维数组进行选择
b = np.array([
[1,2,3,4],
[5,6,7,8],
[9,10,11,12]
])

# 选第 2 行所有数
print("b[1]:\n", b[1])   

# 选第 2 行，第 1 列的数
print("b[1,0]:\n", b[1,0])   

# 这个看着有点纠结，如果对应到数据，
# 第一个拿的是数据位是 [1,2]
# 第二个拿的是 [0,3]
print("b[[1,0],[2,3]]:\n", 
b[[1,0],
[2,3]])

​ 总之，不管是几维数据，我们都可以在其不同维度上挑选那个维度上对应序号上的数值。而且还能一次从原数据上选取多个数据点。

切片划分
  • array[:3]
a = np.array([1, 2, 3])
print("a[0:2]：\n", a[0:2])
print("a[1:]：\n", a[1:])
print("a[-2:]：\n", a[-2:])
#使用 : 就能让你跨着取数字，而且一次取一批。注意，在 Numpy 中：一次取一批和一个个拎起来，拎了一批，是不同的概念哦 一次取一批来的更快， 因为它不用去一个个查看，一个个数了。

运行结果：

a[0:2]：
 [1 2]
a[1:]：
 [2 3]
a[-2:]：
 [2 3]

切片划分

  • array[2:4, 1:3]
#在多维上，也可以进行切片划分
b = np.array([
[1,2,3,4],
[5,6,7,8],
[9,10,11,12]
])

print("b[:2]:\n", b[:2])
print("b[:2, :3]:\n", b[:2, :3])
print("b[1:3, -2:]:\n", b[1:3, -2:])

运行结果：

b[:2]:
 [[1 2 3 4]
 [5 6 7 8]]
b[:2, :3]:
 [[1 2 3]
 [5 6 7]]
b[1:3, -2:]:
 [[ 7  8]
 [11 12]]
条件筛选
  • array[array<0]
a = np.array([
[1,2,3,4],
[5,6,7,8],
[9,10,11,12]
])

print(a[a>7])
#运行结果如下
#[ 8  9 10 11 12]
#a>7 的返回结果是布尔类型
condition = a > 7
print(condition)
print(a[condition])
#运行结果如下
#[[False False False False]
#[False False False  True]
#[ True  True  True  True]]
#[ 8  9 10 11 12]

​ 这种筛选的底层逻辑就是只要我们得到一种True和False数据，那么就可以进行筛选。

condition = (a > 7) & (a != 10)
print(a[condition])
#[ 8  9 11 12]
  • np.where(array, array < 0)

​ 除了这种直接用[]的形式，在 Numpy 中，还有一个专用的函数来做数据筛选。这种筛选更强大，它还能做筛选结果的替换工作。 它可已将满足条件的位置变成你设定的数字。下面满足条件的，都改成 -1，不满足的，都还是 a 里面的数字。

a = np.array([
[1,2,3,4],
[5,6,7,8],
[9,10,11,12]
])
condition = a > 7
print(np.where(condition, -1, a))
#[[ 1  2  3  4]
#[ 5  6  7 -1]
#[-1 -1 -1 -1]]

​ 或者将不满足条件的也变成你期望的数字或者另一组数据

a = np.array([
[1,2,3,4],
[5,6,7,8],
[9,10,11,12]
])
condition = a > 7
#满足的变成-1，不满足的变成2
print(np.where(condition,-1,2))
#[[ 2  2  2  2]
#[ 2  2  2 -1]
#[-1 -1 -1 -1]]
#定义b
b = -a - 1
print(np.where(condition,a,b))
#[[-2 -3 -4 -5]
#[-6 -7 -8  8]
#[ 9 10 11 12]]

​ 所以 np.where() 函数真的十分强大，每每当我想要按条件选择、替换数据的时候，我脑海中，都是 np.where() 的身影。

总结

​ 数据虽然有格式，但是如果要把数据用起来，还是得学会挑选和筛选。而今天介绍的单个、分段、条件筛选，都是数据工程师必备的一项技能。也是后续数据分析和机器学习的基石。

基础运算

加减乘除
  • 在Python的List中进行计算的常规步骤
l = [150,166,183,170]
#* 使用循环
for i in range(len(l))
    l[i] += 3
print(l)
#[153, 169, 186, 173]

#* 使用map函数
print(list(map(lambda x: x+3,[150,166,183,170])))
#[153, 169, 186, 173]
  • 使用numpy的方式进行计算 +-*/
import numpy as np
a = np.array([150,166,183,170])
print(a + 3)
#[153 169 186 173]

​ Numpy 是可以批量进行计算的，只需要简单的 +-*/，就能进行全元素的运算，也就是向量化运算。同理，我们也可以进行其他符号的批量运算。

print("a + 3:", a + 3)
print("a - 3:", a - 3)
print("a * 3:", a * 3)
print("a / 3:", a / 3)
#a + 3: [153 169 186 173]
#a - 3: [147 163 180 167]
#a * 3: [450 498 549 510]
#a / 3: [50.         55.33333333 61.         56.66666667]
  • 矩阵点积运算 np.dot()

a = np.array([
  [1,2],
  [3,4]
])
b = np.array([
  [5,6],
  [7,8]
])
print(a.dot(b))
print(np.dot(a,b))
#[[19 22]
#[43 50]]
#[[19 22]
#[43 50]]

​ 因此，我们可以得知，dot函数有两种写法，一种是a.dot(b)，另一种是np.dot(a,b)，矩阵还有很多其他的计算，比如 np.outer() 矩阵外积，np.inner() 矩阵内积 （和 np.dot() 的用法稍稍有些不同，你可以理解成 np.dot(a, b）= np.inner(a, b.T), 把 b 做一次转置）。

数据统计分析

​ 在数据分析时，大部分时间还是以pandas的使用为主，但是数据量比较大的时候，可以使用numpy，毕竟numpy的速度比Pandas要快上不少。

​ 数据分析的定义：在数据中找到你想要的一些变量，总结数据的规律。

  • np.max() np.min() np.sum() np.prod() np.count()
#对给定的身高数据，找最高的和最矮的
a = np.array([150,166,183,170])
print("max:",np.max(a))
print("min:",np.min(a))
#或者
print("max:",a.max())
print("min:",a.min())
#计算累加和
print(a.sum())
#计算累乘
print(a.prod())
#计算总共有几个值
print(a.size)
#计算一共有多少个非零值
a = np.arrat([0,1,2,3])
print("非零总数：",np.count_nonzero(a))
  • np.std() np.mean() np.median()
month_salary = [1.2, 20, 0.5, 0.3, 2.1]
print("标准差：", np.std(month_salary))
print("平均工资：", np.mean(month_salary))
print("工资中位数：", np.median(month_salary))
特殊运算符号
  • np.argmax() np.argmin()
a = np.array([150, 166, 183, 170])
name = ["小米", "OPPO", "Huawei", "诺基亚"]
#关心最大/最小数值的序号 使用argmax()/argmin()
high_idx = np.argmax(a)
low_idx = np.argmin(a)
print("{} 最高".format(name[high_idx]))
print("{} 最矮".format(name[low_idx]))
  • np.ceil() np.floor() np.clip()

​ 另外一个时不时会用到的功能是，取天花板的值还是地板的值，这个在 AI 算法中也比较常见， 比如我要对其做取整处理，抹除小数部分。

a = np.array([150.1, 166.4, 183.7, 170.8])
print("ceil:", np.ceil(a))
print("floor:", np.floor(a))

​ 可以用 np.clip() 来做上下界限的值截取

a = np.array([150.1, 166.4, 183.7, 170.8])
print("clip:", a.clip(160, 180))
总结

​ 其实 Numpy 中做数据运算的功能，比我这里列举的要多很多，我只是列举了一些我在数据分析和人工智能算法中，经常会使用到的一些功能。 还有更多的功能，可以在他的官方网站查找哦。

改变数据形态

​ 如何做数据的变换？

改变形态
  • array[np.newaxis, :]

​ 改变形态，其实是针对与多维度空间上的数据，要改变它的维度信息，和每个维度中的数据格式。所以第一点你就要清楚，如何添加维度。 其实在 多维数据教程中 中我们就提到过添加维度的方法，我这里在总结括展一下。

import numpy as np
a = np.array([1,2,3,4,5,6])
a_2d = a[np.newaxis, :]
print(a.shape, a_2d.shape)
#(6,) (1, 6)

​ 除了这种方式的其它几种，能达到同样效果的方式。比如用 None 或者 np.expand_dims()

a = np.array([1,2,3,4,5,6])
a_none = a[:, None]
a_expand = np.expand_dims(a, axis=1)
print(a_none.shape,a_expand.shape)
#(6, 1) (6, 1)

​ 除了添加维度，我们还能减少维度，但是下面介绍的减少维度，只能减少那些维度 shape 上为 1 的维度。因为减掉这个维度，数据结构上是没有变化的。

a_squeeze = np.squeeze(a_expand)
a_squeeze_axis = a_expand.squeeze(axis=1)
print(a_squeeze.shape)
print(a_squeeze_axis.shape)
#(6,)
#(6,)
  • array.reshape()

​ 上述方法都是添加维度的方式，但是，在机器学习中，我们还有一个更常见的操作，是要改变 shape。维度的添加减少，只能添加减少一个维度，数据结构是不变的。 但是 np.reshape() 可以改变数据结构。 举个例子，a[None, :] 之后，a.shape 会在第一个维度上多一个 1，而 a.reshape([2,3]) 则可以更加自定义的将维度内的个数进行修改。 从而达到改变维度及尺寸。

a = np.array([1,2,3,4,5,6])
a1 = a.reshape([2, 3])
a2 = a.reshape([3,1,2])
print("a1 shape:", a1.shape)
print(a1)
print("a2 shape:", a2.shape)
print(a2)

​ 运行结果

a1 shape: (2, 3)
[[1 2 3]
 [4 5 6]]
a2 shape: (3, 1, 2)
[[[1 2]]

 [[3 4]]

 [[5 6]]]
  • array.ravel(), array.flatten()

​ 其实还有更过的改变形态的方法，比如让数据变直、展平 的 np.ravel(), np.flatten()，这两个比较特殊， 我会在对速度有洁癖这节的时候详细说明。

  • array.transpose()

​ 在矩阵运算的时候，也有一种形态的转化，叫做矩阵转置，np.transpose(), 在机器学习中也用得很多。这里提一下， 给一个小案例，你们玩玩试试。

a = np.array([1,2,3,4,5,6]).reshape([2, 3])
aT1 = a.T
aT2 = np.transpose(a)

print(aT1)
print(aT2)

​ 运行结果

[[1 4]
 [2 5]
 [3 6]]
[[1 4]
 [2 5]
 [3 6]]
合并
  • np.column_stack(), np.row_stack()

​ 在介绍多维数组的时候， 我们也稍微介绍了一下如何添加和并数组。现在我们再详细把数组的合并拆解都细说一下。

​ 一般来说，在数据分析统计，机器学习中的数据，都是以二维来存储的。行是数据样本（第一维度），列是特征（第二维度）。 所以我们可以组合特征和组合样本。 比如将列column合并，特征 a 的数据和特征 b 的数据合并。

feature_a = np.array([1,2,3,4,5,6])
feature_b = np.array([11,22,33,44,55,66])
c_stack = np.column_stack([feature_a, feature_b])
print(c_stack)

​ 运行结果

[[ 1 11]
 [ 2 22]
 [ 3 33]
 [ 4 44]
 [ 5 55]
 [ 6 66]]

​ 一条条的数据 sample 和并。

sample_a = np.array([0, 1.1])
sample_b = np.array([1, 2.2])
c_stack = np.row_stack([sample_a, sample_b])
print(c_stack)

​ 运行结果

[[0.  1.1]
 [1.  2.2]]
  • np.vstack(), np.hstack(), np.stack()

​ 上面的两种方法 np.column_stack() 和 np.row_stack() 和后面的 np.vstack()、np.hstack() 相比， 有些特殊之处，我们先看看使用 vstack 和 hstack 的案例，再说说不同处吧。

feature_a = np.array([1,2,3,4,5,6])[:, None]
feature_b = np.array([11,22,33,44,55,66])[:, None]
c_stack = np.hstack([feature_a,feature_b])
print(c_stack)

sample_a = np.array([0,1.1])[None, :]
sample_b = np.array([1,2.2])[None, :]
c_stack = np.vstack([sample_a,sample_b])
print(c_stack)

​ 运行结果

[[ 1 11]
 [ 2 22]
 [ 3 33]
 [ 4 44]
 [ 5 55]
 [ 6 66]]
[[0.  1.1]
 [1.  2.2]]

​ 看到了吗？用 column_stack 和 row_stack() 的时候，Numpy 自动帮你处理的维度信息，而用 vstack 和 hstack 的时候，你需要先确保维度信息是正确的，然后再合并。

  • np.concatenate()

​ 有时候，你想要用统一的方法来处理各种不同情况的合并，np.concatenate() 是我最喜欢的方法，管它什么 vstack hstack 甚至是在更高维度上要合并， 我们都可以用 concatenate() 一个功能实现。

a = np.array([
[1,2],
[3,4]
])
b = np.array([
[5,6],
[7,8]
])

print(np.concatenate([a, b], axis=0))
print(np.concatenate([a, b], axis=1))

​ 运行结果

[[1 2]
 [3 4]
 [5 6]
 [7 8]]
[[1 2 5 6]
 [3 4 7 8]]
拆解
  • np.vsplit(), np.hsplit(), np.split()

​ 同样，能横着，竖着合并，那也能横着竖着拆解。np.vsplit() 和 np.hsplit() 就是干这事的。 如果直接在 indices_or_sections 后填入数字，就是要整分的段数， 而如果接着的是一个列表，那就按照列表中的 index 来取区间。可以看看下面代码注解中的意思。

a = np.array(
[[ 1, 11, 2, 22],
 [ 3, 33, 4, 44],
 [ 5, 55, 6, 66],
 [ 7, 77, 8, 88]]
)
print(np.vsplit(a, indices_or_sections=2))  # 分成两段
print(np.vsplit(a, indices_or_sections=[2,3]))  # 分片成 [:2]，[2:3], [3:]

​ 运行结果

[array([[ 1, 11,  2, 22],
       [ 3, 33,  4, 44]]), array([[ 5, 55,  6, 66],
       [ 7, 77,  8, 88]])]
[array([[ 1, 11,  2, 22],
       [ 3, 33,  4, 44]]), array([[ 5, 55,  6, 66]]), array([[ 7, 77,  8, 88]])]

​ np.vsplit 是拿着刀沿着横向切分，那么 np.hsplit 就是沿纵向切分，我就不再举例了。那么有没有既能横切也能纵切的函数呢？ 当然有呀，和 stack 一样，如果直接用 np.split() 你就能选择要切分的维度来自定义切分了。

a = np.array(
[[ 1, 11, 2, 22],
 [ 3, 33, 4, 44],
 [ 5, 55, 6, 66],
 [ 7, 77, 8, 88]]
)
print(np.split(a, indices_or_sections=2, axis=0))  # 分成两段
print(np.split(a, indices_or_sections=[2,3], axis=1))  # 在第二维度，分片成 [:2]，[2:3]，[3:]

​ 运行结果

[array([[ 1, 11,  2, 22],
       [ 3, 33,  4, 44]]), array([[ 5, 55,  6, 66],
       [ 7, 77,  8, 88]])]
[array([[ 1, 11],
       [ 3, 33],
       [ 5, 55],
       [ 7, 77]]), array([[2],
       [4],
       [6],
       [8]]), array([[22],
       [44],
       [66],
       [88]])]
总结

​ 形态变化和合并拆解都是十分有用的功能，我们介绍了很多种实用的方法来完成这些事， 而懂了这些之后，你的数据分析和机器学习才算是真正迈入入圈的第一步。

Pandas

Pandas简介&安装

为什么用Pandas

​ 进入大数据时代，感觉我们如果不会一些分析数据的能力，就将要被时代淘汰（明目张胆拉焦虑）。 不过好在现在的技术越来越好，越来越易用，而且网络上也有越来越多的教学内容。 只要你有一些耐心，入门其实并不难。

​ 现在我们将要步入新的阶段，对大数据做出新的定义，直面大数据带来的挑战，学会使用 Pandas 来处理你日常的表格/画图/数据分析等问题。

你正在面临的问题

​ 大数据虽然描述的是海量的数据，但是大数据离你却并不远，特别是大数据所涵盖的技术，在你生活当中，是时刻都能使用这些大数据涉及到的技术， 来解决你生活中的具体问题。

​ 是什么时候才会让我想要使用 Pandas 来处理问题呢？我下面列一条，说不定就有你正面临的问题：

  • 办公自动化
    • 上学上班，有 Excel 或者格式化的文本文件，需要进行数据加工处理
    • 对大量的这些文本文件作图，想要自动化处理
  • 人工智能
    • 数据分析，可视化数据规律
    • 数据前处理，为 AI 模型展平道路

Pandas是什么

​ 简单来说，Pandas 是 Python 中一个比较常用的第三方库，里面集成了很多和数据相关的功能组件。上面提到的那些场景中， 无非就是要：

  1. 处理数据
  2. 分析数据
  3. 画图

​ 所以 Pandas 就围绕着这些环节施展能力。而且它承接了 Numpy 的能力，使用的底层也是 Numpy。按理来说，我们也能用 Numpy 来实现上述功能， 但为什么 Pandas 还是这么广为流传呢？关于这个话题，我想在后文中详细论述。

总结

​ Pandas 是数据的伙伴，帮你处理和分析海量数据，学会用 Python，会很常需要处理数据，只要需要处理数据，希望你都能回想起来有这么一位数据伙伴的存在。

安装Pandas

安装Python（略）
安装Pandas

​ 打开cmd或者terminal，输入指令：

pip install pandas
#或者
pip3 install pandas

​ 安装完成后，打开python编辑器，输入下列代码

import pandas as pd
print(pd.Series([1,2,3]))
#0    1
#1    2
#2    3
#dtype: int64
总结

​ 在本地安装起来很简单，使用 Python 自带的 pip 就好了。记得安装好了之后检查一下是否能正常运行， 和是否安装到其他 Python 版本里去了（如果你电脑里有多个 Python 版本的话）。

Pandas和Numpy的差别

​ 我们已经讲过，Pandas 是在 Numpy 上的封装。 继承了 Numpy 的所有优点，但是这种封装有好有坏，我们在这节内容中就先来阐述一下 Pandas 和 Numpy 的对比。

类比Python

​ 用过 Python，你肯定熟悉里面的 List 和 Dictionary, 我比较常拿这两种形态来对比 Numpy 和 Pandas 的关系。

a_list = [1,2,3]
a_dict = {"a": 1, "b": 2, "c": 3}
print("list:", a_list)
#list: [1, 2, 3]
print("dict:", a_dict)
#dict: {'a': 1, 'b': 2, 'c': 3}

​ 上面就是一种最常见的 Python 列表和字典表达方式。而下面，我们展示的就是 Numpy 和 Pandas 的一种构建方式。 试着执行下面的代码。

import pandas as pd
import numpy as np

a_array = np.array([
    [1,2],
    [3,4]
])
a_df = pd.DataFrame(
    {"a": [1,3], 
     "b": [2,4]}
)

print("numpy array:\n", a_array)
print("\npandas df:\n", a_df)

​ 运行结果

numpy array:
 [[1 2]
 [3 4]]

pandas df:
    a  b
0  1  2
1  3  4

​ 你会发现，我们看到的结果中，Numpy的是没有任何数据标签信息的，你可以认为它是纯数据；而Pandas就像字典一样，还记录着数据的外围信息，比如标签名(Column)和索引(Row index)。所以我总说Numpy是Python里的列表，而Pandas是Python里的字典。

对比Numpy

​ 对于数据运算，既然我们有了 Numpy，为什么还要用 Pandas？对比列表和字典，我们很容易感受到其中的一种原因：Pandas帮我们记录的信息量变多了。

​ 在Numpy中，如果你不特别在其他地方标注，你是不清楚记录的这里边记录的是什么信息的，而Pandas记录的信息可以特别丰富，你给别人使用传播数据的时候，这些信息也会一起传递过去。或者你自己处理数据时对照着信息来加工数据，也会更加友善。这就是在我看来Pandas对比Numpy的一个最直观的好处。

​ 另外 Pandas 用于处理数据的功能也比较多，信息种类也更丰富，特别是你有一些包含字符的表格，Pandas 可以帮你处理分析这些字符型的数据表。 当然还有很多其它功能，比如处理丢失信息，多种合并数据方式，读取和保存为更可读的形式等等。

​ 但是Pandas也有不足的地方：运算速度稍微比Numpy慢一些。

​ 你想想，因为Pandas是在Numpy之上的一层封装，所以肯定在处理数据的时候要多几层处理，小数据量的处理不要紧，慢一点就慢一点，你也感受不到处理速度的变化；但是当数据量变大时，Numpy处理需要1小时的数据，你用Pandas处理可能得2小时。所以在使用时需要注意自己的实际需求。比如：如果在做少量数据的分析时，因为不涉及到机器学习的模型运算等，我都可以用 Pandas，但如果要模型训练， 训练过程中还一直要调用数据处理的功能， 我肯定毫不犹豫都用 Numpy 来做。

总结

​ Pandas 是 Numpy 的封装库，继承了 Numpy 的很多优良传统，也具备丰富的功能组件，但是你还是得分情况来酌情选择要使用的工具。

注：该笔记非原创，主要是对该网站中教程内容的记录