Python基础 语法特别注意笔记（和Java相比）

#数据类型

print

(

0xff00

);

#十六进制用0x前缀和0-9，a-f表示

print

(

1.23e9

);

#对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10^9就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

#在Python中，可以直接用True、False表示布尔值（请注意大小写）布尔值可以用and、or和not运算。

#空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

#----------------------------------------

#print语句

print

'hello,world'

print

'Thequickbrownfox'

,

'jumpsover'

,

'thelazydog'

#遇到逗号“,”会输出一个空格

print

'100+200='

,

100

+

200

#计算100+200的结果

#--------------------------------------------

#变量

a

=

1

#变量是用一个变量名表示，变量名必须是大小写英文、数字和_的组合，且不能用数字开头

#可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，称为动态语言

#-------------------------------------------

#可以使用转义字符\、\n、\t等等

#-------------------------------------------

#raw字符串与多行字符串

print

(r

'\(~_~)/\(~_~)/'

);

#我们可以在字符串前面加个前缀r，表示这是一个raw字符串，里面的字符就不需要转义了

#但是r'...'表示法不能表示多行字符串，也不能表示包含'和"的字符串

#如果要表示多行字符串，可以用'''...'''表示

print

(

'''Pythoniscreatedby"Guido".

Itisfreeandeasytolearn.

Let'sstartlearnPythoninimooc!'''

);

#等同于'Line1\nLine2\nLine3'

#---------------------------------------------------

#Python在后来添加了对Unicode的支持，以Unicode表示的字符串用u'...'表示，比如：

print

u

'中文'

#如果中文字符串在Python环境下遇到UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释(目的是告诉Python解释器，用UTF-8编码读取源代码。)

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

#---------------------------------------------------

#布尔类型

a

=

True

print

a

and

'a=T'

or

'a=F'

#计算结果不是布尔类型，而是字符串'a=T'，这是为什么呢？

#因为Python把0、空字符串''和None看成False，其他数值和非空字符串都看成True，所以：

a

and

'a=T'

#计算结果是'a=T'

print

a

and

'a=T'

or

'a=F'

#计算结果还是'a=T'

#要解释上述结果，又涉及到and和or运算的一条重要法则：短路计算。

#1.在计算aandb时，如果a是False，则根据与运算法则，整个结果必定为False，因此返回a；如果a是True，则整个计算结果必定取决与b，因此返回b。

#2.在计算aorb时，如果a是True，则根据或运算法则，整个计算结果必定为True，因此返回a；如果a是False，则整个计算结果必定取决于b，因此返回b。

#所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

#list是一种有序的集合，可以随时添加和删除其中的元素

#一个元素可以没有的list，就是空list：

empty_list

=

[]

#创建List

L

=

[

'Adam'

,

95.5

,

'Lisa'

,

85

,

'Bart'

,

59

]

print

L

#按照索引访问list

print

L[

4

]

#输出Bart，下标是从0开始

#倒序访问list

print

L[

-

2

]

#输出Bart，下标是从0开始

#添加新元素

L.append(

'Paul'

)

L.insert(

0

,

'Paul'

)

#添加到指定位置

#从list删除元素

L.pop()

#pop()方法总是删掉list的最后一个元素，并且它还返回这个元素

pop(

2

)

#删除指定位置元素

#替换元素

L[

2

]

=

'Paul'

#对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素

#---------------------------------------------------

#tuple是另一种有序的列表，中文翻译为“元组”。tuple和list非常类似，但是，tuple一旦创建完毕，就不能修改了。

#创建tuple

t

=

(

'Adam'

,

'Lisa'

,

'Bart'

)

#创建tuple和创建list唯一不同之处是用()替代了[]

#获取tuple元素的方式和list是一模一样的

#包含0个元素的tuple，也就是空tuple，直接用()表示

t

=

()

#打印()

#创建包含1个元素的tuple

t

=

(

1

,)

#打印(1,)，加上“，”是因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果(1)被Python解释器计算出结果1，导致我们得到的不是tuple，而是整数1。

#“可变”的tuple

t

=

(

'a'

,

'b'

,[

'A'

,

'B'

])

#当我们把list的元素'A'和'B'修改为'X'和'Y'后,tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。

#花括号{}表示这是一个dict，然后按照key:value,写出来即可。最后一个key:value的逗号可以省略。由于dict也是集合，len()函数可以计算任意集合的大小

d

=

{

'Adam'

:

95

,

'Lisa'

:

85

,

'Bart'

:

59

}

#访问dict

print

d[

'Adam'

]

