Python

一、数据类型、运算符、字符串

string,int,float,+-，*,/,//(整除),%，**指数

1
2
3
4
5
6
7
print(type('abc'))
int(x)#类型转换为int
float(x)
str(x)
print(10**10)#100
name="888"
print("ABC"+name+"666")

字符串格式化

1
2
3
4
5
6
name="luhao"
print("555%s" %name)
location="HZ"
print("555%sin%s" %(name,location))
staic= 7
print(f"666{name}{staic}")#快速格式化
格式符号 转化
%s 将内容转换成字符串，放入占位位置
%d 将内容转换成整数，放入占位位置
%f 将内容转换成浮点型，放入占位位置

我们可以使用辅助符号”m.n”来控制数据的宽度和精度

• m，控制宽度，要求是数字（很少使用）,设置的宽度小于数字自身，不生效

•.n，控制小数点精度，要求是数字，会进行小数的四舍五入

•%5d：表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成：空格空格空格11，用三个空格补足宽度。

•%5.2f：表示将宽度控制为5，将小数点精度设置为2

小数点和小数部分也算入宽度计算。如，对11.345设置了%7.2f 后，结果是：空格 空格11.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为 .35

•%.2f：表示不限制宽度，只设置小数点精度为2，如11.345设置%.2f后，结果是11.35

输入语句:

input()

1
name=input("请输入:")#括号内是默认值

二、判断、循环语句、函数

if..else

1
2
3
4
5
6
7
8
a=10.135
print("555+%5.2f"%a)
if a<10 :
    print(6)
elif a>10 :
    print(3)
else:
    print(2)

while循环

1
2
while age >-1 :
    age+=1

for循环

1
2
3
4
5
6
7
8
9
10
11
money="itheima"
for x in moneys:
    print(x)
for x in range(1,10,1)#n1-n2,step 1
	print(x)
    
for x in range(10)#0-10
	print(x)

    for x in range(1,10)#1-10
	print(x)

continue and break

函数

1
2
3
4
5
6
7
8
9
10
11
12
def countlen2(data):
    """
    :param data:
    :return:
    """
    global count#全局变量
    count=0
    for x in data:
        count+=1
    return count
len = countlen("ITHEIMA")

  • 如果有两个return 只用第一个

  • 多个返回值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    def count(date):
        return 1,2
    a=count(1)
    b=count(2)
    print(a)#(1,2)
    print(b)#(1,2)
    c,d=count(3)
    print(c)#(1)
    print(d)#(2)

图片3

图片4

位置传递

1
2
3
4
5
def count2(*args):
    for i in args:
        print(i)

count2("6","梁贺不行",7)

关键字传递

1
2
3
4
5
6
def count3(**kwargs):
    keys=kwargs.keys()
    for i in keys:
        print(kwargs[i])

count3(name=1000,names=1000,name3=1000)

注意：

参数是“键=值”形式的形式的情况下, 所有的“键=值”都会被kwargs接受, 同时会根据“键=值”组成字典.

图片5

三、数据容器

1.list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
mylist=['1', 2, True]#类型可不同
mylist1=["1", [2,1], True]
print(mylist[-1])#从尾部开始取
print(mylist1[2][1])
were=mylist.index("a")#查找a在哪个地方
mylist.insert(1,"abc")#1处差"abc"
mylist.append(777)#尾部添加777
mylist.extend(mylist1)#列表合并
del  mylist[2]#删除2处的元素
A=mylist.pop(0)#弹出0给A
mylist.remove("itheima")
# 删除第一个出现的该元素
mylist.clear()
mylist.count("itheima")
# 计算itheima数量
lenss=len(mylist)
for i in mylist:
    #遍历

2.元组

不可修改

编号 方法 作用
1 index() 查找某个数据，如果数据存在返回对应的下标，否则报错
2 count() 统计某个数据在当前元组出现的次数
3 len(元组) 统计元组内的元素个数 
1
2
3
t1=tuple(1,"2",3)
t2=(1,"3",2)
# 元组index,count,len,不可修改

