【深度学习】计算机视觉（一）——认识和基础（上）

step1：深度学习和机器学习的概念

因为没怎么接触过，我一直没有分清楚“深度学习”、“机器学习”和“神经网络”这几个十分常见的词到底是干什么的。所以当我要开始相关方面的学习时，第一件事情就是弄清它们的概念。由于学习了数据挖掘的课程，我大概了解到神经网络是一个算法（或者说是一个方法），所以这里就不与深度学习、机器学习放在一起比较了。

机器学习

机器学习是人工智能技术的补充，有如下几种常用算法：

• Find-S
• 决策树
• 随机森林算法
• 神经网络

机器学习算法通常分为以下三大类：

• 有监督学习：需要从有标签的数据中学到或者建立一个模式。
• 无监督学习：数据是无标签的，机器学习算法需要先将数据分类，然后对数据结构进行描述，使复杂的数据看起来简单，以便进行后续分析工作。
• 强化学习：与监督学习相似，通过不断地探索学习，从而获得一个好的策略。

深度学习

深度学习是通过模拟人类决策能力的神经网络找出问题解决方法。深度学习可看作是特殊的机器学习，我们可以利用深度学习来解决任何需要思考的问题。

深度神经网络由三种类型的层组成：

• 输入层
• 隐藏层
• 输出层

区别？

我们使用机器学习算法解析数据，并根据从数据中学习到的知识做出决策。深度学习利用各个层组合创建人工“神经网络”，它能够智能地学习和做出决策。深度学习可以说是机器学习的子领域。

之前我在准备联系导师的时候，查阅到一些深度学习相关的资料（原文忘了），大致就是说人类大脑处理问题时并不是直接决策的，而是一层一层处理，每层有各自的功能，所以神经网络其实是模仿人脑，构造出这个模型。

1. 数据依赖
   深度学习与机器学习的主要区别是在于性能。当数据量很少的时候，深度学习的性能并不好，因为深度学习算法需要大量数据才能很好理解其中蕴含的模式。
   

2. 硬件支持
   深度学习算法严重依赖高端机，而传统的机器学习算法在低端机上就能运行。深度学习需要GPUs进行大量的矩阵乘法运算。

3. 特征工程
   特征工程就是将领域知识输入特征提取器，降低数据复杂度。从时间和专业性来讲，这个过程开销很高。
   在机器学习中，大多数应用的特征都需要专家确定然后编码为一种数据类型。特征可以是像素值、形状、纹理、位置和方向。大多数机器学习算法的性能依赖于所提取的特征的准确度。深度学习尝试从数据中直接获取高等级的特征，这是深度学习与传统机器学习算法的主要的不同。基于此，深度学习削减了对每一个问题设计特征提取器的工作。
   

4. 解决方案
   通常，我们使用传统的算法解决问题，这需要将问题化整为零，分别解决，得到结果后再将其进行组合。传统机器学习通常会将问题分解为多个子问题并逐个子问题解决最后结合所有子问题的结果获得最终结果。相反，深度学习提倡直接的端到端的解决问题。
   假设有一个多物体检测的任务需要图像中的物体的类型和各物体在图像中的位置。
   传统机器学会将问题分解为两步：物体检测和物体识别。首先，使用一个边界框检测算法扫描整张图片找到可能的是物体的区域；然后使用物体识别算法对上一步检测出来的物体进行识别。相反，深度学习会直接将输入数据进行运算得到输出结果。

5. 执行时间
   由于深度学习中含有非常多的参数，较机器学习而言会耗费更多的时间。机器学习在训练数据的时候费时较少，同时只需几秒到几小时。

6. 可解释性
   由于太过复杂，深度学习是机器学习中的黑盒子，无法解释深度学习的可解释性。在一些需要可解释性的场景，例如数据挖掘，需要结合结果和原始特征进行一些解释，这时候就只能用机器学习。

