Python语法速览与实战清单

本文是对于 现代 Python 开发：语法基础与工程实践的总结，更多 Python 相关资料参考 Python 学习与实践资料索引；本文参考了 Python Crash Course - Cheat Sheets，pysheeet 等。本文仅包含笔者在日常工作中经常使用的，并且认为较为关键的知识点与语法，如果想要进一步学习 Python 相关内容或者对于机器学习与数据挖掘方向感兴趣，可以参考程序猿的数据科学与机器学习实战手册。

站在用户的角度思考问题，与客户深入沟通，找到浦北网站设计与浦北网站推广的解决方案，凭借多年的经验，让设计与互联网技术结合，创造个性化、用户体验好的作品，建站类型包括：网站设计、成都网站建设、企业官网、英文网站、手机端网站、网站推广、国际域名空间、虚拟空间、企业邮箱。业务覆盖浦北地区。

基础语法

Python 是一门高阶、动态类型的多范式编程语言；定义 Python 文件的时候我们往往会先声明文件编码方式:

 
 
 
    
  
  
  
  1. # 指定脚本调用方式
    2. 
  
  
  
  2. #!/usr/bin/env python
    3. 
  
  
  
  3. # 配置 utf-8 编码
    4. 
  
  
  
  4. # -*- coding: utf-8 -*-
    5. 
  
  
  
  5. 
  
  
  
  6. # 配置其他编码
    7. 
  
  
  
  7. # -*- coding:  -*-
    8. 
  
  
  
  8. 
  
  
  
  9. # Vim 中还可以使用如下方式
    10. 
  
  
  
  10. # vim:fileencoding=
    11.

人生苦短，请用 Python，大量功能强大的语法糖的同时让很多时候 Python 代码看上去有点像伪代码。譬如我们用 Python 实现的简易的快排相较于 Java 会显得很短小精悍:

 
 
 
    
  
  
  
  1. def quicksort(arr):
    2. 
  
  
  
  2.     if len(arr) <= 1:
    3. 
  
  
  
  3.         return arr
    4. 
  
  
  
  4.     pivot = arr[len(arr) / 2]
    5. 
  
  
  
  5.     left = [x for x in arr if x < pivot]
    6. 
  
  
  
  6.     middle = [x for x in arr if x == pivot]
    7. 
  
  
  
  7.     right = [x for x in arr if x > pivot]
    8. 
  
  
  
  8.     return quicksort(left) + middle + quicksort(right)
    9. 
  
  
  
  9.     
    10. 
  
  
  
  10. print quicksort([3,6,8,10,1,2,1])
    11. 
  
  
  
  11. # Prints "[1, 1, 2, 3, 6, 8, 10]"
    12.

控制台交互

可以根据 __name__ 关键字来判断是否是直接使用 python 命令执行某个脚本，还是外部引用；Google 开源的 fire 也是不错的快速将某个类封装为命令行工具的框架：

 
 
 
    
  
  
  
  1. import fire
    2. 
  
  
  
  2. 
  
  
  
  3. class Calculator(object):
    4. 
  
  
  
  4.   """A simple calculator class."""
    5. 
  
  
  
  5. 
  
  
  
  6.   def double(self, number):
    7. 
  
  
  
  7.     return 2 * number
    8. 
  
  
  
  8. 
  
  
  
  9. if __name__ == '__main__':
    10. 
  
  
  
  10.   fire.Fire(Calculator)
    11. 
  
  
  
  11. 
  
  
  
  12. # python calculator.py double 10  # 20
    13. 
  
  
  
  13. # python calculator.py double --number=15  # 30
    14.

Python 2 中 print 是表达式，而 Python 3 中 print 是函数；如果希望在 Python 2 中将 print 以函数方式使用，则需要自定义引入:

 
 
 
    
  
  
  
  1. from __future__ import print_function
    2.

我们也可以使用 pprint 来美化控制台输出内容：

 
 
 
    
  
  
  
  1. import pprint
    2. 
  
  
  
  2. 
  
  
  
  3. stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni']
    4. 
  
  
  
  4. pprint.pprint(stuff)
    5. 
  
  
  
  5. 
  
  
  
  6. # 自定义参数
    7. 
  
  
  
  7. pp = pprint.PrettyPrinter(depth=6)
    8. 
  
  
  
  8. tup = ('spam', ('eggs', ('lumberjack', ('knights', ('ni', ('dead',('parrot', ('fresh fruit',))))))))
    9. 
  
  
  
  9. pp.pprint(tup)
    10.

模块

Python 中的模块（Module）即是 Python 源码文件，其可以导出类、函数与全局变量；当我们从某个模块导入变量时，函数名往往就是命名空间（Namespace）。而 Python 中的包（Package）则是模块的文件夹，往往由 __init__.py 指明某个文件夹为包:

 
 
 
    
  
  
  
  1. # 文件目录
    2. 
  
  
  
  2. someDir/
    3. 
  
  
  
  3.     main.py
    4. 
  
  
  
  4.     siblingModule.py
    5. 
  
  
  
  5. 
  
  
  
  6. # siblingModule.py
    7. 
  
  
  
  7. 
  
  
  
  8. def siblingModuleFun():
    9. 
  
  
  
  9.     print('Hello from siblingModuleFun')
    10. 
  
  
  
  10.     
    11. 
  
  
  
  11. def siblingModuleFunTwo():
    12. 
  
  
  
  12.     print('Hello from siblingModuleFunTwo')
    13. 
  
  
  
  13. 
  
  
  
  14. import siblingModule
    15. 
  
  
  
  15. import siblingModule as sibMod
    16. 
  
  
  
  16. 
  
  
  
  17. sibMod.siblingModuleFun()
    18. 
  
  
  
  18. 
  
  
  
  19. from siblingModule import siblingModuleFun
    20. 
  
  
  
  20. siblingModuleFun()
    21. 
  
  
  
  21. 
  
  
  
  22. try:
    23. 
  
  
  
  23.     # Import 'someModuleA' that is only available in Windows
    24. 
  
  
  
  24.     import someModuleA
    25. 
  
  
  
  25. except ImportError:
    26. 
  
  
  
  26.     try:
    27. 
  
  
  
  27.         # Import 'someModuleB' that is only available in Linux
    28. 
  
  
  
  28.         import someModuleB
    29. 
  
  
  
  29.     except ImportError:
    30.

Package 可以为某个目录下所有的文件设置统一入口:

 
 
 
    
  
  
  
  1. someDir/
    2. 
  
  
  
  2.     main.py
    3. 
  
  
  
  3.     subModules/
    4. 
  
  
  
  4.         __init__.py
    5. 
  
  
  
  5.         subA.py
    6. 
  
  
  
  6.         subSubModules/
    7. 
  
  
  
  7.             __init__.py
    8. 
  
  
  
  8.             subSubA.py
    9. 
  
  
  
  9. 
  
  
  
  10. # subA.py
    11. 
  
  
  
  11. 
  
  
  
  12. def subAFun():
    13. 
  
  
  
  13.     print('Hello from subAFun')
    14. 
  
  
  
  14.     
    15. 
  
  
  
  15. def subAFunTwo():
    16. 
  
  
  
  16.     print('Hello from subAFunTwo')
    17. 
  
  
  
  17. 
  
  
  
  18. # subSubA.py
    19. 
  
  
  
  19. 
  
  
  
  20. def subSubAFun():
    21. 
  
  
  
  21.     print('Hello from subSubAFun')
    22. 
  
  
  
  22.     
    23. 
  
  
  
  23. def subSubAFunTwo():
    24. 
  
  
  
  24.     print('Hello from subSubAFunTwo')
    25. 
  
  
  
  25. 
  
  
  
  26. # __init__.py from subDir
    27. 
  
  
  
  27. 
  
  
  
  28. # Adds 'subAFun()' and 'subAFunTwo()' to the 'subDir' namespace 
    29. 
  
  
  
  29. from .subA import *
    30. 
  
  
  
  30. 
  
  
  
  31. # The following two import statement do the same thing, they add 'subSubAFun()' and 'subSubAFunTwo()' to the 'subDir' namespace. The first one assumes '__init__.py' is empty in 'subSubDir', and the second one, assumes '__init__.py' in 'subSubDir' contains 'from .subSubA import *'.
    32. 
  
  
  
  32. 
  
  
  
  33. # Assumes '__init__.py' is empty in 'subSubDir'
    34. 
  
  
  
  34. # Adds 'subSubAFun()' and 'subSubAFunTwo()' to the 'subDir' namespace
    35. 
  
  
  
  35. from .subSubDir.subSubA import *
    36. 
  
  
  
  36. 
  
  
  
  37. # Assumes '__init__.py' in 'subSubDir' has 'from .subSubA import *'
    38. 
  
  
  
  38. # Adds 'subSubAFun()' and 'subSubAFunTwo()' to the 'subDir' namespace
    39. 
  
  
  
  39. from .subSubDir import *
    40. 
  
  
  
  40. # __init__.py from subSubDir
    41. 
  
  
  
  41. 
  
  
  
  42. # Adds 'subSubAFun()' and 'subSubAFunTwo()' to the 'subSubDir' namespace
    43. 
  
  
  
  43. from .subSubA import *
    44. 
  
  
  
  44. 
  
  
  
  45. # main.py
    46. 
  
  
  
  46. 
  
  
  
  47. import subDir
    48. 
  
  
  
  48. 
  
  
  
  49. subDir.subAFun() # Hello from subAFun
    50. 
  
  
  
  50. subDir.subAFunTwo() # Hello from subAFunTwo
    51. 
  
  
  
  51. subDir.subSubAFun() # Hello from subSubAFun
    52. 
  
  
  
  52. subDir.subSubAFunTwo() # Hello from subSubAFunTwo
    53.

表达式与控制流

条件选择

Python 中使用 if、elif、else 来进行基础的条件选择操作：

 
 
 
    
  
  
  
  1. if x < 0:
    2. 
  
  
  
  2.      x = 0
    3. 
  
  
  
  3.      print('Negative changed to zero')
    4. 
  
  
  
  4.  elif x == 0:
    5. 
  
  
  
  5.      print('Zero')
    6. 
  
  
  
  6.  else:
    7. 
  
  
  
  7.      print('More')
    8.

