基础知识

  1. 什么是程序？

    指令集合 + 算法

  2. 程序之间的通信?

    同台PC机器上
两台PC机器上
多台PC机器上

  3. 计算机网络的一些关键字

    IP地址
IPV4, IPV6
子网掩码
默认网关
DNS
MAC

  4. 交换机通信形式:

    单播
组播

    ​ 广播

  5. 路由器
    用来连接不同的网段

  6. 网段
    一个局域网内的IP的范围

  7. 网关

    局域网的出入口

  8. OSI 开放系统互连 七层协议

    应用层
表示层
会话层
传输层
网络层
数据链路层
物理层

    OSI 简化为五层协议

    应用层:        http/https/ftp/...
传输层:        tcp/udp/... 四层交换机, 四层路由器
网络层:        ip/icmp/... 路由器, 交换机
数据链路层:    arp/... 以太网交换机, 网卡, 网桥
物理层:        传输电信号, 网线, 光纤, 中继器, 集线器

    OSI 简化为四层协议

    应用层
传输层
网络层
物理网络层

    网络中大概的传输过程

    a, 由应用层的发送端发送出数据, 注册添加首部信息, [层层处理之后], 最终走到物理层向外发送数据
b, 发送出的数据经过多个节点(交换机, 路由器)传输, 每个节点解析物理地址信息和网络信息, 并且添加到新的网络物理信息, 最终到达主机
c, 主机接收数据, 接收数据之后从物理层开始进行解析, 最终呈现到客户端的应用层.

  9. 网络主机
    标识一台主机所在的网络的位置. 也就是其地址(URL)

  10. 全球有13服务器, 构成了全球互联网
    1台跟服务器
    12台主服务器

  11. IP地址
    一台主机在网络中的位置

  12. 端口号
    是网络地址中的一部分, 用于区分主机上不同应用程序.
    可以理解为程序在主机上的唯一ID
    在一个系统中, 所有的端口号都是唯一的.
    端口号的数据值在0–65535之间

  13. 域名:
    127.0.0.1 localhost
    14.215.177.38 www.baidu.com

  14. URL地址
    http://www.baidu.com:80/com.cn/index.html
    协议://域名:端口号/URI[GET参数]

  15. 基于TCP协议的传输层

    a, TCP传输的特征:
    提供了可靠的数据传输, 在此过程中: 无丢失, 无失序, 无差错, 无重复
b, 传输的前提: 在传输之间建立好连接
c, 建立三次握手:
    1, 客户端向服务器端发送SYN消息报文请求连接
    2, 服务器接收请求之后, 回复ACK报文确定可以连接
    3, 客户端接收消息回复, 发送ACK报文建立连接

SYN=1, seq=x
SYN=1, ACK=x+1, seq=y
SYN=1, ACK=y+1, seq=x+1

    d, 断开连接的四次挥手

    1, 主动方发送断开请求
2, 被动方接收到请求, 立即回复, 并且准备断开
3, 被动方准备就绪之后, 再次方法报文消息给主动方, 可以进行断开
4, 主动方发送最终确认报文, 断开连接

FIN + ACK + seq

    SYN : 位数值1, 表示建立TCP连接
    ACK : 表示验证字段
    FIN : 位数值1, 表示断开TCP连接

    重点: 在整个过程中有 11 种状态.

    和upd的比较
    粘包问题的处理

  16. HTTP协议: 超文本传输协议
    主要用在网页种的数据传输
    属于OSI种的应用层协议
    基于传输层的TCP协议
    无状态, 不记录任何内容

    重点: HTTP1.0 和 HTTP1.1 和 HTTP2.0 版本之间的区别

    客户端向服务器端发送数据就是请求
    服务器端向客户端发送数据就是响应

  17. 请求模块

    a, 请求行: 包括具体的请求类别和请求内容
    1, 请求格式
        GET(POST)/HTTP1.1
        请求类别  请求内容  版本信3息
    2, 请求类型
    GET:    获取网络资源
    POST:    提交一定的信息, 并且得到反馈

     HEAD:    只用于获取网络资源的响应头信息
    PUT:    用于更新服务器资源
    DELETE:    用户删除服务器资源
    TRACE:    用来做测试
    OPTIONS:用于获取服务器性能的信息
    CONNECT:

    ​ 3, 请求内容
    ​ 表示要获取的具体的信息内容

  18. b, 请求头:

    对于请求的进一步解释阐述

    c, 空行

    d, 请求体

    可以理解为在请求的基础上, 对请求的更加细致的表达描述

  19. 响应模块

    a, 响应行: 最基本的响应信息内容
    1, 响应格式: HTTP1.1 200 OK
        版本信息  响应状态码  附加信息

    ​ 2, 响应状态码: 三位数的表示
    ​ 1xx : 提示信息, 表示请求被接收
    ​ 2xx : 响应成功
    ​ 3xx : 重定向, 响应需要被进一步处理
    ​ 4xx : 客户端发生错误
    ​ 5xx : 服务器内部发生错误

    ​ b, 响应头:
    ​ Content-Type: text/html

    ​ c, 空行

    ​ d, 响应体
    ​ 响应的主体信息内容