总结——本质区别

机器学习是人手动选取特征，而深度学习是给出大量的数据然后让机器自己去学习选择特征
后者是前者的进一步智能化，智能化在对象的特征提取。
机器学习还是有部分人工干预，而深度学习几乎无人工干预了。后者更像是人类思考的过程，知道其结果是对的，但不知道是怎么做到的。

脉络清晰了！

step2：基本语法复习

学了Python课，笔记全都记在书上了。后续也许会放一些重点（但是现在没有）。

step3：深度学习常用库

了解深度学习是什么之后，就开始正式入门。我虽然没学过，但一直都知道深度学习要用Python，就不解释为什么了。

我的学习环境：
语言：Python
操作系统：Windows
编程软件：pycharm
Python版本：Python3.9

NumPy

基本概念

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代 MatLab，是一个强大的科学计算环境.。

NumPy 是一个运行速度非常快的数学库，主要用于数组计算。

安装
由于我把Anaconda删掉了，所以我选择用pip安装。因为之前安装过，具体的安装方法和问题处理之前的博客已经说得很清楚了，此处不赘述：
在pycharm用python画图【概要】

numpy对象——dtype

介绍：

数据类型对象：numpy.dtype用来描述与数组对应的内存区域是如何使用，它描述了数据的以下几个方面：

• 数据的类型（整数，浮点数或者 Python 对象）。
• 数据的大小（例如， 整数使用多少个字节存储）。
• 数据的字节顺序（小端法或大端法）。字节顺序是通过对数据类型预先设定 < 或 > 来决定的。 < 意味着小端法(最小值存储在最小的地址，即低位组放在最前面)。> 意味着大端法(最重要的字节存储在最小的地址，即高位组放在最前面)。
• 在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分。（numpy可以对C语言定义的结构体进行处理）
• 如果数据类型是子数组，那么它的形状和数据类型是什么。

创建：numpy.dtype()

dtype 对象是使用以下语法构造的：

numpy.dtype(object, align, copy)
"""
object - 要转换为的数据类型对象
align - 如果为 true，填充字段使其类似 C 的结构体。
copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用
"""

举例：

import numpy as np

# 使用标量类型
dt = np.dtype(np.int32)
print(dt)
print("******")

# int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替（其他代替方式附在下面）
dt = np.dtype('i4')
print(dt)
print("******")

# 字节顺序标注（默认小端）
dt = np.dtype('>i4')
print(dt)
print("******")

# 创建结构化数据类型，字段的名称、每个字段的数据类型
"""
创建结构化数据类型的方法：
用方括号定义结构体：[(变量1),(变量2),(变量3)……]
变量的定义方式：(变量名称,数据类型)
numpy.dtype(object, align, copy)中将结构体放入参数object处
"""
dt = np.dtype([('age',np.int32),('id',np.int32)]) 
print(dt)
print("******")

附：
附一、np中的数据类型：

名称	描述
bool_	布尔型数据类型（True 或者 False）
int_	默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc	与 C 的 int 类型一样，一般是 int32 或 int 64
intp	用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8	字节（-128 to 127）
int16	整数（-32768 to 32767）
int32	整数（-2147483648 to 2147483647）
int64	整数（-9223372036854775808 to 9223372036854775807）
uint8	无符号整数（0 to 255）
uint16	无符号整数（0 to 65535）
uint32	无符号整数（0 to 4294967295）
uint64	无符号整数（0 to 18446744073709551615）
float_	float64 类型的简写
float16	半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32	单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64	双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_	complex128 类型的简写，即 128 位复数
complex64	复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128	复数，表示双 64 位浮点数（实数部分和虚数部分）

附二、内建类型的字符代码：

字符	对应类型
b	布尔型
i	(有符号) 整型
u	无符号整型 integer
f	浮点型
c	复数浮点型
m	timedelta（时间间隔）
M	datetime（日期时间）
O	(Python) 对象
S, a	(byte-)字符串
U	Unicode
V	原始数据 (void)

