1 一些代码片段
1 输出hello，world：
Python版
print("hello，world")
Java版
public class HelloWorld { //这里的HelloWorld需要与文件名相同
public static void main(String[] args) {
System.out.println("hello,world");
}
}
2 获取键盘输入,并输出：
Python版
name = input("请输入您的名字：")
print(name)
Java版
import java.util.Scanner;
public class inputstr {
public static void main(String[] args) {
System.out.println("请输入您的名字：");
String name = new Scanner(System.in).next();
System.out.println(name);
}
}
3 输出1到10的随机一个数字：
Python版
import random
print(random.randint(1,10))
Java版
import java.util.Random;
public class prandom {
public static void main(String[] args) {
System.out.println(new Random().nextInt(10)+1)
}
}
4 定义变量：
Python版
a = 1 #python中不需要分号结尾，python用缩进判断代码块
a="123" #python中单引号双引号不区分
Python定义变量的时候不需要给出类型，直接定义即可，Python会自动判断变量类型。
String类型：
Java版
int a = 1;
String a = new String();
a = "123";
5 Python中if语句bool表达式的运算符
java: && || 取反 ! true
python: and or 取反 not true
if a > 0 && a < 10 && !a == 5{}
if a > 0 and a < 10 and not a == 5:
6 Pyhthon中的除法
Java整数除法运算结果只取整数部分
python整数除法运算总是返回浮点数,
python 使用//运算，对除法运算结果进行取整。
7 数组定义
java：
String[] a = new String[5];
int[] array={1, 2, 3, 4, 5};
python:
c=[1,2,3,4]
d=[123,"3",c] #python中数组接受任意类型,并且各个类型都嫩恶搞互相转换
8 Python中对数组的切片
一般数字数组
a[x:y:z] #x表示起始点，y终止点（不包含），z步长
a = [1,2,3,4,5]
print(a[1:-1]) #打印出数组a下标从1到-1（不包含）的数字
结果是
[2,3,4]
字符串数组
b ="12345"
print(b[1:-1]) #结果是'234'
print(int(b)) #将数组强制转换成int数组（必须字符串数组中全为数字）
利用切片倒序数组
a=[1,2,3,4,5]
a[::-1] [5,4,3,2,1]
省略前面两个参数，表示对整个数组，步数-1 从后往前
a[4:0:-1] [5,4,3,2]
完整的写完区间，但是会发现无法将一个数字倒序，因为切片不包含结束点
但当你的起始或者终止点超过数组长度，就返回最大能返回的
a[4:-6:-1]
a[5:-9:-1]
上面两个都是一样的，因为第一个是结束点超出数组范围
第二个是起始点和结束点都超过
记住 -1表示倒数第一个小标，所以你不能写成
a[4:-1:-1] 这个表示起始终止点都是最后最后一个，所以返回空
9 for循环
java:
//形式一：
for (int i=0; i<9; i++){
System.out.println(i);
}
//形式二：
String[] s1 = {"1","2","3","3"};
for(String ss : s1){
System.out.print(ss);
}
python:
for i in range(0,9): #range（）函数，不包含右边
print(i)
#会发现在java用‘{’的地方，python使用‘：’表示
#比如if，class，for，while，定义函数时等等
相比之下会发现，python的语法更加接近我们英语语法，for i 对于每个i 在0-9（不包含9）中。
python 的 for 语句还可以配合 else 使用，for循环中的语句没有执行break，则 else 语句将不会执行，反之亦然。代码如下：
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, 'equals', x, '*', n//x)
break
else:
# loop fell through without finding a factor
print(n, 'is a prime number')
以上代码执行结果为：
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3
10 while循环
java：
while(int i < 9){
System.out.print(i);
i--;
}
python:
while i>0 :
print(i)
i = i-1 #注意python中没有自加自减
11 函数定义
Java中的函数定义很固定：访问范围+是否静态+是否final+返回类型+函数名+（参数类型 参数名，参数类型2 参数名 ，...），例如：
public static void main(String[] args){
//statements;
}
访问范围：public，private，protected 和 默认（不指定则表示是默认的作用域，在同一个包内的类能够访问）
是否静态：用static关键字申明，如果是‘static’，表示该方法为类方法，否则为成员方法。
是否final：用final关键字申明，如果是‘final’，则表示该方法不可被继承。
返回类型：返回类型可以是void，Java定义9种简单数据类型，Java类。
一般情况下，Java函数的参数都是固定的N(N>=0)个参数，按照 effective java 的建议，参数的个数最好不要超过4个。
当函数的所有参数都是同一个类型的时候，Java支持可变参数的申明形式，如下：
public static void main(String...args){
//statements;
}
python 中定义函数的语法形式为：def+函数名+(参数,参数,...,参数=缺省值)，例如：
def ask_ok(prompt, retries=4, reminder='Please try again!'):
while True:
ok = input(prompt)
if ok in ('y', 'ye', 'yes'):
return True
if ok in ('n', 'no', 'nop', 'nope'):
return False
retries = retries - 1
if retries < 0:
raise ValueError('invalid user response')
print(reminder)
说明：python在定义函数的时候，函数的参数列表是可以指定缺省值的。当指定了缺省值，在调用函数的时候，指定缺省值的参数就成为了非必传参数了。
现在我们定义一个filter函数，只保留数组中的偶数
a = [1,2,3,4,5,6,7,8,9]
def filter(l): #def表示定义函数
x=[]
for i in range(0,len(l)): #len函数获取数组长度
if l[i]%2 == 0:
x.append(l[i]) #.append往数组中加元素
return x
然后比较魔性的写法
def filter(l):
return [x for x in l if x%2 == 0]
12 递归函数
定义一个函数求出一个数字的阶乘
def fn(n):
if n == 1:
return 1
else:
return n*fn(n-1)
13 Python中的class概念
class Person:
def __init__(self, name):
self.name = name
def getName(self):
return self.name
上面这段代码表示class Person的构造函数，使用这个类，必须传入一个name的参数，然后里面还定义了一个getName（）函数，得到这个类的name参数值
a = Person("abc") #新定义一个变量名为a的Person类，里面的name值为abc
a.asd = 123 #与java不同的是，可以随时忘类中加入新的参数和值
print(a.name, a.asd)
14 改写Python的原有函数
Python可以将print这类基础函数改写，但是java做不到
oldPrint = print
def myprint(x):
oldPrint(":::", x)
print = myprint
print("ashdhabsd") #结果：:::ashdhabsd
print(345) #结果：:::345
15 Map函数
map(函数名，数组)
比如我有一个power平方函数和int数组a[1,2,3]
a=list(map(power,a))
[1,4,9] 注意这里用map必须在前面加list转换，否则显示的不是数组
16 Lambda函数
Lanbda可以免去在外面定义函数，一些简单只需要用一次的函数可以直接写在表达式中
a = [1,2,3,4,5]
a = map(lambda x: x**2, a)
a = list(a)
print(a)
16 Python中的字典{} （HashMap）
a{ key1 : value1 , key2 : value2 } 一个key对应一个value
a = {"name":"abc","age":17}
a ['sex']='male' #为字典中加入新的元素
判断key或者value是否在字典中
"name" in a #ture
"abc" in a #false in a 默认是keys的集合
"abc" in a.values() #ture
不仅仅只是字典，其他字符串也可以同样操作
a = "hello 12 3 abc"
"abc" in a #true
17 函数缺省值:
py:
class Employee():
def __init__(self, name , gender="male" , maritalStatus="single" ):
self.name = name
self.gender = gender
self.maritalStatus = maritalStatus
2 python Java 语法对比
两者优势对比，内容来自Quora
Both Java and Python are powerful in their own areas. Its up to you to choose one for your project. While Java is fast and more portable, Python is simple and concise.
Python is best for data science, Artificial Intelligence and Machine Learning, Java does best with embedded & cross platform applications.
Here are some benefits of Java over Python-
Portability
Python and Java are highly portable languages. Due to the extreme popularity of Java, it wins this battle. The JVM (Java Virtual Machine) can be found almost everywhere.
Database Access
Python’s database access layers are weaker than Java’s Java Database Connectivity (JDBC).
Compilation
Compiles easily on any platform without hassles. It’s this flexibility that gives is an edge.
Language type
General purpose programming language. Follows “write once” run anywhere.
Concurrency
Python can only use a single CPU core due to the GIL, but Java doesn't have this restriction.
Here are some benefits of Python over Java
Easy to Use
Python is easy to pick up. If you are just stepping into the world of Programming, beginning with Python is a good choice. It is easy to code , easy to understand. However it isn’t same with Java.
Simplicity
Coding in Python raises programmers productivity because they need to write only so much code needed and it is concise.
Interpreted
Tools like Integrated Development Environment, you can interpret Python instead of compiling it. While it reduces the program length, & boosts productivity & also result in slower overall execution.
参考文章：
https://www.quora.com/What-are-the-differences-between-Python-and-Java
网友评论