python-多人聊天室

由服务端和客户端组成

service.py

'''
强语言类型: java
弱语言类型: python, js

这是开发多人聊天室的服务器端,
服务器端主要是监控客户端上线, 下线, 数据的收发等等
'''

# 是是一个双向管道流的网络套接字
# 用于数据的交互(接收和发送)
import socket
# 使用线程级别的开发.
# 每一个在线的客户都是一个线程
import threading

# 创建一个带有网络套接字的socket服务器端对象
serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# [测试]
print('[测试]服务器端创建成功')

# 这是设置服务器的IP地址和端口号
HOST_IP = 'localhost'
PORT = 5566

# 为socket设置IP地址和端口号
# 由于这是元组类型, 所以需要写小括号
serverSocket.bind((HOST_IP, PORT))

# [测试]
print('服务器绑定的IP地址为{0}, 端口号为: {1}'.format(HOST_IP, PORT))

# 需要为该服务器设置监听, 这里是设置的最大监听数为5
MAX_NUM = 5
serverSocket.listen(MAX_NUM)
print('服务器正在开启监听功能...')

# 这是字典类型, 用于存放用户的昵称
nicknameDict = dict()
# 这是列表类型, 用于存储所有的客户端的通信通道对象
myList = list()

''' 
    这是广播消息的功能
    第一个参数, 是需要排除的客户端
    第二个参数: 是需要广播的消息
 '''
def broadcastData(exceptNum, message):
    # 需要广播给列表中的所有其它客户
    for conn in myList:
        # 排除掉自身
        if conn.fileno() != exceptNum:
            try:
                # 发送数据
                conn.send(message.encode())

            except:
                pass


''' 创建线程对象的处理函数
    做程序执行时候的过程
    其实就表示为一个独立的, 与服务器端通信的线程
    就用来与服务器进行通信 
 '''
def subThreadIn(conn, connNumber):
    # 接收客户端的昵称
    nickname = conn.recv(1024).decode()
    # 把获取到的新用户的昵称存入到字典种
    # 这里的存值方式为 Key--Value
    nicknameDict[conn.fileno()] = nickname
    # 讲新客户端的通信通道存入到列表中
    myList.append(conn)

    # [测试] 模拟日志处理
    print('[日志文件]: 客户端:{0}, 设置昵称: {1}'.format(connNumber, nickname))

    # 通过广播, 向所有其它在线客户端发送有人进入聊天室的数据
    broadcastData(connNumber, '系统提示: <' + nicknameDict[connNumber] + '> 进入聊天室')

    # 开启一个死循环, 用于接收客户端发送的数据, 然后发送给其它所有的客户
    while True:
        try:
            # 接收客户端发送的数据
            recvMsg = conn.recv(1024).decode()

            # 判断是真的接收到了数据
            if recvMsg:
                # 广播给其它所有的在线客户
                broadcastData(connNumber, nicknameDict[connNumber] + ':' + recvMsg)
        except(OSError, ConnectionResetError):
            try:
                # 由于某些异常的原因, 需要把该连接客户给移除掉
                myList.remove(conn)
            except:
                pass

            # [测试]
            print('[日志信息]{0} 退出聊天室, 当前聊天室人数为: {1} 人'.format(nicknameDict[connNumber], len(myList)))

            # 把客户下线的信息广播给所有客户
            broadcastData(connNumber, '[系统消息: ' + nicknameDict[connNumber] + ' 已经离开聊天室]')

            # 关闭连接对象
            conn.close()

            return


