Python与Java的语法区别
数据容器/数组/集合
Python: 对数据容器的操作
# 对list进行切片，从1开始，4结束，步长1（默认步长为1） my_list = [0, 1, 2, 3, 4, 5, 6] result1 = my_list[1:4] print(f"结果1：{result1}") # 对tuple进行切片，从头开始，到最后结束，步长1 my_tuple = (0, 1, 2, 3, 4, 5, 6) result2 = my_tuple[:] # 其实和结束不写表示从头到尾，步长为1可以省略 print(f"结果2：{result2}") # 对str进行切片，从头开始，到最后结束，步长2 my_str = "01234567" result3 = my_str[::2] print(f"结果3：{result3}") # 对str进行切片，从头开始，到最后结束，步长-1 my_str = "01234567" result4 = my_str[::-1] # 等同于序列反转了 print(f"结果4：{result4}") # 对列表进行切片，从3开始，到1结束，步长-1 my_list = [9, 10, 21, 3, 4, 5, 6] result5 = my_list[3:1:-1] print(f"结果5：{result5}") # 对元组进行切片，从头开始，到尾结束，步长-2 my_tuple = (0, 1, 2, 3, 4, 5, 6) result6 = my_tuple[::-2] print(f"结果6：{result6}")
Java: 对数组的操作
//对list进行切片，从1开始，4结束，补偿1 int[] my_list = {0, 1, 2, 3, 4, 5, 6}; int[] sub_list = Arrays.copyOfRange(my_list, 1, 5); for (int i : sub_list) { System.out.print(i); }
Python: 字典
# 定义字典 my_dict1 = {"王力宏":99, "周杰伦":88, "林俊杰": 77}
score = my_dict1["王力宏"]
print(f"王力宏的考试分数是：{score}")
Java: Map集合
Map<String, Integer> map = new HashMap<>(); map.put("王力宏",99); map.put("周杰伦",88); map.put("林俊杰",77); int score = map.get("王力宏"); System.out.println("王力宏的考试分数是："+score);
Python: 遍历字典
# 获取全部Key my_dict = {"周杰伦": 99, "林俊杰": 88, "张学友": 77} keys = my_dict.keys() print(f"该字典的全部Keys是：{keys}") # 遍历字典 # 方式1：通过获取全部的Key来完成遍历 for key in keys: print(f"字典的key是：{key}") print(f"字典的value是：{my_dict[key]}") # 方式2：直接对字典进行for循环，每一次循环都是直接得到key for key in my_dict: print(f"2字典的key是：{key}") print(f"2字典的value是：{my_dict[key]}") # 统计字典内的元素数量，len()函数 num = len(my_dict) print(f"字典中的元素数量有:{num}个")
Java: 遍历Map
//遍历Map
Map<String, Integer> map = new HashMap<>();
map.put("王力宏",99);
map.put("周杰伦",88);
map.put("林俊杰",77);
for (Map.Entry<String, Integer> entry : map.entrySet()) {
String name = entry.getKey();
int score = entry.getValue();
System.out.println(name + "的考试分数是：" + score);
}
// 统计字典内的元素数量
int size = scores.size();
System.out.println("Map中元素的数量是：" + size);
Python: 容器的通用操作
my_list = [1, 2, 3, 4, 5] my_tuple = (1, 2, 3, 4, 5) my_str = "abcdefg" my_set = {1, 2, 3, 4, 5} my_dict = {"key1": 1, "key2": 2, "key3": 32, "key4": 4, "key5": 5} # len元素个数 print(f"列表 元素个数有：{len(my_list)}") print(f"元组 元素个数：{len(my_tuple)}") print(f"字符串 元素个数有：{len(my_str)}") print(f"集合 元素个数有：{len(my_set)}") print(f"字典 元素个数有：{len(my_dict)}") # max最大元素 print(f"列表 最大的元素有：{max(my_list)}") print(f"元组 最大的元素有：{max(my_tuple)}") print(f"字符串最大的元素有：{max(my_str)}") print(f"集合 最大的元素有：{max(my_set)}") print(f"字典 最大的元素有：{max(my_dict)}") # min最小元素 print(f"列表 最小的元素有：{min(my_list)}") print(f"元组 最小的元素有：{min(my_tuple)}") print(f"字符串 最小的元素有：{min(my_str)}") print(f"集合 最小的元素有：{min(my_set)}") print(f"字典 最小的元素有：{min(my_dict)}") # 类型转换：容器转列表 print(f"列表 转 列表的结果是：{list(my_list)}") print(f"元组 转 列表的结果是：{list(my_tuple)}") print(f"字符串 转 列表的结果是：{list(my_str)}") print(f"集合 转 列表的结果是：{list(my_set)}") print(f"字典 转 列表的结果是：{list(my_dict)}") # 类型转换：容器转元组 print(f"列表 转 元组的结果是： {tuple(my_list)}") print(f"元组 转 元组的结果是： {tuple(my_tuple)}") print(f"字符串 转 元组的结果是： {tuple(my_str)}") print(f"集合 转 元组的结果是： {tuple(my_set)}") print(f"字典 转 元组的结果是： {tuple(my_dict)}") # 类型转换：容器转字符串 print(f"列表 转 字符串的结果是： {str(my_list)}") print(f"元组 转 字符串的结果是： {str(my_tuple)}") print(f"字符串 转 字符串的结果是： {str(my_str)}") print(f"集合 转 字符串的结果是： {str(my_set)}") print(f"字典 转 字符串的结果是： {str(my_dict)}") # 类型转换：容器转集合 print(f"列表 转 集合的结果是： {set(my_list)}") print(f"元组 转 集合的结果是： {set(my_tuple)}") print(f"字符串 转 集合的结果是： {set(my_str)}") print(f"集合 转 集合的结果是： {set(my_set)}") print(f"字典 转 集合的结果是： {set(my_dict)}") my_list = [3, 1, 2, 5, 4] my_tuple = (3, 1, 2, 5, 4) my_str = "abcdefg" my_set = {3, 1, 2, 5, 4} my_dict = {"key3": 1, "key1": 2, "key2": 32, "key5": 4, "key4": 5} # 进行容器的排序 print(f"列表 对象的排序结果是： {sorted(my_list)}") print(f"元组 对象的排序结果是： {sorted(my_tuple)}") print(f"字符串 对象的排序结果是： {sorted(my_str)}") print(f"集合 对象的排序结果是： {sorted(my_set)}") print(f"字典 对象的排序结果是： {sorted(my_dict)}") # 进行容器的反向排序 print(f"列表 对象的反向排序结果是： {sorted(my_list, reverse=True)}") print(f"元组 对象的反向排序结果是： {sorted(my_tuple, reverse=True)}") print(f"字符串 对象的反向排序结果是： {sorted(my_str, reverse=True)}") print(f"集合 对象的反向排序结果是： {sorted(my_set, reverse=True)}") print(f"字典 对象的反向排序结果是： {sorted(my_dict, reverse=True)}")
Java: 省略，比Python复杂
Python: 函数的多返回值
# 演示使用多个变量，接收多个返回值 def test_return(): return 1,"hello",True x, y, z = test_return() print(x) print(y) print(z)
Java: 无法返回多个返回值。如果有多个值需要返回，需要用对象包装起来，最终返回一个对象
Python: 多种传参的形式：
def user_info(name, age, gender): print(f"姓名是：{name}, 年龄是：{age}, 性别是：{gender}") # 位置参数 - 默认使用形式 user_info('小明', 20, '男') # 关键字参数 user_info(name='小王', age=11, gender='女') user_info(age=10, gender='女', name='晓晓') user_info('甜甜', gender='女', age=20) # 缺省参数（默认值） def user_info(name, age, gender='男'): print(f"姓名是：{name}, 年龄是：{age}, 性别是：{gender}") def user_info(name, age, gender='男',hobby='any'): print(f"姓名是：{name}, 年龄是：{age}, 性别是：{gender}, 爱好是：{hobby}") # 注意，Python里可以定义2个相同名字的函数，但是后面的函数会覆盖前面的函数 user_info('小天', 13) user_info('小天', 13, gender='女') user_info('小天', 13, gender='女', hobby='足球') # 不定长 - 位置不定长，*号 # 不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入 def user_info(*args): print(f"args参数的类型是：{type(args)}, 内容是：{args}") user_info(1,2,3,'小明', '男孩') # 不定长 - 关键字不定长，**号 ， kw代表 key - word (keyword) def user_info(**kwargs): print(f"kwargs参数的类型是：{type(kwargs)}, 内容是：{kwargs}") user_info(name='小王', age=11, gender='男') """ 上面的输出结果： 姓名是：小明, 年龄是：20, 性别是：男 姓名是：小王, 年龄是：11, 性别是：女 姓名是：晓晓, 年龄是：10, 性别是：女 姓名是：甜甜, 年龄是：20, 性别是：女 姓名是：小天, 年龄是：13, 性别是：男, 爱好是：any 姓名是：小天, 年龄是：13, 性别是：女, 爱好是：any 姓名是：小天, 年龄是：13, 性别是：女, 爱好是：足球 args参数的类型是：<class 'tuple'>, 内容是：(1, 2, 3, '小明', '男孩') kwargs参数的类型是：<class 'dict'>, 内容是：{'name': '小王', 'age': 11, 'gender': '男'} """
Java: 省略
Python: 函数作为参数传递
# 定义一个函数，接收另一个函数作为传入参数 def test_func(compute): result = compute(1, 2) # 确定compute是函数 print(f"compute参数的类型是：{type(compute)}") print(f"计算结果是：{result}") # 定义一个函数，准备作为参数传入另一个函数 def compute(x, y): return x + y # 调用，并传入函数 test_func(compute) """ 上面的输出结果是： compute参数的类型是：<class 'function'> 计算结果是：3 """
Java: 没有类似语法
Python: lambda匿名函数
# 定义一个函数，接收其他函数输入 def test_func(compute): result = compute(1, 2) print(f"结果是：{result}") # 通过lambda匿名函数的形式，将匿名函数作为参数传入 # 语法： lambda 传入参数: 函数体(一行代码) test_func(lambda x, y: x + y) test_func(lambda x, y: x + y)
Java: 省略
Python: 读文件
"""
演示文件的读取
"""
import time
# 打开文件
f = open("D:\\test.txt",'r',encoding='UTF-8')
print(type(f))
# 读取文件 - read()
print(f'读取的10个字节的结果为：{f.read(10)}')
print(f'read方法读取全部内容的结果是：{f.read()}')
# 读取文件 - readLines()
lines = f.readlines() # 读取文件的全部行，封装到列表中
print(f"lines对象的类型：{type(lines)}")
print(f"lines对象的内容是：{lines}")
# 读取文件 - readline()
line1 = f.readline()
line2 = f.readline()
line3 = f.readline()
print(f"第一行数据是：{line1}")
print(f"第二行数据是：{line2}")
print(f"第三行数据是：{line3}")
# for循环读取文件行
for line in f :
print(f"每一行数据是：{line}")
# 文件的关闭
# f.close()
# time.sleep(500000)
# with open 语法操作文件
with open("D:\\test.txt",'r',encoding='UTF-8') as f:
for line in f:
print(f"每一行数据是：{line}")
Java: 省略
Python: 文件的写入
"""
# 打开文件，不存在的文件，r,w,a
import time
"""
f = open("D:/word.txt", "w", encoding="UTF-8")
# write写入
f.write("Hello World!!fffffffffDDDDDDDD!") # 内容写入到内存中
# flush 刷新
# f.flush() # 将内存中积攒的内容，写入到硬盘的文件
# close关闭
f.close() # close方法，内置了flush的功能的
Java: 省略
Python: 异常的捕获
"""
演示捕获异常
"""
# 基本捕获语法
try:
f = open("D:/abc.txt", "r", encoding="UTF-8")
except:
print("出现异常了，因为文件不存在，我将open的模式，改为w模式去打开")
f = open("E:/storage/study/Python/python-learn/day01/02-python-learn/08_文件操作/素材/abc.txt", "w", encoding="UTF-8")
# 捕获指定的异常
try:
print(name)
# 1 / 0
except NameError as e:
print("出现了变量未定义的异常")
print(e)
# 捕获多个异常
try:
# 1 / 0
print(name)
except (NameError, ZeroDivisionError) as e:
print("出现了变量未的定义 或者 除以0的异常错误")
# 未正确捕获异常类型，将无法捕获异常
# 捕获所有异常
try:
f = open("E:/storage/study/Python/python-learn/day01/02-python-learn/08_文件操作/素材/123.txt", "r", encoding="UTF-8")
except Exception as e:
print("出现异常了")
f = open("E:/storage/study/Python/python-learn/day01/02-python-learn/08_文件操作/素材/123.txt", "w", encoding="UTF-8")
else:
print("好高兴，没有异常")
finally:
print("我是finally, 有没有异常我都要执行")
f.close()
Java：异常的捕获
try {
System.out.println("你好");
}catch (Exception e){
e.printStackTrace();
}finally {
System.out.println("我好");
}
Python: 模块的导入
"""
演示Python的模块导入
"""
# 使用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(5)
print("我好")
# 使用as给特定功能加上别名
import time as t
print("你好")
t.sleep(5)
print("我好")
from time import sleep as sl
print("你好")
sl(5)
print("我好")
Java：模块的导入
import java.util.Random;
public static void main(String[] args) {
Random random = new Random();
System.out.println(random.nextInt());
}
Python: 自定义模块
# 导入自定义模块使用
# import my_module_1
# my_module_1.test_a(1, 2)
# 导入不同模块的同名功能
# from my_module_1 import test_a
# from my_module_2 import test_a
# test_a(1,2)
# __main__变量
# from my_module_1 import test_a
# test_a(1,2)
# __all__变量
from my_module_1 import *
test_a(1,2)
test_b(1,2)
#----------------------------my_module_1.py----------------------------
__all__ = ['test_a']
def test_a(a, b):
print(a+b)
def test_b(a, b):
print(a*b)
# test_a(2,3)
if __name__ == '__main__':
test_a(2,3)
#----------------------------my_module_2.py----------------------------
def test_a(a, b):
print(a - b)
Java:省略
Python: 安装包
pip install 包名
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称
Java：省略
Python: json数据格式
"""
演示JSON数据和Python字典的相互转换
"""
import json
# 准备列表，列表内每一个元素都是字典，将其转换为JSON
data = [{"name":"张大山","age":11},{"name":"王大锤","age":13},{"name":"赵小虎","age":20}]
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":20}]'
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)
Java: 省略
Python: 折线图开发
"""
演示可视化需求1：折线图开发
"""
import json
from pyecharts.charts import Line
from pyecharts.options import TitleOpts, LabelOpts
# 处理数据
f_us = open("E:/storage/study/Python/python-learn/day01/02-python-learn/10_可视化案例/素材/美国.txt", "r", encoding="UTF-8")
f_jp = open("E:/storage/study/Python/python-learn/day01/02-python-learn/10_可视化案例/素材/日本.txt", "r", encoding="UTF-8")
f_in = open("E:/storage/study/Python/python-learn/day01/02-python-learn/10_可视化案例/素材/印度.txt", "r", encoding="UTF-8")
# 去掉不合json规范的开头
us_data = f_us.read()
jp_data = f_jp.read()
in_data = f_in.read()
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轴，取202年（到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%", is_show=True)
)
# 调用render方法，生成图表
line.render()
# 关闭文件对象
f_us.close()
f_jp.close()
f_in.close()
Java: 省略
Python: 地图可视化的基本使用
import json
from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts
# 读取数据文件
file = open("E:/storage/study/Python/python-learn/day01/02-python-learn/10_可视化案例/素材/疫情.txt", "r", encoding="UTF-8")
# 读取全部数据
data = file.read()
# 关闭文件
file.close()
# 取到各省数据
# 将字符串json转换为python的字典
data_dic = json.loads(data) # 基础数据字典
# 从字典中取出省份的数据
province_data_list = data_dic['areaTree'][0]['children']
# 组装每个省份和确诊人数为元组，并各个省的数据都封装到列表内
data_list = [] # 绘图需要用的数据列表
for province_data in province_data_list:
province_name = province_data['name'] # 省份名称
if ((province_name=="北京") | (province_name=="上海") | (province_name == "天津") | (province_name == "重庆")):
province_name += "市"
elif (province_name=="内蒙古") | (province_name=="西藏"):
province_name += "自治区"
elif (province_name=="广西"):
province_name += "壮族自治区"
elif (province_name=="新疆"):
province_name += "维吾尔自治区"
elif (province_name=="宁夏"):
province_name += "回族自治区"
elif (province_name=="香港") | (province_name=="澳门"):
province_name += "特别行政区"
else:
province_name += "省"
confirm = province_data['total']['confirm'] # 确诊人数
data_list.append((province_name,confirm))
# 创建地图对象
map = Map()
# 添加数据
map.add("各省份确诊人数", data_list, 'china')
# 设置全局配置，定制分段的视觉映射
map.set_global_opts(
visualmap_opts = VisualMapOpts(
is_show=True, # 是否显示
is_piecewise=True, # 是否分段
pieces=[
{"min": 0, "max": 99, "label": "0-99人", "color": 'green'},
{"min": 100, "max": 999, "label": "100-999人", "color": 'black'},
{"min": 1000, "max": 5000, "label": "1000-5000人", "color": 'yellow'},
{"min": 5000, "max": 9999, "label": "5000-9999人", "color": 'blue'},
{"min": 10000, "max": 99999, "label": "10000-99999人", "color": 'red'},
{"min": 100000, "label": "100000人以上", "color": 'pink'}
]
)
)
# 绘图
map.render("全国疫情地图.html")
Python: 面向对象》类的创建
# 1. 设计一个类（类比生活中：设计一张登记表）
class Student:
name = None # 记录学生姓名
gender = None # 记录学生性别
nationality = None # 记录学生国籍
native_place = None # 记录学生籍贯
age = None # 记录学生年龄
# 2. 创建一个对象（类比生活中：打印一张登记表）
stu1 = Student()
# 3. 对象属性进行赋值（类比生活中：填写表单）
stu1.name = "林俊杰"
stu1.gender="男"
stu1.nationality="中国"
stu1.native_place="山东省"
stu1.age=31
# 4. 获取对象中记录的信息
print(stu1.name)
print(stu1.gender)
print(stu1.nationality)
print(stu1.native_place)
print(stu1.age)
Java: 面向对象》类的创建
public class Student {
private String name;
private int age;
public static void main(String[] args) {
Student student = new Student();
student.name = "林俊杰";
student.age = 20;
}
}
Python: 成员方法
class Student:
name = None # 学生的姓名
def say_hi(self):
print(f"大家好呀，我是{self.name}, 欢迎大家多多关照")
def say_hi2(self, msg):
print(f"大家好呀，我是{self.name},{msg}")
stu1 = Student()
stu1.name = "张三"
stu1.say_hi()
Java: 成员方法
public class Student {
private String name;
private int age;
public void say_hi(){
System.out.println("姓名："+this.name+" ，年龄："+this.age);
}
public static void main(String[] args) {
Student student = new Student();
student.name = "林俊杰";
student.age = 20;
}
}
Python: 类和对象
"""
演示类和对象的关系，即面对对象的编程套路（思想）
"""
class Clock:
id = None # 序列化
price = None # 价格
def ring(self):
import winsound
winsound.Beep(2000,5000)
# 构建2个闹钟对象并让其工作
clock1 = Clock()
clock1.id = "0020"
clock1.price = 100
print(f"闹钟ID：{clock1.id}, 价格：{clock1.price}")
clock1.ring()
Java: 省略
Python: 构造方法
# 演示使用构造方法对成员变量进行赋值
# 构造方法的名称： __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(f"名字为：{self.name}, 年龄为：{self.age}, 电话为：{self.tel}")
stu1 = Student("张三", 20, "18679772038")
print(stu1.name)
print(stu1.age)
print(stu1.tel)
Java: 构造方法
public class Student {
private String name;
private int age;
Student(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Student student = new Student("林俊杰", 20);
System.out.println(student.name);
System.out.println(student.age);
}
}
Python: 其他内置方法
class Student:
def __init__(self, name, age, tel):
self.name = name
self.age = age
self.tel = tel
print(f"名字为：{self.name}, 年龄为：{self.age}, 电话为：{self.tel}")
# __lt__魔术方法
def __lt__(self, other):
return self.age < other.age
# __le__魔术方法
def __le__(self, other):
return self.age < other.age
# __eq__魔术方法
def __eq__(self, other):
return self.age == other.age
# __str__魔术方法
def __str__(self):
return f"名字为：{self.name}, 年龄为：{self.age}, 电话为：{self.tel}"
stu1 = Student("张三", 20, "18679772986")
stu2 = Student("李四", 30, "18679832729")
print(stu1 < stu2)
print(stu1 > stu2)
print(stu1 <= stu2)
print(stu1 >= stu2)
print(stu1 == stu2)
print(stu1)
print(stu2)
Java: hash方法，toString方法
省略
Python: 封装
# 定义一个类，内含私有成员变量和私有成员方法
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()
# print(phone.__current_voltage) # 报错
phone.call_by_5g()
Java: 封装
public class Phone {
private int current_voltage = 1;
private void keep_single_core(){
System.out.println("让CPU以单核模式运行");
}
public void call_by_5g(){
if (this.current_voltage > 1) {
System.out.println("5g通话已开启");
}else {
System.out.println("电量不足，无法使用5g通话，并已设置为单核运行进行省点。");
}
}
public static void main(String[] args) {
Phone student = new Phone();
student.keep_single_core();
}
}
Python: 继承
# 演示单继承
class Phone:
IMEI = None # 序列号
producer = "HM" # 厂商
def call_by_4g(self):
print("4g通话")
class Phone2022(Phone):
face_id = "1001" # 面部识别ID
def call_by_5g(self):
print("5g通话")
phone = Phone2022()
phone.call_by_4g()
phone.call_by_5g()
# 演示多继承
class NFCReader:
nfc_type = "第五代"
producer = "New HM"
def read_card(self):
print("NFC读卡")
def write_card(self):
print("NFC写卡")
class RemoteControl:
rc_type = "红外遥控"
def control(self):
print("红外遥控开启了")
class MyPhone(Phone, NFCReader, RemoteControl):
pass
myPhone = MyPhone()
myPhone.call_by_4g()
myPhone.read_card()
myPhone.write_card()
myPhone.control()
print(myPhone.producer)
Java: Java中不支持类的多继承，继承通过extends关键字。如果想要实现多继承，可以使用接口实现多继承。
Python: 继承》复写和使用父类成员
class Phone:
IMEI = None # 序列号
producer = "ITCAST" # 厂商
def call_by_5g(self):
print("使用5g网络进行通话")
# 定义子类，复写父类成员
class MyPhone(Phone):
producer = "ITHEIMA" # 复写父类的成员属性
def call_by_5g(self):
print("开启CPU单核模式，确保通话的时候省电")
# 在子类中调用父类成员
# 方式1
# print(f"父类的厂商是：{Phone.producer}")
# Phone.call_by_5g(self)
# 方式2
print(super().producer)
super().call_by_5g()
print("关闭CPU单核模式，确保性能")
phone = MyPhone()
phone.call_by_5g()
Java: 省略
Python: 类型注解--变量
类型注解只是帮助开发者自身对变量进行类型注释
import json
import random
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: list[int] = [1,2,3]
my_tuple: tuple[int, str, bool] = (1, "itheima", True)
my_dict: dict[str,int] = {"itheima": 666}
# 在注释中进行类型注解
var_1 = random.randint(1,10) # type: int
var_2 = json.loads('{"name": "zhangsan"}') # type: dict[str,str]
def func():
return 10
var_3 = func() # type: int
# 类型注解的限制
var_4: int = "itheima" # 运行程序不会报错
var_5: str = 123 # 运行程序不会报错
Java: 省略
Python: 类型注解 -- 函数和方法
"""
演示对函数（方法）进行类型注解
"""
# 对形参进行类型注解
def add(x: int, y: int):
return x+y
# 对返回值进行类型注解
def func(data: list) -> list:
return data
# 类型注解不是强制性的，只是用于备注作用，就算类型对不上也不会报错
print(func(1)) # 输出 1
Java: 省略
Python: 类型注解 -- Union联合类型
"""
演示Union联合类型注解
"""
# 使用Union类型，必须先导包
from typing import Union
my_list: list[Union[int, str]] = [1,2,"itheima", "itcast"]
def func(data: Union[int,str]) -> Union[int,str]:
pass
func(1)
Java: 没有这种语法
Python: 多态
"""
演示面向对象的多阿泰特性及抽象类（接口）的使用
"""
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
print("汪汪汪")
class Cat(Animal):
def speak(self):
print("喵喵喵")
def make_noise(animal: Animal):
"""制造点噪音，需要传入Animal对象"""
animal.speak()
# 演示多态：使用2个子类对象来调用函数
dog = Dog()
cat = Cat()
make_noise(dog)
make_noise(cat)
# 演示抽象类
class AC:
def cool_wind(self):
"""制冷"""
pass
def hot_wind(self):
"""制热"""
pass
def swing_l_r(self):
"""左右摆风"""
pass
class Midea_AC(AC):
def cool_wind(self):
print("美的空调制冷")
def hot_wind(self):
print("美的空调制热")
def swing_l_r(self):
print("美的空调左右摆风")
class GREE_AC(AC):
def cool_wind(self):
print("格力空调制冷")
def hot_wind(self):
print("格力空调制热")
def swing_l_r(self):
print("格力空调左右摆风")
def make_cool(ac: AC):
ac.cool_wind()
midea_ac = Midea_AC()
gree_ac = GREE_AC()
make_cool(midea_ac)
make_cool(gree_ac)
Java: 省略
浙公网安备 33010602011771号