python double语法_珍藏版，Python 语法速览与实战清单！

珍藏版，Python 语法速览与实战清单！

基础语法

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

珍藏版，Python 语法速览与实战清单！

# 指定脚本调用方式

!/usr/bin/env python

配置 utf-8 编码

-- coding: utf-8 --

配置其他编码

-- coding: --

Vim 中还可以使用如下方式

vim:fileencoding=

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

def quicksort(arr):

if len(arr) <= 1:

return arr

pivot = arr[len(arr) / 2]

left = [x for x in arr if x < pivot]

middle = [x for x in arr if x == pivot]

right = [x for x in arr if x > pivot]

return quicksort(left) + middle + quicksort(right)

print quicksort([3,6,8,10,1,2,1])

Prints "[1, 1, 2, 3, 6, 8, 10]"

珍藏版，Python 语法速览与实战清单！

控制台交互

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

import fire

class Calculator(object):

"""A simple calculator class."""

def double(self, number):

return 2 * number

if name == 'main':

fire.Fire(Calculator)

python calculator.py double 10 # 20

python calculator.py double --number=15 # 30

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 语法速览与实战清单！

模块

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

# 文件目录

someDir/

main.py

siblingModule.py

siblingModule.py

def siblingModuleFun():

print('Hello from siblingModuleFun')

def siblingModuleFunTwo():

print('Hello from siblingModuleFunTwo')

import siblingModule

import siblingModule as sibMod

sibMod.siblingModuleFun()

from siblingModule import siblingModuleFun

siblingModuleFun()

try:

Import 'someModuleA' that is only available in Windows

import someModuleA

except ImportError:

try:

Import 'someModuleB' that is only available in Linux

import someModuleB

except ImportError:

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

someDir/

main.py

subModules/

init.py

subA.py

subSubModules/

init.py

subSubA.py

subA.py

def subAFun():

print('Hello from subAFun')

def subAFunTwo():

print('Hello from subAFunTwo')

subSubA.py

def subSubAFun():

print('Hello from subSubAFun')

def subSubAFunTwo():

print('Hello from subSubAFunTwo')

init.py from subDir

Adds 'subAFun()' and 'subAFunTwo()' to the 'subDir' namespace

from .subA import *

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 *'.

Assumes 'init.py' is empty in 'subSubDir'

Adds 'subSubAFun()' and 'subSubAFunTwo()' to the 'subDir' namespace

from .subSubDir.subSubA import *

Assumes 'init.py' in 'subSubDir' has 'from .subSubA import *'

Adds 'subSubAFun()' and 'subSubAFunTwo()' to the 'subDir' namespace

from .subSubDir import *

init.py from subSubDir

Adds 'subSubAFun()' and 'subSubAFunTwo()' to the 'subSubDir' namespace

from .subSubA import *

main.py

import subDir

subDir.subAFun() # Hello from subAFun

subDir.subAFunTwo() # Hello from subAFunTwo

subDir.subSubAFun() # Hello from subSubAFun

subDir.subSubAFunTwo() # Hello from subSubAFunTwo

珍藏版，Python 语法速览与实战清单！

表达式与控制流

珍藏版，Python 语法速览与实战清单！

条件选择

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()]

进行强制判断(falseValue, trueValue)[test == True]# 或者使用 bool 类型转换函数(falseValue, trueValue)[bool()]

珍藏版，Python 语法速览与实战清单！

循环遍历

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])

珍藏版，Python 语法速览与实战清单！

基本数据类型

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

int(str)

float(str)

str(int)

str(float)

珍藏版，Python 语法速览与实战清单！

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 提供了常见的逻辑操作符，不过需要注意的是 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"

珍藏版，Python 语法速览与实战清单！

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."

珍藏版，Python 语法速览与实战清单！

Regex: 正则表达式

import re

判断是否匹配

re.match(r'^[aeiou]', str)

以第二个参数指定的字符替换原字符串中内容

re.sub(r'^[aeiou]', '?', str)

re.sub(r'(xyz)', r'�', str)

编译生成独立的正则表达式对象

expr = re.compile(r'^.../pre>)

expr.match(...)

expr.sub(...)

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

# 检测是否为 HTML 标签

re.search('<[/>][>]*>', '')

常见的用户名密码

re.match('^[a-zA-Z0-9-]{3,16}/pre>, 'Foo') is not None

re.match('^w|[-]{3,16}/pre>, 'Foo') is not None

Email

re.match('^([a-z0-9_.-]+)@([da-z.-]+).([a-z.]{2,6})/pre>, 'hello.world@example.com')

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]?)/pre>'', re.X)

exp.match('192.168.1.1')

珍藏版，Python 语法速览与实战清单！

集合类型

珍藏版，Python 语法速览与实战清单！

List: 列表

珍藏版，Python 语法速览与实战清单！

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

珍藏版，Python 语法速览与实战清单！

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]"

珍藏版，Python 语法速览与实战清单！

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]

珍藏版，Python 语法速览与实战清单！

字典类型

珍藏版，Python 语法速览与实战清单！

创建增删

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 语法速览与实战清单！

索引遍历

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

# 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():

珍藏版，Python 语法速览与实战清单！

其他序列类型

珍藏版，Python 语法速览与实战清单！

集合

# 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 语法速览与实战清单！

函数

珍藏版，Python 语法速览与实战清单！

函数定义

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

珍藏版，Python 语法速览与实战清单！

参数

珍藏版，Python 语法速览与实战清单！

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}

珍藏版，Python 语法速览与实战清单！

生成器

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

珍藏版，Python 语法速览与实战清单！

装饰器

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

# 简单装饰器

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 语法速览与实战清单！

类与对象

珍藏版，Python 语法速览与实战清单！

类定义

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)

珍藏版，Python 语法速览与实战清单！

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

珍藏版，Python 语法速览与实战清单！

类方法与静态方法

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 语法速览与实战清单！

对象

珍藏版，Python 语法速览与实战清单！

实例化

珍藏版，Python 语法速览与实战清单！

属性操作

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'

'

珍藏版，Python 语法速览与实战清单！