numpy对象——Ndarray

ndarray 对象是用于存放同类型元素的多维数组，ndarray
中的每个元素在内存中都有相同存储大小的区域。它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

介绍：

• 一个指向数据（内存或内存映射文件中的一块数据）的指针。
• 数据类型或 dtype，描述在数组中的固定大小值的格子。
• 一个表示数组形状（shape）的元组，表示各维度大小的元组。
• 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。

创建：numpy.array()

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

其中参数为：

名称	描述
object	数组或嵌套的数列
dtype	数组元素的数据类型（可选）
copy	对象是否需要复制（可选）
order	创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok	默认返回一个与基类类型一致的数组
ndmin	指定生成数组的最小维度

举例：

import numpy as np

# 正常的一个二维数组
a = np.array([[1,  2],  [3,  4]])
print(a)
print("********")

# 设置了不同的最低维度之后比较（注意看中括号的数量）
a = np.array([1, 2, 3, 4, 5], ndmin=2)
print(a)
print("********")
a = np.array([[1, 2, 3, 4, 5],[6, 7, 8, 9, 0]], ndmin=3) # 把二维数组变成三维数组
print(a)
print("********")

# 设置dtype参数
a = np.array([1,  2,  3], dtype=complex)
print(a)
print("********")
# 创建结构化数据类型，将数据类型应用于ndarray对象
dt = np.dtype([('age',np.int32)]) 
a = np.array([(10,),(20,),(30,)], dtype = dt) # 只有一个字段的结构体数组
print(a)
print("********")
dt = np.dtype([('age',np.int32),('id',np.float32)]) 
a = np.array([(10,10.50,),(20,20.50,),(30,30.50,)], dtype = dt) # 有两个字段的结构体数组
print(a)
print("********")

输出：

结构体数据类型的使用较为复杂，我们可以理解为使用numpy.array，将许多由某个结构体定义的对象转换成矩阵。如下图：

import numpy as np

# 类型字段名可以用于存取实际的 age 列
dt = np.dtype([('id',np.int8),('name', 'S20'),('age',np.int8),('tel',np.int8)]) 
a = np.array([(1, 'Bob', 13, 33625),(2, 'Lucca', 15, 51412),(3, 'Carl', 16, 33452)], dtype = dt)
print(a)

得到的结构体（一维矩阵）：

画上面矩阵图是为了理解另一种使用方法：可以使用字段名调用一整列的数据。

import numpy as np

# 类型字段名可以用于存取实际的 age 列
dt = np.dtype([('id',np.int8),('name', 'S20'),('age',np.int8),('tel',np.int8)]) 
a = np.array([(1, 'Bob', 13, 33625),(2, 'Lucca', 15, 51412),(3, 'Carl', 16, 33452)], dtype = dt) 
print(a['age'])

只抽取了’age’部分的数据，但是输出的结果仍然是矩阵（大概因为a是numpy的对象）

属性：

ndim——秩

NumPy 数组的维数称为秩（rank），秩就是轴的数量，即数组的维度。使用ndarray.ndim返回数组的维数，即秩。

shape——维度

在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。

axis=0，表示沿着第0轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。

ndarray.shape表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"。可以通过改变ndarray.shape的值调整数组大小，也可以通过ndarray.reshape函数来调整数组大小。

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a)
print("******")
a.shape =  (3,2)
print(a)
print("******")
b = a.reshape(2,3)
print(b)
print(a) # reshape不改变原来的ndarray，而是复制一个新的

**注意：**由reshape返回的是非拷贝副本，虽然a和b的格式不一样，但是如果改变b数组中的值，那么a对应位置的值也会改变。

size

ndarray.size返回数组元素的总个数，相当于shape 中 n*m 的值。

dtype

ndarray.dtype返回对象的元素类型

