Scatter函数是一个强大的画散点图函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

matplotlib.pyplot.scatter(x, y, s=None, c=None, marker=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, verts=None, edgecolors=None, *, data=None, **kwargs)

#x,y：表示数据的位置，也就是x,y轴
#s：表示图形的大小
#c：表示颜色或颜色序列，可能的情况如下： 

'''
  1. 单一颜色
  2. 颜色序列
  3. 使用cmap映射到颜色的序列数
  4. 一个行为RGB的2-D数组

marker：绘出的图形的形状，具有多种风格 
'''

一、画散点图(一)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#散点图
#导入必要的模块
import numpy as np
import matplotlib.pyplot as plt

#参数随机数
N=50
x=np.random.randn(N)
y=np.random.randn(N)

#画散点图
plt.scatter(x,y,s=50,c='r',marker='o',alpha=0.5)
#x--->x轴，y--->y轴
#s--->散点面积
#c--->散点颜色
#颜色参数c：b-->blue  c-->cyan g-->green  k-->black  m-->magenta  r-->red 
#w-->white  y-->yellow
#marker--->散点形状
#marker='o'为圆点，marker='x'为×号，marker='s'显示为小正方形
#alpha--->散点透明度

#显示所画的图
plt.show()

二、画散点图(二）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#导入必要的模块 
import numpy as np 
import matplotlib.pyplot as plt 

#产生测试数据 
x = np.arange(1,10) 
y = x 
fig = plt.figure() 
ax1 = fig.add_subplot(111) 

#设置标题 
ax1.set_title('Scatter Plot') 

#设置X轴标签 
plt.xlabel('X') 

#设置Y轴标签 
plt.ylabel('Y') 

#画散点图 
ax1.scatter(x,y,c = 'r',marker = 'o') 

#设置图标 
plt.legend('x1') 

#显示所画的图 
plt.show()

​ 最近深度学习发展非常迅猛，大有一统江湖的趋势。经过一段时间学习，发现自己对这种神奇的玄学非常感兴趣，希望能够进一步的研究。而这种研究性学科单纯地看论文比较难以明白，所以希望能够跟进大牛们写的代码深入学习。我发现很多大牛给的源码是基于python写的，于是就打算学习python。

一、Spyder的用法

• Spyder是一个简单的集成开发环境，它模拟MATLAB的‘工作空间’的功能，可以很方便的观察和修改数组的值。
• 推荐您使用IPython Console，因为它比标准的Python Console的功能更多，并且建议您将它设置为默认控制台。
• 命名空间（在任何给定时间内在console中定义的对象集合）在IPython中可以使用%reset命令清除。输入%reset然后按下enter键，用y确认。
• 首先要进行工具栏设置，调出QT窗体来显示图形。
• 第一步：选择工具栏的Tools–>Preferences

• 第二步：点击IPython console选项

• 第三步：选择Graphics选项，在Backend选择Qt5，然后保存重启就行

Windows10环境下的安装python+tensorflow

使用Anoconda简单安装CPU版tensorflow的方法，此方法能够一键安装常用
机器学习所需的科学计算包，免去了手动配置python环境变量的过程。
安装环境：

• Windows10 64位
• Python 3.5.2
• Anocoda3 4.2.0
• tensorflow 0.1.2
  1、tensorflow
  谷歌发布的开源框架，涉及到自然语言处理NLP
  机器翻译，图像描述，图像分类等一些列技术
  tensorflow为我们封装了大量机器学习，神经网络的函数，帮助我们高效的解决问题
  2、Anoconda
  Anoconda可以看做是Python的一个集成安装环境。
  安装它就默认安装了python，IPython，集成开发环境Spyder和众多的包和模块
  非常方便。而且Anaconda会为我们安装pip（强大的包管理程序）
  我们可以在Windows的命令行中使用pip直接安装我们需要的包
  3、下载Anaconda
  官网的最新版Anaconda-4.4.0继承了python-3.6
  但是tensorflow仍然不能支持3.6，因为我们安装集成python-3.5的Anaconda3-4.2.0
  Anaconda下载地址：Anaconda

安装过后可以再命令行，输入conda list来查看Anaconda为我们集成的环境。
ps:快捷点Win+R,然后输入cmd，然后输入conda list来查看Anaconda为我们集成的环境。

环境里包含：
numpy(一个python的科学计算包，高效存储和处理大型矩阵)
pandas(包含了大量库和一些标准的数据模型，提供高效的操作大型数据集所需要的工具)
pip(简单好用的包管理工具)

4、安装TensorFlow

• 使用pip自动安装TensorFlow

​ pip install tensorflow

• 当遇到提示更新pip版本的时候，先进行pip更新到最新版本

​ python -m pip install –upgrade pip

• 安装的时候尽量使用管理员身份来打开命令行窗口（ps:Win10系统点击左下角Win图标右键，选择管理员身份就行）
• 安装TensorFlow

​ pip install tensorflow

• 测试是否安装成功

​ 输入python进入python环境

​ 输入import tensorflow,若没有红字报错，表示环境配置成功

其实异步是目的，多线程是实现这个目的方法。

• 异步：A发起一个操作后，可以继续自顾自的处理它自己的事儿，不用干等着这个耗时操作返回
• 随着拥有多线程CPU,多核的普及，多线程和异步操作等并发程序设计方法也受到更多

1、多线程和异步操作的异同

• 多线程和异步操作两者都可以达到避免调用线程阻塞的目的，从而提高软件的可响应性。
• 甚至有些时候我们认为多线程和异步操作是等同的。但是多线程和异步操作还是有一些区别

2、异步操作的本质：

• 所有的程序最终都会由计算机硬件来执行。所以为了更好的理解异步操作的本质，网卡，声卡，显卡都是有DMA功能的DMA就是直接内存访问的意思（Driect Memory Access）
• 也就是说，拥有DMA功能的硬件在和内存进行数据交换的时候可以不消耗CPU资源
• 只要CPU在发起数据传输时发送一个指令，硬件就开始自己和内存交换数据在传输完成后硬件会触发一个中断来通知操作完成这些无需消耗CPU时间的I/O操作正是异步操作的硬件基础。
• 所以即使在DOS这样的单进程（无线程概念）系统中也同样可以发起异步的DMA操作

3、线程的本质

• 线程不是一个计算机硬件的功能，而是操作系统提供的一种逻辑功能
• 线程本质上是进程中一段并发运行的代码，所以线程需要操作系统投入CPU资源来运行和调度

4、异步操作的特点

• 因为异步操作 不需要额外的线程负担，并且使用回调的方式进行处理在设计良好的情况下，处理函数可以不必使用共享变量，即使无法完全不用，最起码也可以减少共享变量的数量。减少了死锁的可能。
• 当然异步操作也并非完美无瑕。编写异步操作的复杂程度较高，程序主要使用回调方式进行处理与普通人的思维方式有些初入，而且难以调试。

5、多线程的优缺点

• 线程中的护理程序依然是顺序执行，符合普通人的思维习惯。所以编程简单但是多线程的缺点也明显
• 线程的滥用会给系统带来上下文切换的额外负担并且线程间的共享变量可能造成死锁的出现。
• 当需要执行I/O操作的时候，使用异步操作比使用线程+同步I/O操作更合还是I/O操作不仅包括了直接的文件，网络的读写，还包括数据库操作，WebService，HttpRequest等跨进程的调用
• 线程的适用范围是需要长时间CPU运算的场合比如耗时较长图形处理和算法执行，但是往往由于线程编程的简单和符合习惯，所以很多朋友往往适用线程来执行耗时较长的IO操作，这样在之后又少数几个并发操作的时候还行，需要处理大量的并发操作就不合适了，因为要不停的上下文切换

6、异步调用

• 异步调用并不是要减少线程的开销，目的是让调用方法的主线程不需要同步等待这个函数
• 调用上，从而可以让主线程继续执行他下面的代码，同时系统会从ThreadPool线程池中取一个线程来执行，帮助我们将我们要写/读的数据发送到网卡，由于不需要我们等待，我们等于同时做了两件事情

7、线程池的实现方法

• 线程池的实现方法与线程不一样的，初始化时候，在线程池的线程为0，当进程需要一个线程的时候，创建一个线程由此线程执行用户的方法，这个线程执行完后并不立即销毁，而是挂起等待，如果有其他方法需要
• 执行，则唤醒进行处理 ，只有当它等待到40秒还没有任务执行的时候才唤醒自己，并销毁自己
• 当然如果线程池中的线程不够处理任务的时候，会再次创建一个新的线程来执行。

1、同步交互：发送一个请求，需要等待返回，然后才能够发送下一个请求，有个等待过程

2、异步交互：发送一个请求，不需要等待返回，随时可以再发送下一个请求，也就是不需要等待

• 区别：一个需要等待，一个不需要等待，再部分情况下，我们的项目开发中都会优先选择不需要等待的异步交互方式。
• 同步：用来确保资源一次只能被一个县城使用的过程。同步对于单线程程序没有任何好处。

使用同步比非同步的性能差三到四倍

线程都是独立的，而且异步执行，也就是说每个线程都包含了运行时所需要的数据或者方法

而不需要外部的资源或者方法，也不必关心其他线程的状态或者行为。

但是经常有些同时运行的线程需要共享数据，此时就需要考虑其他线程的状态和行为。

否则就不能保证程序的运行结果的正确性

需要做的是允许一个线程彻底完成他的任务后，在允许执行下一个线程执行。必须保证一个共享的

资源一次只能被一个线程使用，实现的目的过程叫做同步。

• 比如广播就是一个异步的例子。发起者不关心接受者的状态，不需要等待接受者的返回信息
• 比如电话就是一个同步的例子，发起者需要等待接收者，接通电话后，通信才能开始，需要等待接收者的返回信息。

同步和异步的区别：

在进行网络编程的时候，我们会看到同步，异步，阻塞，非阻塞4种调用方式以及他们的组合

其中同步方式，异步方式主要是由客户端client控制的

同步sync：

就是发起一个功能调用的时候，在没有得到结果之前，该调用就不返回或者继续执行后续操作

Java中所有方法都是同步调用，因为必须要等待结果后才能继续执行

我们说的同步，异步的时候，一般而言是指那些需要其他端写作或者需要一定时间完成的任务

简单而言：同步就是必须一件一件事做，等前一件做完了后才能做下一件事

B/S模式的表单提交：客户端提交请求–》等待服务器处理–》处理完毕返回

在这个过程中客户端（浏览器）不能做其他事情

异步（Async）

异步与同步相反，当一个异步过程调用发出后，调用者在没有得到结果之前，就可以继续执行后续操作

当这个调用完成后，一般通过状态，通知和回调来通知调用者。

对于异步调用，调用的返回并不受调用者控制

对于通知调用者的三种方式：

• 状态：监听被调用者的状态（轮询），调用者需要每隔一定时间检查一次，效率会很低
• 通知：当被调用者执行完成后，发出通知告知调用者，不需要消耗太多性能
• 回调：与通知类似，当被调用者执行完成后，会调用调用者提供的回调函数

B/S模式的ajax的请求，具体过程：客户端发出ajax请求–》服务端处理–》处理完毕执行客户端回调

在客户端（浏览器）发出请求后，仍然可以做其他的事情

同步与异步的区别：请求发出后，是否需要等待结果，才能继续执行其他操作。

单例模式要求一个类只能有一个实例，并且提供了一个全局的访问点。

比如说，中国主席的职位是Singleton，法律规定主席选举，任何时间只能有一个主席。

1、逻辑模型图：

2、物理模型图：

3、具体实现：

3.1、懒汉式单例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

//懒汉式单例
public sealed class Singleton//类设置属性为密封，不能被继承。
{
    static Singleton instance=null;
    Singleton()
    {}
    
    public static Singleton Instance
    {
        get
        {
            if(instance==null)
            {
                instance=new Singleton();
            }
            return instance;
        }
    }
}
//这种实现方式，不是线程安全的，因为多线程的时候，可能会得到Singleton类的多个实例。
//假如有两个线程都去判断if(instance==null)并且得到结果为true，这时两个线程
//都会创建类Singleton的实例，违背了单例模式只能有一个类对象的实例的原则。

3.2、线程安全的单例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public sealed class Singleton
{
    static Singleton instance=null;
    static readonly object padlock=new object();//进程辅助对象
    
    Singleton()
    {
    
    }
    
    public static Singleton Instance
    {
        get
        {
            lock(padlock)
            {
                if(instance==null)
                {
                    instance=new Singleton();
                }
                return instance;
            }
        }
    }
}
//对于线程来说是安全的，首先创建了一个进程的辅助对象，线程进入时先对padlock加锁
//然后在检测对象是否被创建，这样可以确保只有一个实例被创建，而且加入了锁，导致程序只有
//一个线程可以进去，对象实例有最先进入的那个线程创建，后面进来的线程进入时if(instance==null)为false
//不会再去创建对象实例，这种方式增加了额外的开销，损失了性能。

3.3、双重锁定

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public sealed class Singleton
{
    static Singleton instance=null;
    static readonly object padlock=new object();
    
    Singleton()
    {
    
    }
    
    public static Singleton Instance
    {
        get
        {
            if(instance==null)
            {
                lock(padlock)
                {
                    if(instance==null)
                    {
                        instance=new Singleton();
                    }
                }
            }
            return instance;
        }
    }
}
//对于多线程是安全的，而且并不是线程每次都加锁，只有判断对象实例没有被创建的时候才会加锁
//加锁还再进行对象是否被创建的判断。解决了线程并发的问题，但是实际上需要这样实现，大多数我们会
//使用静态初始化，但是静态初始化有自己的缺点，无法实现延迟初始化

3.4、静态初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public sealed class Singleton
{
    static readonly Singleton instance=new Singleton();
    //静态初始化的无参构造方法
    static Singleton()
    {
    
    }
    
    Singleton()
    {
    
    }
    
    public static Singleton Instance
    {
        get
        {
            return instance;
        }
    }
}
//类标记为sealed不能继承，因为继承可能会增加实例。
//变量标记为readonly，表示只能在静态初始化时候或者在构造方法中分配变量。

3.5、延迟初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

//如果类，结构，代理，枚举是外置，那么修饰符只有public和internal，默认是internal
//如果是内置的，修饰符默认是private
//举例： class A{}//类A是internal，internal表示同一个程序集中所有代码都可以访问类型或者成员
//其他程序集不可以访问。
//举例：class A
//            {
//                class B{}//类B是private
//            }
public sealed class Singleton
{
    Singleton()//类的构造函数默认为private
    {
    
    }
    
    public static Singleton Instance
    {
        get
        {
            return Lazy.instance;
        }
    }
    
    class Lazy//lazy默认是internal
    {
        static Lazy()
        {
        
        }
        internal static readonly Singleton instance=new Singleton();
    }
    
}
//初始化的时候有一个Lazy类的一个静态成员来完成，这样实现了延迟初始化。

4、实现总结：

Singleton单例模式构造方法可以设置为protected，允许子类继承。

单例模式不要支持实例化，可能导致多个对象实例，也不要支持Icloneable接口，导致多个对象的实例，单例模式只考虑了对象创建的管理，没有考虑对象销毁的管理，支持垃圾回收的平台的对象的开销来讲，没必要对其销毁进行特殊的管理。

理解：Singleton模式核心：如何控制用户使用new对一个类的构造方法任意调用。