Python 同样支持 ternary conditional operator:

 
 
 
    
  
  
  
  1. a if condition else b
    2.

也可以使用 Tuple 来实现类似的效果：

 
 
 
    
  
  
  
  1. # test 需要返回 True 或者 False
    2. 
  
  
  
  2. (falseValue, trueValue)[test]
    3. 
  
  
  
  3. 
  
  
  
  4. # 更安全的做法是进行强制判断
    5. 
  
  
  
  5. (falseValue, trueValue)[test == True]
    6. 
  
  
  
  6. 
  
  
  
  7. # 或者使用 bool 类型转换函数
    8. 
  
  
  
  8. (falseValue, trueValue)[bool()]
    9.

循环遍历

for-in 可以用来遍历数组与字典：

 
 
 
    
  
  
  
  1. words = ['cat', 'window', 'defenestrate']
    2. 
  
  
  
  2. 
  
  
  
  3. for w in words:
    4. 
  
  
  
  4.     print(w, len(w))
    5. 
  
  
  
  5. 
  
  
  
  6. # 使用数组访问操作符，能够迅速地生成数组的副本
    7. 
  
  
  
  7. for w in words[:]:
    8. 
  
  
  
  8.     if len(w) > 6:
    9. 
  
  
  
  9.         words.insert(0, w)
    10. 
  
  
  
  10. 
  
  
  
  11. # words -> ['defenestrate', 'cat', 'window', 'defenestrate']
    12.

如果我们希望使用数字序列进行遍历，可以使用 Python 内置的 range 函数：

 
 
 
    
  
  
  
  1. a = ['Mary', 'had', 'a', 'little', 'lamb']
    2. 
  
  
  
  2. 
  
  
  
  3. for i in range(len(a)):
    4. 
  
  
  
  4.     print(i, a[i])
    5.

基本数据类型

可以使用内建函数进行强制类型转换（Casting）:

 
 
 
    
  
  
  
  1. int(str)
    2. 
  
  
  
  2. float(str)
    3. 
  
  
  
  3. str(int)
    4. 
  
  
  
  4. str(float)
    5.

Number: 数值类型

 
 
 
    
  
  
  
  1. x = 3
    2. 
  
  
  
  2. print type(x) # Prints ""
    3. 
  
  
  
  3. print x       # Prints "3"
    4. 
  
  
  
  4. print x + 1   # Addition; prints "4"
    5. 
  
  
  
  5. print x - 1   # Subtraction; prints "2"
    6. 
  
  
  
  6. print x * 2   # Multiplication; prints "6"
    7. 
  
  
  
  7. print x ** 2  # Exponentiation; prints "9"
    8. 
  
  
  
  8. x += 1
    9. 
  
  
  
  9. print x  # Prints "4"
    10. 
  
  
  
  10. x *= 2
    11. 
  
  
  
  11. print x  # Prints "8"
    12. 
  
  
  
  12. y = 2.5
    13. 
  
  
  
  13. print type(y) # Prints ""
    14. 
  
  
  
  14. print y, y + 1, y * 2, y ** 2 # Prints "2.5 3.5 5.0 6.25"
    15.

布尔类型

Python 提供了常见的逻辑操作符，不过需要注意的是 Python 中并没有使用 &&、|| 等，而是直接使用了英文单词。

 
 
 
    
  
  
  
  1. t = True
    2. 
  
  
  
  2. f = False
    3. 
  
  
  
  3. print type(t) # Prints ""
    4. 
  
  
  
  4. print t and f # Logical AND; prints "False"
    5. 
  
  
  
  5. print t or f  # Logical OR; prints "True"
    6. 
  
  
  
  6. print not t   # Logical NOT; prints "False"
    7. 
  
  
  
  7. print t != f  # Logical XOR; prints "True" 
    8.

String: 字符串

Python 2 中支持 Ascii 码的 str() 类型，独立的 unicode() 类型，没有 byte 类型；而 Python 3 中默认的字符串为 utf-8 类型，并且包含了 byte 与 bytearray 两个字节类型：

 
 
 
    
  
  
  
  1. type("Guido") # string type is str in python2
    2. 
  
  
  
  2. # 
    3. 
  
  
  
  3. 
  
  
  
  4. # 使用 __future__ 中提供的模块来降级使用 Unicode
    5. 
  
  
  
  5. from __future__ import unicode_literals
    6. 
  
  
  
  6. type("Guido") # string type become unicode
    7. 
  
  
  
  7. # 
    8.

