好文推荐： netty搭建websocket集群（高性能.,高并发） springboot 实现延时队列（超级实用） 2.5万字讲解DDD领域驱动设计（史上最全DDD） 史上最全从0到1搭建最新版本jenkins可持续集成
文章目录
前言：区别：开发环境：hello world:方法：类：命名规范：if 语句：for语句：while语句：switch语句：接口：封装：继承：多态：常量：反射：枚举：数据类型：数组：集合：处理集合：泛型：lambda：线程:线程安全：定时任务：IO：异常：总结：
前言：
现在人工智能，数据分析，机器学习，爬虫，越来越火，而python正是最合适的编程语言，物联网+大数据+机器学习将会是以后的趋势，跟随潮流学习python，技多不压身！java转python是非常容易的，小编以java为基础点来一起入门python！从各个角度学习python，包括开发环境，hello world，方法，类，命名规范，if语句，for语句，while语句，switch语句，接口，封装，继承，多态，常量，反射，枚举，数据类型，数组，集合，处理集合，泛型，lambda，多线程，线程安全，定时任务，IO，异常等角度入门python，简简单单入门，轻轻松松上手。
区别：
语法： Java：静态类型语言，要求在编译时声明变量类型，语法较为严格。 Python：动态类型语言，变量类型在运行时确定，语法简洁，易于阅读。编译与解释： Java：编译成字节码，通过 Java 虚拟机（JVM）运行，具有跨平台能力。 Python：通常是解释执行，直接运行源代码，速度相对较慢。 性能： Java：通常性能较高，适合大型应用和高性能需求。 Python：性能较低，但开发速度快，适合快速原型开发。库和框架： Java：有丰富的企业级框架（如 Spring），适合构建大型应用。 Python：有大量的库（如 NumPy、Pandas、Django），适合数据科学、机器学习和Web开发。 社区和生态： Java：有成熟的社区和生态，广泛应用于企业级开发。 Python：社区活跃，特别是在数据科学和人工智能领域。多线程： Java：支持多线程，使用线程池和同步机制。 Python：由于全局解释器锁（GIL），多线程性能受限，通常使用多进程或异步编程。 用途： Java：广泛用于企业应用、Android开发和大规模系统。 Python：常用于数据分析、机器学习、Web开发和自动化脚本。 这两种语言各有优缺点，选择哪种语言取决于具体的项目需求和开发者的熟悉程度。
开发环境：
java 安装jdk，配置开发环境，开发工具使用idea，java具体步骤不再赘述python ①安装python解释器，点击下载，一路安装即可， ②下载开发工具使用VS Code或者PyCharm ③打开VScode，您要在VS Code IDE的“Extensions”中安装插件Python
③使用快捷键：Ctrl+Shift+P弹出命令面板，在命令面板中输入>Python: select Interpreter 根据需要选择相应的Python解释器 ④打开开发工具新建hello.py文件即可开发 ⑤运行py程序，右键->运行python->在终端中运行python文件
hello world:
java:
//Main.java
public class Main {
public static void main(String[] args) {
System.out.println("Hello, Java!");
}
}
python
# main.py
print("Hello, Python!")
说明： python的hello world比java要简单的多！
方法：
java：
public class Demo {
// 定义一个方法，返回两个数的和
public static int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
int result = add(5, 3);
System.out.println("Java: 5 + 3 = " + result);
}
}
python： 第一种：
def add(a, b):
# 定义一个方法，返回两个数的和
return a + b
result = add(5, 3)
print(f"Python: 5 + 3 = {result}")
第二种：
def add(a: int, b: int) -> int: # 方法，参数类型，返回值
return a + b # 返回值
result = add(5, 3) # 方法参数
print("Result:", result)
解释 Java：使用 public static 关键字定义方法，方法需要在类中，并通过 main 方法调用，如果方法需要多个返回值，使用数组或自定义类来返回多个值。 Python：直接使用 def 关键字定义方法，调用时不需要类的结构。如果方法需要多个返回值，可以直接返回多个值，使用元组解包。
# Python 示例：直接返回多个值
def get_values():
return 1, 2, 3
value1, value2, value3 = get_values()
print("Value 1:", value1)
print("Value 2:", value2)
print("Value 3:", value3)
类：
java：
// 文件名: Demo.java
public class Demo {
private String name;
public Demo(String name) {
this.name = name;
}
public void greet() {
System.out.println("Hello, " + name + "!");
}
public static void main(String[] args) {
Demo demo = new Demo("World");
demo.greet();
}
}
python：
# 文件名: demo.py
class Demo:
def __init__(self, name):
self.name = name
def greet(self):
print(f"Hello, {self.name}!")
if __name__ == "__main__":
demo = Demo("World")
demo.greet()
解释 Java：使用 class 关键字定义类，构造函数通过 public 关键字定义，方法使用 void 表示无返回值。 Python：使用 class 关键字定义类，构造函数为 init 方法，使用 self 关键字引用实例属性。
命名规范：
java：
类名：使用大驼峰命名法（PascalCase）。方法名：使用小驼峰命名法（camelCase）。变量名：使用小驼峰命名法（camelCase）。常量名：使用全大写字母，单词之间用下划线分隔。
// Java 示例
public class MyDemoClass {
private static final int MAX_VALUE = 100; // 常量
public void myMethod() { // 方法
int myVariable = 10; // 变量
System.out.println("Hello, World!");
}
}
python： 类名：使用大驼峰命名法（PascalCase）。 2. 函数名：使用小写字母，单词之间用下划线分隔（snake_case）。 变量名：使用小写字母，单词之间用下划线分隔（snake_case）。 常量名：使用全大写字母，单词之间用下划线分隔。
# Python 示例
class MyDemoClass:
MAX_VALUE = 100 # 常量
def my_method(self): # 函数
my_variable = 10 # 变量
print("Hello, World!")
总结 Java：类名和方法名使用驼峰命名法，常量使用全大写。 Python：类名使用驼峰命名法，函数和变量使用下划线分隔，常量使用全大写。
if 语句：
java：
public class IfDemo {
public static void main(String[] args) {
int number = 10;
if (number > 0) {
System.out.println("数字是正数");
} else if (number < 0) {
System.out.println("数字是负数");
} else {
System.out.println("数字是零");
}
}
}
python：
number = 10
if number > 0:
print("数字是正数")
elif number < 0:
print("数字是负数")
else:
print("数字是零")
解释 Java：使用大括号 {} 来定义代码块，条件语句以 if 开头，后面可以跟 else if 和 else。 Python：使用缩进来定义代码块，条件语句以 if 开头，后面可以跟 elif 和 else。
for语句：
java:
public class ForLoopDemo {
public static void main(String[] args) {
// Java 中的 for 循环
for (int i = 0; i < 5; i++) {
System.out.println("当前值: " + i);
}
}
}
python:
# Python 中的 for 循环
for i in range(5):
print("当前值:", i)
解释 Java：使用 for 关键字，定义循环变量 i，并设置循环条件和增量。 Python：使用 for 关键字和 range() 函数，直接遍历指定范围的数字。
while语句：
Java
public class WhileDemo {
public static void main(String[] args) {
int count = 0;
while (count < 5) {
System.out.println("Count is: " + count);
count++;
}
}
}
python
count = 0
while count < 5:
print("Count is:", count)
count += 1
解释 Java：使用 while 语句循环，直到 count 小于 5，每次循环打印当前计数并递增 count。 Python：逻辑相同，语法更简洁，使用 print 函数输出。
switch语句：
java
public class SwitchDemo {
public static void main(String[] args) {
int day = 3;
String dayName;
switch (day) {
case 1:
dayName = "星期一";
break;
case 2:
dayName = "星期二";
break;
case 3:
dayName = "星期三";
break;
case 4:
dayName = "星期四";
break;
case 5:
dayName = "星期五";
break;
case 6:
dayName = "星期六";
break;
case 7:
dayName = "星期日";
break;
default:
dayName = "无效的天数";
break;
}
System.out.println(dayName);
}
}
python
def switch_demo(day):
switcher = {
1: "星期一",
2: "星期二",
3: "星期三",
4: "星期四",
5: "星期五",
6: "星期六",
7: "星期日"
}
return switcher.get(day, "无效的天数")
day = 3
print(switch_demo(day))
Python 3.10 及以上版本可以使用 match 语句，类似于 switch：
day = 3
match day:
case 1:
day_name = "星期一"
case 2:
day_name = "星期二"
case 3:
day_name = "星期三"
case 4:
day_name = "星期四"
case 5:
day_name = "星期五"
case 6:
day_name = "星期六"
case 7:
day_name = "星期日"
case _:
day_name = "无效的天数"
print(day_name)
接口：
Java 示例：
// 定义接口
interface Animal {
void makeSound();
}
// 实现接口的类
class Dog implements Animal {
@Override
public void makeSound() {
System.out.println("Woof!");
}
}
// 主类
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog();
myDog.makeSound(); // 输出: Woof!
}
}
python示例：
from abc import ABC, abstractmethod
# 定义接口
class Animal(ABC):
@abstractmethod
def make_sound(self):
pass
# 实现接口的类
class Dog(Animal):
def make_sound(self):
print("Woof!")
# 主程序
if __name__ == "__main__":
my_dog = Dog()
my_dog.make_sound() # 输出: Woof!
解释 Java：使用 interface 关键字定义接口，类通过 implements 关键字实现接口。 Python：使用 ABC 模块和 abstractmethod 装饰器定义抽象基类，子类实现接口中的方法。
封装：
java示例：
// Java: 封装示例
public class Person {
// 私有属性
private String name;
private int age;
// 构造函数
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 公共方法：获取姓名
public String getName() {
return name;
}
// 公共方法：设置姓名
public void setName(String name) {
this.name = name;
}
// 公共方法：获取年龄
public int getAge() {
return age;
}
// 公共方法：设置年龄
public void setAge(int age) {
this.age = age;
}
}
// 使用示例
public class Main {
public static void main(String[] args) {
Person person = new Person("Alice", 30);
System.out.println(person.getName() + " is " + person.getAge() + " years old.");
}
}
python示例：
# Python: 封装示例
class Person:
def __init__(self, name, age):
self.__name = name # 私有属性
self.__age = age # 私有属性
# 公共方法：获取姓名
def get_name(self):
return self.__name
# 公共方法：设置姓名
def set_name(self, name):
self.__name = name
# 公共方法：获取年龄
def get_age(self):
return self.__age
# 公共方法：设置年龄
def set_age(self, age):
self.__age = age
# 使用示例
person = Person("Alice", 30)
print(f"{person.get_name()} is {person.get_age()} years old.")
封装：在这两个示例中，name 和 age 属性被定义为私有，外部无法直接访问。通过公共方法（getter 和 setter），可以安全地访问和修改这些属性。
继承：
java示例
// 父类
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
// 子类
class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
// 主类
public class Demo {
public static void main(String[] args) {
Animal myDog = new Dog();
myDog.sound(); // 输出: Dog barks
}
}
python示例：
# 父类
class Animal:
def sound(self):
print("Animal makes a sound")
# 子类
class Dog(Animal):
def sound(self):
print("Dog barks")
# 主程序
if __name__ == "__main__":
my_dog = Dog()
my_dog.sound() # 输出: Dog barks
python多继承
# Python: src/main.py
class Animal:
def speak(self):
print("Animal speaks")
class Pet:
def play(self):
print("Pet plays")
class Dog(Animal, Pet):
def bark(self):
print("Dog barks")
if __name__ == "__main__":
dog = Dog()
dog.speak() # 输出: Animal speaks
dog.play() # 输出: Pet plays
dog.bark() # 输出: Dog barks
说明： Java：使用 extends 关键字来实现继承，子类可以重写父类的方法。只支持单继承 Python：使用括号来指定父类，子类同样可以重写父类的方法。支持单继承和多继承，Dog 类可以同时继承 Animal 和 Pet 类。
多态：
java示例：
// Java 多态示例
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
class Cat extends Animal {
void sound() {
System.out.println("Cat meows");
}
}
public class PolymorphismDemo {
public static void main(String[] args) {
Animal myDog = new Dog();
Animal myCat = new Cat();
myDog.sound(); // 输出: Dog barks
myCat.sound(); // 输出: Cat meows
}
}
python示例：
# Python 多态示例
class Animal:
def sound(self):
print("Animal makes a sound")
class Dog(Animal):
def sound(self):
print("Dog barks")
class Cat(Animal):
def sound(self):
print("Cat meows")
def polymorphism_demo():
my_dog = Dog()
my_cat = Cat()
my_dog.sound() # 输出: Dog barks
my_cat.sound() # 输出: Cat meows
polymorphism_demo()
解释 Java：通过父类 Animal 和子类 Dog、Cat 实现多态，使用相同的方法 sound() 但不同的实现。 Python：同样通过继承实现多态，子类重写父类的方法，调用时根据对象类型执行相应的方法。
常量：
java示例：
public final class Constants {
public static final String APP_NAME = "MyApp";
public static final int MAX_USERS = 100;
// 私有构造函数，防止实例化
private Constants() {}
}
// 使用常量
public class Main {
public static void main(String[] args) {
System.out.println(Constants.APP_NAME);
System.out.println(Constants.MAX_USERS);
}
}
python示例：
class Constants:
APP_NAME = "MyApp"
MAX_USERS = 100
# 使用常量
if __name__ == "__main__":
print(Constants.APP_NAME)
print(Constants.MAX_USERS)
解释 Java：使用 final 关键字定义常量，并通过私有构造函数防止类被实例化。 Python：通过类属性定义常量，虽然没有强制性，但使用全大写的命名约定来表示常量。
反射：
java示例：
import java.lang.reflect.Method;
public class ReflectionDemo {
public void sayHello() {
System.out.println("Hello from Java!");
}
public static void main(String[] args) {
try {
// 获取类的 Class 对象
Class clazz = Class.forName("ReflectionDemo");
// 创建实例
Object obj = clazz.getDeclaredConstructor().newInstance();
// 获取方法
Method method = clazz.getMethod("sayHello");
// 调用方法
method.invoke(obj);
} catch (Exception e) {
e.printStackTrace();
}
}
}
python示例
class ReflectionDemo:
def say_hello(self):
print("Hello from Python!")
# 获取类的引用
clazz = ReflectionDemo
# 创建实例
obj = clazz()
# 获取方法
method = getattr(obj, 'say_hello')
# 调用方法
method()
解释 Java：使用 Class.forName() 获取类的 Class 对象，通过反射创建实例并调用方法。 Python：直接使用类名创建实例，使用 getattr() 获取方法并调用。
枚举：
java示例:
// Java 枚举示例
public class EnumDemo {
public enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}
public static void main(String[] args) {
Day today = Day.MONDAY;
System.out.println("Today is: " + today);
}
}
python示例：
# Python 枚举示例
from enum import Enum
class Day(Enum):
SUNDAY = 1
MONDAY = 2
TUESDAY = 3
WEDNESDAY = 4
THURSDAY = 5
FRIDAY = 6
SATURDAY = 7
today = Day.MONDAY
print(f"Today is: {today.name}")
解释 Java：使用 enum 关键字定义枚举类型，枚举值是常量，通常用于表示固定的集合。 Python：使用 Enum 类定义枚举，枚举值可以是任何类型，通常用于表示一组相关的常量。
数据类型：
Java 有八种基本数据类型： byte，short，int，long，float，double，char，boolean
public class DataTypesDemo {
public static void main(String[] args) {
// 基本数据类型
int intValue = 10;
float floatValue = 10.5f;
double doubleValue = 20.99;
char charValue = 'A';
boolean booleanValue = true;
byte byteValue = 100;
short shortValue = 30000;
long longValue = 100000L;
// 输出基本数据类型
System.out.println("int: " + intValue);
System.out.println("float: " + floatValue);
System.out.println("double: " + doubleValue);
System.out.println("char: " + charValue);
System.out.println("boolean: " + booleanValue);
System.out.println("byte: " + byteValue);
System.out.println("short: " + shortValue);
System.out.println("long: " + longValue);
}
}
Java 引用数据类型： String，数组，类，接口
public class ReferenceTypesDemo {
public static void main(String[] args) {
// 引用数据类型
String strValue = "Hello, Java!";
int[] arrayValue = {1, 2, 3, 4, 5};
// 输出引用数据类型
System.out.println("String: " + strValue);
System.out.print("Array: ");
for (int num : arrayValue) {
System.out.print(num + " ");
}
}
}
python： Python 的数据类型不需要显式声明，常用的基本数据类型包括： int，float，str，bool
# 基本数据类型
int_value = 10
float_value = 10.5
str_value = "Hello, Python!"
bool_value = True
# 输出基本数据类型
print("int:", int_value)
print("float:", float_value)
print("str:", str_value)
print("bool:", bool_value)
Python 的引用数据类型包括： 列表（List） 字典（Dictionary） 元组（Tuple） 集合（Set）
# 引用数据类型
list_value = [1, 2, 3, 4, 5]
dict_value = {"key": "value"}
tuple_value = (1, 2, 3)
set_value = {1, 2, 3}
# 输出引用数据类型
print("List:", list_value)
print("Dictionary:", dict_value)
print("Tuple:", tuple_value)
print("Set:", set_value)
总结 Java 有八种基本数据类型和多种引用数据类型，类型是静态的。基本数据类型（如 int, double, boolean）与其对应的包装类（如 Integer, Double, Boolean）是不同的类型。包装类提供了对象的功能。 Python 的数据类型更为灵活，类型是动态的。所有数据类型都是对象，没有单独的基本数据类型和包装类的区分。
数组：
java:
public class ArrayDemo {
public static void main(String[] args) {
// 一维数组
int[] oneDimensionalArray = {1, 2, 3, 4, 5};
System.out.println("一维数组:");
for (int num : oneDimensionalArray) {
System.out.print(num + " ");
}
System.out.println();
// 二维数组
int[][] twoDimensionalArray = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
System.out.println("二维数组:");
for (int[] row : twoDimensionalArray) {
for (int num : row) {
System.out.print(num + " ");
}
System.out.println();
}
}
}
python
# 一维数组
one_dimensional_array = [1, 2, 3, 4, 5]
print("一维数组:")
for num in one_dimensional_array:
print(num, end=" ")
print()
# 二维数组
two_dimensional_array = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
print("二维数组:")
for row in two_dimensional_array:
for num in row:
print(num, end=" ")
print()
解释 一维数组：在 Java 和 Python 中，分别使用 int[] 和列表来定义一维数组。 二维数组：在 Java 中使用数组的数组，而在 Python 中使用嵌套列表。
集合：
java：
import java.util.*;
public class Demo {
public static void main(String[] args) {
// List 示例
List
list.add("Apple");
list.add("Banana");
System.out.println("List: " + list);
// Set 示例
Set
set.add("Apple");
set.add("Banana");
set.add("Apple"); // 重复元素不会被添加
System.out.println("Set: " + set);
// Map 示例
Map
map.put("Apple", 1);
map.put("Banana", 2);
System.out.println("Map: " + map);
}
}
python：
# List 示例
list_example = ["Apple", "Banana"]
print("List:", list_example)
# Set 示例
set_example = {"Apple", "Banana", "Apple"} # 重复元素不会被添加
print("Set:", set_example)
# Map 示例 (使用字典)
map_example = {"Apple": 1, "Banana": 2}
print("Map:", map_example)
解释 List：有序集合，可以包含重复元素。 Set：无序集合，不允许重复元素。 Map：键值对集合，允许通过键快速访问值。Python 中使用字典（dict）来实现。
处理集合：
java:
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamDemo {
public static void main(String[] args) {
List
// 使用 Stream 过滤出偶数并平方
List
.filter(n -> n % 2 == 0)
.map(n -> n * n)
.collect(Collectors.toList());
System.out.println(squaredEvens); // 输出: [4, 16, 36]
}
}
python
numbers = [1, 2, 3, 4, 5, 6]
# 过滤出偶数并平方
squared_evens = [n * n for n in numbers if n % 2 == 0]
print(squared_evens) # 输出: [4, 16, 36]
解释 Java：使用 stream() 方法创建流，filter() 进行过滤，map() 进行映射，最后使用 collect() 收集结果。 Python：使用列表推导式直接在一行中实现过滤和映射。
泛型：
import java.util.ArrayList;
import java.util.List;
public class GenericDemo {
public static void main(String[] args) {
// 创建一个泛型列表
List
stringList.add("Hello");
stringList.add("World");
// 遍历并打印列表
for (String str : stringList) {
System.out.println(str);
}
}
}
python 在 Python 中，泛型通常通过类型提示实现，使用 typing 模块。
from typing import List
def print_list(items: List[str]) -> None:
for item in items:
print(item)
# 使用泛型函数
string_list = ["Hello", "World"]
print_list(string_list)
解释 Java：使用 List 定义一个字符串类型的列表，确保列表中只能存储字符串。 Python：使用 List[str] 作为类型提示，表示该函数接受一个字符串列表，虽然 Python 本身不强制类型检查，但提供了类型提示以增强可读性和工具支持。
lambda：
java
import java.util.Arrays;
import java.util.List;
public class LambdaDemo {
public static void main(String[] args) {
List
// 使用 Lambda 表达式打印每个名字
names.forEach(name -> System.out.println(name));
}
}
python
# 使用 Lambda 表达式定义一个简单的函数
square = lambda x: x ** 2
# 打印 1 到 5 的平方
for i in range(1, 6):
print(square(i))
总结 Java：使用 Lambda 表达式简化函数式接口的实现，通常与集合操作结合使用。 Python：使用 Lambda 表达式创建匿名函数，适用于简单的函数定义。
线程:
// Java 线程示例
class MyThread extends Thread {
@Override
public void run() {
System.out.println("线程正在运行: " + Thread.currentThread().getName());
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
thread1.start(); // 启动线程1
thread2.start(); // 启动线程2
}
}
python
import threading
# Python 线程示例
class MyThread(threading.Thread):
def run(self):
print("线程正在运行:", threading.current_thread().name)
if __name__ == "__main__":
thread1 = MyThread()
thread2 = MyThread()
thread1.start() # 启动线程1
thread2.start() # 启动线程2
thread1.join() # 等待线程1完成
thread2.join() # 等待线程2完成
解释 Java：使用 Thread 类创建线程，重写 run 方法并调用 start() 启动线程。 Python：使用 threading.Thread 类，重写 run 方法并调用 start() 启动线程，使用 join() 等待线程完成。
线程安全：
Java
public class Counter {
private int count = 0;
// 使用 synchronized 确保线程安全
public synchronized void increment() {
count++;
}
public int getCount() {
return count;
}
public static void main(String[] args) throws InterruptedException {
Counter counter = new Counter();
Thread[] threads = new Thread[10];
for (int i = 0; i < 10; i++) {
threads[i] = new Thread(() -> {
for (int j = 0; j < 1000; j++) {
counter.increment();
}
});
threads[i].start();
}
for (Thread thread : threads) {
thread.join();
}
System.out.println("Final count: " + counter.getCount());
}
}
python：
import threading
class Counter:
def __init__(self):
self.count = 0
self.lock = threading.Lock()
def increment(self):
with self.lock: # 使用锁确保线程安全
self.count += 1
def get_count(self):
return self.count
def worker(counter):
for _ in range(1000):
counter.increment()
if __name__ == "__main__":
counter = Counter()
threads = []
for _ in range(10):
thread = threading.Thread(target=worker, args=(counter,))
threads.append(thread)
thread.start()
for thread in threads:
thread.join()
print("Final count:", counter.get_count())
解释 Java 示例：使用 synchronized 关键字来确保 increment 方法在同一时间只能被一个线程访问。 Python 示例：使用 threading.Lock 来确保在对 count 进行修改时，只有一个线程可以访问该部分代码。
定时任务：
java
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledTaskDemo {
public static void main(String[] args) {
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
Runnable task = () -> {
System.out.println("定时任务执行: " + System.currentTimeMillis());
};
// 每隔 5 秒执行一次
scheduler.scheduleAtFixedRate(task, 0, 5, TimeUnit.SECONDS);
}
}
python
import time
def my_task():
print("定时任务执行中...")
while True:
my_task()
time.sleep(5) # 休眠1秒
IO：
java:
import java.io.*;
public class FileIOExample {
public static void main(String[] args) {
String content = "Hello, World!";
String filePath = "example.txt";
// 写入文件
try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
writer.write(content);
} catch (IOException e) {
e.printStackTrace();
}
// 读取文件
try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
python
# 写入文件
content = "Hello, World!"
file_path = "example.txt"
with open(file_path, 'w') as file:
file.write(content)
# 读取文件
with open(file_path, 'r') as file:
for line in file:
print(line.strip())
解释 Java：使用 BufferedWriter 和 BufferedReader 进行文件的写入和读取。 Python：使用 open 函数和上下文管理器 (with) 来处理文件的写入和读取，代码更简洁。
异常：
java
public class ExceptionDemo {
public static void main(String[] args) {
try {
int result = divide(10, 0); // 可能抛出异常
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
System.out.println("捕获到异常: " + e.getMessage());
} finally {
System.out.println("执行 finally 块");
}
}
public static int divide(int a, int b) {
return a / b; // 可能抛出 ArithmeticException
}
}
python
def divide(a, b):
return a / b # 可能抛出 ZeroDivisionError
try:
result = divide(10, 0) # 可能抛出异常
print("Result:", result)
except ZeroDivisionError as e:
print("捕获到异常:", e)
finally:
print("执行 finally 块")
解释 Java：使用 try-catch-finally 结构来捕获和处理异常。ArithmeticException 用于处理除以零的情况。 Python：同样使用 try-except-finally 结构，ZeroDivisionError 用于处理除以零的情况。
总结：
没有最好的编程语言，只有最合适的编程语言！大家一起学起来吧！
如果看到这里，说明你喜欢这篇文章，请关注和点赞小编。关注【微信公众号微信】搜索【老板再来一杯时光】回复【进群】即可进入无广告交流群！
好文推荐： netty搭建websocket集群（高性能.,高并发） springboot 实现延时队列（超级实用） 2.5万字讲解DDD领域驱动设计（史上最全DDD） 史上最全从0到1搭建最新版本jenkins可持续集成