从JAVA工程师的角度快速上手Python-基础语法
基础语法
代码块和控制结构的表示
-
Java使用大括号({})来表示代码块,例如:
for (int i = 0; i < 5; i++) { System.out.println("Java"); }
-
Python使用缩进来表示代码块,通常是四个空格,例如:
for i in range(5): print("Python")
变量和类型声明
-
Java是一种静态类型语言,需要在变量声明时指定其类型,例如:
int num = 10; String name = "Java";
-
Python是一种动态类型语言,变量的类型可以根据赋值自动推断,例如:
num = 10 name = "Python"
函数
定义
-
Java中定义函数需要使用关键字
void
(表示无返回值)或指定返回类型,并使用return
语句返回值,例如:public int add(int a, int b) { return a + b; }
-
Python中定义函数使用关键字
def
,不需要指定返回类型,并使用return
语句返回值,例如:def add(a, b): return a + b
静态方法和类方法
-
在Java中,可以使用
static
关键字定义静态方法和静态变量,静态方法可以直接通过类名调用,例如:public class MyClass { public static void staticMethod() { System.out.println("Static method"); } } MyClass.staticMethod();
-
在Python中,可以使用
@staticmethod
装饰器定义静态方法,静态方法可以通过类名或实例调用,例如:class MyClass: @staticmethod def static_method(): print("Static method") MyClass.static_method()
默认参数
-
在Java中,方法的参数没有默认值,每次调用方法都需要显式传递参数,例如:
public void greet(String name) { System.out.println("Hello, " + name); } greet("John");
-
在Python中,方法的参数可以指定默认值,如果调用方法时没有传递对应参数,则使用默认值,例如:
def greet(name="John"): print("Hello, " + name) greet() # 使用默认值 greet("Alice") # 传递参数
匿名函数
-
在Java中,可以使用接口和匿名类来实现类似于匿名函数的功能,例如:
Runnable runnable = new Runnable() { @Override public void run() { System.out.println("Hello"); } };
-
在Python中,可以使用Lambda表达式来创建匿名函数,例如:
my_func = lambda x: x * 2 result = my_func(3) # 输出:6
函数式编程
-
在Java中,函数式编程的支持较为有限,但可以使用Lambda表达式和Stream API来实现一些函数式编程的特性,例如:
import java.util.Arrays; import java.util.List; public class Main { public static void main(String[] args) { List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); // 使用Lambda表达式和Stream API进行函数式编程 int sum = numbers.stream() .filter(n -> n % 2 == 0) .mapToInt(n -> n * 2) .sum(); System.out.println(sum); // 输出:18 } }
-
在Python中,函数式编程是一种核心特性,支持函数作为一等公民,可以使用Lambda表达式、高阶函数和内置函数等来实现函数式编程的特性,例如:
numbers = [1, 2, 3, 4, 5] # 使用Lambda表达式和内置函数进行函数式编程 sum = sum(map(lambda n: n * 2, filter(lambda n: n % 2 == 0, numbers))) print(sum) # 输出:18
类型注解
-
在Java中,可以使用类型注解来提供额外的类型信息,以帮助编译器进行类型检查和类型推断,例如:
import java.util.List; public class Main { public static void main(String[] args) { List<@NonNull String> names = new ArrayList<>(); names.add("John"); names.add(null); // 编译器会报错,不允许添加null值 } }
-
在Python中,从Python 3.5开始引入了类型注解的支持,可以使用类型注解来提供变量和函数的类型信息,例如:
from typing import List def greet(name: str) -> str: return "Hello, " + name names: List[str] = ["John", "Jane"]
-
类型注解是可选的,不是强制要求的。在 Python 中,仍然可以编写没有类型注解的代码。但是,类型注解可以提供更好的代码可读性和可维护性,特别是在大型项目或多人协作的情况下。
-
类型注解可以使用 Python 3.5 引入的函数注解语法来实现,也可以使用类型注解库如
typing
库来提供更丰富的类型注解功能。以下是一个使用类型注解的示例:def add(a: int, b: int) -> int: return a + b
-
条件语句
-
Java中的条件语句使用
if-else
结构,例如:int num = 10; if (num > 0) { System.out.println("Positive"); } else { System.out.println("Negative"); }
-
Python中的条件语句使用
if-else
结构,但没有括号,并且使用缩进来表示代码块,例如:num = 10 if num > 0: print("Positive") else: print("Negative")
循环结构
-
Java中的常见循环结构是
for
循环和while
循环,例如:for (int i = 0; i < 5; i++) { System.out.println(i); } int i = 0; while (i < 5) { System.out.println(i); i++; }
-
Python中的常见循环结构是
for
循环和while
循环,例如:for i in range(5): print(i) i = 0 while i < 5: print(i) i += 1
集合
类型
-
在Java中,常见的集合类型有List、Set和Map等,需要使用相应的类来实例化和操作集合,例如:
List<String> list = new ArrayList<>(); Set<Integer> set = new HashSet<>(); Map<String, Integer> map = new HashMap<>();
-
在Python中,内置了列表(List)、集合(Set)和字典(Dictionary)等集合类型,可以直接使用,例如:
list = [1, 2, 3] set = {1, 2, 3} map = {"name": "John", "age": 30}
数组和列表
-
Java中的数组是固定长度的,需要在声明时指定大小,并且只能存储相同类型的元素,例如:
int[] numbers = new int[3]; numbers[0] = 1; numbers[1] = 2; numbers[2] = 3;
-
在Python中,列表是动态长度的数据结构,可以根据需要动态添加或删除元素,例如:
list = [1, 2, 3] list.append(4)
列表切片
-
在Java中,可以使用
List.subList()
方法来获取子列表,例如:List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); List<Integer> subList = list.subList(1, 4);
-
在Python中,可以使用切片(Slice)操作来获取子列表,例如:
list = [1, 2, 3, 4, 5] subList = list[1:4]
字典操作
-
在Java中,可以使用
Map
接口和相关的实现类来操作字典,例如获取、添加、删除和遍历字典的操作比较繁琐。 -
在Python中,字典的操作更加简洁和方便,可以直接使用字典的方法进行操作,例如:
dict = {"name": "John", "age": 30} value = dict.get("name") # 获取值 dict["city"] = "New York" # 添加键值对 del dict["age"] # 删除键值对
迭代器
-
在Java中,可以使用迭代器(Iterator)来遍历集合(如List、Set等),例如:
List<String> names = Arrays.asList("John", "Jane", "Tom"); Iterator<String> iterator = names.iterator(); while (iterator.hasNext()) { String name = iterator.next(); System.out.println(name); }
-
在Python中,可以使用迭代器和生成器来遍历可迭代对象,例如:
names = ["John", "Jane", "Tom"] iterator = iter(names) for name in iterator: print(name)
生成器
-
在Python中,可以使用生成器(Generator)来实现迭代器,使用
yield
关键字定义生成器函数,例如:def my_generator(): yield 1 yield 2 yield 3 for num in my_generator(): print(num)
列表推导式和集合推导
-
在Java中,没有直接的语法来创建列表或集合的推导式,需要使用循环和条件语句来实现。
-
在Python中,可以使用列表推导式和集合推导式来快速创建列表或集合,例如:
my_list = [x for x in range(1, 5)] # 列表推导式 my_set = {x for x in my_list if x % 2 == 0} # 集合推导式
字符串操作
-
Java中的字符串是不可变的,使用
+
操作符进行字符串拼接,例如:String str1 = "Hello"; String str2 = "World"; String result = str1 + " " + str2;
-
Python中的字符串是可变的,可以使用
+
操作符或+=
运算符进行字符串拼接,例如:str1 = "Hello" str2 = "World" result = str1 + " " + str2
函数调用和参数传递
值传递方式
Java中的参数传递方式是值传递,也就是说,当你将一个参数传递给一个函数时,函数会得到一个参数的副本,而不是参数本身。这意味着在函数内部修改参数的值不会影响传递给函数的原始值。
Python中的参数传递方式是引用传递,也就是说,当你将一个参数传递给一个函数时,函数会得到一个指向参数的引用,而不是参数本身。这意味着在函数内部修改参数的值会影响传递给函数的原始值。
例如,在Java中,以下代码将打印出“10”:
public static void main(String[] args) {
int a = 10;
changeValue(a);
System.out.println(a);
}
public static void changeValue(int b) {
b = 20;
}
而在Python中,以下代码将打印出“20”:
def main():
a = 10
changeValue(a)
print(a)
def changeValue(b):
b = 20
main()
对象传递方式
-
在Java中,对象是通过引用传递的,即传递的是对象的引用而不是对象本身,例如:
public void changeValue(StringBuilder str) { str.append(" World"); } StringBuilder sb = new StringBuilder("Hello"); changeValue(sb); System.out.println(sb.toString()); // 输出:Hello World
-
在Python中,对象的传递方式是值传递,但对于可变对象(如列表、字典等),传递的是对象的引用,例如:
def change_value(lst): lst.append("World") lst = ["Hello"] change_value(lst) print(lst) # 输出:['Hello', 'World']
模块和导入
-
在Java中,代码通常组织在包(package)中,需要使用
import
语句导入其他包或类,例如:import java.util.ArrayList; ArrayList<String> list = new ArrayList<>();
-
在Python中,代码通常组织在模块(module)中,使用
import
语句导入其他模块或函数,例如:from math import sqrt result = sqrt(25)
特殊方法(魔术方法)
-
在Java中,没有像Python中的特殊方法(也称为魔术方法),这些方法以双下划线开头和结尾,用于实现对象的特定行为(如迭代、比较、运算符重载等)。
-
在Python中,特殊方法允许类自定义对象的行为,例如
__init__()
用于初始化对象,__str__()
用于返回对象的字符串表示等。
例如,在Python中定义一个类并重写特殊方法的示例:
class MyClass:
def __init__(self, value):
self.value = value
def __str__(self):
return str(self.value)
obj = MyClass(10)
print(obj) # 输出:10
- 在Python中,以下是一些常见的以
__
开头和以__
结尾的特殊方法:__init__()
:对象初始化方法,在创建对象时自动调用。__str__()
:返回对象的字符串表示,可以通过str()
函数或print()
函数调用。__repr__()
:返回对象的可打印字符串表示,可以通过repr()
函数调用。__len__()
:返回对象的长度,可以通过len()
函数调用。__getitem__()
:通过索引获取对象的元素,可以通过[]
运算符调用。__setitem__()
:通过索引设置对象的元素,可以通过[]
运算符调用。__delitem__()
:通过索引删除对象的元素,可以通过del
关键字和[]
运算符调用。__iter__()
:返回一个迭代器对象,用于支持对象的迭代。__next__()
:返回迭代器的下一个元素,用于支持对象的迭代。__enter__()
和__exit__()
:用于定义上下文管理器,管理资源的获取和释放。__call__()
:使对象可以像函数一样被调用。
注释
-
在Java中,注释有单行注释(
//
)和多行注释(/* ... */
),例如:// 这是单行注释 /* * 这是多行注释 */
-
在Python中,注释使用井号(
#
、'''
、"""
),例如:# 这是注释 '''这是注释''' """这是注释"""
-
中文编码声明
#coding:utf-8
异常类型
-
在Java中,异常类型需要在方法签名中声明或捕获,例如:
public void myMethod() throws IOException { // 可能会抛出IOException的代码 } try { // 可能会抛出异常的代码 } catch (IOException e) { // IOException异常的处理 }
-
在Python中,异常类型不需要在方法签名中声明,可以在
except
块中捕获特定的异常类型,例如:def my_method(): # 可能会引发异常的代码 raise ValueError("Invalid value") try: # 可能会引发异常的代码 except ValueError as e: # ValueError异常的处理 else: # 如果没有异常走这里 finally: # 无论是否异常,总会执行的代码
-
python常见的异常
- ZeroDivisionError:除(或取模)零异常
- IndexError:序列中没有此索引
- KeyError:映射中没有这个键
- NameError:未声明/初始化对象(没有属性)
- SyntaxError:Python语法错误
- ValueError:传入无效的参数
-
traceback模块
- 打印异常信息:
traceback.pringt_exc()
- 打印异常信息: