更新了基础部分的部分内容

Day01-15/Appendix-A/code/excel1.py

+"""
+
+创建Excel文件
+
+Version: 0.1
+Author: 骆昊
+Date: 2018-03-26
+
+"""
+
+from openpyxl import Workbook
+from openpyxl.worksheet.table import Table, TableStyleInfo
+
+workbook = Workbook()
+sheet = workbook.active
+data = [
+    [1001, '白元芳', '男', '13123456789'],
+    [1002, '白洁', '女', '13233445566']
+]
+sheet.append(['学号', '姓名', '性别', '电话'])
+for row in data:
+    sheet.append(row)
+tab = Table(displayName="Table1", ref="A1:E5")
+
+tab.tableStyleInfo = TableStyleInfo(
+    name="TableStyleMedium9", showFirstColumn=False,
+    showLastColumn=False, showRowStripes=True, showColumnStripes=True)
+sheet.add_table(tab)
+workbook.save('./res/全班学生数据.xlsx')

Day01-15/Appendix-A/code/excel2.py

+"""
+
+读取Excel文件
+
+Version: 0.1
+Author: 骆昊
+Date: 2018-03-26
+
+"""
+
+from openpyxl import load_workbook
+from openpyxl import Workbook
+
+workbook = load_workbook('./res/学生明细表.xlsx')
+print(workbook.sheetnames)
+sheet = workbook[workbook.sheetnames[0]]
+print(sheet.title)
+for row in range(2, 7):
+	for col in range(65, 70):
+		cell_index = chr(col) + str(row)
+		print(sheet[cell_index].value, end='\t')
+	print()

Day01-15/Appendix-A/code/pdf1.py

+"""
+
+创建PDF文件
+
+Version: 0.1
+Author: 骆昊
+Date: 2018-03-26
+
+"""
+
+import PyPDF2

Day01-15/Appendix-A/code/pdf2.py

+"""
+
+读取PDF文件
+
+Version: 0.1
+Author: 骆昊
+Date: 2018-03-26
+
+"""
+
+from PyPDF2 import PdfFileReader
+
+with open('./res/Python课程大纲.pdf', 'rb') as f:
+	reader = PdfFileReader(f, strict=False)
+	print(reader.numPages)
+	if reader.isEncrypted:
+		reader.decrypt('')
+	current_page = reader.getPage(5)
+	print(current_page)
+	print(current_page.extractText())

Day01-15/Appendix-A/code/pillow1.py