itemsize

ndarray.itemsize以字节的形式返回ndarray数组中每一个元素的大小。

import numpy as np 
 
# int8为一个字节
x = np.array([1,2,3,4,5], dtype = np.int8)  
print (x.itemsize)
print("******")
# float64为八个字节
y = np.array([1,2,3,4,5], dtype = np.float64)  
print (y.itemsize)

flags——内存信息

ndarray.flags返回 ndarray 对象的内存信息。

import numpy as np 
 
x = np.array([1,2,3,4,5])  
print (x.flags)

"""
运行结果为（#后面的是注释，不在运行结果中）：
C_CONTIGUOUS : True # 数据是在一个单一的C风格的连续段中
F_CONTIGUOUS : True # 数据是在一个单一的Fortran风格的连续段中
OWNDATA : True # 数组拥有它所使用的内存或从另一个对象中借用它
WRITEABLE : True # 数据区域可以被写入，将该值设置为 False，则数据为只读
ALIGNED : True # 数据和所有元素都适当地对齐到硬件上
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False # 这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新
"""

real

ndarray.real返回元素的实部。

imag

ndarray.imag返回元素的虚部。

data

ndarray.data包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

方法：

ndarray.reshape

例：ndarray.reshape([3, 4])返回一个三行四列的新ndarray，且不改变原ndarray。

numpy方法

numpy.array

上面介绍ndarray时已经介绍过了。

numpy.empty

numpy.empty方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组。因为没有初始化，所以数组的值是随机的。

import numpy as np 
"""
numpy.empty(shape, dtype = float, order = 'C')
shape	数组形状
dtype	数据类型，可选
order	有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
"""
x = np.empty([3,2], dtype = int) # 这里可以是列表也可以是元组
print (x)

numpy.zeros

numpy.zeros创建指定大小的数组，数组元素以 0 来填充。

import numpy as np
"""
numpy.zeros(shape, dtype = float, order = 'C')
shape	数组形状
dtype	数据类型，可选
order	'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组
"""
# 默认为浮点数
x = np.zeros(5) 
print(x)
print("******")
 
# 设置类型为整数
y = np.zeros((5,), dtype = int) 
print(y)
print("******")
 
# 自定义类型
z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])  
print(z)
print("******")

numpy.ones

numpy.ones创建指定形状的数组，数组元素以 1 来填充。

import numpy as np
"""
numpy.ones(shape, dtype = None, order = 'C')
shape	数组形状
dtype	数据类型，可选
order	'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组
"""
# 默认为浮点数
x = np.ones(5) 
print(x)
print("******")

# 自定义类型
x = np.ones([2,2], dtype = int)
print(x)
print("******")

numpy.asarray

numpy.asarray类似numpy.array，用于从已有的数组创建数组。

import numpy as np

"""
numpy.asarray(a, dtype = None, order = None)

参数说明：
a:任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
dtype:数据类型，可选
order:可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
"""

# 将列表转换为ndarray
x = [1, 2, 3]
a = np.asarray(x)
print(a)
print("************************")
# 将元组列表转换为 ndarray
x = [(1, 2, 3), (4, 5, 6)]
a = np.asarray(x)
print(a)
print("************************")
# 设置了dtype参数：
x = [1, 2, 3]
a = np.asarray(x, dtype=float)
print(a)
print("************************")

numpy.frombuffer

numpy.frombuffer用于实现动态数组，接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。

import numpy as np

"""
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
注意：buffer是字节流，处理字符串的时候，Python3默认str是Unicode类型，所以要转成bytestring在原str前加上b。

参数说明：
buffer：可以是任意对象，会以流的形式读入。
dtype：返回数组的数据类型，可选
count：读取的数据数量，默认为-1，读取所有数据。
offset：读取的起始位置，默认为0。
"""

s = b'Hello World'
a = np.frombuffer(s, dtype='S1')
print(a)
print("************************")

