从零开始的python学习生活1

python函数的对返回值

本来多个return是不行的

这种语法就能接受多个返回值

def hanshu():
    return 1,"hello",True
x,y,z = hanshu()
print(x)
print(y)
print(z)
1
2
3
4
5
6

函数的多种传参方式

提前说明白了顺序就无所谓了




关键字传递一个传递参数，一个传递键值对，都是可以传递很多个的

def user(name,age,gender):
    print(f"姓名是{name}，年龄是{age}，性别是{gender}")
# 位置传参
user("刘承",22,"女")
# 关键字传参，可以不按照顺序去传参
user(age=22,gender="女",name="雪dis")
# 缺省参数（默认值）在函数定义的时候就定义默认值了，而且设置的默认值一定要在最后，不管有几个都是在最后
def userinfo(name,age,gender="男"):
    print(f"姓名是{name}，年龄是{age}，性别是{gender}")

userinfo("liihua",22)
# 不定长-位置不定长，*号（应该是元组）
def user_info(*args):
    print(args)

user_info("haha")
user_info("haha",23)
# 不定长-关键字不定长，**号（转换为字典）
def user_infos(**kwargs):
    print(kwargs)

user_infos(name="lch",age=22,gender="女")

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

匿名函数

函数作为参数被其他的函数调用

def computer(x,y):
    return x+y
def output(computer):
    result=computer(1,2)
    print(result)
output(computer)
1
2
3
4
5
6

它行倒是行，但是没懂有啥意义

这个是逻辑的传递，不是数据的传递

# 定义一个函数，接受另一个函数作为传入参数
def diaoyong(computer):
    result=computer(1,2)
    print(f"computer参数的类型是{type(computer)}")
    print(f"计算结果是{result}")
# 定义一个函数，准备作为参数传入另一个函数
def computer(x,y):
    return x+y
# 调用，并传入函数
diaoyong(computer)

1
2
3
4
5
6
7
8
9
10
11

好吧，多少懂一点了，好处估计是确定了函数名和input之后，函数里面具体怎么算就不管了
lambda匿名函数



lambda匿名函数一次性的

# 定义一个函数，接受其他函数输入
def diaoyong(computer):
    result=computer(1,2)
    print(f"结果是{result}")

# 通过lambda匿名函数的形式，将匿名函数作为参数传入
# 冒号前面是lambda匿名函数的传入参数，后面是函数体，在里面进行具体的操作
diaoyong(lambda x,y:x+y)
1
2
3
4
5
6
7
8

文件编码

将我们的文件转换为0,1然后进行存储

每一个字符都有各自的翻译规则对应

文件的读取操作

打开，关闭，读，写








单独牌面，以后都这么写，免得忘了

# 打开文件
import time

f=open("D:/测试.txt","r",encoding="utf-8")
print(type(f))
# 读取文件-read（）多次调用read，记录上次读到的地方，继续读取
# print(f"读取10个字节的结果：{f.read(10)}")
# print(f"读取全部的结果：{f.read()}")

# 读取文件-readLines（）
# lines=f.readlines()
# print(f"lines对象的类型是{type(lines)}")
# print(f"lines对象的内容是{lines}")
# line1=f.readline()
# line2=f.readline()
# line3=f.readline()
# print(f"第一行数据：{line1}")
# print(f"第二行数据：{line2}")
# print(f"第三行数据：{line3}")
# for循环读取文件行
for line in f:
    print(line)
# 文件的关闭
time.sleep(500)
# 上面的是睡眠
f.close()
# with open 语法操作文件
with open("D:/测试.txt","r",encoding="utf-8") as f:
    for line in f:
        print(line)
time.sleep(500)
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

文件读取课后题练习

with open("D:/测试.txt","r",encoding="utf-8") as f:
    count=0
    for line in f:
        line = line.split()
        for word in line:
            if word=="itheima":
                count+=1
        # print(line)
        # print("\n")
    print(count)
        # 能看出来是字符串形式，那我们就可以以字符串的手段来处理了
        # print(f"{type(line)}")
