• 幕客老师召集小伙伴
  • python自动化运维项目实战
  • nginx从入门到实战
  • 阿里云与Centos7实战

DevOPS - Python开发进阶

一、匿名函数

1、什么是匿名?

匿名是因为不需要以标准的方式来声明 ,如使用def语句。

2、匿名函数语法

lambda [arg1[, arg2, ... argN]]: expression 

def true():

    return True

等价于:
def true():return True

等价于:

In [84]: true()

Out[84]: True

 

In [85]: a = lambda x,y=2:x + y

In [86]: a(2)

Out[86]: 4

In [87]: a(3,4)

Out[87]: 7

In [91]: b = lambda *z: z

In [92]: b(23,11)

Out[92]: (23, 11)

 


二、Python的正则表达式

一、re模块

函数/方法 描述
re 模块的函数
compile(pattern,flags=0) 对正则表达式模式 pattern 进行编译,flags是可选标志符,返回一个regex对象。

match(pattern,string, flags=0) 尝试用正则表达式模式 pattern 匹配字符串 string, flags 是可选标志符,如果匹配成功,则返回一个匹配对 象;否则返回 None 

search(pattern,string, flags=0)  在字符串 string 中查找正则表达式模式 pattern 的第 一次出现,flags 是可选标志符,如果匹配成功,则返回 一个匹配对象;否则返回 None 

findall(pattern,string[,flags])    在字符串 string 中查找正则表达式模式 pattern 的所有 (非重复)出现;返回一个匹配对象的列表 

finditer(pattern,string[, flags])     和 findall()相同,但返回的不是列表而是迭代器;对 于每个匹配,该迭代器返回一个匹配对象 

split(pattern,string, max=0)        根据正则表达式 pattern 中的分隔符把字符 string 分割为一个列表,返回成功匹配的列表,最多分割 max 次(默认是分割所有匹配的地方)。

group(num=0)                           返回全部匹配对象(或指定编号是 num 的子组) 

In [1]: import re    #导入一个re模块

 

In [2]: pattern=re.compile(r'abc')              #abc为正则表达式,r使用正则表达式,将其进行编成为一个对象給pattern

 

In [3]: match=pattern.match('abcdefg')       #在目标字符串中查找并且匹配目标对象

 

In [4]: if match:

   ...:     print(match)           #打印对象

   ...:     print(match.group())    #打印匹配内容

   ...: 

<_sre.SRE_Match object at 0x104d168b8>

abc

二、预编译的好处

使用预编译代码对象要比使用字符串快,因 为解释器在执行字符串形式的代码前必须先把它编译成代码对象。 

在模式匹配之前,正则表达式模式必须先被编译成 regex 对象。 由于正则表达式在执行过程中被多次用于比较,我们强烈建议先对它做预编译,而且,既然正则表 达式的编译是必须的,那使用么预先编译来提升执行性能无疑是明智之举。re.compile() 就是用来 提供此功能的。 

 

4.1.3 实例讲解

 一、match和seach区别

In [4]: re.match("foo","food")

Out[4]: <_sre.SRE_Match at 0x10c79c8b8>

 

In [5]: re.match("foo","seafood") #返回空,match从头部开始查找

 

In [6]: re.search("foo","seafood") #seach会从左往右搜索整个字符串,而后进行匹配

Out[6]: <_sre.SRE_Match at 0x10c79c920>

 

二、group、groups

例1、

In [15]: patt = '\w+@(\w+\.)?\w+\.com'

 

In [16]: re.match(patt, 'nobody@xxx.com').group()

Out[16]: 'nobody@xxx.com'

 

In [17]: re.match(patt, 'nobody@www.xxx.com').group()

Out[17]: 'nobody@www.xxx.com'

 

例2、

 

In [88]: import re

 

In [89]: m = re.match('(\w\w\w)-(\d\d\d)', 'abc-123') 

 

In [90]: m.group()

Out[90]: 'abc-123'

 

In [91]: m.group(1)

Out[91]: 'abc'

 

In [92]: m.group(2)

Out[92]: '123'

 

In [93]: m.groups(2)

Out[93]: ('abc', '123')

 

例3、

In [94]: m = re.match("(a(b))","ab")

 

In [95]: m.group()

Out[95]: 'ab'

 

In [96]: m.group(1)

Out[96]: 'ab'

 

In [97]: m.group(2)

Out[97]: 'b'

 

In [98]: m.groups()

Out[98]: ('ab', 'b')

 

三、错误异常捕获

1、描述

错误:语法错误 逻辑错误

语法错误:代码结构上存在问题,导致解释器或者编译器无法正常运行

逻辑错误:代码逻辑无法完成