Python 字符串支持分片、模板字符串等常见操作:

 
 
 
    
  
  
  
  1. var1 = 'Hello World!'
    2. 
  
  
  
  2. var2 = "Python Programming"
    3. 
  
  
  
  3. 
  
  
  
  4. print "var1[0]: ", var1[0]
    5. 
  
  
  
  5. print "var2[1:5]: ", var2[1:5]
    6. 
  
  
  
  6. # var1[0]:  H
    7. 
  
  
  
  7. # var2[1:5]:  ytho
    8. 
  
  
  
  8. 
  
  
  
  9. print "My name is %s and weight is %d kg!" % ('Zara', 21)
    10. 
  
  
  
  10. # My name is Zara and weight is 21 kg!
    11. 
  
  
  
  11. str[0:4]
    12. 
  
  
  
  12. len(str)
    13. 
  
  
  
  13. 
  
  
  
  14. string.replace("-", " ")
    15. 
  
  
  
  15. ",".join(list)
    16. 
  
  
  
  16. "hi {0}".format('j')
    17. 
  
  
  
  17. str.find(",")
    18. 
  
  
  
  18. str.index(",")   # same, but raises IndexError
    19. 
  
  
  
  19. str.count(",")
    20. 
  
  
  
  20. str.split(",")
    21. 
  
  
  
  21. 
  
  
  
  22. str.lower()
    23. 
  
  
  
  23. str.upper()
    24. 
  
  
  
  24. str.title()
    25. 
  
  
  
  25. 
  
  
  
  26. str.lstrip()
    27. 
  
  
  
  27. str.rstrip()
    28. 
  
  
  
  28. str.strip()
    29. 
  
  
  
  29. 
  
  
  
  30. str.islower()
    31. 
  
  
  
  31. # 移除所有的特殊字符
    32. 
  
  
  
  32. re.sub('[^A-Za-z0-9]+', '', mystring) 
    33.

如果需要判断是否包含某个子字符串，或者搜索某个字符串的下标:

 
 
 
    
  
  
  
  1. # in 操作符可以判断字符串
    2. 
  
  
  
  2. if "blah" not in somestring: 
    3. 
  
  
  
  3.     continue
    4. 
  
  
  
  4. 
  
  
  
  5. # find 可以搜索下标
    6. 
  
  
  
  6. s = "This be a string"
    7. 
  
  
  
  7. if s.find("is") == -1:
    8. 
  
  
  
  8.     print "No 'is' here!"
    9. 
  
  
  
  9. else:
    10. 
  
  
  
  10.     print "Found 'is' in the string."
    11.

Regex: 正则表达式

 
 
 
    
  
  
  
  1. import re
    2. 
  
  
  
  2. 
  
  
  
  3. # 判断是否匹配
    4. 
  
  
  
  4. re.match(r'^[aeiou]', str)
    5. 
  
  
  
  5. 
  
  
  
  6. # 以第二个参数指定的字符替换原字符串中内容
    7. 
  
  
  
  7. re.sub(r'^[aeiou]', '?', str)
    8. 
  
  
  
  8. re.sub(r'(xyz)', r'\1', str)
    9. 
  
  
  
  9. 
  
  
  
  10. # 编译生成独立的正则表达式对象
    11. 
  
  
  
  11. expr = re.compile(r'^...$')
    12. 
  
  
  
  12. expr.match(...)
    13. 
  
  
  
  13. expr.sub(...)
    14.

下面列举了常见的表达式使用场景:

 
 
 
    
  
  
  
  1. # 检测是否为 HTML 标签
    2. 
  
  
  
  2. re.search('<[^/>][^>]*>', '')
    3. 
  
  
  
  3. 
  
  
  
  4. # 常见的用户名密码
    5. 
  
  
  
  5. re.match('^[a-zA-Z0-9-_]{3,16}$', 'Foo') is not None
    6. 
  
  
  
  6. re.match('^\w|[-_]{3,16}$', 'Foo') is not None
    7. 
  
  
  
  7. 
  
  
  
  8. # Email
    9. 
  
  
  
  9. re.match('^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$', 'hello.world@cdxwcx.com')
    10. 
  
  
  
  10. 
  
  
  
  11. # Url
    12. 
  
  
  
  12. exp = re.compile(r'''^(https?:\/\/)? # match http or https
    13. 
  
  
  
  13.                 ([\da-z\.-]+)            # match domain
    14. 
  
  
  
  14.                 \.([a-z\.]{2,6})         # match domain
    15. 
  
  
  
  15.                 ([\/\w \.-]*)\/?$        # match api or file
    16. 
  
  
  
  16.                 ''', re.X)
    17. 
  
  
  
  17. exp.match('www.google.com')
    18. 
  
  
  
  18. 
  
  
  
  19. # IP 地址
    20. 
  
  
  
  20. exp = re.compile(r'''^(?:(?:25[0-5]
    21. 
  
  
  
  21.                      |2[0-4][0-9]
    22. 
  
  
  
  22.                      |[1]?[0-9][0-9]?)\.){3}
    23. 
  
  
  
  23.                      (?:25[0-5]
    24. 
  
  
  
  24.                      |2[0-4][0-9]
    25. 
  
  
  
  25.                      |[1]?[0-9][0-9]?)$''', re.X)
    26. 
  
  
  
  26. exp.match('192.168.1.1')
    27.

集合类型

List: 列表