1
2
3
4
5
6
7
8
9
10
11
12

恩，就是6个
老师的方法：

with open("D:/测试.txt","r",encoding="utf-8") as f:
    content = f.read()
    count=content.count("itheima")
    print(count)

f.close()
1
2
3
4
5
6

我滴个乖乖，这显得我很若只

文件的写入操作

写入实际操作·就是这两个
写一堆语句然后统一flush进去
open创建一个新文件的时候，w会写入，假如用open打开一个已经存在的文件，那么再write会把之前的内容覆盖掉

# 打开文件，不存在的文件，r,w,a
import time
f=open("D:/test1.txt","w",encoding="utf-8")
# write写入
f.write("hello world")
# flush刷新
f.flush()
time.sleep(200)
# close关闭
f.close()

# 打开一个存在的文件
f=open("D:/test2.txt","w",encoding="utf-8")
# write写入，flush刷新
f.write("itheima")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

文件的追加写入

# 打开文件，不存在的文件，r,w,a
import time
# f=open("D:/test.txt","a",encoding="utf-8")
# write写入
# f.write("hello world")
# flush刷新
# f.flush()
# time.sleep(200)
# close关闭
# f.close()
# 打开一个已经存在的文件
f=open("D:/test.txt","a",encoding="utf-8")
# write写入，flush刷新
f.write("追加内容")
# close关闭
f.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

要换行的话就\n

文件操作综合案例

# 打开文件，不存在的文件，r,w,a
f=open("D:/bill.txt","r",encoding="utf-8")
file1=open("D:/bill.txt.bak","w",encoding="utf-8")
for line in f:
    if "测试" not in line:
        file1.write(line)
        print("\n")
file1.flush()
f.close()
file1.close()
1
2
3
4
5
6
7
8
9
10

老师的代码：

最后记得关闭即可

异常

异常的捕获

类似java里面的trywhile异常



这里写了filefounderror异常

类似于我提前感觉代码有点问题，我就加一下try和except


异常很多种，所以还是一开始就写个通用的比较方便


可以捕获所有异常等于下面这个简单写法



finally不管有没有异常我都要执行

异常的传递性

假如在函数里面有异常，那么其他的函数调用也能看到这个异常，在其他函数里面也可以捕捉

模块的概念和导入

import time
print("begin")
time.sleep(2)
print("end")
1
2
3
4

python里面的时间单位估计不是ms级别，估计就是s的单位

单独导入time模块的一个功能（sleep）

from time import *
print("begin")
sleep(3)
print("end")
1
2
3
4

给某个模块相当于直接改名

有的模块名字可能比较长

功能也能起别名

自定义模块并导入

自定义一个模块

自定义python包

好多模块在一个文件夹里面，就是python包
创建python包

import diy.module
import diy.module1
diy.module.info_print()
diy.module1.info_print1()
1
2
3
4

三种导入方式，看个人爱好

安装第三方包

安装成功

下载python包，好用爱用！

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称
1

清华的超快下载链接

我使用setting下载和显示有点问题，直接使用命令安装把

综合案例

文件结构

文件的函数代码：

def print_file_info(file_name):
    try:
        f = open(file_name, 'r',encoding="utf-8")
        content = f.read()
        print(f"文件的全部内容如下{content}")
        # lines = f.readlines()
        # for line in lines:
        #     print(line)
    except Exception as e:
        print(f'程序出现异常了，原因是{e}')
    finally:
        f.close()

def append_to_file(file_name,data):
    f=open(file_name, mode='a',encoding="utf-8")
    f.write(data)



if __name__ == '__main__':
    print_file_info("D:/abc.txt")
    append_to_file("D:/abc.txt", "我要添加好多东西哇咔咔")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

字符串的函数代码：

def str_reverse(s):
    return s[::-1]
def substr(s,x,y):
    return s[x:y]