+"""
+
+使用pillow操作图像
+
+Version: 0.1
+Author: 骆昊
+Date: 2018-03-26
+
+"""
+
+from PIL import Image
+
+img = Image.open('./res/guido.jpg')
+print(img.size)
+print(img.format)
+print(img.format_description)
+img.save('./res/guido.png')
+
+img2 = Image.open('./res/guido.png')
+img3 = img2.crop((335, 435, 430, 615))
+for x in range(4):
+	for y in range(5):
+		img2.paste(img3, (95 * y , 180 * x))
+img2.resize((img.size[0] // 2, img.size[1] // 2))
+img2.rotate(90)
+img2.save('./res/guido2.png')

Day01-15/Appendix-A/code/word1.py

+"""
+
+创建Word文件
+
+Version: 0.1
+Author: 骆昊
+Date: 2018-03-26
+
+"""
+

Day01-15/Appendix-A/code/word2.py

+"""
+
+读取Word文件
+
+Version: 0.1
+Author: 骆昊
+Date: 2018-03-26
+
+"""
+
+from docx import Document
+
+doc = Document('./res/用函数还是用复杂的表达式.docx')
+print(len(doc.paragraphs))
+print(doc.paragraphs[0].text)
+# print(doc.paragraphs[1].runs[0].text)
+
+content = []
+for para in doc.paragraphs:
+	content.append(para.text)
+print(''.join(content))

Day01-15/Appendix-A/图像和办公文档处理.md

+## 图像和办公文档处理
+
+用程序来处理图像以及办公文档在实际开发中非常常见，我们可以通过Python生态圈中的第三方模块来完成这些操作。
+
+### 操作图像
+
+#### 计算机图像相关知识
+
+1. 颜色。如果你有使用颜料画画的经历，那么一定知道混合红、黄、蓝三种颜料可以得到其他的颜色，事实上这三种颜色就是被我们称为美术三原色的东西，它们是不能再分解的基本颜色。在计算机中，我们可以将红、绿、蓝三种色光以不同的比例叠加来组合成其他的颜色，因此这三种颜色就是色光三原色，所以我们通常会将一个颜色表示为一个RGB值或RGBA值（其中的A表示Alpha通道，它决定了透过这个图像的像素，也就是透明度）。
+2. 像素。对于一个由数字序列表示的图像来说，最小的单位就是图像上单一颜色的小方格，这些小方块都有一个明确的位置和被分配的色彩数值，而这些一小方格的颜色和位置决定了该图像最终呈现出来的样子，它们是不可分割的单位，我们通常称之为像素（pixel）。每一个图像都包含了一定量的像素，这些像素决定图像在屏幕上所呈现的大小。
+
+#### 用Pillow操作图像
+
+- 剪裁图片
+- 调整图片大小
+- 旋转和翻转
+- 操作像素
+- 添加水印
+
+### 处理Excel电子表格
+
+Python的OpenPyXL模块让我们可以在Python程序中读取和修改Excel电子表格，LibreOffice Calc和OpenOffice Calc也都能处理Excel的电子表格文件，这就意味着OpenPyXL模块也能处理来自这些应用程序的电子表格。关于OpenPyXL的使用手册和使用文档可以查看它的[官方文档](https://openpyxl.readthedocs.io/en/stable/#)。
+
+### 处理Word文档
+
+| 属性          | 描述       |
+| ------------- | ---------- |
+| bold          | 粗体       |
+| italic        | 斜体       |
+| underline     | 下划线     |
+| strike        | 删除线     |
+| double_strike | 双删除线   |
+| all_caps      | 大写首字母 |
+| small_caps    | 大写首字母 |
+| shadow        | 带阴影     |
+| outline       | 轮廓显示   |
+| rtl           | 从右向左   |
+| imprint       | 凹嵌页面   |
+| emboss        | 凸出页面   |
+
+
+### 处理PDF文档
+
+PDF是Portable Document Format的缩写，使用.pdf作为文件扩展名。
\ No newline at end of file

Day01-15/Appendix-B/chatclient.py

+from socket import socket
+from threading import Thread
+
+
+def main():
+
+    class RefreshScreenThread(Thread):
+
+        def __init__(self, client):
+            super().__init__()
+            self._client = client
+
+        def run(self):
+            while running:
+                data = self._client.recv(1024)
+                print(data.decode('utf-8'))
+
+    nickname = input('请输入你的昵称: ')
+    myclient = socket()
+    myclient.connect(('10.7.189.118', 12345))
+    running = True
+    RefreshScreenThread(myclient).start()
+    while running:
+        content = input('请发言: ')
+        if content == 'byebye':
+            myclient.send(content.encode('utf-8'))
+            running = False
+        else:
+            msg = nickname + ': ' + content
+            myclient.send(msg.encode('utf-8'))
+
+
+if __name__ == '__main__':
+    main()

Day01-15/Appendix-B/chatserver.py

+from socket import socket
+from threading import Thread
+
+
+def main():
+
+    class ClientHandler(Thread):
+
+        def __init__(self, client):
+            super().__init__()
+            self._client = client
+
+        def run(self):
+            try:
+                while True:
+                    try:
+                        data = self._client.recv(1024)
+                        if data.decode('utf-8') == 'byebye':
+                            clients.remove(self._client)
+                            self._client.close()
+                            break
+                        else:
+                            for client in clients:
+                                client.send(data)
+                    except Exception as e:
+                        print(e)
+                        clients.remove(self._client)
+                        break
+            except Exception as e:
+                print(e)
+
+    server = socket()
+    server.bind(('10.7.189.118', 12345))
+    server.listen(512)
+    clients = []
+    while True:
+        curr_client, addr = server.accept()
+        print(addr[0], '连接到服务器.')
+        clients.append(curr_client)
+        ClientHandler(curr_client).start()
+
+
+if __name__ == '__main__':
+    main()

Day01-15/Appendix-B/fileclient.py

+from socket import socket
+from json import loads
+from base64 import b64decode
+
+
+def main():
+    client = socket()
+    client.connect(('192.168.1.2', 5566))
+    # 定义一个保存二进制数据的对象
+    in_data = bytes()
+    # 由于不知道服务器发送的数据有多大每次接收1024字节
+    data = client.recv(1024)
+    while data:
+        # 将收到的数据拼接起来
+        in_data += data
+        data = client.recv(1024)
+    # 将收到的二进制数据解码成JSON字符串并转换成字典
+    # loads函数的作用就是将JSON字符串转成字典对象
+    my_dict = loads(in_data.decode('utf-8'))
+    filename = my_dict['filename']
+    filedata = my_dict['filedata'].encode('utf-8')
+    with open('/Users/Hao/' + filename, 'wb') as f:
+        # 将base64格式的数据解码成二进制数据并写入文件
+        f.write(b64decode(filedata))
+    print('图片已保存.')
+
+
+if __name__ == '__main__':
+    main()

Day01-15/Appendix-B/fileserver.py

+from socket import socket, SOCK_STREAM, AF_INET
+from base64 import b64encode
+from json import dumps
+from threading import Thread
+
+
+def main():
+
+    # 自定义线程类
+    class FileTransferHandler(Thread):
+
+        def __init__(self, cclient):
+            super().__init__()
+            self.cclient = cclient
+
+        def run(self):
+            my_dict = {}
+            my_dict['filename'] = 'guido.jpg'
+            # JSON是纯文本不能携带二进制数据
+            # 所以图片的二进制数据要处理成base64编码
+            my_dict['filedata'] = data
+            # 通过dumps函数将字典处理成JSON字符串
+            json_str = dumps(my_dict)
+            # 发送JSON字符串
+            self.cclient.send(json_str.encode('utf-8'))
+            self.cclient.close()
+
+    # 1.创建套接字对象并指定使用哪种传输服务
+    server = socket()
+    # 2.绑定IP地址和端口(区分不同的服务)
+    server.bind(('192.168.1.2', 5566))
+    # 3.开启监听 - 监听客户端连接到服务器
+    server.listen(512)
+    print('服务器启动开始监听...')
+    with open('guido.jpg', 'rb') as f:
+        # 将二进制数据处理成base64再解码成字符串
+        data = b64encode(f.read()).decode('utf-8')
+    while True:
+        client, addr = server.accept()
+        # 用一个字典(键值对)来保存要发送的各种数据
+        # 待会可以将字典处理成JSON格式在网络上传递
+        FileTransferHandler(client).start()
+
+
+if __name__ == '__main__':
+    main()

Day01-15/Appendix-B/mmdownloader.py

+from time import time
+from threading import Thread
+
+import requests
+
+
+class DownloadHanlder(Thread):
+
+    def __init__(self, url):
+        super().__init__()
+        self.url = url
+
+    def run(self):
+        filename = self.url[self.url.rfind('/') + 1:]
+        resp = requests.get(self.url)
+        with open('/Users/Hao/Downloads/' + filename, 'wb') as f:
+            f.write(resp.content)
+
+
+def main():
+    # 通过requests模块的get函数获取网络资源
+    resp = requests.get(
+        'http://api.tianapi.com/meinv/?key=772a81a51ae5c780251b1f98ea431b84&num=10')
+    # 将服务器返回的JSON格式的数据解析为字典
+    data_model = resp.json()
+    for mm_dict in data_model['newslist']:
+        url = mm_dict['picUrl']
+        # 通过多线程的方式实现图片下载
+        DownloadHanlder(url).start()
+
+
+if __name__ == '__main__':
+    main()

Day01-15/Appendix-B/socket1.py

+"""
+
+套接字 - 基于TCP协议创建时间服务器
+
+Version: 0.1
+Author: 骆昊
+Date: 2018-03-22
+
+"""
+
+from socket import *
+from time import *
+
+server = socket(AF_INET, SOCK_STREAM)
+server.bind(('localhost', 6789))
+server.listen()
+print('服务器已经启动正在监听客户端连接.')
+while True:
+	client, addr = server.accept()
+	print('客户端%s:%d连接成功.' % (addr[0], addr[1]))
+	currtime = localtime(time())
+	timestr = strftime('%Y-%m-%d %H:%M:%S', currtime)
+	client.send(timestr.encode('utf-8'))
+	client.close()
+server.close()

Day01-15/Appendix-B/socket2.py

+"""
+
+套接字 - 基于TCP协议创建时间客户端
+
+Version: 0.1
+Author: 骆昊
+Date: 2018-03-22
+
+"""
+
+from socket import *
+
+client = socket(AF_INET, SOCK_STREAM)
+client.connect(('localhost', 6789))
+while True:
+	data = client.recv(1024)
+	if not data:
+		break
+	print(data.decode('utf-8'))
+client.close()

Day01-15/Appendix-B/socket3.py

+"""
+
+套接字 - 基于UDP协议Echo服务器
+
+Version: 0.1
+Author: 骆昊
+Date: 2018-03-22
+
+"""
+
+from socket import *
+from time import *
+
+server = socket(AF_INET, SOCK_DGRAM)
+server.bind(('localhost', 6789))
+while True:
+	data, addr = server.recvfrom(1024)
+	server.sendto(data, addr)
+server.close()

Day01-15/Appendix-B/socket4.py

+"""
+
+套接字 - 基于UDP协议创建Echo客户端
+
+Version: 0.1
+Author: 骆昊
+Date: 2018-03-22
+
+"""
+
+from socket import *
+
+client = socket(AF_INET, SOCK_DGRAM)
+while True:
+	data_str = input('请输入: ')
+	client.sendto(data_str.encode('utf-8'), ('localhost', 6789))
+	data, addr = client.recvfrom(1024)
+	data_str = data.decode('utf-8')
+	print('服务器回应:', data_str)
+	if data_str == 'bye':
+		break
+client.close()

Day01-15/Appendix-B/socket5.py

+"""
+
+使用socketserver模块创建时间服务器
+
+Version: 0.1
+Author: 骆昊
+Date: 2018-03-22
+
+"""
+
+from socketserver import TCPServer, StreamRequestHandler
+from time import *
+
+
+class EchoRequestHandler(StreamRequestHandler):
+
+	def handle(self):
+		currtime = localtime(time())
+		timestr = strftime('%Y-%m-%d %H:%M:%S', currtime)
+		self.wfile.write(timestr.encode('utf-8'))
+
+
+server = TCPServer(('localhost', 6789), EchoRequestHandler)
+server.serve_forever()

Day01-15/Appendix-B/timeclient.py

+from socket import socket
+
+
+def main():
+    client = socket()
+    client.connect(('10.7.152.69', 6789))
+    print(client.recv(1024).decode('utf-8'))
+    client.close()
+
+
+if __name__ == '__main__':
+    main()

Day01-15/Appendix-B/timeserver.py

+from socket import socket, SOCK_STREAM, AF_INET
+from datetime import datetime
+
+
+def main():
+    # 1.创建套接字对象并指定使用哪种传输服务
+    # family=AF_INET - IPv4地址
+    # family=AF_INET6 - IPv6地址
+    # type=SOCK_STREAM - TCP套接字
+    # type=SOCK_DGRAM - UDP套接字
+    # type=SOCK_RAW - 原始套接字
+    server = socket(family=AF_INET, type=SOCK_STREAM)
+    # 2.绑定IP地址和端口(区分不同的服务)
+    server.bind(('192.168.1.2', 6789))
+    # 3.开启监听 - 监听客户端连接到服务器
+    server.listen(512)
+    print('服务器启动开始监听...')
+    # 4.通过循环接收客户端的连接并作出相应的处理(提供服务)
+    while True:
+        # accept方法是一个阻塞方法如果没有客户端连接到服务器
+        # 这个方法就会阻塞代码不会向下执行
+        # accept方法返回元组其中的第一个元素是客户端对象
+        # 第二个元素是客户端的地址(由IP和端口两部分构成)
+        client, addr = server.accept()
+        print(str(addr) + '连接到了服务器.')
+        # 5.发送数据
+        client.send(str(datetime.now()).encode('utf-8'))
+        # 6.断开连接
+        client.close()
+
+
+if __name__ == '__main__':
+    main()

Day01-15/Day10/code/renju.py

+import pygame
+
+EMPTY = 0
+BLACK = 1
+WHITE = 2
+
+black_color = [0, 0, 0]
+white_color = [255, 255, 255]
+
+
+class RenjuBoard(object):
+
+    def __init__(self):
+        self._board = [[]] * 15
+        self.reset()
+
+    def reset(self):
+        for row in range(len(self._board)):
+            self._board[row] = [EMPTY] * 15
+
+    def move(self, row, col, is_black):
+        if self._board[row][col] == EMPTY:
+            self._board[row][col] = BLACK if is_black else WHITE
+            return True
+        return False
+
+    def draw(self, screen):
+        for index in range(1, 16):
+            pygame.draw.line(screen, black_color,
+                             [40, 40 * index], [600, 40 * index], 1)
+            pygame.draw.line(screen, black_color,
+                             [40 * index, 40], [40 * index, 600], 1)
+        pygame.draw.rect(screen, black_color, [36, 36, 568, 568], 4)
+        pygame.draw.circle(screen, black_color, [320, 320], 5, 0)
+        pygame.draw.circle(screen, black_color, [160, 160], 5, 0)
+        pygame.draw.circle(screen, black_color, [480, 480], 5, 0)
+        pygame.draw.circle(screen, black_color, [480, 160], 5, 0)
+        pygame.draw.circle(screen, black_color, [160, 480], 5, 0)
+        for row in range(len(self._board)):
+            for col in range(len(self._board[row])):
+                if self._board[row][col] != EMPTY:
+                    ccolor = black_color \
+                        if self._board[row][col] == BLACK else white_color
+                    pos = [40 * (col + 1), 40 * (row + 1)]
+                    pygame.draw.circle(screen, ccolor, pos, 20, 0)
+
+
+def main():
+    board = RenjuBoard()
+    is_black = True
+    pygame.init()
+    pygame.display.set_caption('五子棋')
+    screen = pygame.display.set_mode([640, 640])
+    screen.fill([255, 255, 0])
+    board.draw(screen)
+    pygame.display.flip()
+    running = True
+    while running:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                running = False
+            elif event.type == pygame.KEYUP:
+                pass
+            elif event.type == pygame.MOUSEBUTTONDOWN\
+                    and event.button == 1:
+                x, y = event.pos
+                row = round((y - 40) / 40)
+                col = round((x - 40) / 40)
+                if board.move(row, col, is_black):
+                    is_black = not is_black
+                    screen.fill([255, 255, 0])
+                    board.draw(screen)
+                    pygame.display.flip()
+    pygame.quit()
+
+
+if __name__ == '__main__':
+    main()

Day01-15/Day10/code/snake.py

+from abc import ABCMeta, abstractmethod
+from enum import Enum, unique
+from random import randrange
+from threading import Thread
+
+import pygame
+
+
+class Color(object):
+    """颜色"""
+
+    GRAY = (242, 242, 242)
+    BLACK = (0, 0, 0)
+    GREEN = (0, 255, 0)
+    PINK = (255, 20, 147)
+
+
+@unique
+class Direction(Enum):
+    """方向"""
+
+    UP = 0
+    RIGHT = 1
+    DOWN = 2
+    LEFT = 3
+
+
+class GameObject(object, metaclass=ABCMeta):
+    """游戏中的对象"""
+
+    def __init__(self, x=0, y=0, color=Color.BLACK):
+        """
+        初始化方法
+
+        :param x: 横坐标
+        :param y: 纵坐标
+        :param color: 颜色
+        """
+        self._x = x
+        self._y = y
+        self._color = color
+
+    @property
+    def x(self):
+        return self._x
+
+    @property
+    def y(self):
+        return self._y
+
+    @abstractmethod
+    def draw(self, screen):
+        """
+        绘制
+
+        :param screen: 屏幕
+        """
+        pass
+
+
+class Wall(GameObject):
+    """围墙"""
+
+    def __init__(self, x, y, width, height, color=Color.BLACK):
+        """
+        初始化方法
+
+        :param x: 横坐标
+        :param y: 纵坐标
+        :param width: 宽度
+        :param height: 高度
+        :param color: 颜色
+        """
+        super().__init__(x, y, color)
+        self._width = width
+        self._height = height
+
+    @property
+    def width(self):
+        return self._width
+
+    @property
+    def height(self):
+        return self._height
+
+    def draw(self, screen):
+        pygame.draw.rect(screen, self._color,
+                         (self._x, self._y, self._width, self._height), 4)
+
+
+class Food(GameObject):
+    """食物"""
+
+    def __init__(self, x, y, size, color=Color.PINK):
+        """
+        初始化方法
+
+        :param x: 横坐标
+        :param y: 纵坐标
+        :param size: 大小
+        :param color: 颜色
+        """
+        super().__init__(x, y, color)
+        self._size = size
+        self._hidden = False
+
+    def draw(self, screen):
+        if not self._hidden:
+            pygame.draw.circle(screen, self._color,
+                               (self._x + self._size // 2, self._y + self._size // 2),
+                               self._size // 2, 0)
+        self._hidden = not self._hidden
+
+
+class SnakeNode(GameObject):
+    """蛇身上的节点"""
+
+    def __init__(self, x, y, size, color=Color.GREEN):
+        """
+        初始化方法
+
+        :param x: 横坐标
+        :param y: 纵坐标
+        :param size: 大小
+        :param color: 颜色
+        """
+        super().__init__(x, y, color)
+        self._size = size
+
+    @property
+    def size(self):
+        return self._size
+
+    def draw(self, screen):
+        pygame.draw.rect(screen, self._color,
+                         (self._x, self._y, self._size, self._size), 0)
+        pygame.draw.rect(screen, Color.BLACK,
+                         (self._x, self._y, self._size, self._size), 1)
+
+
+class Snake(GameObject):
+    """蛇"""
+
+    def __init__(self, x, y, size=20, length=5):
+        """
+        初始化方法
+
+        :param x: 横坐标
+        :param y: 纵坐标
+        :param size: 大小
+        :param length: 初始长度
+        """
+        super().__init__()
+        self._dir = Direction.LEFT
+        self._nodes = []
+        self._alive = True
+        self._new_dir = None
+        for index in range(length):
+            node = SnakeNode(x + index * size, y, size)
+            self._nodes.append(node)
+
+    @property
+    def dir(self):
+        return self._dir
+
+    @property
+    def alive(self):
+        return self._alive
+
+    @property
+    def head(self):
+        return self._nodes[0]
+
+    def change_dir(self, new_dir):
+        """
+        改变方向
+
+        :param new_dir: 新方向
+        """
+        if new_dir != self._dir and \
+                (self._dir.value + new_dir.value) % 2 != 0:
+            self._new_dir = new_dir
+
+    def move(self):
+        """移动"""
+        if self._new_dir:
+            self._dir, self._new_dir = self._new_dir, None
+        snake_dir = self._dir
+        x, y, size = self.head.x, self.head.y, self.head.size
+        if snake_dir == Direction.UP:
+            y -= size
+        elif snake_dir == Direction.RIGHT:
+            x += size
+        elif snake_dir == Direction.DOWN:
+            y += size
+        else:
+            x -= size
+        new_head = SnakeNode(x, y, size)
+        self._nodes.insert(0, new_head)
+        self._nodes.pop()
+
+    def collide(self, wall):
+        """
+        撞墙
+
+        :param wall: 围墙
+        """
+        head = self.head
+        if head.x < wall.x or head.x + head.size > wall.x + wall.width \
+                or head.y < wall.y or head.y + head.size > wall.y + wall.height:
+            self._alive = False
+
+    def eat_food(self, food):
+        """
+        吃食物
+
+        :param food: 食物
+
+        :return: 吃到食物返回True否则返回False
+        """
+        if self.head.x == food.x and self.head.y == food.y:
+            tail = self._nodes[-1]
+            self._nodes.append(tail)
+            return True
+        return False
+
+    def eat_self(self):
+        """咬自己"""
+        for index in range(4, len(self._nodes)):
+            node = self._nodes[index]
+            if node.x == self.head.x and node.y == self.head.y:
+                self._alive = False
+
+    def draw(self, screen):
+        for node in self._nodes:
+            node.draw(screen)
+
+
+def main():
+
+    def refresh():
+        """刷新游戏窗口"""
+        screen.fill(Color.GRAY)
+        wall.draw(screen)
+        food.draw(screen)
+        snake.draw(screen)
+        pygame.display.flip()
+
+    def handle_key_event(key_event):
+        """处理按键事件"""
+        key = key_event.key
+        if key == pygame.K_F2:
+            reset_game()
+        elif key in (pygame.K_a, pygame.K_w, pygame.K_d, pygame.K_s):
+            if snake.alive:
+                if key == pygame.K_w:
+                    new_dir = Direction.UP
+                elif key == pygame.K_d:
+                    new_dir = Direction.RIGHT
+                elif key == pygame.K_s:
+                    new_dir = Direction.DOWN
+                else:
+                    new_dir = Direction.LEFT
+                snake.change_dir(new_dir)
+
+    def create_food():
+        """创建食物"""
+        unit_size = snake.head.size
+        max_row = wall.height // unit_size
+        max_col = wall.width // unit_size
+        row = randrange(0, max_row)
+        col = randrange(0, max_col)
+        return Food(wall.x + unit_size * col, wall.y + unit_size * row, unit_size)
+
+    def reset_game():
+        """重置游戏"""
+        nonlocal food, snake
+        food = create_food()
+        snake = Snake(250, 290)
+
+    def background_task():
+        nonlocal running, food
+        while running:
+            if snake.alive:
+                refresh()
+            clock.tick(10)
+            if snake.alive:
+                snake.move()
+                snake.collide(wall)
+                if snake.eat_food(food):
+                    food = create_food()
+                snake.eat_self()
+
+    """
+    class BackgroundTask(Thread):
+
+        def run(self):
+            nonlocal running, food
+            while running:
+                if snake.alive:
+                    refresh()
+                clock.tick(10)
+                if snake.alive:
+                    snake.move()
+                    snake.collide(wall)
+                    if snake.eat_food(food):
+                        food = create_food()
+                    snake.eat_self()
+    """
+
+    wall = Wall(10, 10, 600, 600)
+    snake = Snake(250, 290)
+    food = create_food()
+    pygame.init()
+    screen = pygame.display.set_mode((620, 620))
+    pygame.display.set_caption('贪吃蛇')
+    # 创建控制游戏每秒帧数的时钟
+    clock = pygame.time.Clock()
+    running = True
+    # 启动后台线程负责刷新窗口和让蛇移动
+    # BackgroundTask().start()
+    Thread(target=background_task).start()
+    # 处理事件的消息循环
+    while running:
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                running = False
+            elif event.type == pygame.KEYDOWN:
+                handle_key_event(event)
+    pygame.quit()
+
+
+if __name__ == '__main__':
+    main()

Day76-90/Python数据可视化.md

+## Python数据可视化
+
+数据的处理、分析和可视化已经成为Python近年来最为重要的应用领域之一，其中数据的可视化指的是将数据呈现为漂亮的统计图表，然后进一步发现数据中包含的规律以及隐藏的信息。数据可视化又跟数据挖掘和大数据分析紧密相关，而这些领域以及当下被热议的“深度学习”其最终的目标都是为了实现从过去的数据去对未来的状况进行预测。Python在实现数据可视化方面是非常棒的，即便是使用个人电脑也能够实现对百万级甚至更大体量的数据进行探索的工作，而这些工作都可以在现有的第三方库的基础上来完成（无需“重复的发明轮子”）。[Matplotlib](https://matplotlib.org/)就是Python绘图库中的佼佼者，它包含了大量的工具，你可以使用这些工具创建各种图形（包括散点图、折线图、直方图、饼图、雷达图等），Python科学计算社区也经常使用它来完成数据可视化的工作。
+
+### 安装matplotlib
+
+可以使用pip来安装matplotlib，命令如下所示。
+
+```Shell
+pip install matplotlib
+```
+
+### 绘制折线图
+
+```Python
+# coding: utf-8
+import matplotlib.pyplot as plt
+
+
+def main():
+    # 保存x轴数据的列表
+    x_values = [x for x in range(1, 11)]
+    # 保存y轴数据的列表
+    y_values = [x ** 2 for x in range(1, 11)]
+    # 设置图表的标题以及x和y轴的说明
+    plt.title('Square Numbers')
+    plt.xlabel('Value', fontsize=18)
+    plt.ylabel('Square', fontsize=18)
+    # 设置刻度标记的文字大小
+    plt.tick_params(axis='both', labelsize=16)
+    # 绘制折线图
+    plt.plot(x_values, y_values)
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()
+
+```
+
+运行程序，效果如下图所示。
+
+![](./res/result1.png)
+
+如果使用jupyter的notebook，需要使用魔法指令`%matplotlib inresline`来设置在页面中显示图表，效果如下所示。
+
+![](./res/result-in-jupyter.png)
+
+### 绘制散点图
+
+可以将上面代码中的的`plot`函数换成`scatter`函数来绘制散点图，效果如下图所示。
+
+![](./res/result2.png)
+
+当然，也可以直接通过`plot`函数设置绘图的颜色和线条的形状将折线图改造为散点图，对应的代码如下所示，其中参数'xr'表示每个点的记号是‘x’图形，颜色是红色（<u>r</u>ed）。
+
+```Python
+plt.plot(x_values, y_values, 'xr')
+```
+
+重新运行程序，效果如下图所示。
+
+![](./res/result3.png)
+
+可能大家已经注意到了，1和10对应的‘x’记号在图形边角的位置不太明显，要解决这个问题可以通过添加下面的代码调整x轴和y轴的坐标范围。
+
+```Python
+plt.axis([0, 12, 0, 120])
+```
+
+调整后的效果如下图所示。
+
+![](./res/result4.png)
+
+### 绘制正弦曲线
+
+在下面的程序中，我们使用了名为[NumPy](http://www.numpy.org/)的第三方库来产生样本并计算正弦值。NumPy是一个运行速度非常快的数学库，主要用于数组计算。它可以让你在Python中使用向量和数学矩阵，以及许多用C语言实现的底层函数。如果想通过Python学习数据科学或者机器学习相关的内容，那么就得先学会使用NumPy。
+
+```Python
+# coding: utf-8
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def main():
+    # 指定采样的范围以及样本的数量
+    x_values = np.linspace(0, 2 * np.pi, 1000)
+    # 计算每个样本对应的正弦值
+    y_values = np.sin(x_values)
+    # 绘制折线图(线条形状为--, 颜色为蓝色)
+    plt.plot(x_values, y_values, '--b')
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()
+
+```
+
+运行程序，效果如下图所示。
+
+![](./res/result5.png)
+
+如果要在一个坐标系上绘制多个图像，可以按照如下的方式修改代码。
+
+```Python
+# coding: utf-8
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def main():
+    x_values = np.linspace(0, 2 * np.pi, 1000)
+    plt.plot(x_values, np.sin(x_values), '--b')
+    plt.plot(x_values, np.sin(2 * x_values), '--r')
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()
+
+```
+
+修改后的代码运行效果如下图所示。
+
+![](./res/result6.png)
+
+如果需要分别在两个坐标系上绘制出两条曲线，可以按照如下的方式操作。
+
+```Python
+# coding: utf-8
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def main():
+    # 将样本数量减少为50个
+    x_values = np.linspace(0, 2 * np.pi, 50)
+    # 设置绘图为2行1列活跃区为1区(第一个图)
+    plt.subplot(2, 1, 1)
+    plt.plot(x_values, np.sin(x_values), 'o-b')
+    # 设置绘图为2行1列活跃区为2区(第二个图)
+    plt.subplot(2, 1, 2)
+    plt.plot(x_values, np.sin(2 * x_values), '.-r')
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()
+
+```
+
+效果如下图所示。
+
+![](./res/result7.png)
+
+### 绘制直方图
+
+我们可以通过NumPy的random模块的normal函数来生成[正态分布](https://zh.wikipedia.org/wiki/%E6%AD%A3%E6%80%81%E5%88%86%E5%B8%83)的采样数据，其中的三个参数分别表示期望、标准差和样本数量，然后绘制成直方图，代码如下所示。
+
+```Python
+# coding: utf-8
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def main():
+    # 通过random模块的normal函数产生1000个正态分布的样本
+    data = np.random.normal(10.0, 5.0, 1000)
+    # 绘制直方图(直方的数量为10个)
+    plt.hist(data, 10)
+    plt.show()
+
+
+if __name__ == '__main__':
+    main()
+
+```
+
+运行效果如下图所示。
+
+![](./res/result8.png)
+
+### 使用Pygal绘制矢量图
+
+矢量图（SVG）是[计算机图形学](https://zh.wikipedia.org/wiki/%E8%AE%A1%E7%AE%97%E6%9C%BA%E5%9B%BE%E5%BD%A2%E5%AD%A6)中用点、直线或者多边形等基于数学方程的几何图元表示的图像，也是目前应用得非常多的一种图像文件格式，全称是“Scalable Vector Graphics”。和使用像素表示图像的位图不同，SVG基于XML存储图像数据，它是W3C定义的一种开放标准的矢量图形语言，可以用来设计更为清晰的Web图像，因为SVG与分辨率无关，在任意放大时不会丢失细节或影响清晰度。SVG可以直接用代码来描绘图像，也可以用任何文字处理工具来打开它，通过改变SVG的代码我们可以让图像具备交互功能。
+
+Python中可以使用Pygal来生成SVG，可以通过pip来安装它。
+
+```Python
+from random import randint
+import pygal
+
+
+def roll_dice(n=1):
+	total = 0
+	for _ in range(n):
+		total += randint(1, 6)
+	return total
+
+
+def main():
+    results = []
+    # 将两颗色子摇10000次记录点数
+    for _ in range(10000):
+        face = roll_dice(2)
+        results.append(face)
+    freqs = []
+    # 统计2~12点各出现了多少次
+    for value in range(2, 13):
+        freq = results.count(value)
+        freqs.append(freq)
+    # 绘制柱状图
+    hist = pygal.Bar()
+    hist.title = 'Result of rolling two dice'
+    hist.x_labels = [x for x in range(2, 13)]
+    hist.add('Frequency', freqs)
+    # 保存矢量图
+    hist.render_to_file('result.svg')
+
+
+if __name__ == '__main__':
+    main()
+    
+
+```
+
+运行上面的程序，效果如下图所示。
+
+![](./res/result9.png)
+
+### 后记
+
+Matplotlib和NumPy的强大我们在这里也只是窥视了其冰山一角，我们在后续的内容里面还会使用到这两个第三方库，到时候我们再续点为大家介绍其他的功能。
\ No newline at end of file