Nemo

Nemo

路漫漫其修远兮,吾将上下而求索。

Nemo

Nemo

关注TA

路漫漫其修远兮,吾将上下而求索。

  •  普罗旺斯
  • 负责帅就完事了
  • 写了1,457,592字

该文章投稿至Nemo社区   编程其他  板块 复制链接


Java/Python3/Go语法简单对比

发布于 2021/08/31 11:26 405浏览 0回复 14,796

1、Hello world

java

public class HelloWorld{

    public static void main(String args[]){
        System.out.println("Hello world!");
    }

}

python

print("Hello world!");

Go

package main

import "fmt"

func main() {
fmt.Println("Hello world!")}

Go里面的程序入口包名需为main,且需提供main方法;

java中只需提供main方法入口;

python中可任意在python文件中定义需要执行的代码。

2、行代码标记结束

java

System.out.println("Hello world!");

python

print("Hello world")

Go

fmt.Println("Hello world!")

java是以分号;来标记结束,而python和Go则是以换行来作为标记,当然,python和Go也可以添加分号在语句的末尾,但是一般不推荐。


3、代码块

java

if(true){
    System.out.println("Hello world!");
    System.out.println("Hello world,again!");
}

python

if True:
    print("Hello world!");
    print("Hello world, again!");

Go

if true {
fmt.Println("Hello world!")
fmt.Println("Hello world, again!") }