if __name__ == '__main__':
    print(str_reverse("nihaohahagaga"))
    print(substr("你是一只小猪雪distance", 2, 5))
1
2
3
4
5
6
7
8

测试的代码：

from my_utils.str_util import str_reverse
from my_utils.str_util import substr
from my_utils.file_util import print_file_info
from my_utils.file_util import append_to_file
print(str_reverse("nihaohahagaga"))
print(substr("你是一只小猪雪distance", 2, 5))
print_file_info("D:/abc.txt")
append_to_file("D:/abc.txt","我要添加好多东西哇咔咔")


1
2
3
4
5
6
7
8
9
10

常回来看看，pspycharm自动猜你想写啥代码的功能实在是太好了

案例介绍（应该是到了数据可视化部分了）

画各种折线图，柱形图，条形图巴拉巴拉的

开发折线图



我们之前学习的字典，和嵌套字典的列表

python转json：dumps（）
json转python：loads（）

"""
演示JSON数据和Python字典的相互转换
"""
import json
# 准备列表，列表内每一个元素都是字典，将其转换为JSON
data = [{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}]
# 下面那个ensure那个表明不转换为ASCII码，直接输出出去
json_str = json.dumps(data, ensure_ascii=False)
print(type(json_str))
print(json_str)
# 准备字典，将字典转换为JSON
d = {"name":"周杰轮", "addr":"台北"}
json_str = json.dumps(d, ensure_ascii=False)
print(type(json_str))
print(json_str)
# 将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))
print(l)
# 将JSON字符串转换为Python数据类型{k: v, k: v}
s = '{"name": "周杰轮", "addr": "台北"}'
d = json.loads(s)
print(type(d))
print(d)

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

pyecharts模块

pyecharts参考文档
https://pyecharts.org/#/zh-cn/intro
pyecharts-gallery图展示
https://gallery.pyecharts.org/#/README

中间可能会报错，但是测试了import并无问题

pyecharts入门

from pyecharts.charts import Line
line = Line()
line.add_xaxis(["中国","美国","英国"])
line.add_yaxis("GDP",[30,20,10])
line.render("test.html")
1
2
3
4
5

这里基本上就是参考pyechart官网和前端差不多，现场查询

# 导包
from pyecharts.charts import Line
from pyecharts.options import TitleOpts, LegendOpts, ToolboxOpts, VisualMapOpts
# 创建一个折线图对象
line = Line()
# 给折线图对象添加x轴的数据
line.add_xaxis(["中国", "美国", "英国"])
# 给折线图对象添加y轴的数据
line.add_yaxis("GDP", [30, 20, 10])

# 设置全局配置项set_global_opts来设置,
line.set_global_opts(
    # 控制标题
    title_opts=TitleOpts(title="GDP展示", pos_left="center", pos_bottom="1%"),
    legend_opts=LegendOpts(is_show=True),
    toolbox_opts=ToolboxOpts(is_show=True),
    visualmap_opts=VisualMapOpts(is_show=True),
)

# 通过render方法，将代码生成为图像
line.render()

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

title_opts标题
legend_opts是否显示上面的线（下面GDP那一条图例）
toolbox_opts工具箱，里面有下载之类的
visualmap_opts左下角那个渐变色条条

数据处理（折线图）

json处理数据ab.173网址

import json
# 打开txt
f_us=open("D:/美国.txt","r",encoding="utf-8")
# 读取里面的内容
us_data=f_us.read()
# 前后有一些异常数据，所以要通过replace和切片给去掉
us_data=us_data.replace("jsonp_1629344292311_69436(","")
us_data=us_data[:-2]
# 将json数据转换为字典
us_dict=json.loads(us_data)
# 拨开了几层
us_trend_data=us_dict['data'][0]['trend']
us_x_data=us_trend_data["updateDate"][:314]
# 其实这个x轴也可以写成下面这种形式，这个就截止到22年底的数据就可以了
# us_x_data=us_dict['data'][0]['trend']["updateDate"][:314]
# print(trend_data)
# y轴同理，也是可以直接从头拨到尾
us_quezhen_data=us_trend_data['list'][0]["data"]
y_data=us_quezhen_data[:314]
print(us_quezhen_data)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

