Python相对java入门比较

基本数据类型及格式使用

1.基本数据类型

1.整数，浮点数，字符的与java差别不大；

2.字符串与javascript相似，可用’'或""括起；

3.布尔 的 True 和 False 首字母必须大写，&&用and，||用or，!用not；

4.空值null用None。

2.格式使用

1.定义变量时不需要使用数据类型可以直接写变量名；

2.每一句之后不需要;分号；

3.注释用#；

4.print 不需要小括号可以直接在空格后接打印内容，与java不同的是字符串和变量之间不能用+加号拼接，而是用,逗号隔开，逗号占位的部分在打印结果中会以空格的形式展现

5.if,for,while等方法的不需要用大括号及小括号，可直接在语句末尾添加:冒号，内容通过缩进表示。

if 3<5:
	print a<b

i=1
while i<=5:
	print i

关键词及语法

1.字符串中

1.r,在以r开头的字符串中所有内容均不转义，\n，’，" 等均无法生效；

2.’’’ ‘’'中的字符串内容可以多行表达类似于java中/* */的效果，但不是注释；

3.在’’’ ‘’'前也可加r关键字，定义多行不转义字符串；

4.u,以u开头的字符串是unicode字符串，单行多行均适用；

5.中文必须在unicode字符串中才能显示，如果中文字符串遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加如下注释,告诉编译器用UTF-8编码读取源代码；

# -*- coding: utf-8 -*-

6.切片，也就是java中的字符串截取，与list切片类似，可以将字符串看做是多个字符组成的tuple。

2.基本数据类型中

1.整数及浮点数运算与java相似，整数可通过与浮点数的运算转换运算结果为浮点型，相较于java方便处在于数没有长度大小的限制；c

2.布尔型的and,or,not可用于其他数据类型，把 0 、 空字符串’’ 和 None 看成 False，其他数值和非空字符串都看成 True，短路原则与java相似。

3.list数列-顺序集合（len(L)可以计算任意集合的元素个数）

1.与java中的list相似，但数据格式及使用方法与数组相似；

2.内容用[]中括号括起，内容可是任意类型，并且可以多种类型混合；

L=['A',12,4.4,"b",True]

3.访问内容时通过下标索引，也可使用倒序索引访问，倒数第一，倒数第二之类的，访问时不可越界；

print L[0]	#第一个元素 -> A
print L[-1]	#倒数第一个元素 -> True 

4.用append(‘c’)将元素添加到末尾，用insert(2,‘c’)将元素添加到索引为2的位置，之后的所有元素都自动向后顺延；

L.append('c')
L.insert(2,'c')

5.pop()删除最后一个元素，pop(2)删除索引为2的元素，之后的所有元素都自动向前移动，并且pop()会返回被删除的元素；

print L.pop(2)	#4.4
print L	#['A',12,"b",True]

6.替换元素类似于数组，直接赋值即可；

7.切片，tuple的切片与list相似

L[0:3]	#取索引0-3的元素
L[:3]	#取索引0-3的元素,0可以省略
L[:]	#从0取到最后一个元素,L[:]实际上复制出了一个新list
 L[::2]	#也可以指定第三个元素，每两个元素取出一个，也就是隔一个取一个

例：

L = range(1, 101)

print L[:10]	#前10个数
print L[2::3]	#3的倍数
print L[4:51:5]	#不大于50的5的倍数

倒序切片第一个元素的索引是-1。倒序切片包含起始索引，不包含结束索引；

L = range(1, 101)
print L[-10:]	#最后10个数
print L[-46::5]	#最后10个5的倍数

8.列表生成式
与range()函数类似的功能，生成一个list数列
(1) range()结合for循环可以达到生成不同规则的数列

L = []
for x in range(1, 11):
	L.append(x * x)
L	# -> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

使用列表生成式可以通过一行代码结合二者

[x * x for x in range(1, 11)]	# -> [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

(2) 复杂表达式，因为for循环不仅可以迭代list也可以迭代dict，所以甚至可以用复杂表达式生成HTML代码
字符串可以通过 % 进行格式化，用指定的参数替代 %s。字符串的join()方法可以把一个 list 拼接成一个字符串