java以及Go是以花括号{}来标记代码块逻辑层次,而python则是以tab键缩进来标记代码块的逻辑层次。需要注意的是,Go中,“{”不能单独占用一行,而Java中则可以。


4、注释

Java

/**
 *  这是一个文本注释,
 *  当然,文本注释也是可以多行的
*/
public static void main(String args[]){

        //这是一个行注释
        System.out.println("以上是一个行注释");

        /*
            这是第一行注释
            这是第二行注释
        */
        System.out.println("以上是一个多行注释");
}    

python

def test():
    '''   
            这是一个多行注释的第一行
            这是一个多行注释的第二行
    '''
    print("以上是一个多行注释方式1")


    """ 
            这是一个多行注释的第一行
            这是一个多行注释的第二行
    """
    print("以上是一个多行注释的方式2")
  

    #这是一个行注释
    print("以上是一个行注释")


    #这是第一行注释
    #这是第二行注释
    print("以上是一个多行注释方式3")
Go
func main(){
// 单行注释
fmt.Println("上面是一个单行注释!")
/*
这是一个多行注释
*/
fmt.Println("上面是一个多行注释!")
}


5、标识符

python、java以及Go所有组成部分都需要名字:变量,函数...姑且都统称他们作标识符好了。

Java

所有的标识符都应该以字母(A-Z或者a-z),美元符($)、或者下划线(_)开始。
首字符之后可以是字母(A-Z或者a-z),美元符($)、下划线(_)或数字的任何字符组合。
关键字不能用作标识符。
标识符是大小写敏感的。

Python

第一个字符必须是字母表中字母或下划线 _ 。
标识符的其他的部分由字母、数字和下划线组成。
关键字不能用作标识符。
标识符对大小写敏感。

GO

可以由字母,数字,下划线组成。
首字母必须是字母。
关键字不能用作标识符。
标识符是大小写敏感的

不同之处在于,java可以包含$字符,Go只能以字母开头。


6、基本常用数据类型

6.1、基本数字类型

java
public static void main(String args[]){

    byte b = 100; //整数类型,占用空间只有int的1/4,8位

    short s = 1000; //整数类型,占用空间只有int的1/2,16位

    int i = 100000; //整数类型,32位

    Long l = 100000L; //整数类型,64位

    float f = 123.5f; //单精度浮点类型,32位

    double d = 123.5; //双精度浮点类型,64位

}

python

i = 10 # 整数
 
f = 0.0 #浮点数

c = 3.14j #复数

Go

func main(){
// 无符号 8 位整型 (0 到 255)
var uint8Val uint8 = 100
fmt.Printf("无符号uint8类型值:%v\n", uint8Val)

// 无符号 16 位整型 (0 到 65535)
var uint16Val uint8 = 100
fmt.Printf("无符号uint16类型值:%v\n", uint16Val)

// 无符号 32 位整型 (0 到 4294967295)
var uint32Val uint8 = 100
fmt.Printf("无符号uint32类型值:%v\n", uint32Val)

// 无符号 64 位整型 (0 到 18446744073709551615)
var uint64Val uint8 = 100
fmt.Printf("无符号uint64类型值:%v\n", uint64Val)

// 有符号 8 位整型 (-128 到 127)
var int8Val int8 = 100
fmt.Printf("有符号int8类型值:%v\n", int8Val)

// 有符号 16 位整型 (-32768 到 32767)
var int16Val int16 = 100
fmt.Printf("有符号int8类型值:%v\n", int16Val)

// 有符号 32 位整型 (-2147483648 到 2147483647)
var int32Val int32 = 100
fmt.Printf("有符号int8类型值:%v\n", int32Val)

// 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
var int64Val int64 = 100
fmt.Printf("有符号int8类型值:%v\n", int64Val)

// IEEE-754 32位浮点型数
var float32Val float32 = 100.1
fmt.Printf("32位浮点类型值:%v\n", float32Val)

// IEEE-754 64位浮点型数
var float64Val float64 = 100.1
fmt.Printf("32位浮点类型值:%v\n", float64Val)

// 32 位实数和虚数
var complex64Val complex64 = 100.1
fmt.Printf("32 位实数和虚数值:%v\n", complex64Val)

// 64 位实数和虚数
var complex128Val complex128 = 100.1
fmt.Printf("32位浮点类型值:%v\n", complex128Val)
}


java中有6中数字类型,python中只有4种,但是python支持复数,而java则不支持。Go中对于数值类型则会按占用空间做了更多的区分,这大概也是go之所以高效率的原因之一。

上面提到了一些python中的数字类型,但是其实还有一种:布尔类型。这里单独放到下面举例。

6.2、布尔类型

java

boolean b = false; //只有两种可能,true 或者false

python

b = False #注意,这里的F是大写的,python3中,布尔类型也是一种数字类型,False可以是数字0,True可以是数字1

Go

var b bool = true; //只有两种可能,true或者false


6.3、字符类型/字符串类型

java

public static void main(String args[]){

        char c1 = 'a'; //java中,字符为基本类型,这里的c1指代任意一个在ASCII编码表中的字符,用单引号括起来

        System.out.println("打印一个字符:"+c1);

        chat c2 = 111; //这里的c2指代在ASCII编码表中索引为111的字符,即a

        System.out.println("打印一个字符数值在ASCII编码表中对应的字符:"+ c2); //

        String str = "Hello world!"; //java中,字符串并非基本类型,而是属于引用类型,表示多个字符拼接在一起

        System.out.println("打印一串字符:"+str);

}

python

str1 = 'Hello world!' #字符串定义方式1

str 2 = "Hello world!"; # 字符串定义方式2

Go

var str = "Hello World" 

python中没有字符类型,只有字符串类型,并且字符串类型是python的基本类型之一。

6.4、List(列表)

java
int array[] = {1,2,3,4}; //方式1:定长数组

array[0] = -1;            //修改数组第0个元素的值

System.out.println("第一个值为:"+array[0]);
System.out.println("数组长度为:"+array.length);

list = new ArrayList(); //方式2:可变列表
list.add(1);
list.add(2);
list.add(3);
list.add(4);             //设置初始化值

list.set(0,-1);          //修改第0个元素的值

System.out.println("第一个值为:"+list.get(0));
System.out.println("列表长度为:"+list.size());
python
list1 = ['Google', 'Runoob', 1997, 2000] #列表1,同时参杂字符串 和 数字

list2 = [1, 2, 3, 4, 5 ]                 #列表2,只包含数字

list3 = ["a", "b", "c", "d"]             #列表3,只包含字符串

list1[0] = 'Nemo'

list1.append('Hello')                    #往列表最后新增一个元素

print('第一个值为:%s'%(list1[0]))

print('列表长度为:%d'%(len(list1)))

for item in list1:

    print('遍历打印:%s'%(item))

Go

// 数组定义,必须指定长度,如果不确定数组长度,可以用...代替数组长度,编译器会根据实际元素指定长度: var balance [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0} balance[1] = 999 // 通过下标访问数组元素 for item := range balance{
fmt.Println(balance[item]) }