附python2使用方法：

numpy.fromiter

numpy.fromiter方法从可迭代对象中建立ndarray对象，返回一维数组。

import numpy as np

"""
numpy.fromiter(iterable, dtype, count=-1)

参数	描述：
iterable：可迭代对象
dtype：返回数组的数据类型
count：读取的数据数量，默认为-1，读取所有数据
"""

# step1：使用 range 函数创建列表对象
list = range(1, 10, 2)
it = iter(list)
# 使用迭代器创建 ndarray
x = np.fromiter(it, dtype=float)
print(x)

numpy.arange

numpy.arange创建数值范围并返回ndarray对象。

import numpy as np

"""
numpy.arange(start, stop, step, dtype)
根据start与stop指定的范围以及step设定的步长，生成一个ndarray。

参数说明：
start：起始值，默认为0
stop：终止值（不包含）
step：步长，默认为1
dtype：返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。
"""

x = np.arange(5, dtype=float)
print(x)

numpy.linspace

numpy.linspace函数用于创建一个一维数组，数组是一个等差数列构成的。

import numpy as np

"""
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数说明：
start：序列的起始值
stop：序列的终止值，如果endpoint为true，该值包含于数列中
num：要生成的等步长的样本数量，默认为50
endpoint：该值为 true 时，数列中包含stop值，反之不包含，默认是True。
retstep：如果为 True 时，生成的数组中会显示间距，反之不显示。
dtype：ndarray的数据类型
"""

# 设置元素全部是1的等差数列：
a = np.linspace(1, 1, 5)
print(a)
print("************************")
a = np.linspace(10, 20, 5, endpoint=False)
print(a)
print("************************")
# 设置显示间距
a = np.linspace(1, 10, 10, retstep=True)
print(a)
print("************************")
a = np.linspace(1, 10, 10)
print(type(a))

numpy.logspace

numpy.logspace函数用于创建一个于等比数列.

import numpy as np

"""
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

参数描述:
start：序列的起始值为：base ** start（base的start次方）
stop：序列的终止值为：base ** stop（base的stop次方）。如果endpoint为true，该值包含于数列中
num：要生成的等步长的样本数量，默认为50
endpoint：该值为 true 时，数列中中包含stop值，反之不包含，默认是True。
base：幂运算中的底数，默认为10
dtype：ndarray的数据类型
"""

a = np.logspace(1.0, 2.0, num=10)
print(a)
print("************************************************************************")
a = np.logspace(0, 9, 10, base=2)
print(a)

索引和切片

ndarray 数组可以基于 0 - n 的下标进行索引。

import numpy as np

# 1. 切片对象可以通过内置的slice函数，并设置start，stop及step参数进行，从原数组中切割出一个新数组。
a = np.arange(10)
s = slice(2, 7, 2)  # 从索引 2 开始到索引 7 停止，间隔为2
print(a[s])
print("************************")

# 2. 通过冒号分隔切片参数 start:stop:step 来进行切片操作
b = a[2:7:2]   # 从索引 2 开始到索引 7 停止，间隔为 2
print(b)
print("************************")
"""
如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。
如果为 [2:]，表示从该索引开始以后的所有项都将被提取。
如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。
"""
"""
多维数组同样适用
"""
a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
print(a)
print(a[1:])
print("************************")
"""
切片还可以包括省略号，来使选择元组的长度与数组的维度相同。
"""
print(a[..., 1])  # 第2列元素
print(a[1, ...])  # 第2行元素
print(a[..., 1:])  # 第2列及剩下的所有元素

pandas

Pandas 是 Python 语言的一个扩展程序库，用于数据分析。Pandas 可以从各种文件格式比如CSV、JSON、SQL、Microsoft Excel 导入数据。Pandas可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征。

安装：略

数据结构：Series和DataFrame

Series （一维数据）