3.字符串

编号 操作 说明
1 字符串[下标] 根据下标索引取出特定位置字符
2 字符串.index(字符串） 查找给定字符的第一个匹配项的下标
3 字符串.replace(字符串1, 字符串2) 将字符串内的全部字符串1，替换为字符串2 不会修改原字符串，而是得到一个新的
4 字符串.split(字符串) 按照给定字符串，对字符串进行分隔 不会修改原字符串，而是得到一个新的列表
5 字符串.strip() 字符串.strip(字符串) 移除首尾的空格和换行符或指定字符串
6 字符串.count(字符串) 统计字符串内某字符串的出现次数
7 len(字符串) 统计字符串的字符个数 
1
2
3
4
5
6
7
8
9
10
11
12
13
mystr="ithrima"
STR=mystr[2]
mys=mystr.index("th")
# 查找起始下标
mystr.replace("yh","66")
# 将yh全部替换为66
mylitsbeh=mystr.split(" ")
# 以空格分割
# strip去除前后空格
# strip(“666")去除前后指定的666
mystr.count("it")
# 计算it出现次数
len("mystr")

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
25
26
27
28
29
30
my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]	# 下标1开始，下标4（不含）结束，步长1
print(new_list)		# 结果：[2, 3, 4]


my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:]	# 从头开始，到最后结束，步长1
print(new_tuple)	

my_list = [1, 2, 3, 4, 5]
new_list = my_list[::2]		# 从头开始，到最后结束，步长2
print(new_list)		# 结果：[1, 3, 5]


my_str = "12345"
new_str = my_str[:4:2]	# 从头开始，到下标4（不含）结束，步长2
print(new_str)		# 结果："13"

my_str = "12345"
new_str = my_str[::-1]	# 从头（最后）开始，到尾结束，步长-1（倒序）
print(new_str)		# 结果："54321"

my_list = [1, 2, 3, 4, 5]
new_list = my_list[3:1:-1]	# 从下标3开始，到下标1（不含）结束，步长-1（倒序）
print(new_list)		# 结果：[4, 3]

my_tuple = (1, 2, 3, 4, 5)
new_tuple = my_tuple[:1:-2] 	# 从头（最后）开始，到下标1(不含)结束，步长-2（倒序）
print(new_tuple)		# 结果：(5, 3)

5.set

•列表可修改、支持重复元素且有序

•元组、字符串不可修改、支持重复元素且有序

无序，不支持下标索引访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14
my_set={"Hello","world"}
my_set.add("itheima")/#随即插入
my_set.remove("Hello")
my_set.pop()#随即弹出
my_set.clear()

set1={1,23,4}
set2={1,4,9}
set1.diffenrence(set2)#得到差集

set1.difference_update(set2)#消除相同元素
set1.union(set2)#合并
len(set1)

编号 操作 说明
1 集合.add(元素) 集合内添加一个元素
2 集合.remove(元素) 移除集合内指定的元素
3 集合.pop() 从集合中随机取出一个元素
4 集合.clear() 将集合清空
5 集合1.difference(集合2) 得到一个新集合，内含2个集合的差集 原有的2个集合内容不变
6 集合1.difference_update(集合2) 在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变
7 集合1.union(集合2) 得到1个新集合，内含2个集合的全部元素 原有的2个集合内容不变
8 len(集合) 得到一个整数，记录了集合的元素数量

6.字典

•Key不可重复，重复会对原有数据覆盖

图片1

图片2