while True:
    # 接收客户端的请求连接
    # 这一个函数会得到两个对象,
    # 第一个是连接对象
    # 第二个是客户端地址对象
    conn, addr = serverSocket.accept()

    # [测试]
    print('服务器端接收到了一个客户端的连接<{0}>, 连接编号: <{1}>'.format(conn.getsockname(), conn.fileno()))

    try:
        # 设置服务器的缓冲区, 接收客户端发送的数据, 并且转码
        buf = conn.recv(1024).decode()

        # 要求第一次上线的用户必须发送字符'1', 表示第一次连接
        # 可以在客户端对第一次上线的客户进行系统的欢迎提示
        if buf == '1':
            # 这是由于send函数发送的就是字节类型的数据, 所以这里发送英文字节比较好
            conn.send(b'welcome to server')

            # 为当前上线的客户开辟一个新的线程
            myThread = threading.Thread(target=subThreadIn, args=(conn, conn.fileno()))
            # 可以把该线程对象设置为后台(精灵线程)
            myThread.setDaemon(True)

            # 启动线程
            myThread.start()
        else:
            conn.send(b'get out')
            # 关闭掉连接通道
            conn.close()
    except:
        pass

client.py

''' 客户端 '''

import socket
import threading

# 创建出客户端程序
clientSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务器, 需要传入地址和端口号
clientSocket.connect(('localhost', 5566))
# 马上向服务器Q'1'
clientSocket.send(b'1')
# 输出服务器响应的数据
print(clientSocket.recv(1024).decode())

# 设置客户端的昵称
nickname = input('请设置昵称:')

# 把设置好的昵称发送到服务器
clientSocket.send(nickname.encode())

''' 发送数据的线程 '''
def sendThreadFunc():
    ''' 数据来自于用户的输入 '''
    while True:
        try:
            # 接收用户输入的数据
            myword = input()
            clientSocket.send(myword.encode())
        except ConnectionAbortedError:
            print('Server closed this connection')
        except ConnectionResetError:
            print("Server is closed")


# 接收服务器端发送的数据
def recvThreadFunc():
    while True:
        try:
            otherword = clientSocket.recv(1024)

            if otherword:
                print(otherword.decode())
            else:
                pass
        except ConnectionAbortedError:
            print('Server closed this connection')
        except ConnectionResetError:
            print("Server is closed")


# 发送数据和接收数据, 是两个功能
# 所以我们可以开辟两个线程
th1 = threading.Thread(target=sendThreadFunc)
th2 = threading.Thread(target=recvThreadFunc)

# 启动线程
threads = [th1, th2]

for t in threads:
    t.setDaemon(True)
    t.start()

t.join()

知识点：python多线程、守护进程和join方法

守护线程与非守护线程：当一个进程启动时，会默认产生一个主线程。当设置多线程时，主线程会创建多个子线程，在python中，默认是非守护线程(setDaemon(False))，主线程执行完自己的任务以后，就退出了，此时子线程会继续执行自己的任务，直到任务结束，程序结束。当我们使用setDaemon(True)时，设置子线程为守护线程，主线程一旦执行结束，则所有守护线程都被终止执行，程序结束。

join方法的作用就是线程同步，即主线程任务结束之后，进入阻塞状态，一直等待其他的子线程执行结束，主线程在执行。

举例：

  1. python多线程默认情况

    import threading
    import time
     
    def run():
        time.sleep(2)
        print('当前线程的名字是： ', threading.current_thread().name)
        time.sleep(2)
     
     
    if __name__ == '__main__':
     
        start_time = time.time()
     
        print('这是主线程：', threading.current_thread().name)
        thread_list = []
        for i in range(5):
            t = threading.Thread(target=run)
            thread_list.append(t)
     
        for t in thread_list:
            t.start()
     
        print('主线程结束！' , threading.current_thread().name)
        print('一共用时：', time.time()-start_time)

    image-20200727191729432

关键点：

* 主线程结束，打印出主线程的用时
* 主线程结束之后，子线程执行，子线程执行完毕，程序结束

  1. 设置守护线程

    import threading
    import time
     
    def run():
     
        time.sleep(2)
        print('当前线程的名字是： ', threading.current_thread().name)
        time.sleep(2)
     
     
    if __name__ == '__main__':
     
        start_time = time.time()
     
        print('这是主线程：', threading.current_thread().name)
        thread_list = []
        for i in range(5):
            t = threading.Thread(target=run)
            thread_list.append(t)
     
        for t in thread_list:
            t.setDaemon(True)
            t.start()
     
        print('主线程结束了！' , threading.current_thread().name)
        print('一共用时：', time.time()-start_time)

    image-20200727191955525