Operation: 创建增删

 
 
 
    
  
  
  
  1. l = []
    2. 
  
  
  
  2. l = list()
    3. 
  
  
  
  3. 
  
  
  
  4. # 使用字符串的 split 方法，可以将字符串转化为列表
    5. 
  
  
  
  5. str.split(".")
    6. 
  
  
  
  6. 
  
  
  
  7. # 如果需要将数组拼装为字符串，则可以使用 join 
    8. 
  
  
  
  8. list1 = ['1', '2', '3']
    9. 
  
  
  
  9. str1 = ''.join(list1)
    10. 
  
  
  
  10. 
  
  
  
  11. # 如果是数值数组，则需要先进行转换
    12. 
  
  
  
  12. list1 = [1, 2, 3]
    13. 
  
  
  
  13. str1 = ''.join(str(e) for e in list1)
    14.

可以使用 append 与 extend 向数组中插入元素或者进行数组连接

 
 
 
    
  
  
  
  1. x = [1, 2, 3]
    2. 
  
  
  
  2. 
  
  
  
  3. x.append([4, 5]) # [1, 2, 3, [4, 5]]
    4. 
  
  
  
  4. 
  
  
  
  5. x.extend([4, 5]) # [1, 2, 3, 4, 5]，注意 extend 返回值为 None
    6.

可以使用 pop、slices、del、remove 等移除列表中元素：

 
 
 
    
  
  
  
  1. myList = [10,20,30,40,50]
    2. 
  
  
  
  2. 
  
  
  
  3. # 弹出第二个元素
    4. 
  
  
  
  4. myList.pop(1) # 20
    5. 
  
  
  
  5. # myList: myList.pop(1)
    6. 
  
  
  
  6. 
  
  
  
  7. # 如果不加任何参数，则默认弹出***一个元素
    8. 
  
  
  
  8. myList.pop()
    9. 
  
  
  
  9. 
  
  
  
  10. # 使用 slices 来删除某个元素
    11. 
  
  
  
  11. a = [  1, 2, 3, 4, 5, 6 ]
    12. 
  
  
  
  12. index = 3 # Only Positive index
    13. 
  
  
  
  13. a = a[:index] + a[index+1 :]
    14. 
  
  
  
  14. 
  
  
  
  15. # 根据下标删除元素
    16. 
  
  
  
  16. myList = [10,20,30,40,50]
    17. 
  
  
  
  17. rmovIndxNo = 3
    18. 
  
  
  
  18. del myList[rmovIndxNo] # myList: [10, 20, 30, 50]
    19. 
  
  
  
  19. 
  
  
  
  20. # 使用 remove 方法，直接根据元素删除
    21. 
  
  
  
  21. letters = ["a", "b", "c", "d", "e"]
    22. 
  
  
  
  22. numbers.remove(numbers[1])
    23. 
  
  
  
  23. print(*letters) # used a * to make it unpack you don't have to
    24.

Iteration: 索引遍历

你可以使用基本的 for 循环来遍历数组中的元素，就像下面介个样纸:

 
 
 
    
  
  
  
  1. animals = ['cat', 'dog', 'monkey']
    2. 
  
  
  
  2. for animal in animals:
    3. 
  
  
  
  3.     print animal
    4. 
  
  
  
  4. # Prints "cat", "dog", "monkey", each on its own line.
    5.

如果你在循环的同时也希望能够获取到当前元素下标，可以使用 enumerate 函数:

 
 
 
    
  
  
  
  1. animals = ['cat', 'dog', 'monkey']
    2. 
  
  
  
  2. for idx, animal in enumerate(animals):
    3. 
  
  
  
  3.     print '#%d: %s' % (idx + 1, animal)
    4. 
  
  
  
  4. # Prints "#1: cat", "#2: dog", "#3: monkey", each on its own line
    5.

Python 也支持切片（Slices）:

 
 
 
    
  
  
  
  1. nums = range(5)    # range is a built-in function that creates a list of integers
    2. 
  
  
  
  2. print nums         # Prints "[0, 1, 2, 3, 4]"
    3. 
  
  
  
  3. print nums[2:4]    # Get a slice from index 2 to 4 (exclusive); prints "[2, 3]"
    4. 
  
  
  
  4. print nums[2:]     # Get a slice from index 2 to the end; prints "[2, 3, 4]"
    5. 
  
  
  
  5. print nums[:2]     # Get a slice from the start to index 2 (exclusive); prints "[0, 1]"
    6. 
  
  
  
  6. print nums[:]      # Get a slice of the whole list; prints ["0, 1, 2, 3, 4]"
    7. 
  
  
  
  7. print nums[:-1]    # Slice indices can be negative; prints ["0, 1, 2, 3]"
    8. 
  
  
  
  8. nums[2:4] = [8, 9] # Assign a new sublist to a slice
    9. 
  
  
  
  9. print nums         # Prints "[0, 1, 8, 9, 4]"
    10.

Comprehensions: 变换