1
2
print(stu_score["王力宏"])
print(stu_score["王力宏"]['语文'])
1
2
3
4
5
6
7
8
9
10
11
#新增元素
stu_score["卢浩"]={"语文":100,"数学":100,"英语":100}
#更新
stu_score["卢浩"]={"语文":1000,"数学":1000,"英语":1000}
#删除元素
stu_score.pop("卢浩")
#清空字典
stu_score.clear()
#获取全部的key
stu_score.keys()
#遍历字典  语法：for key in 字典.keys()
编号 操作 说明
1 字典[Key] 获取指定Key对应的Value值
2 字典[Key] = Value 添加或更新键值对
3 字典.pop(Key) 取出Key对应的Value并在字典内删除此Key的键值对
4 字典.clear() 清空字典
5 字典.keys() 获取字典的全部Key，可用于for循环遍历字典
6 len(字典) 计算字典内的元素数量

四、文件操作、异常、模块

模式 描述
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除。 如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后。 如果该文件不存在，创建新文件进行写入。
操作 功能
文件对象 = open(file, mode, encoding) 打开文件获得文件对象
文件对象.read(num) 读取指定长度字节 不指定num读取文件全部
文件对象.readline() 读取一行
文件对象.readlines() 读取全部行，得到列表
for line in 文件对象 for循环文件行，一次循环得到一行数据
文件对象.close() 关闭文件对象
with open() as f 通过with open语法打开文件，可以自动关闭 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
with open("python.txt", "r") as f:
    f.readlines()

# 通过在with open的语句块中对文件进行操作
# 可以在操作完成后自动关闭close文件，避免遗忘掉close方法
# 1. 打开文件，通过a模式打开即可
f = open('python.txt', 'a')

# 2.文件写入
f.write('hello world')

# 3. 内容刷新
f.flush()
# 1. 打开文件
f = open('python.txt', 'w')

# 2.文件写入
f.write('hello world')

# 3. 内容刷新
f.flush()

异常

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
try:
    f = open('linux.txt', 'r')
except:
    f = open('linux.txt', 'w')
    
try:
    print(name)
except NameError as e:
    print('name变量名称未定义错误')
    
try:
    print(1/0)
except (NameError, ZeroDivisionError):
    print('ZeroDivision错误...')
try:
    print(num)
except (NameError, ZeroDivisionError) as e:
    print(e)
try:
    print(name)
except Exception as e:
    print(e)
    
    
    
try:
    f = open('test.txt', 'r')
except Exception as e:
    f = open('test.txt', 'w')
else:
    print('没有异常，真开心')
finally:
    f.close()

  • import 模块名
  • from 模块名 import 类、变量、方法等
  • from 模块名 import *
  • import 模块名 as 别名(别名.功能)
  • from 模块名 import 功能名 as 别名(可直接调用别名)
1
2
3
4
5
6
7
def test(a, b):
    print(a + b)

# 只在当前文件中调用该函数，其他导入的文件内不符合该条件，则不执行test函数调用
if __name__ == '__main__':
    test (1, 1)

_ _all _ _=[‘text’] 外部只引入textA模块

_ _init _ _=[‘text’] 外部只引入textA包

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

五、python数据处理

json:

1
2
3
4
# json数据的格式可以是： 
{"name":"admin","age":18} 
# 也可以是：  
[{"name":"admin","age":18},{"name":"root","age":16},{"name":"张三","age":20}] 
1
2
3
4
5
6
7
8
9
10
11
# 导入json模块 
import json 

# 准备符合格式json格式要求的python数据 
data = [{"name": "老王", "age": 16}, {"name": "张三", "age": 20}]
 
# 通过 json.dumps(data) 方法把python数据转化为了 json数据 
data = json.dumps(data) 

# 通过 json.loads(data) 方法把json数据转化为了 python数据 
data = json.loads(data)

1.折线图

查看官方示例打开官方画廊：https://gallery.pyecharts.org/#/README