// 切片定义,不需指定长度,可根据需要随意修改

var numbers = []int{100,200,500,300,400}
numbers[1] = 999
numbers = append(numbers, 555555)
for item := range numbers{
fmt.Println(numbers[item])
}


可以看到,java的数组、列表与python、Go的列表都有相似之处:

1、都是属于有序列表。

2、索引都是从0开始。

3、里面的值都可以修改。

不同的地方大概就在于

1、java数组和Go数组是定长的,并且元素类型一般一致(Java Object泛型除外)。

2、java列表和Go列表是可变长度的,并且元素类型一般一致(Java Object泛型除外)。

3、python列表是可变长度,并且里面的元素类型不需要一致。

6.5、Tuple(元组)

java/Go中与python元组类似的也就是列表和数组,关于java以及Go中的列表和数组以上已做过说明,此处暂且略去。

python

tup1 = ('Google', 'Runoob', 1997, 2000) #元组1,同时参杂字符串 和 数字

tup2 = (1, 2, 3, 4, 5)                  #元组2,只包含数字

tup3 = ("a", "b", "c", "d")             #元组3,只包含字符串

#tup1[0] = 'Nemo'                       #此操作会导致异常

#tup1.append('Hello')                   #往元组最后新增一个元素  #异常

print('第一个值为:%s'%(tup1[0]))

print('列表长度为:%d'%(len(tup1)))

for item in tup1:

    print('遍历打印:%s'%(item))

可以看到,python中的元组和Java列表其实非常类似的,区别之处就在于:

元组元素不可以修改,而列表可以。

所以总结下来java中,列表、数组与python中的元组的区别就在于:

1、都是属于有序列表。

2、索引都是从0开始。

不同的地方大概就在于:

1、java数组和Go数组是定长的,并且元素类型一般一致(Java Object泛型除外)。

2、java列表和Go列表是可变长度的,并且元素类型一般一致(Java Object泛型除外)。

3、python元组是定长的,并且里面的元素类型不需要一致,且元素不可修改。


6.6、Set(集合)

java
//这里只用HashSet做说明,TreeSet不做涉及
Set set = new HashSet();

set.add("Nemo");
set.add("Nemo");
set.add("Kira");
set.add("1");
set.add("2");

System.out.println("集合长度 :" + set.size());  //输出: 

for(String val : set){
    System.out.println("值输出:"+val);
}

(某次)最终输出:

集合长度:4
值输出:1
值输出:2
值输出:Nemo
值输出:Kira

python

bus = {'Nemo','Kira',1,2,'Nemo'}
bus.add('Nemo')
print('集合长度:%d'%(len(bus)))
for item in bus:
    print('值输出%s'%(item))

(某次)最终输出:

集合长度:4
值输出:1
值输出:2
值输出:Nemo
值输出:Kira

Go

Go中并无如Java/Python中的Set类型定义,如需参考,可使用切片做示例。

可以看到,Java和Python的集合是非常类似的。

1、元素都不可重复。

2、元素都无序。

不同之处在于:

1、python的集合里面的元素类型可以不一致,而java则一般一致(Java Object泛型除外)。


6.7、Dictionary/Map(字典/集合)

//这里只用HashMap作为说明
Map<String,String> map = new HashMap<>;
map.put("name","Nemo");
map.put("name","Kira");
map.put("age","Nemo");
map.put("age","17");

System.out.println("字典长度:"+map.size());

for(String key : map.keySet()){
    System.out.println("键:"+key + " - 值:"+map.get(key));
}

(某次)最终输出:

字典长度:2

键:name - 值:Kira
键:age - 值:17

python

// Python中称之为字典
dict = {'name':'Nemo','age':17}

dict['name'] = 'Kira'

print('字典长度:%d'%(len(dict)))

for (key,val) in dict.items():
    print('键:%s - 值:%s'%(key,val))

(某次)最终输出:

字典长度:2
键:name - 值:Kira
键:age - 值:17

GO

