Python 基础语法（和Java相比）

Python变量和数据类型

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

#数据类型 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  'The quick brown fox' ,  'jumps over' ,  'the lazy dog'  #遇到逗号“,”会输出一个空格 print  '100 + 200 =' ,  100  +  200  #计算100 + 200的结果   #-------------------------------------------- #变量 a  =  1  #变量是用一个变量名表示，变量名必须是大小写英文、数字和_的组合，且不能用数字开头   #可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，称为动态语言   #------------------------------------------- #可以使用转义字符 \ 、\n、\t等等   #------------------------------------------- #raw字符串与多行字符串 print  (r '\(~_~)/ \(~_~)/' );  #我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了   #但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串 #如果要表示多行字符串，可以用'''...'''表示 print  ( '''Python is created by "Guido". It is free and easy to learn. Let's start learn Python in imooc!''' );   #等同于'Line 1\nLine 2\nLine 3'   #--------------------------------------------------- #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. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。 #2. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。 #所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

List和Tuple类型

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

#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和Set类型

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

#花括号 {} 表示这是一个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()前需要判断。

条件判断和循环

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

#if语句 age  =  20 if  age > =  118 :      print  'your age is' , age      print  'adult' else :      print  'your age is' , 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

函数

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

#可以直接从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。return None可以简写为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 就好了。

切片

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#取前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和字符

迭代

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58

#普通迭代  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-valueiterator object at 0x106adbb50> 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() 不占用额外的内存。

列表生成式

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#要生成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)

---

参考

        慕课网