美国的抽取x轴和y轴的代码，详细解释版
三个国家的整体代码

import json
from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LabelOpts

# 处理各国数据
f_us=open("D:/美国.txt","r",encoding="utf-8")
f_jp=open("D:/日本.txt","r",encoding="utf-8")
f_in=open("D:/印度.txt","r",encoding="utf-8")
# 读取里面的内容
us_data=f_us.read()
jp_data=f_jp.read()
in_data=f_in.read()

# 前后有一些异常数据，所以要通过replace和切片给去掉,这是去掉乱码开头
us_data = us_data.replace("jsonp_1629344292311_69436(", "")
jp_data = jp_data.replace("jsonp_1629350871167_29498(", "")
in_data = in_data.replace("jsonp_1629350745930_63180(", "")
# 这是去掉结尾
us_data=us_data[:-2]
jp_data=jp_data[:-2]
in_data=in_data[:-2]
# 将json数据转换为字典
us_dict=json.loads(us_data)
jp_dict=json.loads(jp_data)
in_dict=json.loads(in_data)
# x轴
us_trend_data = us_dict['data'][0]['trend']
jp_trend_data = jp_dict['data'][0]['trend']
in_trend_data = in_dict['data'][0]['trend']

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轴同理，也是可以直接从头拨到尾
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轴数据,x轴数据大家都是一样的
line.add_xaxis(us_x_data)
# 添加y轴数据
line.add_yaxis("美国确诊人数",us_y_data,label_opts=LabelOpts(is_show=False))
line.add_yaxis("日本确诊人数",jp_y_data,label_opts=LabelOpts(is_show=False))
line.add_yaxis("印度确诊人数",in_y_data,label_opts=LabelOpts(is_show=False))
# 设置全局属性
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

地图

全国疫情图代码

"""
演示全国疫情可视化地图开发
"""
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

现在的主要难点在于不知道那些是关键数据从而提取出来

省级疫情地图绘制（地图）

"""
演示河南省疫情可视化地图开发
"""
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)        # 基础数据字典
# 从字典中取出省份的数据
shandong_data = data_dict["areaTree"][0]["children"][11]["children"][1]
# 组装每个省份和确诊人数为元组，并各个省的数据都封装入列表内
data_list = []      # 绘图需要用的数据列表
for data in shandong_data:
    shi_name = shandong_data["name"]+"市"                   # 省份名称
    shi_confirm = shandong_data["total"]["confirm"]    # 确诊人数
    data_list.append((shi_name, shi_confirm))


# 创建地图对象
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

pyecharts里面要想形成某个省形状的地图，直接输入“山东”“china”之类的就可以

动态柱状图

基础柱状图

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")
1
2
3
4
5
6
7
8
9
10
11
12

动态柱状图

"""
演示带有时间线的柱状图开发
"""
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=100,#毫秒为单位
    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方法

my_list = [["a", 33], ["b", 55], ["c", 11]]

# def choose(element):
#     return element[1]

# my_list.sort(key=choose, reverse=True)
my_list.sort(key=lambda element:element[1], reverse=True)
print(my_list)
1
2
3
4
5
6
7
8

一种定义函数写法，一种匿名写法
拿不下这个案例了，思考一下能看懂，但是自己写是绝对写不出来的

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

面向对象

# 设计一个类
class Student:
    name=None
    gender=None
    guoji=None#国籍
    jiguan=None#籍贯
    age=None

# 创建一个对象
student1=Student()
student1.name="lihua"
student1.guoji="china"
student1.jiguan="shandong"
student1.age=18
student1.gender="male"

print(student1.name)
print(student1.gender)
print(student1.age)
print(student1.jiguan)
print(student1.guoji)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

更加规范