// Go中称之为集合
// 创建集合
var countryCapitalMap map[string]string
countryCapitalMap = make(map[string]string)

countryCapitalMap [ "France" ] = "巴黎"
countryCapitalMap [ "Italy" ] = "罗马"
countryCapitalMap [ "India " ] = "新德里"
countryCapitalMap [ "Japan" ] = "东京"

for country := range countryCapitalMap {
fmt.Println(country, "首都是", countryCapitalMap [country])
}

(某次)最终输出:

Italy 首都是 罗马
India 首都是 新德里
Japan 首都是 东京
France 首都是 巴黎

可以看到,三者的是非常类似的。

1、元素都不可重复。

2、元素都无序。

不同之处在于:

1、python的集合里面的元素类型可以不一致,而java和Go中则一般一致(Java Object泛型除外)。

7、运算符

7.1、算术运算符

java

+(加法)、-(减法)、*(乘法)、/(除法)、%(取余)、++(自增1)、--(自减1)

python

+(加法)、-(减法)、*(乘法)、/(除法)、%(取余)、**(幂)、//(取整除)

Go

+(加法)、-(减法)、*(乘法)、/(除法)、%(取余)、++(自增1)、--(自减1)

7.2、关系运算符

== 检查两个操作数是否相等
!= 检查两个操作数是否不相等
>  检查左边的操作数是否大于右边的操作数
<  检查左边的操作数是否小于右边的操作数
>= 检查左边的操作数是否大于或者等于右边的操作数
<= 检查左边的操作数是否小于或者等于右边的操作数

python、java、Go三者基本一致。

7.3、位运算符

java

&  按位与运算符
|  按位或运算符
^  按位异或运算符
~  按位取反运算符
<< 按位左移运算符
>> 按位右移运算符
>>>按位右移补零操作符

python

&  按位与运算符
|  按位或运算符
^  按位异或运算符
~  按位取反运算符
<< 按位左移运算符
>> 按位右移运算符

Go

&  按位与运算符
| 按位或运算符
^ 按位异或运算符
<< 按位左移运算符
>> 按位右移运算符

python较java少按位右移补零操作符,而Go则相较之下支持的操作更少。

7.4、逻辑运算符

java

&& 逻辑与运算符
|| 逻辑或操作符
!  逻辑非运算符

python

and 逻辑与运算符
or  逻辑或运算符
not 逻辑非运算符

Go

&& 逻辑与运算符
|| 逻辑或操作符
! 逻辑非运算符


7.5、赋值预算符

java

=   简单的赋值运算符
+=  加和赋值操作符
-=  减和赋值操作符
*=  乘和赋值操作符
/=  除和赋值操作符
(%)=取模和赋值操作符
<<= 左移位赋值运算符
>>= 右移位赋值运算符
&=  按位与赋值运算符
^=  按位异或赋值操作符
|=  按位或赋值操作符

python

=   简单的赋值运算符
+=  加法赋值运算符
-=  减法赋值运算符
*=  乘法赋值运算符
/=  除法赋值运算符
%=  取模赋值运算符
**= 幂赋值运算符
//= 取整除赋值运算符

Go

=   简单的赋值运算符
+= 加和赋值操作符
-= 减和赋值操作符
*= 乘和赋值操作符
/= 除和赋值操作符
%= 求余后赋值操作符
<<= 左移位赋值运算符
>>= 右移位赋值运算符
&= 按位与赋值运算符
^= 按位异或赋值操作符
|= 按位或赋值操作符


8、条件控制

java

public class Test {
   public static void main(String args[]){
      int x = 30;
      if( x == 10 ){
         System.out.print("Value of X is 10");
      }else if( x == 20 ){
         System.out.print("Value of X is 20");
      }else if( x == 30 ){
         System.out.print("Value of X is 30");
      }else{
         System.out.print("这是 else 语句");
      }
   }
}

python

x = 30
if x == 10:
    print('Value of x is 10')
elif x == 20:
    print('Value of x is 20')
elif x == 30:
    print('Value of x is 30')
else:
    print('这是 else 语句')

Go

package main

import "fmt"