1
2
3
4
5
6
7
8
9
10
11
12
from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LegendOpts,ToolboxOpts,VisualMapOpts
line=Line()
line.add_xaxis(["中国","美国","英国"])
line.add_yaxis("GDP",[30,20,10])
line.set_global_opts(
    title_opts=TitleOpts("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)
)
line.render()

图片6

数据处理

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
import json
from pyecharts.charts import Line
from pyecharts.options import TitleOpts, LabelOpts

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

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

f_in = open("D:/sjfx/印度.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()
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%")
)
line.render()
# 关闭文件对象
f_us.close()
f_jp.close()
f_in.close()

折线图相关配置项

配置项 作用 代码实例
init_opts 对折线图初始化设置宽高 init_opts=opts.InitOpts(width=”1600px”, height=”800px”)
.add_xaxis 添加x轴数据 .add_xaxis(列表)
.add_yaxis 添加y轴数据

.add_yaxis相关配置选项

配置项 作用 代码实例
series_name 设置图例名称 series_name=”美国确诊人数”
y_axis 输入y轴数据 y_axis=[“列表”]
symbol_size 设置点的大小 symbol_size=10
label_opts 标签设置项：不显示标签 label_opts=opts.LabelOpts(is_show=False)
linestyle_opts 线条宽度和样式 linestyle_opts=opts.LineStyleOpts(width=2)

.set_global_opts全局配置选项

配置项 作用 代码实例
title_opts 设置图标题和位置 title_opts=opts.TitleOpts(title=”标题”, pos_left=”center”)
yaxis_opts y轴配置项 yaxis_opts=opts.AxisOpts(name=”累计确诊人数”)
xaxis_opts x轴配置项 xaxis_opts=opts.AxisOpts(name=”时间”)
legend_opts 图例配置项 legend_opts=opts.LegendOpts(pos_left=’70%’) 
1
2
3
4
5
6
7
8
9
10
.set_global_opts(
	# 设置图标题和位置 
	title_opts=opts.TitleOpts(title="2020年 印🇮🇳美🇺🇸日🇯🇵 累计确诊人数对比图",pos_left="center"), 
	# x轴配置项 
	xaxis_opts=opts.AxisOpts(name=“时间”),    # 轴标题 
	# y轴配置项 
	yaxis_opts=opts.AxisOpts(name=“累计确诊人数”),    # 轴标题 
	# 图例配置项 
	legend_opts=opts.LegendOpts(pos_left=‘70%‘),    # 图例的位置 
)

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
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
from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts,TitleOpts
import json
map=Map()
f = open("D:/sjfx/疫情.txt", "r", encoding="UTF-8")
data=f.read()
f.close()
data_json=json.loads(data)
province_data_list=data_json["areaTree"][0]["children"]
# print(province_data_list)

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))

# print(data_list)
map.add("各省份确诊人数",data_list,"china")
map.set_global_opts(
    title_opts=TitleOpts("全国确诊地图"),
    visualmap_opts=VisualMapOpts(
        is_show=True,
        is_piecewise=True,# is_piecewise : 是否为分段型 
        pieces=[
            {"min":1,"max":99,"label":"1-99人","color":"#CCFFFF"},
            {"min":100,"max":399,"label":"100-399人","color":"#FFFF99"},
            {"min":400,"max":999,"label":"400-599人","color":"#FF9966"},
            {"min":1000,"max":2999,"label":"1000-2999人","color":"#FF6666"},
            {"min":3000,"max":9999,"label":"3000-9999人","color":"#CC3333"},
            {"min":10000,"label":"10000+","color":"#990033"},
        ]
    )
)
map.render()

3.柱状图

1
2
3
4
5
6
7
8
9
10
11
12
13
from pyecharts.charts import Bar
from pyecharts.options import LabelOpts
bar=Bar()
bar.add_xaxis(["中国","美国","英国"])
bar.add_yaxis("GDP",[30,20,10],label_opts=LabelOpts(position="right"))
# bar.set_global_opts(
#     title_opts=TitleOpts("",pos_left="center",pos_bottom="1%"),
#     legend_opts=LegendOpts(is_show=True),
#     toolbox_opts=ToolboxOpts(is_show=True),
#     visualmap_opts=VisualMapOpts(is_show=True)
# )
bar.reversal_axis()
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
32
33
34
35
36
37
38
39
40
41
42
43
from pyecharts.charts import Bar, Timeline
from pyecharts.options import LabelOpts
f = open("D:/sjfx/1960-2019全球GDP数据.csv", "r", encoding="GB2312")
datalines=f.readlines()
f.close()
datalines.pop(0)