Python 中同样可以使用 map、reduce、filter，map 用于变换数组:

 
 
 
    
  
  
  
  1. # 使用 map 对数组中的每个元素计算平方
    2. 
  
  
  
  2. items = [1, 2, 3, 4, 5]
    3. 
  
  
  
  3. squared = list(map(lambda x: x**2, items))
    4. 
  
  
  
  4. 
  
  
  
  5. # map 支持函数以数组方式连接使用
    6. 
  
  
  
  6. def multiply(x):
    7. 
  
  
  
  7.     return (x*x)
    8. 
  
  
  
  8. def add(x):
    9. 
  
  
  
  9.     return (x+x)
    10. 
  
  
  
  10. 
  
  
  
  11. funcs = [multiply, add]
    12. 
  
  
  
  12. for i in range(5):
    13. 
  
  
  
  13.     value = list(map(lambda x: x(i), funcs))
    14. 
  
  
  
  14.     print(value)
    15.

reduce 用于进行归纳计算:

 
 
 
    
  
  
  
  1. # reduce 将数组中的值进行归纳
    2. 
  
  
  
  2. 
  
  
  
  3. from functools import reduce
    4. 
  
  
  
  4. product = reduce((lambda x, y: x * y), [1, 2, 3, 4])
    5. 
  
  
  
  5. 
  
  
  
  6. # Output: 24
    7.

filter 则可以对数组进行过滤:

 
 
 
    
  
  
  
  1. number_list = range(-5, 5)
    2. 
  
  
  
  2. less_than_zero = list(filter(lambda x: x < 0, number_list))
    3. 
  
  
  
  3. print(less_than_zero)
    4. 
  
  
  
  4. 
  
  
  
  5. # Output: [-5, -4, -3, -2, -1]
    6.

字典类型

创建增删

 
 
 
    
  
  
  
  1. d = {'cat': 'cute', 'dog': 'furry'}  # 创建新的字典
    2. 
  
  
  
  2. print d['cat']       # 字典不支持点（Dot）运算符取值
    3.

如果需要合并两个或者多个字典类型：

 
 
 
    
  
  
  
  1. # python 3.5
    2. 
  
  
  
  2. z = {**x, **y}
    3. 
  
  
  
  3. 
  
  
  
  4. # python 2.7
    5. 
  
  
  
  5. def merge_dicts(*dict_args):
    6. 
  
  
  
  6.     """
    7. 
  
  
  
  7.     Given any number of dicts, shallow copy and merge into a new dict,
    8. 
  
  
  
  8.     precedence goes to key value pairs in latter dicts.
    9. 
  
  
  
  9.     """
    10. 
  
  
  
  10.     result = {}
    11. 
  
  
  
  11.     for dictionary in dict_args:
    12. 
  
  
  
  12.         result.update(dictionary)
    13. 
  
  
  
  13.     return result
    14.

索引遍历

可以根据键来直接进行元素访问:

 
 
 
    
  
  
  
  1. # Python 中对于访问不存在的键会抛出 KeyError 异常，需要先行判断或者使用 get
    2. 
  
  
  
  2. print 'cat' in d     # Check if a dictionary has a given key; prints "True"
    3. 
  
  
  
  3. 
  
  
  
  4. # 如果直接使用 [] 来取值，需要先确定键的存在，否则会抛出异常
    5. 
  
  
  
  5. print d['monkey']  # KeyError: 'monkey' not a key of d
    6. 
  
  
  
  6. 
  
  
  
  7. # 使用 get 函数则可以设置默认值
    8. 
  
  
  
  8. print d.get('monkey', 'N/A')  # Get an element with a default; prints "N/A"
    9. 
  
  
  
  9. print d.get('fish', 'N/A')    # Get an element with a default; prints "wet"
    10. 
  
  
  
  10. 
  
  
  
  11. 
  
  
  
  12. d.keys() # 使用 keys 方法可以获取所有的键
    13.

可以使用 for-in 来遍历数组:

 
 
 
    
  
  
  
  1. # 遍历键
    2. 
  
  
  
  2. for key in d:
    3. 
  
  
  
  3. 
  
  
  
  4. # 比前一种方式慢
    5. 
  
  
  
  5. for k in dict.keys(): ...
    6. 
  
  
  
  6. 
  
  
  
  7. # 直接遍历值
    8. 
  
  
  
  8. for value in dict.itervalues(): ...
    9. 
  
  
  
  9. 
  
  
  
  10. # Python 2.x 中遍历键值
    11. 
  
  
  
  11. for key, value in d.iteritems():
    12. 
  
  
  
  12. 
  
  
  
  13. # Python 3.x 中遍历键值
    14. 
  
  
  
  14. for key, value in d.items():
    15.

其他序列类型

集合

 
 
 
    
  
  
  
  1. # Same as {"a", "b","c"}
    2. 
  
  
  
  2. normal_set = set(["a", "b","c"])
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4. # Adding an element to normal set is fine
    5. 
  
  
  
  5. normal_set.add("d")
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7. print("Normal Set")
    8. 
  
  
  
  8. print(normal_set)
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10. # A frozen set
    11. 
  
  
  
  11. frozen_set = frozenset(["e", "f", "g"])
    12. 
  
  
  
  12.  
    13. 
  
  
  
  13. print("Frozen Set")
    14. 
  
  
  
  14. print(frozen_set)
    15. 
  
  
  
  15.  
    16. 
  
  
  
  16. # Uncommenting below line would cause error as
    17. 
  
  
  
  17. # we are trying to add element to a frozen set
    18. 
  
  
  
  18. # frozen_set.add("h")
    19.