func main() {
x := 30
if x == 10 {
fmt.Println("Value of X is 10")
} else if x == 20 {
fmt.Println("Value of X is 20")
} else if x == 30 {
fmt.Println("Value of X is 30")
} else {
fmt.Println("这是 else 语句")
}
}


9、循环控制

9.1、while/do...while/while...else

java

//java:while 
public class Test {
   public static void main(String args[]) {
      int x = 10;
      while( x < 20 ) {
         System.out.print("value of x : " + x );
         x++;
         System.out.print("\n");
      }
   }
}

python

# python: while
x = 10
while x < 20:
    print('Value of x:%d'%x)
    x = x + 1


java

// java: do...while
public class Test {
   public static void main(String args[]){
      int x = 10;
      do{
         System.out.print("value of x : " + x );
         x++;
      }while( x < 20 );
   }
}

python

# python: while...else
x = 10 
while x < 20:   
    print('value of x : %d',x)
    x = x + 1
else:
    print(' else ')


Go

Go中无while关键字,可参考for true {...} 实现。



9.2、for

java

public class Test {
   public static void main(String args[]) {
      //普通for:
      for(int x = 10; x < 20; x = x+1) {
         System.out.println("value of x : " + x );
      }

      //增强for:
      int numbers = {10,20,30,40,50};
      for(int x : numnbers){
             if(x == 20){
                continue;
             }
             if(x == 40){
                 break;
             }
            System.out.println("value of x : " + x);
      }
   }
}

python

numbers = [10,20,30,40,50]
for x in numbers:
    if x == 20:
        continue
    if x == 40:
        break
    print('value of x : %d'%x)


Go

var names = []string{"Tom", "Nemo", "Eva"}
for i:=0;i<len(names);i++{
fmt.Println(names[i])
}
for index,value := range names{
fmt.Println(index, "=>", value)
}
var num = 100;
for true {
if num % 2 == 0 {
fmt.Println(num)
}else if num % 7 == 0{
break
}else{
continue
}
num --
}


10、函数/方法

java

基本语法:
修饰符 返回值类型 方法名(参数类型 参数名, 参数类型 参数名){
    // 方法体
    return 返回值;
}


public class MyClass{

//ex 1:
public static int sum(int num1,int num2){
int result = num1 + num2;
return result;
}

//ex 2:
public void stdout(int sum){
System.out.println("The sum is:" + sum);
}

//ex 3:
public void stdlog(){
System.out.println("Log is here");
}


    // call
public static void main(String[]args){
MyClass myClass = new MyClass();
//call ex1:
int num1 = 100;
int num2 = 200;
int sum = myClass.sum(num1, num2);

// call ex2:
myClass.stdout(sum);

// call ex3
myClass.stdlog();
}
}

Python

基本语法:
def 方法名(参数列表):
# 方法体
return 返回值1, 返回值2

# ex1

def sum(num1, num2):
return num1 + num2


# ex2
def stdout(sum):
print('The sum is: ' + str(sum))


# ex3
def stdlog():
print('Log is here"')


// call
num1 = 100
num2 = 200
sum = sum(num1, num2)
stdout(sum)
stdlog()

Go

基础语法:
func 函数名(参数名 参数类型, 参数名 参数类型) 返回值类型,返回值类型{
// 方法体
return 返回值1, 返回值2
}

func sum(num1 int, num2 int)int{
    return num1 + num2
}

func stdout(sum int){
    fmt.Println("The sum is : " + strconv.Itoa(sum))
}

func stdlog(){
    fmt.Println("Log is here")
}

func main() {
    num1 := 100
    num2 := 200
    sum := sum(num1, num2)
    stdout(sum)
    stdlog()
}


11、访问控制

Java

public     //公开访问,任意类可访问
private //私有访问,仅本类可访问
default //本包可访问,默认不写修饰符即为default
protected //本包可访问,不能用于类(内部类除外)和接口方法修饰

Python

Python并无修饰符,访问权限仅有两种:
1、公开访问:不以_开头命名的方法、成员变量等。
2、私有访问:以_开头命名的方法、成员变量等。

Go

Go中并无修饰符,访问权限仅有两种:
1、公开访问:方法、成员变量等以大写字母开头。
2、私有访问:方法、成员变量等不以大写字母开头。






点赞(1)
点了个评