Series 是一种类似于一维数组的对象，它由一组数据（各种Numpy数据类型）以及一组与之相关的数据标签（即索引）组成。

import pandas as pd
"""
pandas.Series( data, index, dtype, name, copy)

参数说明：
data：一组数据(ndarray 类型)。
index：数据索引标签，如果不指定，默认从 0 开始。
dtype：数据类型，默认会自己判断。
name：设置名称。
copy：拷贝数据，默认为 False。
"""

# 创建series样例
a = [1, 2, 3]
p = pd.Series(a)
print(p) # pd.series返回的是series的详细信息，包括数据、索引、数据类型
print("******************************")

# 通过索引读取数据
print(p[2])
print("******************************")

# 指定索引值，指定name
p = pd.Series(a, ['x', 'y', 'z'])  # 参数也可以写为index = ['x', 'y', 'z']的形式
print(p['y'])
print("******************************")

# 使用key/value创建series
a = {1: "zhangsan", 2: "lisi", 3: "wangwu"}
p = pd.Series(a)
print(p[2])
print("******************************")
p = pd.Series(a, [3, 1])  # 可以通过指定索引截取字典数据
print(p)
print("******************************")

# 指定name
p = pd.Series(a, name="table")  # 指定name=""才可以省略中间的参数
print(p)
print("******************************")

结果：

0    1
1    2
2    3
dtype: int64
******************************
3
******************************
2
******************************
lisi
******************************
3      wangwu
1    zhangsan
dtype: object
******************************
1    zhangsan
2        lisi
3      wangwu
Name: table, dtype: object
******************************

DataFrame（二维数据）

DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。DataFrame既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）。

心得：python能很好地处理索引和值的关系，而不是以数据类型为主去操作数。所以使用python更类似与人脑的处理，屏蔽掉了很多底层逻辑，直观地判断。那么在初期学习和使用的过程中也不必过多纠结如何定义数据。

import pandas as pd
"""
pandas.DataFrame( data, index, columns, dtype, copy)

参数说明：
data：一组数据(ndarray、series, map, lists, dict 等类型)。
index：索引值，或者可以称为行标签。
columns：列标签，默认为 RangeIndex (0, 1, 2, …, n) 。
dtype：数据类型。
copy：拷贝数据，默认为 False。
"""

# 创建dataframe样例
data = [['ZhangSan', 10], ['LiSi', 12], ['WangWu', 13]]
df = pd.DataFrame(data, columns=['name', 'Age'])  # 如果传递了 index，则索引的长度应等于数组的长度
print(df)  # 如果没有传递索引，则默认情况下，索引将是range(n)，其中n是数组长度。
print("******************************")

# 使用 ndarrays 创建，ndarrays长度必须相同。
data = {'Name': ['ZhangSan', 'LiSi', 'WangWu'], 'Age': [10, 12, 13]}  # 这不是key/value方法吗？
df = pd.DataFrame(data)
print(df)
print("******************************")

# 使用字典创建
data = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]  # 这才是key/value，是以行为单位；ndarrys是整列处理，还是有区别的
df = pd.DataFrame(data)
print(df)  # 长度可以不同，没有的数据为NaN
print("******************************")

# 使用 loc 属性返回指定行的数据，默认索引是0，1，2……
data = {
  "calories": [420, 380, 390],
  "duration": [50, 40, 45]
}  # 这样写更清晰了
df = pd.DataFrame(data)
print(df.loc[1])  # 返回的是以列名为索引的一行series（这里刚开始学的时候想的比较乱）
print("******************************")
print(df.loc[[1, 2]])  # 多个索引返回多行数据时，返回的就是dataframe了，两个中括号也是直接改变了维度
print("******************************")

       name  Age
0  ZhangSan   10
1      LiSi   12
2    WangWu   13
******************************
       Name  Age
0  ZhangSan   10
1      LiSi   12
2    WangWu   13
******************************
   a   b     c
