因最近在学习Python，简单总结一下java和Python的区别，持续更新

数据类型

java的数据类型:

1.基本数据类型:
byte,short,int,log,float,double,boolean,char
2.引用数据类型:
string,Integer,Double等引用对象

python的数据类型:

int,float,复数,string,列表(list()–>[]),元祖(tuple()–>()),集合(set()–>{}),字典(dict()–>{})

语法规则

1.java以;结尾,python结尾啥都不需要
2.写java时正常换行即可,python需要考虑缩进
3.定义变量时:
java需要在变量前面跟上数据类型 例如 int i = 5
python则不需要跟数据类型,后面数据是啥就默认是啥 例如 i = 5
4.在做除法运算时:
java只会保留整数位
python则会保留到小数位
5.if…else:
java中if…else if…else,if(表达式){} 即java用{}来包裹一段代码块
python中 if…elif…else,if 表达式: 即Python用:来开启一段代码块 并且表达式不需要被括号包裹起来
6.while同if…else
7.for循环
java中for循环用的比较多的就是高效for循环和i=0;i<xxx.size();i++的情况
python中的for循环是for 变量 in 可迭代对象(可以是列表,元祖,字典,字符串)或者就是for i in range(1,101)(这个范围是左闭右开即 循环1-100)
8.字符串分割
java用substring
python可以直接下标取 例如data[0:3:1] 后面的参数是步长 即隔多少一取 取下标的时候还可以去-1 例如data[-1] 即取到的是data的最后一个元素
9.定义方法/函数时:
java中的命名 public (static) 返回值 方法名(参数){}
python中的命名 def 函数名():
10.推导式

# 生成1-20范围内所有偶数的序列
data_1 = [item for item in range(1, 21) if item % 2 == 0]
print(data_1)

# 获取0-3序列
data_2 = [x for x in range(4)]
print(data_2)

# 获取3序列
data_3 = [x for x in range(3, 4)]
print(data_3)

# 获取1-20序列中的奇数
data_4 = [x for x in range(1, 21) if x % 2 != 0]  # 变量名必须一致
print(data_4)

# 获取元祖序列
data_5 = [(x, y) for x in range(1, 3) for y in range(3)]
print(data_5)
# 相当于
# for x in range(1, 3):
#     for y in range(3):
#         pass


# 对当前出现的序列进行切片并组成一个新的序列
a = [x for x in range(1, 101)]
print(a)
b = [a[x:x+3] for x in range(0, len(a), 3)]
print(b)
for x in range(0, len(a), 3):
    print(a[x:x+3])

11.拆包

list_nums = [1, 2, 3, 4]
num_1, num_2, num_3, num_4 = list_nums  # 拆包
print(num_1, num_2, num_3, num_4)

tuple_nums = (1, 2, 3, 4)
num_1, num_2, num_3, num_4 = tuple_nums  # 拆包
print(num_1, num_2, num_3, num_4)

set_nums = (1, 2, 3, 4)
num_1, num_2, num_3, num_4 = set_nums  # 拆包
print(num_1, num_2, num_3, num_4)

"""
拆包的过程中需要注意两点：
    变量位置和元素位置必须一致
    变量个数与元素个数必须一致
"""

data = [1, 2, 3]
num_2, num_1, num_3 = data
print(num_2, num_1, num_3)

info = {'name': '安娜', 'age': 18}
name, age = info.values()
print(name, age)

# 需要对当前的字典进行整体拆包
for k, v in info.items():
    print(k, v)

a = 5
b = 4
a, b = b, a
print(a, b)

# 函数拆包
def test_1():
    return 1, 2, 3


a, b, c = test_1()
print(a, b, c)


def test_2(a, b, c):
    print(a, b, c)


nums = [11, 22, 33]
test_2(nums[0], nums[1], nums[2])

# *号拆包方式
test_2(*nums)  # 当前的*号就是用来拆包的 需要注意参数个数以及传递的参数位置

"""
字典拆包
"""


def test(name, gender, address):
    print(f'姓名：{name},性别：{gender},地址：{address}')


info = {
    'name':'夏洛',
    'gender':'未知',
    'address':'火星'
}

test(**info)

"""
*args
**kwargs


    用在定义函数时供其他人使用的时候
    如果没有不定长参数的情况在调用函数时参数的个数超出了函数参数个数时会报错
    
*args
**kwargs
    这两个参数没有任何关系
"""