函数

函数定义

Python 中的函数使用 def 关键字进行定义，譬如:

 
 
 
    
  
  
  
  1. def sign(x):
    2. 
  
  
  
  2.     if x > 0:
    3. 
  
  
  
  3.         return 'positive'
    4. 
  
  
  
  4.     elif x < 0:
    5. 
  
  
  
  5.         return 'negative'
    6. 
  
  
  
  6.     else:
    7. 
  
  
  
  7.         return 'zero'
    8. 
  
  
  
  8. 
  
  
  
  9. 
  
  
  
  10. for x in [-1, 0, 1]:
    11. 
  
  
  
  11.     print sign(x)
    12. 
  
  
  
  12. # Prints "negative", "zero", "positive"
    13.

Python 支持运行时创建动态函数，也即是所谓的 lambda 函数：

 
 
 
    
  
  
  
  1. def f(x): return x**2
    2. 
  
  
  
  2. 
  
  
  
  3. # 等价于
    4. 
  
  
  
  4. g = lambda x: x**2
    5.

参数

Option Arguments: 不定参数

 
 
 
    
  
  
  
  1. def example(a, b=None, *args, **kwargs):
    2. 
  
  
  
  2.   print a, b
    3. 
  
  
  
  3.   print args
    4. 
  
  
  
  4.   print kwargs
    5. 
  
  
  
  5. 
  
  
  
  6. example(1, "var", 2, 3, word="hello")
    7. 
  
  
  
  7. # 1 var
    8. 
  
  
  
  8. # (2, 3)
    9. 
  
  
  
  9. # {'word': 'hello'}
    10. 
  
  
  
  10. 
  
  
  
  11. a_tuple = (1, 2, 3, 4, 5)
    12. 
  
  
  
  12. a_dict = {"1":1, "2":2, "3":3}
    13. 
  
  
  
  13. example(1, "var", *a_tuple, **a_dict)
    14. 
  
  
  
  14. # 1 var
    15. 
  
  
  
  15. # (1, 2, 3, 4, 5)
    16. 
  
  
  
  16. # {'1': 1, '2': 2, '3': 3}
    17.

生成器

 
 
 
    
  
  
  
  1. def simple_generator_function():
    2. 
  
  
  
  2.     yield 1
    3. 
  
  
  
  3.     yield 2
    4. 
  
  
  
  4.     yield 3
    5. 
  
  
  
  5. 
  
  
  
  6. for value in simple_generator_function():
    7. 
  
  
  
  7.     print(value)
    8. 
  
  
  
  8. 
  
  
  
  9. # 输出结果
    10. 
  
  
  
  10. # 1
    11. 
  
  
  
  11. # 2
    12. 
  
  
  
  12. # 3
    13. 
  
  
  
  13. our_generator = simple_generator_function()
    14. 
  
  
  
  14. next(our_generator)
    15. 
  
  
  
  15. # 1
    16. 
  
  
  
  16. next(our_generator)
    17. 
  
  
  
  17. # 2
    18. 
  
  
  
  18. next(our_generator)
    19. 
  
  
  
  19. #3
    20. 
  
  
  
  20. 
  
  
  
  21. # 生成器典型的使用场景譬如***数组的迭代
    22. 
  
  
  
  22. def get_primes(number):
    23. 
  
  
  
  23.     while True:
    24. 
  
  
  
  24.         if is_prime(number):
    25. 
  
  
  
  25.             yield number
    26. 
  
  
  
  26.         number += 1
    27.

装饰器

装饰器是非常有用的设计模式:

 
 
 
    
  
  
  
  1. # 简单装饰器
    2. 
  
  
  
  2. 
  
  
  
  3. from functools import wraps
    4. 
  
  
  
  4. def decorator(func):
    5. 
  
  
  
  5.     @wraps(func)
    6. 
  
  
  
  6.     def wrapper(*args, **kwargs):
    7. 
  
  
  
  7.         print('wrap function')
    8. 
  
  
  
  8.         return func(*args, **kwargs)
    9. 
  
  
  
  9.     return wrapper
    10. 
  
  
  
  10. 
  
  
  
  11. @decorator
    12. 
  
  
  
  12. def example(*a, **kw):
    13. 
  
  
  
  13.     pass
    14. 
  
  
  
  14. 
  
  
  
  15. example.__name__  # attr of function preserve
    16. 
  
  
  
  16. # 'example'
    17. 
  
  
  
  17. # Decorator 
    18. 
  
  
  
  18. 
  
  
  
  19. # 带输入值的装饰器
    20. 
  
  
  
  20. 
  
  
  
  21. from functools import wraps
    22. 
  
  
  
  22. def decorator_with_argument(val):
    23. 
  
  
  
  23.   def decorator(func):
    24. 
  
  
  
  24.     @wraps(func)
    25. 
  
  
  
  25.     def wrapper(*args, **kwargs):
    26. 
  
  
  
  26.       print "Val is {0}".format(val)
    27. 
  
  
  
  27.       return func(*args, **kwargs)
    28. 
  
  
  
  28.     return wrapper
    29. 
  
  
  
  29.   return decorator
    30. 
  
  
  
  30. 
  
  
  
  31. @decorator_with_argument(10)
    32. 
  
  
  
  32. def example():
    33. 
  
  
  
  33.   print "This is example function."
    34. 
  
  
  
  34. 
  
  
  
  35. example()
    36. 
  
  
  
  36. # Val is 10
    37. 
  
  
  
  37. # This is example function.
    38. 
  
  
  
  38. 
  
  
  
  39. # 等价于
    40. 
  
  
  
  40. 
  
  
  
  41. def example():
    42. 
  
  
  
  42.   print "This is example function."
    43. 
  
  
  
  43. 
  
  
  
  44. example = decorator_with_argument(10)(example)
    45. 
  
  
  
  45. example()
    46. 
  
  
  
  46. # Val is 10
    47. 
  
  
  
  47. # This is example function.
    48.