为什么要作异常处理?1、防止出现错误,导致程序崩溃,造成重大的损失,这个叫容错。2、应用级别的错误,能給用户一个友好的信息提示。提高交互性。

                  

2、 Python中的异常类型

分为两个阶段: 首先是引起异常发生的错误, 然后是检测(和采取可能的措施)阶段 

第一阶段:发生了一个异常条件(有时候也叫做例外的条件)后发生的. 只要检测到错误 并且意识到异常条件, 解释器会引发一个异常. 

用来处理这个错误并采取相应的操作. 这就是第二阶段 

#NameError 反问一个未声明的变量

In [1]: fv

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-1-00836700353c> in <module>()

----> 1fv

 

NameError: name 'fv' is not defined

 

 #SyntaxError 解释器语法错误,一般都是由于程序语法存在问题

In [2]: for

  File "<ipython-input-2-91e454eba04c>", line 1

    for

       ^

SyntaxError: invalid syntax

 

#IndexError:请求的索引超出序列范围

In [3]: testlist=list()

In [4]: testlist[2]

---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

<ipython-input-4-fd1db6ffe337> in <module>()

----> 1testlist[2]

IndexError: list index out of range

 

KeyError:请求一个不存在的字典关键字 

In [5]: adict={"name":"tom"}

In [6]: adict["name"]

Out[6]: 'tom'

In [7]: adict["address"]

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-7-fd31f45f2a74> in <module>()

----> 1adict["address"]

KeyError: 'address'

 

IOError: 输入/输出错误

In [8]: f=open('/tmp/fsdfs.txt',"r")

---------------------------------------------------------------------------

IOError                                   Traceback (most recent call last)

<ipython-input-8-03a6bdc99bfd> in <module>()

----> 1f=open('/tmp/fsdfs.txt',"r")

IOError: [Errno 2] No such file or directory: '/tmp/fsdfs.txt'

 

AttributeError: 尝试访问未知的对象属性 

In [9]: class test(object):

   ...:     pass

   ...: 

In [10]: dotest=test

In [11]: test.name

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-11-d017a8ab5e2c> in <module>()

----> 1test.name

 

AttributeError: type object 'test' has no attribute 'name'

 

3、 try-except 语句及异常补货方法

try:
    try_suite # watch for exceptions here 监控这里的异常

except Exception[, reason]:
    except_suite # exception-handling code 异常处理代码 

 

In [12]: try:

   ....:     class test(object):

   ....:         pass

   ....:     dotest = test

   ....:     print test.name

   ....: except AttributeError,e:

   ....:     print 'Error ...........',e

   ....: 

Error ........... type object 'test' has no attribute 'name'


三、 模块的导入导出

 

#从模块中导入指定的属性

from module import name1[, name2[,... nameN]] 

from Tkinter import Tk, Frame, Button, Entry, Canvas, Text

from Tkinter import * #不提倡使用

 

#import .. as  语句方式

import Tkinter
from cgi import FieldStorage
. . . 可以替换为 . . .
import Tkinter as tk
from cgi import FieldStorage as form 

#from module import *" 不是良好的编程风格, 因为它"污染"当前名称 空间, 而且很可能覆盖当前名称空间中现有的名字;

但如果某个模块有很多要经常访问的变量或者 模块的名字很长, 这也不失为一个方便的好办法。 

 

#例子:

#vim /tmp/foom.py 新建一个函数模块

# File Name: /tmp/foom.py
# Author:Jeson
# mail:
# Created Time: Thu 10 Mar 2016 08:38:24 PM CST
#===============================================================
#!/usr/bin/python

testkey = "iskey"
def foo():
    print testkey
    print "test.....foo..........."

 

#导入模块

>>> from foom import foo
>>> foo()
iskey
test.....foo...........
>>> testkey = "newkey.."
>>> testkey
'newkey..'
>>> foo()
iskey               #并没有改变模块的作用域
test.....foo...........

 


 

四、装饰器

1、什么是装饰器

 

装饰器本质上是一个Python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象。

当声明一个函数后,进行额外的调用。

#如

 

#有了装饰器,避免了代码的臃肿难看

def use_logging(func):
    def wrapper(*args, **kwargs):
        logging.warn("%s is running" % func.__name__)
        return func(*args)
    return wrapper
@use_logging
def foo():
    print("i am foo")
foo()
 

五、面向对象编程

参考:

http://www.iaskjob.com/admin/zinnia/entry/233/?_changelist_filters=q%3Dpython%2B%2B%25E9%259D%25A2%25E5%2590%2591%25E5%25AF%25B9%25E8%25B1%25A1

 

 

DevOPS - Python开发进阶

Pingbacks已打开。

引用地址

暂无评论

发表评论