关键点：

  • 子线程设置为守护线程，主线程结束以后，终止所有守护线程，程序直接结束

  1. join方法

    import threading
    import time
     
    def run():
     
        time.sleep(2)
        print('当前线程的名字是： ', threading.current_thread().name)
        time.sleep(2)
     
     
    if __name__ == '__main__':
     
        start_time = time.time()
     
        print('这是主线程：', threading.current_thread().name)
        thread_list = []
        for i in range(5):
            t = threading.Thread(target=run)
            thread_list.append(t)
     
        for t in thread_list:
            t.setDaemon(True)
            t.start()
     
        for t in thread_list:
            t.join()
     
        print('主线程结束了！' , threading.current_thread().name)
        print('一共用时：', time.time()-start_time)

![image-20200727192135613](/Users/oujiajie/Library/Application Support/typora-user-images/image-20200727192135613.png)

关键点：

  • 每个线程都使用了join方法，主线程要等待join容器里面的所有线程执行完毕了才能继续执行

聊天室问题

##错误代码：
for t in threads:
    t.setDaemon(True)
    t.start()
		t.join()
​

因为两个子线程都设置为守护线程，且子线程是无限循环，所有当第一个子线程执行join方法时，第一个子线程一直在执行，第二个子执行和主线程一直在等待，程序无法正确执行。
​##正确代码 for t in threads: t.setDaemon(True) t.start() t.join() ​
两个子线程设置为守护线程，如果不使用join方法，则主线程执行结束，会终止两个子线程，所以在第二个子线程使用join方法，这时第一个子线程和第二个子线程都是执行，主线程等待，程序正确执行
​```

```

Django开发

在web开发中, 都是需要以HTTP/TCP协议作为基本支撑的
只要是客户端向服务器端发送的都叫做<请求>
只要是服务器端向客户端发送的都叫做<响应>

Django 采用了MVT的软件设计模式,
M: Model(模型)
V: View(视图)
T: Template(模板)

首先, 需要了解Django, 然后准备好开发环境.
还需要了解, 目前开发的几大架构方式
C/S架构: Client/Server
B/S架构: Browser/Server
RIA架构: Rich Internet Applicationss 富客户端网络应用

Django中的核心功能:
无需sql语句即可以快速实现数据库操作.
url映射匹配处理
模板系统
表单处理
http处理
站点处理
强大的后台管理
等等

Django中的核心组件
Templates:
用来存放web应用中所需要的所有html静态页面
Urls:
路由表, 用于解析浏览器发送的url地址, 并且把该地址交给特定的程序处理
Views:
视图控制器, 用于具体显示接收浏览器发送的请求数据, 并且进行处理和响应
Model:
实现了程序与数据库的对应(ORM)

安装Django的方式:
pip install django
或者
pip install django -i https://pypi.douban.com/simple

检测Django是否安装成功
在cmd输入 python -m django –version

使用命令创建项目
django-admin startproject empSystem
django-admin 是命令
startproject 是指令
empSystem 是项目名称, 可以随意修改

在创建完工程之后, 会出现几个非常重要的文件
manage.py 管理(处理)整个项目
在项目的文件夹中:
settings.py 项目中的全局配置文件
urls.py web站点的根目录, 用于设定url的响应程序的路由
wsgi.py 用户该项目与WSGI兼容的web服务器入口

​ 备注: wsgi: 网关服务器接口

在这里可以进行简单的测试, 测试manage.py是否可用
首先进入到项目中:
cd empSystem;
然后:
python manage.py –version

可以启动服务器, 用来检测整个Django的开发环境是否成功
python manage.py runserver 8000

然后进入到浏览器访问: loacalhost:8000, 查看是否能够看到”小火箭”

注意: 启动程序的端口号不要被占用了

关闭服务器的方式:
CTRL + C 或者 CTRL + BREAK

开始开发项目, 创建出需要的子模块
python manage.py startapp app

startapp 创建子模块的指令
app 是创建的子模块的名称, 可以修改.

在创建的子模块中会出现几个非常重要的py文件
admin.py 用于定义本模块的自定义管理页面
apps.py 本模块的属性文件
models.py 本模块对应的数据库中表的映射关系(ORM)
tests.py 单元测试的文件
views.py 本模块中的视图调度模块