类与对象

类定义

Python 中对于类的定义也很直接:

 
 
 
    
  
  
  
  1. class Greeter(object):
    2. 
  
  
  
  2.     
    3. 
  
  
  
  3.     # Constructor
    4. 
  
  
  
  4.     def __init__(self, name):
    5. 
  
  
  
  5.         self.name = name  # Create an instance variable
    6. 
  
  
  
  6.         
    7. 
  
  
  
  7.     # Instance method
    8. 
  
  
  
  8.     def greet(self, loud=False):
    9. 
  
  
  
  9.         if loud:
    10. 
  
  
  
  10.             print 'HELLO, %s!' % self.name.upper()
    11. 
  
  
  
  11.         else:
    12. 
  
  
  
  12.             print 'Hello, %s' % self.name
    13. 
  
  
  
  13.         
    14. 
  
  
  
  14. g = Greeter('Fred')  # Construct an instance of the Greeter class
    15. 
  
  
  
  15. g.greet()            # Call an instance method; prints "Hello, Fred"
    16. 
  
  
  
  16. g.greet(loud=True)   # Call an instance method; prints "HELLO, FRED!"
    17. 
  
  
  
  17. # isinstance 方法用于判断某个对象是否源自某个类
    18. 
  
  
  
  18. ex = 10
    19. 
  
  
  
  19. isinstance(ex,int)
    20.

Managed Attributes: 受控属性

 
 
 
    
  
  
  
  1. # property、setter、deleter 可以用于复写点方法
    2. 
  
  
  
  2. 
  
  
  
  3. class Example(object):
    4. 
  
  
  
  4.     def __init__(self, value):
    5. 
  
  
  
  5.        self._val = value
    6. 
  
  
  
  6.     @property
    7. 
  
  
  
  7.     def val(self):
    8. 
  
  
  
  8.         return self._val
    9. 
  
  
  
  9.     @val.setter
    10. 
  
  
  
  10.     def val(self, value):
    11. 
  
  
  
  11.         if not isintance(value, int):
    12. 
  
  
  
  12.             raise TypeError("Expected int")
    13. 
  
  
  
  13.         self._val = value
    14. 
  
  
  
  14.     @val.deleter
    15. 
  
  
  
  15.     def val(self):
    16. 
  
  
  
  16.         del self._val
    17. 
  
  
  
  17.     @property
    18. 
  
  
  
  18.     def square3(self):
    19. 
  
  
  
  19.         return 2**3
    20. 
  
  
  
  20. 
  
  
  
  21. ex = Example(123)
    22. 
  
  
  
  22. ex.val = "str"
    23. 
  
  
  
  23. # Traceback (most recent call last):
    24. 
  
  
  
  24. #   File "", line 1, in
    25. 
  
  
  
  25. #   File "test.py", line 12, in val
    26. 
  
  
  
  26. #     raise TypeError("Expected int")
    27. 
  
  
  
  27. # TypeError: Expected int
    28.

类方法与静态方法

 
 
 
    
  
  
  
  1. class example(object):
    2. 
  
  
  
  2.   @classmethod
    3. 
  
  
  
  3.   def clsmethod(cls):
    4. 
  
  
  
  4.     print "I am classmethod"
    5. 
  
  
  
  5.   @staticmethod
    6. 
  
  
  
  6.   def stmethod():
    7. 
  
  
  
  7. 
                新闻名称：Python语法速览与实战清单
                
    
                网站网址：http://www.csdahua.cn/qtweb/news20/405170.html
            
    
            
    
                网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                快上网

成都快上网为您推荐相关内容

网站排名知识

各行业网站

成都富士康招工　　 　重庆网站建设　　 　四川成都网站制作　　 　网站推广　　 　腾讯云香港虚拟主机　　 　成都SEO优化公司　　 　背发光字　　 　网站运营　　 　青羊区雕琢时光　　 　泸州洋跃建站　　 　成都小程序开发公司　　 　成都高电机柜租用　　 　微信公众号开发　　 　成都网站设计公司　　 　创新互联　　 　明安消防器材　　 　南充网站制作　　 　虚拟主机　　 　成都网站推广公司　　 　成都网络公司