#如果key不存在，会直接报错：KeyError。可以先判断一下key是否存在再取值

if

'Paul'

in

d:

print

d[

'Paul'

]

#也可以使用dict本身提供的一个get方法，在Key不存在的时候，返回None

print

d.get(

'Bart'

)

#59

print

d.get(

'Paul'

)

#None

#dict的特点

#dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样(而list的查找速度随着元素增加而逐渐下降。不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。)

#由于dict是按key查找，所以，在一个dict中，key不能重复。

#dict的第二个特点就是存储的key-value序对是没有顺序的

#dict的第三个特点是作为key的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为key。但是list是可变的，就不能作为key

#更新dict

d[

'Paul'

]

=

72

#如果key已经存在，则赋值会用新的value替换掉原来的value

#遍历dict

d

=

{

'Adam'

:

95

,

'Lisa'

:

85

,

'Bart'

:

59

}

for

name

in

d:

print

name,

':'

,d[name]

#---------------------------------------------------

#set持有一系列元素，这一点和list很像，但是set的元素没有重复，而且是无序的，这点和dict的key很像。

#创建

s

=

set

([

'A'

,

'B'

,

'C'

])

#访问set

#由于set存储的是无序集合，所以我们没法通过索引来访问。访问set中的某个元素实际上就是判断一个元素是否在set中。

'Bart'

in

s

#返回True/False.（大小写敏感）

#set的特点

#set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。

#set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。

#最后，set存储的元素也是没有顺序的。

#遍历set

s

=

set

([

'Adam'

,

'Lisa'

,

'Bart'

])

for

name

in

s:

print

name

#更新set

s.add(

4

)

#元素已经存在于set中，add()不会报错，但是不会加进去了

s.remove(

4

)

#元素不存在set中，remove()会报错，所以remove()前需要判断。

#if语句

age

=

20

if

age>

=

118

:

print

'yourageis'

,age

print

'adult'

else

:

print

'yourageis'

,age

print

'END'

#Python代码的缩进规则。具有相同缩进的代码被视为代码块

#缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。

#if-elif-else

age

=

12

if

age>

=

18

:

print

'adult'

elif

age>

=

6

:

print

'teenager'

elif

age>

=

3

:

print

'kid'

else

:

print

'baby'

#这一系列条件判断会从上到下依次判断，如果某个判断为True，执行完对应的代码块，后面的条件判断就直接忽略，不再执行了。(和Java一样)

#for循环遍历一个list或tuple

L

=

[

'Adam'

,

'Lisa'

,

'Bart'

]

for

name

in

L:

print

name

#while循环

N

=

10

x

=

0

while

x<N:

print

x

x

=

x

+

1

#（都和Java一样用法）

#可以使用break退出循环

#continue继续循环

#多重循环

for

x

in

[

'A'

,

'B'

,

'C'

]:

for

y

in

[

'1'

,

'2'

,

'3'

]:

print

x

+

y

#可以直接从Python的官方网站查看文档：http://docs.python.org/2/library/functions.html#ab

#调用函数

print

abs

(

-

2

)

#2

#编写函数

#在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。

def

my_abs(x):

if

x>

=

0

:

return

x

else

:

return

-

x

#如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。returnNone可以简写为return。

#递归函数

def

fact(n):

if

n

=

=

1

:

return

1

return

n

*

fact(n

-

1

)

#分析（很清晰）

=

=

=

>fact(

5

)

=

=

=

>

5

*

fact(

4

)

=

=

=

>

5

*

(

4

*

fact(

3

))

=

=

=

>

5

*

(

4

*

(

3

*

fact(

2

)))

=

=

=

>

5

*

(

4

*

(

3

*

(

2

*

fact(

1

))))

=

=

=

>

5

*

(

4

*

(

3

*

(

2

*

1

)))

=

=

=

>

5

*

(

4

*

(

3

*

2

))

=

=

=

>

5

*

(

4

*

6

)

=

=

=

>

5

*

24

=

=

=

>

120

#（扩展）使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，

#栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试计算fact(10000)。

#定义默认参数函数的默认参数的作用是简化调用

def

power(x,n

=

2

):

s

=

1

while

n>

0

:

n

=

n

-

1

s

=

s

*

x

return

s

print

power(

5

)

#由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面：

#OK:

def

fn1(a,b

=

1

,c

=

2

):

pass

#Error:

def

fn2(a

=

1

,b):

pass

#定义可变参数

def

fn(

*

args):

print

args

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

#取前3个元素

L

=

[

'Adam'

,

'Lisa'

,

'Bart'

,

'Paul'

]

