黑马程序员最新Python教程——第一阶段（3）第二阶段（1）_黑马程序员课件 python

这是这个笔记的第三篇。

第一篇为黑马程序员最新Python教程——第一阶段（1）
第二篇为黑马程序员最新Python教程——第一阶段（2）

欢迎大家批评指正。

第一阶段——第八章

01-文件编码概念

思考：计算机只能识别: 0和1，那么我们丰富的文本文件是如何被计算机识别，并存储在硬盘中呢?
答案：使用编码技术(密码本)将内容翻译成0和1存入。

不同的编码，将翻译成二进制也是不同的。

1.什么是编码?
编码就是一种规则集合，记录了内容和二进制间进行相互转换的逻辑。编码有许多中，我们最常用的是UTF-8编码。

2.为什么需要使用编码?
计算机只认识0和1，所以需要将内容翻译成0和1才能保存在计算机中。同时也需要编码，将计算机保存的0和1，反向翻译回可以识别的内容。

02-文件的读取操作

什么是文件？
内存中存放的数据在计算机关机后就会消失。要长久保存数据，就要使用硬盘、光盘、U盘等设备。为了便于数据的管理和检索，引入了“文件”的概念。
一篇文章、一段视频、一个可执行程序，都可以被保存为一一个文件，并赋予一一个文件名。操作系统以文件为单位管理磁盘中的数据。一般来说，文件可分为文本文件、视频文件、音频文件、图像文件、可执行文件等多种类别。

文件操作包含哪些内容呢?
在日常生活中，文件操作主要包括打开、关闭读、写等操作。

文件的操作步骤
想想我们平常对文件的基本操作，大概可以分为三个步骤(简称文件操作三步走) ：

1. 打开文件
2. 读写文件
3. 关闭文件

open()打开函数

mode常用的三种基础访问模式

读操作相关方法

测试案例：

if __name__ == '__main__':
    #打开文件
    f= open("测试.txt","r",encoding="UTF-8")
    #f是一个文件对象
    print(type(f))  #<class '_io.TextIOWrapper'>
    #读取文件-read
    print(f"读取10个字节的结果：{f.read(10)}")#读取10个字符的结果：黑马程序员是传智教育
    #这里讲错了，open创建对象分字符和字节的，以字符方式打开文件时    num    表示字符数，否则    utf - 8    里常见汉字一个3byte
    print(f"读取10个字节的结果：{f.read(4)}")#旗下高端 ！！！！注意 是继续读！！！！！
    print(f"读取10个字节的结果：{f.read()}")  # 剩下的全部字符
    # 读取文件- readLines()
    lines = f.readlines()
    # 读取文件的全部行，封装到列表中
    print(f"lines对象的类型: {type(lines)}") #<class 'list'>
    print(f"lines对象的内容是: {lines}") #此时为空 为什么？因为print(f"读取10个字节的结果：{f.read()}") 把读字符串的指针已经移动到该txt的最后了
    #想要运行 要注释掉  print(f"读取10个字节的结果：{f.read()}")  # 剩下的全部字符
    f.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

readlines的方法

if __name__ == '__main__':
    #打开文件
    f= open("测试.txt","r",encoding="UTF-8")
    # 读取文件- readLines()
    lines = f.readlines()
    # 读取文件的全部行，封装到列表中
    print(f"lines对象的类型: {type(lines)}") #<class 'list'>
    print(f"lines对象的内容是: {lines}") #这次就可以了   \n是换行符
    f.close()
1
2
3
4
5
6
7
8
9

readline的方法

if __name__ == '__main__':
    #打开文件
    f= open("测试.txt","r",encoding="UTF-8")
    # 读取文件- readline()
    line1 = f.readline()
    line2 = f.readline()
    line3 = f.readline()
    print(f"第一行数据是:{line1}")
    print(f"第二行数据是:{line2}")
    print(f"第三行数据是:{line3}")

    f.close()

    '''
    第一行数据是:黑马程序员是传智教育旗下高端IT教育品牌

    第二行数据是:成立至今以高品质教学质量赢得好口碑
    
    第三行数据是:为企业输送了大批优质IT人才
    '''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

for循环读取

if __name__ == '__main__':
    #打开文件
    f= open("测试.txt","r",encoding="UTF-8")
    # 读取文件- readline()
    # for循环读取文件行
    for line in f:
        print(f"每一行数据是:{line}")

    f.close()

    '''
    每一行数据是:黑马程序员是传智教育旗下高端IT教育品牌

    每一行数据是:成立至今以高品质教学质量赢得好口碑
    
    每一行数据是:为企业输送了大批优质IT人才
    
    每一行数据是:致力于培养高级软件I程师
    
    每一行数据是:现已开设10余个精品热]学科
    
    每一行数据是:20所直营分校遍布全国
    
    每一行数据是:学Python来黑马， 月薪过万。

    '''

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

为什么要关闭文件

利用with open语句 自动运行close 以免忘写

if __name__ == '__main__':
    # with open 语法操作文件
    with open("测试.txt", "r", encoding = "UTF-8") as f:
        for line in f:
            print(f"每一行数据是: {line}")
1
2
3
4
5

03-文件读取的课后练习

if __name__ == '__main__':
    f = open("word.txt","r",encoding="UTF-8")
    nums = 0
    for line in f:
        nums+=line.count("itheima")

    print("里面有 ",nums," 个itheima")
1
2
3
4
5
6
7

04-文件的写出操作

if __name__ == '__main__':

    f = open("123.txt","w",encoding="UTF-8")#当文件不存在时。它会给我自动创建
    #write写入
    f.write("Helloworld!")
    #flush刷新
    f.flush()
    #close内置了flush的功能
    f.close()
1
2
3
4
5
6
7
8
9

05-文件的追加写入操作