data_list = { }
for line in datalines:
    year=int(line.split(",")[0])
    country = line.split(",")[1]
    gdp= float(line.split(",")[2])
    try:
        data_list[year].append([country,gdp])
    except KeyError:
        data_list[year]=[]
        data_list[year].append([country, gdp])
timeline=Timeline()
data_keys=data_list.keys()
for i in data_keys:
    data_list[i].sort(key=lambda element:element[1],reverse=True)
    year_eight=data_list[i][0:8]
    xdata=[]
    ydata=[]

    for j in year_eight:
        xdata.append(j[0])
        ydata.append(j[1]/10000000)
    bar=Bar()
    bar.add_xaxis(xdata)
    xdata.reverse()
    bar.add_yaxis("GDP(亿元)",ydata,label_opts=LabelOpts(position="right"))
    ydata.reverse()
    bar.reversal_axis()
    timeline.add(bar,str(i))

timeline.add_schema(
    play_interval=1000,
    is_timeline_show=True,
    is_auto_play=True,
    is_loop_play=True,
)
timeline.render()

六、面向对象

python支持多继承

复写

一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员

如果需要使用被复写的父类的成员，需要特殊的调用方式:

方式1：

•调用父类成员

使用成员变量：父类名.成员变量

使用成员方法：父类名.成员方法(self)

方式2：

•使用super()调用父类成员

使用成员变量：super().成员变量

使用成员方法：super().成员方法()

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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
import json
import random



class animal:
    # 成员变量
    name=None
    age=None
    hobby=None
    __height=None
    # 构造方法, 有了可省略成员变量定义
    def __init__(self,name,age,hobby):
        self.name=name
        self.age = age
        self.hobby = hobby
    # 成员方法
    def run(self,name):
        print(f"{self.name}在跑")
        print(f"{name}也在跑")

    #魔法方法,toString
    def __str__(self):
        return f"{self.name}年龄{self.age},爱好是{self.hobby}"

    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
    # 私有方法
    def __walk(self):
        print("小梁贺在走")

animals=animal("小梁贺",19,"吃饭")
animals.run("梁贺")
animals.age=20
# animals.walk

print(animals)
animalss=animal("中梁贺",21,"吃饭")

print(animals.__lt__(animalss))

class Dog(animal):
    # name=None
    # age=None
    # hobby=None
    legNumber=None
    # def __init__(self,name,age,hobby):
    #     self.name=name
    #     self.age = age
    #     self.hobby = hobby


    # 复写
    def run(self):
        print(f"{self.name}在跑")

class Cat(animal):
    legNumber=None
    def run(self):
        print(f"{self.name}在跑")

print("================")
smallDog=Dog("梁小贺",22,"吃饭")
smallDog.run()

smallCat=Cat("梁小贺",22,"吃饭")

# 类型注解


var_1: int=10
var_2: float=10.0
var_3:  int=10.0
print(var_1)
# 类型注解错了也没关系
print(var_3)

var_4:list[int,str]=[1,2,3,"NAME"]
var_4.append(4)

class Stu:
    pass
# 标识符，确保语法正确


var_5=random.randint(1,10)#type:int

# var_6=json.loads()#dict[str,int]

def fly(name: str,age: int,data: list[int])->str:
    return "梁贺is fly"

act=fly("lianghe",19,[1])


from ctypes import Union
# my_list: list[Union[str,int]]=[1,2,"itheima"]

def make_noise(animal: animal):
    animal.run()

make_noise(smallCat)
make_noise(smallDog)


# 接口 抽象类
class AC:
    def cool(self):
        """制冷"""
        pass

class M_AC(AC):
    def cool(self):
        print("制冷")