L[

0

:

3

]

#['Adam','Lisa','Bart']

L[

1

:

3

]

#['Lisa','Bart']

L[:]

#表示从头到尾

L[::

2

]

#第三个参数表示每N个取一个，L[::2]表示每两个元素取出一个来

#倒序切片

L

=

[

'Adam'

,

'Lisa'

,

'Bart'

,

'Paul'

]

L[

-

2

:]

#['Bart','Paul']

L[:

-

2

]

#['Adam','Lisa']

L[

-

3

:

-

1

]

#['Lisa','Bart']倒数第三个开始切到倒数第一个

L[

-

4

:

-

1

:

2

]

#['Adam','Bart']

#tuple和字符切片也是一样的，只是返回的是tuple和字符

#普通迭代for...in完成

#索引迭代

L

=

[

'Adam'

,

'Lisa'

,

'Bart'

,

'Paul'

]

for

index,name

in

enumerate

(L):

print

index,

'-'

,name

#0-Adam

#1-Lisa

#2-Bart

#3-Paul

#扩展

#实际上，enumerate()函数把：['Adam','Lisa','Bart','Paul']变成了类似：[(0,'Adam'),(1,'Lisa'),(2,'Bart'),(3,'Paul')]

#因此，迭代的每一个元素实际上是一个tuple：

for

t

in

enumerate

(L):

index

=

t[

0

]

name

=

t[

1

]

print

index,

'-'

,name

#如果我们知道每个tuple元素都包含两个元素，for循环又可以进一步简写为：

for

index,name

in

enumerate

(L):

print

index,

'-'

,name

#这样不但代码更简单，而且还少了两条赋值语句。

#迭代dict的value

#dict对象有一个values()方法，这个方法把dict转换成一个包含所有value的list

d

=

{

'Adam'

:

95

,

'Lisa'

:

85

,

'Bart'

:

59

}

print

d.values()

#[85,95,59]

for

v

in

d.values():

print

v

#85

#95

#59

#扩展

#如果仔细阅读Python的文档，还可以发现，dict除了values()方法外，还有一个itervalues()方法，用itervalues()方法替代values()方法，迭代效果完全一样：

d

=

{

'Adam'

:

95

,

'Lisa'

:

85

,

'Bart'

:

59

}

print

d.itervalues()

#<dictionary-valueiteratorobjectat0x106adbb50>

for

v

in

d.itervalues():

print

v

#85

#95

#59

#那这两个方法有何不同之处呢？

#1.values()方法实际上把一个dict转换成了包含value的list。

#2.但是itervalues()方法不会转换，它会在迭代过程中依次从dict中取出value，所以itervalues()方法比values()方法节省了生成list所需的内存。

#3.打印itervalues()发现它返回一个<dictionary-valueiterator>对象，这说明在Python中，for循环可作用的迭代对象远不止list，tuple，str，unicode，dict等，任何可迭代对象都可以作用于for循环，而内部如何迭代我们通常并不用关心。

#如果一个对象说自己可迭代，那我们就直接用for循环去迭代它，可见，迭代是一种抽象的数据操作，它不对迭代对象内部的数据有任何要求。

#迭代dict的key和value

for

key,value

in

d.items():

print

key,

':'

,value

#Lisa:85

#Adam:95

#Bart:59

#values()有一个itervalues()类似，items()也有一个对应的iteritems()，iteritems()不把dict转换成list，而是在迭代过程中不断给出tuple，所以，iteritems()不占用额外的内存。

#要生成list[1,2,3,4,5,6,7,8,9,10]，我们可以用range(1,11)：

#但如果要生成[1x1,2x2,3x3,...,10x10]怎么做

L

=

[]

for

x

in

range

(

1

,

11

):

L.append(x

*

x)

#还可以用

[x

*

x

for

x

in

range

(

1

,

11

)]

#这种写法就是Python特有的列表生成式。利用列表生成式，可以以非常简洁的代码生成list

#条件过滤如果我们只想要偶数的平方，不改动range()的情况下，可以加上if来筛选：

[x

*

x

for

x

in

range

(

1

,

11

)

if

x

%

2

=

=

0

]

#有了if条件，只有if判断为True的时候，才把循环的当前元素添加到列表中。

#[4,16,36,64,100]

#多层表达式

[m

+

n

for

m

in

'ABC'

for

n

in

'123'

]

#['A1','A2','A3','B1','B2','B3','C1','C2','C3']

#相当于

L

=

[]

for

m

in

'ABC'

:

for

n

in

'123'

:

L.append(m

+

n)