12.全局变量
java中声明全局变量之后直接用变量名即可
python中声明全局变量之后若要是在函数中调用该变量 需要用global关键字声明该变量之后才能使用

nums = 100


def set_global_num():
    # 在函数中修改全局变量
    global nums
    nums += 100
    return nums

13.函数传参类型
java中传参类型:基本类型,引用类型,不定长参数
python中传参类型:基本类型,引用类型,缺省参数,命名参数,不定长参数

# 缺省参数
def test(name, age=18):
    print(name, age)

# 命名参数
def test(a, b):
    print(f'a = {a}, b = {b}')


test(a=1, b=2)

# 不定长参数
def test(a, b, *args, **kwargs):
    """
    :param a:
    :param b:
    :param args: 元祖不定长 与缺省参数类似，可以不传递参数
    :param kwargs: 字典不定长
    :return:
    """
    print(f'a = {a}, b = {b},*args = {args},**kwargs = {kwargs}')


# 如果没有给不定长参数传递值的话则返回空元组与空字典
test(1, 2)

# kwargs接收的是命名参数 不能直接传递一个字典过去，如果直接传递一个字典则会被*args接收
test(1, 2, 3, 4, name='MG')


def test_1(a, b=2, *args, **kwargs):
    print(f'a = {a}, b = {b},*args = {args},**kwargs = {kwargs}')


test_1(1, 2, 3)


"""
*args可以位于形式参数的后面以及缺省参数的前面 但是不建议这么干
**kwargs需要定义在所有参数的最后面
"""

13.高效缓存区
java是针对 integer [-128~127]
python是 [-5,257] pycharm会进行适当的扩容

14.匿名函数

# 没有参数的情况
f = lambda: '这是一个匿名函数'
print(f())


# ===>等同于
def f1():
    return '这是一个匿名函数'


print(f1())

# 有参数的情况
add_func = lambda a, b: a + b
res = add_func(10, 20)
print(res)


# ===>等同于
def add1(a, b):
    return a + b


res = add1(10, 20)
print(res)

面向对象

面向对象对于那种语言都是非常关键的知识点
面向对象三大特性:封装,继承,多态
java中类的定义方式: 权限修饰符(基本是public) class 类名(大驼峰命名){}
python中类的定义方式: class 类名(大驼峰命名):

语法区别

1.构造方法:
java中使用public 类名(){} 可重载
python中使用def init(self): (魔术方法,一般实例属性就在init方法中初始化)
2.实例化
java实例化: ExpProjectPercent expProjectPercent = new ExpProjectPercent();
python实例化:stu = Student('aa', 18)
3.私有属性
java中的私有属性:

private Integer id;

python中的私有属性:

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # age设置成一个私有属性

4.继承
java是单继承,多实现
python是支持多继承,分为树状继承和菱形继承
菱形继承: 参数不一致时要加*args, **kwargs

# 在多继承中有两种继承方式
class Parent:
    def __init__(self, name, *args, **kwargs):
        print('parent开始')
        self.name = name
        print('parent结束')


class Son2(Parent):
    # son2中的构造函数中的参数比父类多
    def __init__(self, name, gender, *args, **kwargs):
        print('son2的init被调用')
        self.gender = gender
        super().__init__(name, *args, **kwargs)
        print('son2的init结束调用')


class Son1(Parent):
    # son1中的构造函数中的参数比父类多
    def __init__(self, name, age, *args, **kwargs):
        print('son1的init被调用')
        self.age = age
        super().__init__(name, *args, **kwargs)
        print('son1的init结束调用')


class GrandSon(Son1, Son2):
    def __init__(self, *, name, age, gender):
        print('grandson的init被调用')
        # Son1.__init__(self, name, age)
        # Son2.__init__(self, name, gender)
        super().__init__(name, age, gender)
        print('grandson的结束调用')


gs = GrandSon(name='a', age=18, gender='男')
# 钻石继承/菱形继承
# 快速分析类的继承关系:使用类对象打印继承链
print(GrandSon.__mro__)

"""
super方法可以解决父类方法被重复调用的问题
但是不是任何地方都可以使用super
"""

5.静态方法
java中有static关键字
python用@staticmethod注解
6.类方法
python中定义类方法用@classmethod注解