创建好子模块之后, 马上把该子模块加入到settings.py的全局配置中.
INSTALLED_APPS中

然后在子模块中创建出templates文件夹, 用于存储所有的html文件

然后再子模块中创建出static文件夹,用于存储所有的静态资源
在static文件夹中可以创建
css 用于存储css文件
scripts 用于存储JavaScript脚本文件
images 用于存储图片资源

Django中默认使用的数据库为SQLite3

在子模块的models.py中写实体对象与数据库中的表的对应关系
每一个实体对象(类), 都必须要继承models.Model

Anacodna安装Scrapy 爬虫项目

爬取网络数据:
1, 获取到整个网站信息
2, 对网站进行结构化分析
3, 获取到需要得数据
4, 把数据进行存储
5, 分析数据
…

Scrapy是适用于Python的一个快速、高层次的屏幕抓取和web抓取框架，用于抓取web站点并从页面中提取结构化的数据。Scrapy用途广泛，可以用于数据挖掘、监测和自动化测试。

Scrapy吸引人的地方在于它是一个框架，任何人都可以根据需求方便的修改。它也提供了多种类型爬虫的基类，如BaseSpider、sitemap爬虫等，最新版本又提供了web2.0爬虫的支持。

scrapy得核心组件

Scrapy Engine(引擎)：负责Spider、ItemPipeline、Downloader、Scheduler中间的通讯，信号、数据传递等。
Scheduler(调度器)：它负责接受引擎发送过来的Request请求，并按照一定的方式进行整理排列，入队，当引擎需要时，交还给引擎。

Downloader（下载器）：负责下载Scrapy Engine(引擎)发送的所有Requests请求，并将其获取到的Responses交还给Scrapy Engine(引擎)，由引擎交给Spider来处理。

Spider（爬虫）：它负责处理所有Responses,从中分析提取数据，获取Item字段需要的数据，并将需要跟进的URL提交给引擎，再次进入Scheduler(调度器)。

Item Pipeline(管道)：它负责处理Spider中获取到的Item，并进行进行后期处理（详细分析、过滤、存储等）的地方。

Downloader Middlewares（下载中间件）：一个可以自定义扩展下载功能的组件。

Spider Middlewares（Spider中间件）：一个可以自定扩展和操作引擎和Spider中间通信的功能组件。

制作 Scrapy 爬虫 一共需要四步：
1, 新建项目 ：新建一个新的爬虫项目
2, 明确目标 （编写items.py）：明确你想要抓取的目标
3, 制作爬虫 （spiders/xxspider.py）：制作爬虫开始爬取网页
4, 存储内容 （pipelines.py）：设计管道存储爬取内容

安装scrapy模块, 准备爬虫环境
首先, 需要下载安装Twisted模块库, 如果没有该模块, 那么在安装scrapy得时候, 很可能会报错.
然后, 安装scrapy

强烈建议使用豆瓣镜像安装

创建项目
通过命令创建项目
scrapy startproject douban
scrapy 是命令
startproject 是创建项目得指令
douban 是项目得名称, 可以随意修改

这里要特别注意, 在写完一条命令之后, 不要习惯性得加分号!!!

可以使用tree /f 命令查看项目工程结构目录

创建核心爬虫脚本程序
首先, 需要进入到项目
cd douban

​ 然后, 使用命令:
​ scrapy genspider 爬虫脚本名称 访问网站得域名
​ scrapy genspider moviespider douban.com

检测程序与网站之间得连接
scrapy shell 网站的url地址
scrapy shell http://www.douban.com

如果我们在测试的时候得到"200"状态码, 表示连接网站正常.

有可能在测试的时候, 得到服务器的响应状态码为"403", 这就是由于网站中设置了"反爬机制".
我们可以去网上多多了解网站的"反爬机制".

解决一般"反爬"方式, 设置user-agent 用户代理信息的列表,
随机以不同的"用户头"访问, 模拟不同的用户访问.

在项目中创建rotate_useragent.py文件.
文件中设置各种的user-agent值

还要把写好的rotate_useragent.py文件配置到settings.py中
DOWNLOADER_MIDDLEWARES = {
    'douban.middlewares.DoubanDownloaderMiddleware': 543,
    'scrapy.contrib.downloadermiddleware.useragent.UserAgentMiddleware':None,
    'douban.rotate_useragent.RotateUserAgentMiddleware':400
}