0  1   2   NaN
1  5  10  20.0
******************************
calories    380
duration     40
Name: 1, dtype: int64
******************************
   calories  duration
1       380        40
2       390        45
******************************

对CSV文件的操作

CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）。

import pandas as pd

# 使用to_csv()方法将DataFrame存储为csv文件
pname = ["ZhangSan", "LiSi", "WangWu", "ZhaoLiu"]
page = [13, 12, 13, 14]
dict = {'name': pname, 'age': page}  # 字典
df = pd.DataFrame(dict, index=['no.1', 'no.2', 'no.3', 'no.4'])
df.to_csv('people.csv')

# 使用read_csv()方法处理文件,空行各个字段的值返回NaN
df = pd.read_csv('people.csv')  # 文件中已经有的索引作为普通列处理，df还会给文件一个索引
print(df.to_string())  # to_string()返回 DataFrame 类型的数据
print("******************************")
# print(df) 如果不使用to_string()函数，则输出结果为数据的前面 5 行和末尾 5 行，中间部分以 ... 代替。

# 使用head(n)方法用于读取前面的n行，默认返回5行
print(df.head(6))
print("******************************")

# 使用tail(n)方法用于读取尾部的n行，默认返回5行
print(df.tail(5))
print("******************************")

  Unnamed: 0      name  age
0       no.1  ZhangSan   13
1       no.2      LiSi   12
2       no.3    WangWu   13
3       no.4   ZhaoLiu   14
******************************
  Unnamed: 0      name  age
0       no.1  ZhangSan   13
1       no.2      LiSi   12
2       no.3    WangWu   13
3       no.4   ZhaoLiu   14
******************************
  Unnamed: 0      name  age
0       no.1  ZhangSan   13
1       no.2      LiSi   12
2       no.3    WangWu   13
3       no.4   ZhaoLiu   14
******************************

此外，info()方法返回表格信息。

对JSON文件/对象的操作

JSON（JavaScript Object Notation，JavaScript 对象表示法），是存储和交换文本信息的语法，类似 XML。

同理，使用read_json()和to_string()方法操作。关于json文件的知识和相关内容这里暂时先不写了，注意一下，我们构造二维数据的时候如何区分行列，里层的逻辑是按行，外层的逻辑是按列。无论是字典还是JSON，都遵循这样的规律。

复杂的json文件样例：

{
    "school_name": "local primary school",
    "class": "Year 1",
    "info": {
      "president": "John Kasich",
      "address": "ABC road, London, UK",
      "contacts": {
        "email": "[email protected]",
        "tel": "123456789"
      }
    },
    "students": [
    {
        "id": "A001",
        "name": "Tom",
        "math": 60,
        "physics": 66,
        "chemistry": 61
    },
    {
        "id": "A002",
        "name": "James",
        "math": 89,
        "physics": 76,
        "chemistry": 51
    },
    {
        "id": "A003",
        "name": "Jenny",
        "math": 79,
        "physics": 90,
        "chemistry": 78
    }]
}

数据清洗

数据清洗是对一些没有用的数据进行处理的过程。
很多数据集存在数据缺失、数据格式错误、错误数据或重复数据的情况，如果要对使数据分析更加准确，就需要对这些没有用的数据进行处理。

空数据

四种空数据：

• n/a
• NA
• —
• na

import pandas as pd

# 使用dropna()方法可以删除包含空字段的数据。
"""
DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)

参数说明：
axis：默认为 0，表示逢空值剔除整行，如果设置参数 axis＝1 表示逢空值去掉整列。
how：默认为 'any' 如果一行（或一列）里任何一个数据有出现 NA 就去掉整行，如果设置 how='all' 一行（或列）都是 NA 才去掉这整行。
thresh：设置需要多少非空值的数据才可以保留下来的。
subset：设置想要检查的列。如果是多个列，可以使用列名的 list 作为参数。
inplace：默认情况下，dropna()方法返回一个新的DataFrame，不会修改源数据。如果设置 True，将修改源数据并返回 None。
"""
# 实例：移除某列中字段值为空的行：
df = pd.read_csv('文件名.csv')
df.dropna(subset=['列名'])
print(df.to_string())
print("******************")