if __name__ == '__main__':

    f = open("1234.txt","a",encoding="UTF-8")#当文件不存在时。它会给我自动创建
    #write写入
    f.write("Helloworld!")
    #flush刷新
    f.flush()
    #close内置了flush的功能
    f.close()
1
2
3
4
5
6
7
8
9

06-文件的综合案例

需求分析：

if __name__ == '__main__':

    f = open("bill.txt","r",encoding="UTF-8")
    a_f =open("bill.txt.bat","a",encoding="UTF-8")
    for line in f:
        line = line.strip()
        split_list = line.split(",")
        if split_list[-1] == "正式":
            a_f.write(line)
            a_f.write("\n" )
    f.close()
    a_f.close()
1
2
3
4
5
6
7
8
9
10
11
12

第一阶段——第九章

01-了解异常

什么是异常
当检测到一个错误时，Python解释 器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的“异常”，也就是我们常说的BUG

异常演示

02-异常的捕获

为什么要捕获异常
世界上没有完美的程序,任何程序在运行的过程中，都有可能出现:异常,也就是出现bug导致程序无法完美运行下去。

我们要做的，不是力求程序完美运行。而是在力所能及的范围内，对可能出现的bug,进行提前准备、提前处理。这种行为我们称之为:异常处理(捕获异常)

当我们的程序遇到了BUG，那么接下来有两种情况：
①整个程序因为一个BUG停止运行
②对BUG进行提醒，整个程序继续运行中

显然在之前的学习中，我们所有的程序遇到BUG就会出现①的这种情况，也就是整个程序直接奔溃。
但是在真实工作中，我们肯定不能因为一个小的BUG就让整个程序全部奔溃，也就是我们希望的是达到②的这种情况。
那这里我们就需要使用到捕获异常。
捕获异常的作用在于:提前假设某处会出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段。

基本语法： 可以捕获所有的异常！！！

try:
	可能发生错误的代码
except:
	如果出现异常执行的代码
1
2
3
4

由于不同类型的异常，处理方法可以不同。所以，我们可以捕获不同类型的异常。

try:
	print(name)
except NameError as e:
	print('name变量名称未定义错误')
1
2
3
4

if __name__ == '__main__':

    try:
        print(name)
    except NameError as e:
        print("出现了变量未定义的异常")
        print(e)

    '''
    出现了变量未定义的异常
    name 'name' is not defined
    '''
1
2
3
4
5
6
7
8
9
10
11
12

捕获多个异常：

try:
	print(1/0)
except (NameError, ZeroDivisionError):#元组
	print('ZeroDivision错误...

1
2
3
4
5

if __name__ == '__main__':

    try:
        # 1/0
        print(name)
    except (NameError,ZeroDivisionError) as e:
        print("出现了变量未定义或者除以0的异常错误")

    '''
    出现了变量未定义或者除以0的异常错误
    '''
1
2
3
4
5
6
7
8
9
10
11

异常的finally

03-异常的传递性

04-模块的概念和导入

什么是模块
Python模块Modle)，是一一个Python文件，以.py结尾、模块能定 义函数，类和变量，模块里也能包含可执行的代码.

模块的作用：python中有 很多各种不同的模块，每- -个模块都可以帮助我们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能。

大白话：模块就是一个Python文件，里面有类、函数、变量等，我们可以拿过来用(导入模块去使用)

模块的导入方式
模块在使用前需要先导入导入的语法如下：[from模块名] import [模块|类|变量|函数|*] [as别名]

常用的组合形式如：

1. import 模块名
2. from模块名import 类、变量、方法等
3. from 模块名import *
4. import 模块名as别名.
5. from 模块名import功能名as别名

if __name__ == '__main__':
    # 使用import导入time模块使用sleep功能(函数)
    # import time
    # 导入Python内置的time模块(time. py这个代码文件)
    # print("你好")
    # time.sleep(5)
    # 通过。就可以使用模块内部的全部功能(类、 函数、变量)
    # print("我好")
    
    # 使用from导入time的sleep功能(函数)
    # from time import sleep
    #
    # print("你好")
    # sleep(5)
    # print("我好")

    #使用 * 导入time模块的全部功能
    # from time import *
    # # *表示全部的意思
    # print("你好")
    # sleep(1)
    # print("我好")

    # 使用as给特定功能加上别名
    import time as t
    print("你好")
    t.sleep(1)
    print("我好")
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

05-自定义模块并导入

再同级文件下创建my_modle1.py

#my_modle1.py
def add(a,b):
    print(a+b)
1
2
3

在main.py中写如下：

if __name__ == '__main__':

    # import my_modle1
    # my_modle1.add(1,2)

    # from my_modle1 import add
    # add(1,2)

    from my_modle1 import add as asdfasdasd
    asdfasdasd(1,2)
1
2
3
4
5
6
7
8
9
10

注意，__all__是列表！！！类似可以公开与不公开。但是它只会限制*的引用，如果你直接引用，也可以正常引用，所以最好不要类比public与private

06-自定义Python包

什么是Python包？
从物理上看，包就是一个文件夹，在该文件夹下包含了一个__init__ .py 文件，该文件夹可用于包含多个模块文件
从逻辑上看，包的本质依然是模块

包的作用：
当我们的模块文件越来越多时，包可以帮助我们管理这些模块，包的作用就是包含多个模块，但包的本质依然是模块。
你可以认为__init__.py是一个标志，当你创建一堆文件放到文件夹中，不放入__init__.py，他就是装着各种.py的文件夹。如果包含__init__.py，说明该文件夹是一个包！
所以

当Python Package时，pycharm会新建功能模块，自动创建__init__.py。

导入包


仔细看，LOGO不同。