接下来就可以对网站进行分析, 编写爬虫程序.
也需要大家对xpath技术有所了解

我们可以把获取到的数据放入到mysql数据库, 放入到CVS文件, 放入到xls文件, 放入到json文件, 放入到文本文件, 等等

比如存入到mysql数据库, 就需要mysql的支持模块
比如放入到CVS文件, 就需要CVS文件的支持模块
比如放入到xls文件, 就需要xls文件的支持模块

通过: scrapy crawl 爬虫文件名, 运行项目

人工智能

刚才项目中用到的技术:
numpy
matplotlib
pandas
Echarts
神经网络

K-Means 做大数据方面 客户价值分析等
比如: 航空大数据客户价值分析, 通过LRFMC数据模型的建立, 数据抽取, 数据清洗, 数据规约, 数据变化以及模型训练对客户价值进行分析,并得出精准营销办法.

在后期的知识储备中需要有:
numpy, pandas, matplotlib, scipy, scikit-learn, …

推荐一个工具:
jupyter notebook

人工智能学科体系结构:
人工智能基础:
扎实的数学基础: 线性代数, 高数, 概率论, 统计学, 运筹学…
常用的相关开发语言: Python, R 等
Python中用户科学计算的各种模块库, 封装了大量的API实现矢量运算

机器学习:
人工智能的入门学习: 监督学习和非监督学习
核心学习算法的应用模型: 逻辑斯蒂回归, 随机梯度下降, SVC支持向量机, 贝叶斯, K近邻等等
Scikit-learn, 这是python中专门用于机器学习的核心及经典模块库, 实现了各种学习模型的算法

注意: SVM, SVC, SVR的区别!!!

深度学习:
推荐常用的框架Tensorflow
回归算法的实现: 最小二乘法, 数据拟合残差值, 自我实现sklearn中的算法, 等等

科学计算与数据分析
可以说是一个人工智能方向的分支, 也可以说是人工智能的基础
需要使用到数据学相关专业知识.
最主要的两方面内容:
1, 研究数据本身
2, 为自然科学和社会科学研究提供一种新方法, 主要用到多维矩阵和矢量运算.

机器学习:
是人工智能的主要领域, 也是人工智能算法的基础

机器学习中涵盖了很多相关交叉学科: 概率论, 统计学, 逼近论, 凸分析, 算法复杂度理论, 等等.
专门用来研究计算机怎样模拟或者实现人类的学习行为, 以获取新的知识点或者技能, 重新组织已有知识结构, 使之段改善自身的性能.

监督学习:
分类学习 和 回归预测
数据特征及任务:
二分类问题, 多分类问题
算法:
LogisticRegression, SGDClassifier, LinearSVC, MultimormialNB, KNeighborsClassifier, …

非监督学习:
数据聚类 和 特征降维
数据聚类: K-means聚类分析
特征降维: 将众多的特征值进行精简和筛选, 得出最能区别数据之间差异的维度选项

核心模块库介绍:
scipy
在科学计算中是一个典型的依赖工具库, 全面支持numpy 和 pandas的模块使用, 我们也可以单独使用.
该模块库是统计学各种统计算法和基础理论的实现库.

numpy
为pytho语言提供了全新的数组类型, 可以快速实现 多维矩阵 以及 常用矢量计算.
该模块库是 高等数学 和 线性代数 等 数学原理的实现库.

pandas
科学计算数据分析的核心模块库.
在numpy和scipy的支撑下, 快速完成对两个基础模块进行二次封装, 提供更加简洁的API函数完成数据的处理和统计分析,
同时添加其特有的数据类型和数据处理的API

matplotlib
数据可视化的基础模块库, 实现数据的可视化呈现, 以各种直观的图标形式, 快速展现数据特征和变化趋势

深度学习
人工智能的应用技术领域
深度学习的概念源于人工神经网络得研究, 含多层的多层感知器, 就是一种深度学习的结构.
深度学习通过组合低层3形成更加抽象的高层表示属性类别或特征, 以发现数据的分布式特征表示.

掌握的知识点:
数据拟合
回归计算
最小二乘积的实现
残差均方值的计算

拓展:
CNN, RNN (LSTM) 等常用的神经网络 以及 常用的学习模型 和 具体实现方法

​