# 通过isnull()判断各个单元格是否为空。
df = pd.read_csv('文件名.csv')
print(df['列名'].isnull())  # 默认把 n/a 和 NA 当作空数据
print("******************")
missing_values = ["n/a", "na", "--"]  # 指定空数据类型
df = pd.read_csv('文件名.csv', na_values=missing_values)
print("******************")

# fillna()方法可以替换空字段
# 实例：使用 12345 替换空字段：
df = pd.read_csv('文件名.csv')
df.fillna(12345, inplace=True)
print(df.to_string())
print("******************")
df = pd.read_csv('文件名.csv')
df['列名'].fillna(12345, inplace=True)  # 指定某一个列来替换数据
print(df.to_string())
print("******************")

数据清洗中的常用计算

• mean()方法：计算列的均值（所有值加起来的平均值）

df = pd.read_csv('文件名.csv')
x = df["列名"].mean()

• median()方法：计算中位数值（排序后排在中间的数）

df = pd.read_csv('文件名.csv')
x = df["列名"].median()

• mode()方法：计算众数（出现频率最高的数）

df = pd.read_csv('文件名.csv')
x = df["列名"].mode()

清洗格式错误数据

import pandas as pd

# to_datetime格式化日期
data = {
  "Date": ['2020/12/01', '2020/12/02', '20201226'],
  "duration": [50, 40, 45]
}
df = pd.DataFrame(data, index=["day1", "day2", "day3"])
df['Date'] = pd.to_datetime(df['Date'])
print(df.to_string())

清洗错误数据

import pandas as pd

# loc()修改数据
person = {
  "name": ['ZhangSan', 'LiSi', 'WangWu'],
  "age": [50, 40, 12345]    # 12345 年龄数据是错误的
}
df = pd.DataFrame(person)
df.loc[2, 'age'] = 30  # 修改数据
print(df.to_string())
print("********************************")

# 删除错误数据的行
df = pd.DataFrame(person)
for x in df.index:
    if df.loc[x, "age"] > 120:
        df.drop(x, inplace=True)
print(df.to_string())
print("********************************")

清洗重复数据

import pandas as pd

# duplicated()检查数据是否有重复，重复会返回 True，否则返回 False。
person = {
  "name": ['ZhangSan', 'LiSi', 'LiSi', 'WangWu'],
  "age": [50, 40, 40, 23]
}
df = pd.DataFrame(person)
print(df.duplicated())
print("************************")

# 使用drop_duplicates()方法删除重复数据
df = pd.DataFrame(person)
df.drop_duplicates(inplace=True)
print(df)

matplotlib

Matplotlib 是 Python 的绘图库，它能让使用者很轻松地将数据图形化，并且提供多样化的输出格式。Matplotlib 可以绘制线图、散点图、等高线图、条形图、柱状图、3D 图形、甚至是图形动画等等。
Matplotlib 通常与 NumPy 和 SciPy（Scientific Python）一起使用， 这种组合广泛用于替代 MatLab

通过之前的线性拟合项目已经对matplotlib有一定的了解，具体的笔记更新在这里
在pycharm用python画图【概要】
.
.
.
. 分割线
.
.
.

---

最后说一点题外话：作为一个不经常上网的人，对于网络方面窍门了解甚少，一直以为学代码最好的地方就是CSDN，偶然发现知乎上有许多更宏观的探讨，也很有价值，如果有和我一样的同学，不要错过知乎。

参考来源：
深度学习和机器学习有什么区别？
NumPy 教程
Pandas 教程
Matplotlib 教程

【欢迎指正】