类的成员方法

函数：类外边的
方法：类里面的（成员方法）

# 设计一个类
class Student:
    name=None
    gender=None
    guoji=None#国籍
    jiguan=None#籍贯
    age=None
    # 不需要传入参数的
    def sayhi(self):
        print(f"hello,大家好，我是{self.name}")
    # 需要传入参数的
    def sayHello(self,msg):
        print(f"hello,大家好，{msg}")

    def sayHi(self,msg):
        print(f"大家好，我是{self.name}，{msg}")

# 创建一个对象
student1=Student()
student1.name="lihua"
student1.guoji="china"
student1.jiguan="shandong"
student1.age=18
student1.gender="male"

stu2=Student()
stu2.name="周杰伦"

stu3=Student()
stu3.name="林俊杰"

stu2.sayHi("哎呦，不错呦")
stu3.sayHi("小伙子我看好你")

# student1.sayHello("很高兴认识大家")
# student1.sayhi()



print(student1.name)
print(student1.gender)
print(student1.age)
print(student1.jiguan)
print(student1.guoji)
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

类比java类的定义
规定一个模板大家都去套模板就可

类和对象

class Clock:
    id=None
    price=None

    def ring(self):
        # 导入这个模块能让电脑发出声音
        import winsound
        winsound.Beep(2000,3000)

clock1=Clock()
clock1.id="001"
clock1.price=19.99
print(f"闹钟的编号是{clock1.id},价格是{clock1.price}")
clock1.ring()

clock2=Clock()
clock2.id="002"
clock2.price=19.99
print(f"闹钟的编号是{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

真的会响（刺耳哈哈）

构造方法

希望能有更加方便简洁的代码去实现上面的内容，引出构造方法

init函数会自动执行，也就是读入你的输入自动赋值进去

class Student:
    name=None
    age=None
    tel=None

    def __init__(self,name,age,tel):
        self.name = name
        self.age = age
        self.tel = tel
        print("Student类创建了一个类对象")


stu=Student("周杰伦",22,"14284638497")
print(stu.name)
print(stu.age)
print(stu.tel)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Student类创建了一个类对象出现了说明init函数自动执行了

练习案例

class Student:
    name=None
    age=None
    address=None
    def __init__(self,name,age,address):
        self.name=name
        self.age=age
        self.address=address
n=1
while n<11:
    print(f"当前录入第{n}位学生信息，总共需要录入10位学生信息")
    name=input("请输入学生姓名")
    age=input("请输入学生年龄")
    address=input("请输入学生地址")
    stu = Student(name,age,address)
    print(f"学生{n}信息录入完成，信息为：【学生姓名：{stu.name}，年龄：{stu.age}地址：{stu.address}】")
    n+=1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

魔术方法

和之前讲的__init__类似

class Student:
    def __init__(self, name,age):
        self.name = name
        self.age = age

    def __str__(self):
        return f'Student类对象{self.name} is {self.age}'

    def __lt__(self, other):
        return self.age < other.age

    def __le__(self, other):
        return self.age <= other.age

    def __eq__(self, other):
        return self.age == other.age

stu=Student("John",18)
stu1=Student("Sam",22)
print(stu1>stu)
print(stu1<stu)
# 因为lt只能比大小，不能带等于号
print(stu1>=stu)
print(stu1<=stu)
# eq比较大小同理,上面那俩个都不行
print(stu1==stu)
# print(stu1=stu)

print(stu)
print(str(stu))

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

面向对象三大特性（封装，继承，多态）

封装

实际上就是将现实世界事物的属性和行为转换成代码中的成员变量和成员方法


但是也有一些权限不对用户开放（不公开的）


也就是封装的方法会关闭一些方法对用户的公开

可以看到用户层面我们是无法调用私有对象和私有方法的
（也就是其他权限的可以用，比如用户无法管理单核还是多核运行，但是生产商可以）

ps：又卡了，下P见，虽然感觉也没人看哈哈哈