if __name__ == '__main__':
    # 创建一个包
    # 导入自定义的包中的模块,并使用
    # import my_package.my_module1
    # import my_package.my_module2
    # my_package.my_module1.info_print1()
    # my_package.my_module2.info_print2()
    ########################################
    from my_package import my_module1
    from my_package import my_module2
    my_module1.info_print1()
    my_module2.info_print2()
    ########################################
	from my_package.my_module1 import info_print1
	from my_package.my_module2 import info_print2

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

07-安装第三方包

我们知道，包可以包含一堆 的Python模块，而每个模块又内含许多的功能。
所以，我们可以认为：一个包，就是一堆同类型功能的集合体。
在Python程序的生态中，有许多非常多的第三方包(非Python官方)，可以极大的帮助我们提高开发效率，如：

1. 科学计算中常用的: numpy包
2. 数据分析中常用的: pandas包
3. 大数据计算中常用的: pyspark、 apache-flink包
4. 图形可视化常用的: matplotlib. pyecharts
5. 人工智能常用的: tensorflow
6. 等

这些第三方的包，极大的丰富了python的生态。
但是由于是第三方，所以Python没有内置，所以我们需要安装它们才可以导入使用哦。

安装第三方包- pip
第三方包的安装非常简单，我们只需要使用Python内置的pip程序即可。
打开我们许久未见的：命令提示符程序，在里面输入：
pip install包名称
即可通过网络快速安装第三方包

推荐直接安装Anaconda 史上最全最详细的Anaconda安装教程
你可以理解成Anaconda 是一个环境，这个环境里面包含了绝大多数我们要的包 不用自己一个个下载。

怎么配置环境，大家可以查看这个大佬的文章介绍超详细~Windows下PyCharm配置Anaconda环境教程
或者自己一个一个在pycharm里面找，为什么要在红框位置输入这个网站，因为这些第三方包都是国外的，下载会超级慢，所以我们加一个网站（镜像源）到国内下载就快了。

08-异常-模块-包-综合案例讲解

案例要求：


main.py

import my_utils.str_util
import my_utils.file_util
if __name__ == '__main__':
    str = my_utils.str_util.str_reverse("heimachengxuyuan")
    print(str)  #nauyuxgnehcamieh
    str_list = my_utils.str_util.substr(str,4,10)
    print(str_list)   #uxgneh
    my_utils.file_util.print_file_info("1234.txt")
    my_utils.file_util.append_to_file("123.txt",str)

1
2
3
4
5
6
7
8
9
10

str_util.py

def str_reverse(s):
    s = s[::-1]
    return s

def substr(s,x,y):
    s_list = s[x:y]
    return s_list
1
2
3
4
5
6
7

file_util.py

def print_file_info(file_name):
    f = None
    try:
        f = open(file_name,"r",encoding="UTF-8")
        for line in f:
            print(line)
    except:
        print("文件不存在")
    finally:
        if f:
            f.close()

def append_to_file(file_name,data):
    f = open(file_name,"a",encoding="UTF-8")
    f.write(data)
    f.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

第一阶段——第十章

01-案例介绍

02-JSON数据格式的转换

什么是json

1. JSON是一种轻量级的数据交互格式。可以按照JSON指定的格式去组织和封装数据
2. JSON本质上是一个带有特定格式的字符串

主要功能: json就是 一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互、类似于:

1. 国际通用语言 -英语
2. 中国56个民族不同地区的通用语言-普通话

json有什么用
各种编程语言存储数据的容器不尽相同,在Python中有字典dict这样的数据类型，而其它语言可能没有对应的字典

为了让不同的语言都能够相互通用的互相传递数据，JSON就是一种非常良好的中转数据格式。如下图，以Python和C语言互传数据为例：

import json
if __name__ == '__main__':
    # 准备列表，列表内每一 个元素都是字典，将其转换为JSON
    data = [{"name": "张大山","age": 11}, {"name":"王大锤","age": 13}, {"name": "赵小虎","age": 16}]
    json_str = json.dumps(data)
    print(type(json_str))#<class 'str'>
    print(json_str) #[{"name": "\u5f20\u5927\u5c71", "age": 11}, {"name": "\u738b\u5927\u9524", "age": 13}, {"name": "\u8d75\u5c0f\u864e", "age": 16}]
    json_str = json.dumps(data,ensure_ascii=False)
    print(json_str) #[{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}]

    # 准备字典，将字典转换为JSON
    d = {"name": "周杰轮","addr": "台北"}
    json_str = json.dumps(d,ensure_ascii = False)
    print(type(json_str))#<class 'str'>
    print(json_str)#{"name": "周杰轮", "addr": "台北"}

    # 将JSON字符串转换为Python数据类型[{k: v, k: v}, {k: v, k: v}]
    s = '[{"name": "张大山","age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}]'
    l = json.loads(s)
    print(type(l))#<class 'list'>
    print(l)#[{'name': '张大山', 'age': 11}, {'name': '王大锤', 'age': 13}, {'name': '赵小虎', 'age': 16}]

    # .将JSON字符串转换为Python数据类型{Kk: V, k: v}
    s = '{"name": "周杰轮", "addr": "台北"}'
    d = json.loads(s)
    print(type(d))#<class 'dict'>
    print(d)#{'name': '周杰轮', 'addr': '台北'}
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

03-pyecharts模块简介

pyecharts模块 ：如果想要 做出数据可视化效果图，可以借助pyecharts模块来完成
概况：
Echarts是个由百度开源的数据可视化，凭借着良好的交互性，精巧的图表设计，得到了众多开发者的认可.而Python是门富有表达力的语言，很适合用于数据处理.当数据分析遇上数据可视化时pyecharts诞生了。

pyecharts.org
还有一个画廊功能：gallery.pyecharts.org
pyecharts模块的安装：pip install pyecharts

04-pyecharts的入门使用

