人生苦短，请用 Python，大量功能强大的语法糖的同时让很多时候 Python 代码看上去有点像伪代码。譬如我们用 Python 实现的简易的快排相较于 Java 会显得很短小精悍:
控制台交互
可以根据 __name__ 关键字来判断是否是直接使用 python 命令执行某个脚本，还是外部引用；Google 开源的 fire 也是不错的快速将某个类封装为命令行工具的框架：
私信小编007 即可获取数十套PDF以及大量的教学视频！其中包括此篇教程的教学教程！
Python 2 中 print 是表达式，而 Python 3 中 print 是函数；如果希望在 Python 2 中将 print 以函数方式使用，则需要自定义引入:
from __future__ import print_function
我们也可以使用 pprint 来美化控制台输出内容：
import pprint
stuff = ['spam', 'eggs', 'lumberjack', 'knights', 'ni']
pprint.pprint(stuff)
# 自定义参数
pp = pprint.PrettyPrinter(depth=6)
tup = ('spam', ('eggs', ('lumberjack', ('knights', ('ni', ('dead',('parrot', ('fresh fruit',))))))))
pp.pprint(tup)
模块
Python
中的模块（Module）即是 Python
源码文件，其可以导出类、函数与全局变量；当我们从某个模块导入变量时，函数名往往就是命名空间（Namespace）。而 Python
中的包（Package）则是模块的文件夹，往往由 __init__.py 指明某个文件夹为包:
Package 可以为某个目录下所有的文件设置统一入口:
表达式与控制流
条件选择
Python 中使用 if、elif、else 来进行基础的条件选择操作：
if x < 0:
x = 0
print('Negative changed to zero')
elif x == 0:
print('Zero')
else:
print('More')
Python 同样支持 ternary conditional operator:
a if condition else b
也可以使用 Tuple 来实现类似的效果：
# test 需要返回 True 或者 False
(falseValue, trueValue)[test]
# 更安全的做法是进行强制判断
(falseValue, trueValue)[test == True]
# 或者使用 bool 类型转换函数
(falseValue, trueValue)[bool()]
循环遍历
for-in 可以用来遍历数组与字典：
words = ['cat', 'window', 'defenestrate']
for w in words:
print(w, len(w))
# 使用数组访问操作符，能够迅速地生成数组的副本
for w in words[:]:
if len(w) > 6:
words.insert(0, w)
# words -> ['defenestrate', 'cat', 'window', 'defenestrate']
如果我们希望使用数字序列进行遍历，可以使用 Python 内置的 range 函数：
a = ['Mary', 'had', 'a', 'little', 'lamb']
for i in range(len(a)):
print(i, a[i])
基本数据类型
可以使用内建函数进行强制类型转换（Casting）:
int(str)
float(str)
str(int)
str(float)
Number: 数值类型
x = 3
print type(x) # Prints ""
print x # Prints "3"
print x + 1 # Addition; prints "4"
print x - 1 # Subtraction; prints "2"
print x * 2 # Multiplication; prints "6"
print x ** 2 # Exponentiation; prints "9"
x += 1
print x # Prints "4"
x *= 2
print x # Prints "8"
y = 2.5
print type(y) # Prints ""
print y, y + 1, y * 2, y ** 2 # Prints "2.5 3.5 5.0 6.25"
布尔类型
Python 提供了常见的逻辑操作符，不过需要注意的是 Python 中并没有使用 &&、|| 等，而是直接使用了英文单词。
t = True
f = False
print type(t) # Prints ""
print t and f # Logical AND; prints "False"
print t or f # Logical OR; prints "True"
print not t # Logical NOT; prints "False"
print t != f # Logical XOR; prints "True"
String: 字符串
Python 2 中支持 Ascii 码的 str() 类型，独立的 unicode() 类型，没有 byte 类型；而 Python 3 中默认的字符串为 utf-8 类型，并且包含了 byte 与 bytearray 两个字节类型：
type("Guido") # string type is str in python2
#
# 使用 __future__ 中提供的模块来降级使用 Unicode
from __future__ import unicode_literals
type("Guido") # string type become unicode
#
Python 字符串支持分片、模板字符串等常见操作:
var1 = 'Hello World!'
var2 = "Python Programming"
print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]
# var1[0]: H
# var2[1:5]: ytho
print "My name is %s and weight is %d kg!" % ('Zara', 21)
# My name is Zara and weight is 21 kg!
str[0:4]
len(str)
string.replace("-", " ")
",".join(list)
"hi {0}".format('j')
str.find(",")
str.index(",") # same, but raises IndexError
str.count(",")
str.split(",")
str.lower()
str.upper()
str.title()
str.lstrip()
str.rstrip()
str.strip()
str.islower()
# 移除所有的特殊字符
re.sub('[^A-Za-z0-9]+', '', mystring)
如果需要判断是否包含某个子字符串，或者搜索某个字符串的下标:
# in 操作符可以判断字符串
if "blah" not in somestring:
continue
# find 可以搜索下标
s = "This be a string"
if s.find("is") == -1:
print "No 'is' here!"
else:
print "Found 'is' in the string."
Regex: 正则表达式
import re
# 判断是否匹配
re.match(r'^[aeiou]', str)
# 以第二个参数指定的字符替换原字符串中内容
re.sub(r'^[aeiou]', '?', str)
re.sub(r'(xyz)', r'', str)
# 编译生成独立的正则表达式对象
expr = re.compile(r'^...$')
expr.match(...)
expr.sub(...)
下面列举了常见的表达式使用场景:
# 检测是否为 HTML 标签
re.search('][^>]*>', '')
# 常见的用户名密码
re.match('^[a-zA-Z0-9-_]{3,16}$', 'Foo') is not None
re.match('^w|[-_]{3,16}$', 'Foo') is not None
# Email
re.match('^([a-z0-9_.-]+)@([da-z.-]+).([a-z.]{2,6})$', '[email protected]')
# Url
exp = re.compile(r'''^(https?://)? # match http or https
([da-z.-]+) # match domain
.([a-z.]{2,6}) # match domain
([/w .-]*)/?$ # match api or file
''', re.X)
exp.match('www.google.com')
# IP 地址
exp = re.compile(r'''^(?:(?:25[0-5]
|2[0-4][0-9]
|[1]?[0-9][0-9]?).){3}
(?:25[0-5]
|2[0-4][0-9]
|[1]?[0-9][0-9]?)$''', re.X)
exp.match('192.168.1.1')
集合类型
List: 列表
Operation: 创建增删
list 是基础的序列类型：
l = []
l = list()
# 使用字符串的 split 方法，可以将字符串转化为列表
str.split(".")
# 如果需要将数组拼装为字符串，则可以使用 join
list1 = ['1', '2', '3']
str1 = ''.join(list1)
# 如果是数值数组，则需要先进行转换
list1 = [1, 2, 3]
str1 = ''.join(str(e) for e in list1)
可以使用 append 与 extend 向数组中插入元素或者进行数组连接
x = [1, 2, 3]
x.append([4, 5]) # [1, 2, 3, [4, 5]]
x.extend([4, 5]) # [1, 2, 3, 4, 5]，注意 extend 返回值为 None
可以使用 pop、slices、del、remove 等移除列表中元素：
myList = [10,20,30,40,50]
# 弹出第二个元素
myList.pop(1) # 20
# myList: myList.pop(1)
# 如果不加任何参数，则默认弹出最后一个元素
myList.pop()
# 使用 slices 来删除某个元素
a = [ 1, 2, 3, 4, 5, 6 ]
index = 3 # Only Positive index
a = a[:index] + a[index+1 :]
# 根据下标删除元素
myList = [10,20,30,40,50]
rmovIndxNo = 3
del myList[rmovIndxNo] # myList: [10, 20, 30, 50]
# 使用 remove 方法，直接根据元素删除
letters = ["a", "b", "c", "d", "e"]
numbers.remove(numbers[1])
print(*letters) # used a * to make it unpack you don't have to
Iteration: 索引遍历
你可以使用基本的 for 循环来遍历数组中的元素，就像下面介个样纸:
animals = ['cat', 'dog', 'monkey']
for animal in animals:
print animal
# Prints "cat", "dog", "monkey", each on its own line.
如果你在循环的同时也希望能够获取到当前元素下标，可以使用 enumerate 函数:
animals = ['cat', 'dog', 'monkey']
for idx, animal in enumerate(animals):
print '#%d: %s' % (idx + 1, animal)
# Prints "#1: cat", "#2: dog", "#3: monkey", each on its own line
Python 也支持切片（Slices）:
nums = range(5) # range is a built-in function that creates a list of integers
print nums # Prints "[0, 1, 2, 3, 4]"
print nums[2:4] # Get a slice from index 2 to 4 (exclusive); prints "[2, 3]"
print nums[2:] # Get a slice from index 2 to the end; prints "[2, 3, 4]"
print nums[:2] # Get a slice from the start to index 2 (exclusive); prints "[0, 1]"
print nums[:] # Get a slice of the whole list; prints ["0, 1, 2, 3, 4]"
print nums[:-1] # Slice indices can be negative; prints ["0, 1, 2, 3]"
nums[2:4] = [8, 9] # Assign a new sublist to a slice
print nums # Prints "[0, 1, 8, 9, 4]"
Comprehensions: 变换
Python 中同样可以使用 map、reduce、filter，map 用于变换数组:
# 使用 map 对数组中的每个元素计算平方
items = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, items))
# map 支持函数以数组方式连接使用
def multiply(x):
return (x*x)
def add(x):
return (x+x)
funcs = [multiply, add]
for i in range(5):
value = list(map(lambda x: x(i), funcs))
print(value)
reduce 用于进行归纳计算:
# reduce 将数组中的值进行归纳
from functools import reduce
product = reduce((lambda x, y: x * y), [1, 2, 3, 4])
# Output: 24
filter 则可以对数组进行过滤:
number_list = range(-5, 5)
less_than_zero = list(filter(lambda x: x < 0, number_list))
print(less_than_zero)
# Output: [-5, -4, -3, -2, -1]
字典类型
创建增删
d = {'cat': 'cute', 'dog': 'furry'} # 创建新的字典
print d['cat'] # 字典不支持点（Dot）运算符取值
如果需要合并两个或者多个字典类型：
# python 3.5
z = {**x, **y}
# python 2.7
def merge_dicts(*dict_args):
"""
Given any number of dicts, shallow copy and merge into a new dict,
precedence goes to key value pairs in latter dicts.
"""
result = {}
for dictionary in dict_args:
result.update(dictionary)
return result
索引遍历
可以根据键来直接进行元素访问:
# Python 中对于访问不存在的键会抛出 KeyError 异常，需要先行判断或者使用 get
print 'cat' in d # Check if a dictionary has a given key; prints "True"
# 如果直接使用 [] 来取值，需要先确定键的存在，否则会抛出异常
print d['monkey'] # KeyError: 'monkey' not a key of d
# 使用 get 函数则可以设置默认值
print d.get('monkey', 'N/A') # Get an element with a default; prints "N/A"
print d.get('fish', 'N/A') # Get an element with a default; prints "wet"
d.keys() # 使用 keys 方法可以获取所有的键
可以使用 for-in 来遍历数组:
# 遍历键
for key in d:
# 比前一种方式慢
for k in dict.keys(): ...
# 直接遍历值
for value in dict.itervalues(): ...
# Python 2.x 中遍历键值
for key, value in d.iteritems():
# Python 3.x 中遍历键值
for key, value in d.items():
其他序列类型
集合
# Same as {"a", "b","c"}
normal_set = set(["a", "b","c"])
# Adding an element to normal set is fine
normal_set.add("d")
print("Normal Set")
print(normal_set)
# A frozen set
frozen_set = frozenset(["e", "f", "g"])
print("Frozen Set")
print(frozen_set)
# Uncommenting below line would cause error as
# we are trying to add element to a frozen set
# frozen_set.add("h")
函数
函数定义
Python 中的函数使用 def 关键字进行定义，譬如:
def sign(x):
if x > 0:
return 'positive'
elif x < 0:
return 'negative'
else:
return 'zero'
for x in [-1, 0, 1]:
print sign(x)
# Prints "negative", "zero", "positive"
Python 支持运行时创建动态函数，也即是所谓的 lambda 函数：
def f(x): return x**2
# 等价于
g = lambda x: x**2
参数
Option Arguments: 不定参数
def example(a, b=None, *args, **kwargs):
print a, b
print args
print kwargs
example(1, "var", 2, 3, word="hello")
# 1 var
# (2, 3)
# {'word': 'hello'}
a_tuple = (1, 2, 3, 4, 5)
a_dict = {"1":1, "2":2, "3":3}
example(1, "var", *a_tuple, **a_dict)
# 1 var
# (1, 2, 3, 4, 5)
# {'1': 1, '2': 2, '3': 3}
生成器
def simple_generator_function():
yield 1
yield 2
yield 3
for value in simple_generator_function():
print(value)
# 输出结果
# 1
# 2
# 3
our_generator = simple_generator_function()
next(our_generator)
# 1
next(our_generator)
# 2
next(our_generator)
#3
# 生成器典型的使用场景譬如无限数组的迭代
def get_primes(number):
while True:
if is_prime(number):
yield number
number += 1
装饰器
装饰器是非常有用的设计模式:
# 简单装饰器
from functools import wraps
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
print('wrap function')
return func(*args, **kwargs)
return wrapper
@decorator
def example(*a, **kw):
pass
example.__name__ # attr of function preserve
# 'example'
# Decorator
# 带输入值的装饰器
from functools import wraps
def decorator_with_argument(val):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
print "Val is {0}".format(val)
return func(*args, **kwargs)
return wrapper
return decorator
@decorator_with_argument(10)
def example():
print "This is example function."
example()
# Val is 10
# This is example function.
# 等价于
def example():
print "This is example function."
example = decorator_with_argument(10)(example)
example()
# Val is 10
# This is example function.
类与对象
类定义
Python 中对于类的定义也很直接:
class Greeter(object):
# Constructor
def __init__(self, name):
self.name = name # Create an instance variable
# Instance method
def greet(self, loud=False):
if loud:
print 'HELLO, %s!' % self.name.upper()
else:
print 'Hello, %s' % self.name
g = Greeter('Fred') # Construct an instance of the Greeter class
g.greet() # Call an instance method; prints "Hello, Fred"
g.greet(loud=True) # Call an instance method; prints "HELLO, FRED!"
# isinstance 方法用于判断某个对象是否源自某个类
ex = 10
isinstance(ex,int)
Managed Attributes: 受控属性
# property、setter、deleter 可以用于复写点方法
class Example(object):
def __init__(self, value):
self._val = value
@property
def val(self):
return self._val
@val.setter
def val(self, value):
if not isintance(value, int):
raise TypeError("Expected int")
self._val = value
@val.deleter
def val(self):
del self._val
@property
def square3(self):
return 2**3
ex = Example(123)
ex.val = "str"
# Traceback (most recent call last):
# File "", line 1, in
# File "test.py", line 12, in val
# raise TypeError("Expected int")
# TypeError: Expected int
类方法与静态方法
class example(object):
@classmethod
def clsmethod(cls):
print "I am classmethod"
@staticmethod
def stmethod():
print "I am staticmethod"
def instmethod(self):
print "I am instancemethod"
ex = example()
ex.clsmethod()
# I am classmethod
ex.stmethod()
# I am staticmethod
ex.instmethod()
# I am instancemethod
example.clsmethod()
# I am classmethod
example.stmethod()
# I am staticmethod
example.instmethod()
# Traceback (most recent call last):
# File "", line 1, in
# TypeError: unbound method instmethod() ...
对象
实例化
属性操作
Python 中对象的属性不同于字典键，可以使用点运算符取值，直接使用 in 判断会存在问题:
class A(object):
@property
def prop(self):
return 3
a = A()
print "'prop' in a.__dict__ =", 'prop' in a.__dict__
print "hasattr(a, 'prop') =", hasattr(a, 'prop')
print "a.prop =", a.prop
# 'prop' in a.__dict__ = False
# hasattr(a, 'prop') = True
# a.prop = 3
建议使用 hasattr、getattr、setattr 这种方式对于对象属性进行操作:
class Example(object):
def __init__(self):
self.name = "ex"
def printex(self):
print "This is an example"
# Check object has attributes
# hasattr(obj, 'attr')
ex = Example()
hasattr(ex,"name")
# True
hasattr(ex,"printex")
# True
hasattr(ex,"print")
# False
# Get object attribute
# getattr(obj, 'attr')
getattr(ex,'name')
# 'ex'
# Set object attribute
# setattr(obj, 'attr', value)
setattr(ex,'name','example')
ex.name
# 'example'
异常与测试
异常处理
Context Manager - with
with 常用于打开或者关闭某些资源:
host = 'localhost'
port = 5566
with Socket(host, port) as s:
while True:
conn, addr = s.accept()
msg = conn.recv(1024)
print msg
conn.send(msg)
conn.close()
单元测试
from __future__ import print_function
import unittest
def fib(n):
return 1 if n<=2 else fib(n-1)+fib(n-2)
def setUpModule():
print("setup module")
def tearDownModule():
print("teardown module")
class TestFib(unittest.TestCase):
def setUp(self):
print("setUp")
self.n = 10