d = { 'Adam': 95, 'Lisa': 85, 'Bart': 59 }

tds = ['<tr><td>%s</td><td>%s</td></tr>' % (name, score) for name, score in d.iteritems()]
print '<table>'
print '<tr><th>Name</th><th>Score</th><tr>'
print '\n'.join(tds)
print '</table>'

生成结果：

<table border="1">
<tr><th>Name</th><th>Score</th><tr>
<tr><td>Lisa</td><td>85</td></tr>
<tr><td>Adam</td><td>95</td></tr>
<tr><td>Bart</td><td>59</td></tr>
</table>

4.tuple元组-顺序u集合

1.tuple 元组 元素用()小括号括起，结构类似于 list，但创建完毕后就不能再进行修改，多运用在各种方法中，常自动生成。若元素为list类型，因为存储的是list的地址，因此只要首地址不变，list中的内容是可变的；

2.单元素tuple若不在最后添加,逗号即与元素无差别，因为为了区别是单元素tuple需在末尾添加,逗号，打印时也会打印出。

t=('A')	#等价于'A'，print t 和 print 'A' 的打印结果相同
t=('A',)
print t	#(A,)

5.dict集合-无序集合

1.类似于java中的HashMap和JSON，由key和value组成：{key:value,key:value}，通过key值查找，无序；

d={
	'a':20,
	'b':40,
	'c':30
}
print d['a']

2.用 in 判断是否存在key

if 'd' in d:
	print d['d']	# 若不存在直接调会报错

3.除了通过 [key] 访问还可以用get(key)方法，不存在时返回None；

4.key 不可重复，不可变，因此可以使用tuple作为key 但不能用list；

5.遍历用for循环。

for key in d:
	print d[key]

for v in d.values():	#	转换成由value组成的list
	print v

for v in d.itervalues():	#	不转换list直接取
	print v

for key, value in d.items():	#	转换成包含tuple的list
	print key,':',value

for key, value in d.iteritems():	#	不转换list直接给出tuple
	print key,':',value

6.set集合-无序集合

1.({})类似于java中的set，元素不重复，且无序，类似tuple不能包含可变元素；

s = set(['A', 'B', 'C'])

2.通过 in 来判断元素是否在set中；

'A' in s  -> True

3.遍历通过 for；

4.更新通过add()和remove()（若元素不存在会报错，删除前先进行判断）。

常用函数的调用及定义函数

1.常用函数

1.1 range()，创建一个数列

range(1, 101) #生成1到100的数列-> [1, 2, 3, ..., 100]
range(1, 100, 2)	#生成list -> [1, 3, 5, 7, 9,...]

1.2 help(函数名)，查看某函数的帮助信息

help(abs)
#->
#Help on built-in function abs in module __builtin__:
#abs(...)
#    abs(number) -> number
#    Return the absolute value of the argument.

1.3 math.sin()/math.cos()/math.sqrt()

import math 引入math包，可以调用math包中的函数。

1.4 str.upper()，把字符变成大写字母

'abc'.upper()	# -> 'ABC'

2.定义函数

2.1 通过def关键词声明函数

相比java可省略返回值类型；

def add(a,b):
	return a+b

2.2 可以给参数设置默认值

设置默认值的参数必须在无默认值参数之后；

def add(a,b=10):
	return a+b

2.3 与java，es6类似参数可以是可变的

Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好；

def fn(*args):
    print args
    
fn()	# -> ()
fn('a')	# -> ('a',)
fn('a', 'b')	# -> ('a', 'b')
fn('a', 'b', 'c')	# -> ('a', 'b', 'c')

2.4 返回多个出参

会将多个出参组装成一个tuple，实际返回的还是一个参数。

def move(x, y, step, angle):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

x, y = move(100, 100, 60, math.pi / 6)
print x, y	# -> 151.961524227 70.0

r = move(100, 100, 60, math.pi / 6)
print r	# -> (151.96152422706632, 70.0)