from pyecharts.charts import Line
if __name__ == '__main__':
    # 导包，导入Line功能构建折线图对象

    # 得到折线图对象
    line = Line()
    # 添加x轴数据
    line.add_xaxis(["中国","美国","英国"])
    # 添加y轴数据
    line.add_yaxis("GDP", [30,20,10])
    # 生成图表
    line.render()
    '''
1
2
3
4
5
6
7
8
9
10
11
12
13

pyecharts有哪些配置选项
pyecharts模块中有 很多的配置选项，常用到2个类别的选项:
全局配置选项
系列配置选项

from pyecharts.charts import Line
from  pyecharts.options import TitleOpts
from  pyecharts.options import LegendOpts
from  pyecharts.options import ToolboxOpts
from  pyecharts.options import VisualMapOpts
if __name__ == '__main__':
    # 导包，导入Line功能构建折线图对象

    # 得到折线图对象
    line = Line()
    # 添加x轴数据
    line.add_xaxis(["中国","美国","英国"])
    # 添加y轴数据
    line.add_yaxis("GDP", [30,20,10])

    line.set_global_opts(
        title_opts=TitleOpts("GDPshow",pos_left= "center",pos_bottom = "90%"),   #添加标题
        legend_opts=LegendOpts(is_show=True),#添加图例
        toolbox_opts=ToolboxOpts(is_show=True),#添加工具箱
        visualmap_opts=VisualMapOpts(is_show=True)

    )

    # 生成图表
    line.render()
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

想要一个好看的图？复制粘贴吧！

05-数据准备

链接：https://pan.baidu.com/s/1fP4riRd3k_J6NQFwIznxeQ
提取码：xq8g

06-生成折线图

"""
演示可视化需求1：折线图开发
"""
import json
from pyecharts.charts import Line
from pyecharts.options import TitleOpts, LabelOpts

# 处理数据
f_us = open("D:/美国.txt", "r", encoding="UTF-8")
us_data = f_us.read()   # 美国的全部内容

f_jp = open("D:/日本.txt", "r", encoding="UTF-8")
jp_data = f_jp.read()   # 日本的全部内容

f_in = open("D:/印度.txt", "r", encoding="UTF-8")
in_data = f_in.read()   # 印度的全部内容

# 去掉不合JSON规范的开头
us_data = us_data.replace("jsonp_1629344292311_69436(", "")
jp_data = jp_data.replace("jsonp_1629350871167_29498(", "")
in_data = in_data.replace("jsonp_1629350745930_63180(", "")

# 去掉不合JSON规范的结尾
us_data = us_data[:-2]
jp_data = jp_data[:-2]
in_data = in_data[:-2]

# JSON转Python字典
us_dict = json.loads(us_data)
jp_dict = json.loads(jp_data)
in_dict = json.loads(in_data)

# 获取trend key
us_trend_data = us_dict['data'][0]['trend']
jp_trend_data = jp_dict['data'][0]['trend']
in_trend_data = in_dict['data'][0]['trend']

# 获取日期数据，用于x轴，取2020年（到314下标结束）
us_x_data = us_trend_data['updateDate'][:314]
jp_x_data = jp_trend_data['updateDate'][:314]
in_x_data = in_trend_data['updateDate'][:314]

# 获取确认数据，用于y轴，取2020年（到314下标结束）
us_y_data = us_trend_data['list'][0]['data'][:314]
jp_y_data = jp_trend_data['list'][0]['data'][:314]
in_y_data = in_trend_data['list'][0]['data'][:314]

# 生成图表
line = Line()       # 构建折线图对象
# 添加x轴数据
line.add_xaxis(us_x_data)   # x轴是公用的，所以使用一个国家的数据即可
# 添加y轴数据
line.add_yaxis("美国确诊人数", us_y_data, label_opts=LabelOpts(is_show=False))     # 添加美国的y轴数据
line.add_yaxis("日本确诊人数", jp_y_data, label_opts=LabelOpts(is_show=False))     # 添加日本的y轴数据
line.add_yaxis("印度确诊人数", in_y_data, label_opts=LabelOpts(is_show=False))     # 添加印度的y轴数据

# 设置全局选项
line.set_global_opts(
    # 标题设置
    title_opts=TitleOpts(title="2020年美日印三国确诊人数对比折线图", pos_left="center", pos_bottom="1%")
)

# 调用render方法，生成图表
line.render()
# 关闭文件对象
f_us.close()
f_jp.close()
f_in.close()

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

第一阶段——第十一章

01-数据可视化案例

"""
演示地图可视化的基本使用
"""
from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts

# 准备地图对象
map = Map()
# 准备数据
data = [
    ("北京", 99),
    ("上海", 199),
    ("湖南", 299),
    ("台湾", 399),
    ("广东", 499)
]
# 添加数据
map.add("测试地图", data, "china")

# 设置全局选项
map.set_global_opts(
    visualmap_opts=VisualMapOpts(
        is_show=True,
        is_piecewise=True,
        pieces=[
            {"min": 1, "max": 9, "label": "1-9", "color": "#CCFFFF"},
            {"min": 10, "max": 99, "label": "10-99", "color": "#FF6666"},
            {"min": 100, "max": 500, "label": "100-500", "color": "#990033"}
        ]
    )
)

# 绘图
map.render()

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
35

02-全国疫情地图构建

"""
演示全国疫情可视化地图开发
"""
import json
from pyecharts.charts import Map
from pyecharts.options import *

# 读取数据文件
f = open("D:/疫情.txt", "r", encoding="UTF-8")
data = f.read()     # 全部数据
# 关闭文件
f.close()
# 取到各省数据
# 将字符串json转换为python的字典
data_dict = json.loads(data)        # 基础数据字典
# 从字典中取出省份的数据
province_data_list = data_dict["areaTree"][0]["children"]
# 组装每个省份和确诊人数为元组，并各个省的数据都封装入列表内
data_list = []      # 绘图需要用的数据列表
for province_data in province_data_list:
    province_name = province_data["name"]                   # 省份名称
    province_confirm = province_data["total"]["confirm"]    # 确诊人数
    data_list.append((province_name, province_confirm))


# 创建地图对象
map = Map()
# 添加数据
map.add("各省份确诊人数", data_list, "china")
# 设置全局配置，定制分段的视觉映射
map.set_global_opts(
    title_opts=TitleOpts(title="全国疫情地图"),
    visualmap_opts=VisualMapOpts(
        is_show=True,           # 是否显示
        is_piecewise=True,      # 是否分段
        pieces=[
            {"min": 1, "max": 99, "lable": "1~99人", "color": "#CCFFFF"},
            {"min": 100, "max": 999, "lable": "100~9999人", "color": "#FFFF99"},
            {"min": 1000, "max": 4999, "lable": "1000~4999人", "color": "#FF9966"},
            {"min": 5000, "max": 9999, "lable": "5000~99999人", "color": "#FF6666"},
            {"min": 10000, "max": 99999, "lable": "10000~99999人", "color": "#CC3333"},
            {"min": 100000, "lable": "100000+", "color": "#990033"},
        ]
    )
)
# 绘图
map.render("全国疫情地图.html")

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48

03-河南省疫情地图绘制

"""
演示河南省疫情地图开发
"""
import json
from pyecharts.charts import Map
from pyecharts.options import *

# 读取文件
f = open("D:/疫情.txt", "r", encoding="UTF-8")
data = f.read()
# 关闭文件
f.close()
# 获取河南省数据
# json数据转换为python字典
data_dict = json.loads(data)
# 取到河南省数据
cities_data = data_dict["areaTree"][0]["children"][3]["children"]

# 准备数据为元组并放入list
data_list = []
for city_data in cities_data:
    city_name = city_data["name"] + "市"
    city_confirm = city_data["total"]["confirm"]
    data_list.append((city_name, city_confirm))

# 手动添加济源市的数据
data_list.append(("济源市", 5))

# 构建地图
map = Map()
map.add("河南省疫情分布", data_list, "河南")
# 设置全局选项
map.set_global_opts(
    title_opts=TitleOpts(title="河南省疫情地图"),
    visualmap_opts=VisualMapOpts(
        is_show=True,           # 是否显示
        is_piecewise=True,      # 是否分段
        pieces=[
            {"min": 1, "max": 99, "lable": "1~99人", "color": "#CCFFFF"},
            {"min": 100, "max": 999, "lable": "100~9999人", "color": "#FFFF99"},
            {"min": 1000, "max": 4999, "lable": "1000~4999人", "color": "#FF9966"},
            {"min": 5000, "max": 9999, "lable": "5000~99999人", "color": "#FF6666"},
            {"min": 10000, "max": 99999, "lable": "10000~99999人", "color": "#CC3333"},
            {"min": 100000, "lable": "100000+", "color": "#990033"},
        ]
    )
)

# 绘图
map.render("河南省疫情地图.html")

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

第一阶段——第十二章

01-基础柱状图构建

"""
演示基础柱状图的开发
"""
from pyecharts.charts import Bar
from pyecharts.options import LabelOpts
# 使用Bar构建基础柱状图
bar = Bar()
# 添加x轴的数据
bar.add_xaxis(["中国", "美国", "英国"])
# 添加y轴数据
bar.add_yaxis("GDP", [30, 20, 10], label_opts=LabelOpts(position="right"))
# 反转x和y轴
bar.reversal_axis()
# 绘图
bar.render("基础柱状图.html")

# 反转x轴和y轴

# 设置数值标签在右侧
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

02-基础时间线柱状图绘制

"""
演示带有时间线的柱状图开发
"""
from pyecharts.charts import Bar, Timeline
from pyecharts.options import LabelOpts
from pyecharts.globals import ThemeType

bar1 = Bar()
bar1.add_xaxis(["中国", "美国", "英国"])
bar1.add_yaxis("GDP", [30, 30, 20], label_opts=LabelOpts(position="right"))
bar1.reversal_axis()

bar2 = Bar()
bar2.add_xaxis(["中国", "美国", "英国"])
bar2.add_yaxis("GDP", [50, 50, 50], label_opts=LabelOpts(position="right"))
bar2.reversal_axis()

bar3 = Bar()
bar3.add_xaxis(["中国", "美国", "英国"])
bar3.add_yaxis("GDP", [70, 60, 60], label_opts=LabelOpts(position="right"))
bar3.reversal_axis()

# 构建时间线对象
timeline = Timeline({"theme": ThemeType.LIGHT})
# 在时间线内添加柱状图对象
timeline.add(bar1, "点1")
timeline.add(bar2, "点2")
timeline.add(bar3, "点3")

# 自动播放设置
timeline.add_schema(
    play_interval=1000,
    is_timeline_show=True,
    is_auto_play=True,
    is_loop_play=True
)

# 绘图是用时间线对象绘图，而不是bar对象了
timeline.render("基础时间线柱状图.html")


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
35
36
37
38
39
40
41

"""
扩展列表的sort方法
在学习了将函数作为参数传递后，我们可以学习列表的sort方法来对列表进行自定义排序
"""

# 准备列表
my_list = [["a", 33], ["b", 55], ["c", 11]]

# 排序，基于带名函数
# def choose_sort_key(element):
#     return element[1]
#
# my_list.sort(key=choose_sort_key, reverse=True)
# 排序，基于lambda匿名函数
my_list.sort(key=lambda element: element[1], reverse=True)

print(my_list)

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

03-动态GDP柱状图绘制

"""
演示第三个图表：GDP动态柱状图开发
"""
from pyecharts.charts import Bar, Timeline
from pyecharts.options import *
from pyecharts.globals import ThemeType

# 读取数据
f = open("D:/1960-2019全球GDP数据.csv", "r", encoding="GB2312")
data_lines = f.readlines()
# 关闭文件
f.close()
# 删除第一条数据
data_lines.pop(0)
# 将数据转换为字典存储，格式为：
# { 年份: [ [国家, gdp], [国家,gdp], ......  ], 年份: [ [国家, gdp], [国家,gdp], ......  ], ...... }
# { 1960: [ [美国, 123], [中国,321], ......  ], 1961: [ [美国, 123], [中国,321], ......  ], ...... }
# 先定义一个字典对象
data_dict = {}
for line in data_lines:
    year = int(line.split(",")[0])      # 年份
    country = line.split(",")[1]        # 国家
    gdp = float(line.split(",")[2])     # gdp数据
    # 如何判断字典里面有没有指定的key呢？
    try:
        data_dict[year].append([country, gdp])
    except KeyError:
        data_dict[year] = []
        data_dict[year].append([country, gdp])

# print(data_dict[1960])
# 创建时间线对象
timeline = Timeline({"theme": ThemeType.LIGHT})
# 排序年份
sorted_year_list = sorted(data_dict.keys())
for year in sorted_year_list:
    data_dict[year].sort(key=lambda element: element[1], reverse=True)
    # 取出本年份前8名的国家
    year_data = data_dict[year][0:8]
    x_data = []
    y_data = []
    for country_gdp in year_data:
        x_data.append(country_gdp[0])   # x轴添加国家
        y_data.append(country_gdp[1] / 100000000)   # y轴添加gdp数据

    # 构建柱状图
    bar = Bar()
    x_data.reverse()
    y_data.reverse()
    bar.add_xaxis(x_data)
    bar.add_yaxis("GDP(亿)", y_data, label_opts=LabelOpts(position="right"))
    # 反转x轴和y轴
    bar.reversal_axis()
    # 设置每一年的图表的标题
    bar.set_global_opts(
        title_opts=TitleOpts(title=f"{year}年全球前8GDP数据")
    )
    timeline.add(bar, str(year))


# for循环每一年的数据，基于每一年的数据，创建每一年的bar对象
# 在for中，将每一年的bar对象添加到时间线中

# 设置时间线自动播放
timeline.add_schema(
    play_interval=1000,
    is_timeline_show=True,
    is_auto_play=True,
    is_loop_play=False
)
# 绘图
timeline.render("1960-2019全球GDP前8国家.html")

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

第二阶段——第一章

01-初始对象

首先，我们为什么要引入对象呢？ 让我们发现痛点！！



使用变量记录数据太乱了。如果程序中也和生活中一样，可以设计表格，可以将设计的表格打印出来，可以将打印好的表格供人填写内容，那么数据的组织就非常方便了。

我们知道了这个痛点，那么好，我们引入对象，使用对象来组织数据！

if __name__ == '__main__':
    # 1.设计一个类(类比生活中:设计一张登记表)
    class  Student:
        name = None        # 记录学生姓名
        gender = None        # 记录学生性别
        nationality = None        # 记录学生国籍
        native_place = None  # 记录学生籍贯
        age = None        # 记录学生年龄


    # 2.创建一个对象(类比生活中:打印- -张登记表)
    stu_1 = Student()
    # 3.对象属性进行赋值(类比生活中:填写表单)
    stu_1.name = "林军杰"
    stu_1.gender = "男"
    stu_1.nationality = "中国"
    stu_1.native_place = "山东省"
    stu_1.age = 31
    # 4.获取对象中记录的信息
    # 4.获取对象中记录的信息
    print(stu_1.name )
    print(stu_1.gender)
    print(stu_1.nationality)
    print(stu_1.native_place)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

02-类的成员方法

类的定义和使用
在上一节中，我们简单了解到可以使用类去封装属性，并基于类创建出一一个个的对象来使用。
现在我们来看看类的使用语法：

class 类名称：
	类的属性
	类的行为
1
2
3

●class是关键字， 表示要定义类了
●类的属性,即定义在类中的变量(成员变量)
● 类的行为， 即定义在类中的函数(成员方法)
创建类对象的语法对象=类名称()

类内部的函数叫（成员）方法，不叫函数。

成员方法的定义语法

if __name__ == '__main__':
    # 1.设计一个类(类比生活中:设计一张登记表)
    class  Student:
        name = None        # 记录学生姓名
        def say_hi(self):
            print("he")
        def say_hi2(self,msg):
            print(f"hi,{msg}")

    s1 = Student()
    s1.say_hi()
    s1.say_hi2("wnm")
1
2
3
4
5
6
7
8
9
10
11
12

可以看到，在传入参数的时间，self是透明的，可以不用理会他。

if __name__ == '__main__':
    # 1.设计一个类(类比生活中:设计一张登记表)
    class  Student:
        name = None        # 记录学生姓名
        def say_hi(self):
            print("he",self.name)


    s1 = Student()
    s1.name = "wnm"
    s1.say_hi()#he wnm

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

03-类和对象

基于类创建对象的语法:对象名=类名称()
为什么非要创建对象才能使用呢?
类只是一种程序内的“设计图纸”,需要基于图纸生产实体(对象),才能正常工作，面向对象编程！！！！

设计类——就是让类干活！

下面代码有声音欧 耳机党小心！！！！！

if __name__ == '__main__':
    # 设计一个闹钟类
    class Clock:
        id = None
        # 序列化
        price = None

        # 价格
        def ring(self):
            import winsound
            winsound.Beep(2000,3000)


    # 构建2个闹钟对象并让其工作
    clock1 = Clock()
    clock1.id = "003032"
    clock1.price = 19.99
    print(f"闹钟ID: {clock1.id}， 价格: {clock1.price}")
    clock1.ring()
    #######################################
    clock2 = Clock()
    clock2.id = "003033"
    clock2.price = 21.99
    print(f"闹钟ID: {clock2.id}， 价格: {clock2.price}")
    clock2.ring()
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

04-构造方法

构造方法：

当写了构造函数：可以下面：

if __name__ == '__main__':
    class Student:
        def __init__(self, name,age, tel):
            self.name = name
            self.age = age
            self.tel = tel
            print("Student类创建了一个类对象")
    stu = Student("周杰轮",31, "18500006666")
1
2
3
4
5
6
7
8

05-魔术方法

__ str __

if __name__ == '__main__':
    class Student:
        def __init__(self, name, age):
            self.name = name# 学生姓名
            self.age = age# 学生年龄
        # __ str__魔术方法
        def __str__(self):
            return f"Student类对象，name:{self.name}, age:{self.age}"
    stu = Student("周杰轮",31)
    print(stu)
    print(str(stu))
#Student类对象，name:周杰轮, age:31
#Student类对象，name:周杰轮, age:31
1
2
3
4
5
6
7
8
9
10
11
12
13

if __name__ == '__main__':
    class Student:
        def __init__(self, name, age):
            self.name = name# 学生姓名
            self.age = age# 学生年龄
        # __ str__魔术方法
        def __str__(self):
            return f"Student类对象，name:{self.name}, age:{self.age}"

        #__lt__魔术方法.
        def __lt__(self,other):
            return self.age < other.age

    stu1 = Student("周杰轮",31)
    stu2 = Student("周轮", 3)
    print(stu1<stu2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

__ le __ （小于等于） 和__ eq __（等于）类似

06-封装

面向对象的三大特性
面向对象编程，是许多编程语言都支持的一种编程思想。
简单理解是:基于模板(类)去创建实体(对象) ,使用对象完成功能开发。
面向对象包含3大主要特性：
➢封装
➢继承
➢多态

封装


所以会有平果越狱和俺卓root的行为，我们想获取他不想让我们看到的东西。

if __name__ == '__main__':
    class Phone:
        __current_voltage = 0.5
        # 当前手机运行电压
        def __keep_single_core(self):
            print("让CPU以单核模式运行")


        def call_by_5g(self):
            if self.__current_voltage >= 1:
                print("5g通话已开启")
            else:
                self.__keep_single_core()
                print("电量不足，无法使用5g通话，并已设置为单核运行进行省电。")

    phone = Phone()
    phone.call_by_5g()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1.封装的概念是指?
将现实世界事物在类中描述为属性和方法,即为封装。

2.什么是私有成员?为什么需要私有成员?
现实事物有部分属性和行为是不公开对使用者开放的。同样在类中描述
属性和方法的时候也需要达到这个要求，就需要定义私有成员了

3.如何定义私有成员?
成员变量和成员方法的命名均以__作为开头即可

4.私有成员的访问限制?
类对象无法访问私有 成员
类中的其它成员可以访问私有成员

07-封装的课后练习题讲解

案例分析：

if __name__ == '__main__':
    class Phone:
        # 提供私有成员变量:__ is_ 5g_ enabZe
        __is_5g_enable = False
        # 5g状态
        # 提供私有成员方法: __ check_ 5g()
        def __check_5g(self):
            if self.__is_5g_enable:
                print("5g开启")
            else:
                print("5g关闭，使用4g网络|")
        # 提供公开成员方法: call_by_5g()
        # 提供公开成员方法: calL_ ,by_ .5g()
        def call_by_5g(self):
            self.__check_5g()
            print("正在通话中")
    phone = Phone()
    phone.call_by_5g()

    '''
    5g关闭，使用4g网络|
    正在通话中
    '''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

08-继承的基础语法

继承的引出：

单继承：

class 类名(父类名):
	类内容体
1
2

其中pass关键字是补全语法。让语法补充，避免错误。当输出同名属性时，以前面为准，听大爸的。

09-复写父类成员和调用父类成员

什么是复写

if __name__ == '__main__':
    class Phone:
        IMEI = None
        # 序列号
        producer = "ITCAST"  # 厂商
        def call_by_5g(se1f):
            print("父类的5g通话")


    class MyPhone(Phone):
        proucer = "ITHEIMA"
        # 复写父类属性
        def call_by_5g(se1f):
            # 复写父类方法
            print("子类的5g通话")

    phone = MyPhone()
    print(phone.proucer)
    phone.call_by_5g()

    '''
    ITHEIMA
    子类的5g通话
    '''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

调用父类的同名成员

if __name__ == '__main__':
    class Phone:
        IMEI = None
        # 序列号
        producer = "ITCAST"  # 厂商
        def call_by_5g(se1f):
            print("父类的5g通话")


    class MyPhone(Phone):
        proucer = "ITHEIMA"
        # 复写父类属性
        def call_by_5g(se1f):
            print(f"父类的厂商是：{Phone.producer}")
            # 复写父类方法
            print("子类的5g通话")
            Phone.call_by_5g(se1f)
            print(f"父类的厂商是：{super().producer}")
            super().call_by_5g()
    phone = MyPhone()
    print(phone.proucer)
    phone.call_by_5g()

    '''
    ITHEIMA
    父类的厂商是：ITCAST
    子类的5g通话
    父类的5g通话
    父类的厂商是：ITCAST
    父类的5g通话
    '''

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

10-变量的类型注解

if __name__ == '__main__':
    # 基础数据类型注解
    var_1: int = 10
    var_2: str = "itheima"
    var_3: bool = True
    # 类对象类型注解
    class Student:
        pass
    stu:Student = Student()
    # 基础容器类型注解.
    my_list: list = [1, 2, 3]
    my_tupLe: tuple = (1, 2,3)
    my_dict: dict = {"itheima": 666}

    # 在注释中进行类型注解
    my_list= [1,2, 3] #type:list
    my_tuple= ("itheima", 666, True)#type:tuple[str, int, bool]

    # 类型注解的限制
    var_7: str = 10 #没事 但是是给自己看的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

11-函数和方法类型注解

函数和方法的形参类型注解语法：

def 函数方法名(形参名:类型，形参名:类型,......):
	pass
1
2

同时，函数(方法)的返回值也是可以添加类型注解的。

def函数方法名(形参:类型.......形参:类型)-> q返回值类型:
pass
1
2

12-Union联合类型注解

Union类型

使用Union[类型,类型…]

13-多态

抽象类可以理解成标准（框架。提出的要求）！什么意思？就是告诉人们，我有这个功能，自己（父类）不实现，但是他的子类必须实现，要不这个要求就是没有实现。

14-数据分析案例步骤-文件读取

链接：https://pan.baidu.com/s/1Up95mikhWrB_ubBE_uxToA
提取码：qli8
大家先下载数据再测试案例嗷！
文件截图如下：


data_ define.py

class Record:
    #定义4个成员变量
    def __init__(self,data,order_id,money,provine):
        self.date = data  #订单日期
        self.order_id = order_id#订单ID
        self.money = money#订单金额
        self.provine = provine#订单省份
    def __str__(self):
        return (f"{self.date},{self.order_id},{self.money},{self.provine}")
1
2
3
4
5
6
7
8
9

file_ define.py

import json

from data_define import Record

class FileReader:
    def read_data(self) :
        pass

class TextFileReader(FileReader):
    def __init__(self,path):
        self.path = path
    def read_data(self):
        f = open(self.path,"r",encoding="UTF-8")
        record_list = []
        for line in f.readlines():
            line = line.strip() #消除反斜杠n
            data_list = line.split(",")
            record= Record(data_list[0],data_list[1],int (data_list[2]),data_list[3])
            record_list.append(record)
        f.close()
        return record_list #list[Record]

class JsonFileReader(FileReader):
    def __init__(self,path):
        self.path = path
    def read_data(self) :
        f = open(self.path,"r",encoding="UTF-8")
        record_list = []
        for line in f.readlines():
            data_dict = json.loads(line)
            record = Record(data_dict["date"],data_dict["order_id"],int(data_dict["money"]),data_dict["province"])
            record_list.append(record)#list[Record]
        f.close()
        return record_list



if __name__ == '__main__':
     text_file_reader = TextFileReader("2011年1月销售数据.txt")
     json_file_reader = JsonFileReader("2011年2月销售数据JSON.txt")
     list1 = text_file_reader.read_data()
     list2 = json_file_reader.read_data()

     for l in list1:
         print(l)
     for l in list2:
         print(l)

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48

15-数据分析案例步骤-数据计算

main.py

from file_define import FileReader,TextFileReader,JsonFileReader
from data_define import Record

text_file_reader = TextFileReader("2011年1月销售数据.txt")
json_file_reader = JsonFileReader("2011年2月销售数据JSON.txt")

jan_data = text_file_reader.read_data() #list[Record]
feb_data = json_file_reader.read_data()#list[Record]

all_data = jan_data+feb_data #list[Record]

data_dict = {}
for record in all_data:
    if record.date in data_dict.keys():
        # 当前日期已经有记录了，所以和老记录做累加即可
        data_dict[record.date] += record. money
    else:
        data_dict[record.date] = record. money
print(data_dict)

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

16-数据分析案例步骤-可视化开发

from file_define import FileReader,TextFileReader,JsonFileReader
from data_define import Record
from pyecharts.charts import Bar
from pyecharts.globals import ThemeType
from pyecharts.options import TitleOpts

text_file_reader = TextFileReader("2011年1月销售数据.txt")
json_file_reader = JsonFileReader("2011年2月销售数据JSON.txt")

jan_data = text_file_reader.read_data() #list[Record]
feb_data = json_file_reader.read_data()#list[Record]

all_data = jan_data+feb_data #list[Record]

data_dict = {}
for record in all_data:
    if record.date in data_dict.keys():
        # 当前日期已经有记录了，所以和老记录做累加即可
        data_dict[record.date] += record. money
    else:
        data_dict[record.date] = record. money

bar = Bar()

bar.add_xaxis(list(data_dict.keys()))
bar.add_yaxis("销售额",list(data_dict.values()))
bar.set_global_opts(
    title_opts = TitleOpts(title="每日销售额")
)
bar.render("每日销售额柱状图.html")

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

main.py

from file_define import FileReader,TextFileReader,JsonFileReader
from data_define import Record
from pyecharts.charts import Bar
from pyecharts.globals import ThemeType
from pyecharts.options import TitleOpts
from pyecharts.options import LabelOpts
from pyecharts.options import InitOpts
text_file_reader = TextFileReader("2011年1月销售数据.txt")
json_file_reader = JsonFileReader("2011年2月销售数据JSON.txt")

jan_data = text_file_reader.read_data() #list[Record]
feb_data = json_file_reader.read_data()#list[Record]

all_data = jan_data+feb_data #list[Record]

data_dict = {}
for record in all_data:
    if record.date in data_dict.keys():
        # 当前日期已经有记录了，所以和老记录做累加即可
        data_dict[record.date] += record. money
    else:
        data_dict[record.date] = record. money

bar = Bar(init_opts=InitOpts(theme=ThemeType.LIGHT))

bar.add_xaxis(list(data_dict.keys()))
bar.add_yaxis("销售额",list(data_dict.values()),label_opts=LabelOpts(is_show =False ))
bar.set_global_opts(
    title_opts = TitleOpts(title="每日销售额")
)
bar.render("每日销售额柱状图.html")
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