跳转至

python

  • 分类于 python
  • 需要 1 分钟阅读时间

python发邮件是件很简单的事情

利用python的smtplib，发邮件将是一件非常简单的事情，下文以用163邮箱来发邮件为例，说明smtplib的应用 

 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
#coding:utf-8
import smtplib

def sendMail(mail_to):
    mail_server = 'smtp.163.com'
    mail_port = '25'
    username = 'soar_1987@163.com'
    password = 'XXXXXXXX'
    mail_title = 'python Test'
    mail_content = 'This is a test from python for sending email'
    if type(mail_to) == str:#之所以要有这样的判断是为了收件人是多个人或者传入的的收件人列表是以list的方式
        mail_list = mail_to.split(';') #将str类型的数据转换为list
    elif type(mail_to) == list:
        mail_list = mail_to
    else:
        print "你输入的收件人格式有误"

    try:
        handle = smtplib.SMTP(mail_server,mail_port)
        handle.login(username,password)
        msg = "From:%srn To:%srnContent-Type: text/html;charset=gb2312rnSubject:%srnrn %s"%("杨彦星",";".join(mail_list),mail_title,mail_content) #这里的msg其实就是一种固定的格式，From:To:Subject
        handle.sendmail(username,mail_list,msg)
        print "Send email sucess"
    except Exception,e:
        print "Send email failed because %s" % e

if __name__ =="__main__":
    sendMail('yanxingyang@gmail.com')

  • 分类于 python
  • 需要 1 分钟阅读时间

可爱的python中的一个与递归相关的小问题

可爱的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
#coding:utf-8
import os,sys

def cdGrep(keyword,filepath):
    filelist = os.listdir(filepath)

    for cdc in filelist:
        if os.path.isdir(cdc):
            filepath2 = os.path.join(filepath,cdc)
            cdGrep(keyword,filepath2)

        elif '.txt' in cdc:
#            print filepath+cdc
            f = open(filepath+''+ cdc)
            for line in f.readlines():
                linelower = line.lower()
                if keyword in linelower:

                    print '您查找的关键词在%s中找到'% (filepath+''+cdc)
                    print line
                f.close()

if __name__ == '__main__':
    keword = raw_input('请输入想要查询的关键字')
    pw = os.getcwd()
    cdGrep(keword,pw)

  • 分类于 python
  • 需要 1 分钟阅读时间

通过一个python小脚本来下载最新的360杀毒安装程序

小脚本很简单，主要是练习一下正则匹配，与简单的urllib库的应用

 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
#coding: utf8
import urllib,re
import os

def getLastinstall():

    page = urllib.urlopen(r'http://sd.360.cn/download_center.html')
    html = page.read()
    page.close()
    rematch = r'http://down.360.cn/360sd/360sd_se_(.*?)exe'
    replusmatch = r'http://down.360.cn/360sd/360sd_plus_(.*?)exe'
    stdname = '360sd_'+(str(re.compile(rematch).findall(html)[0]))+'exe'
    downurlstd = r'http://down.360.cn/360sd/360sd_'+(str(re.compile(rematch).findall(html)[0]))+'exe'
    powname = '360sd_plus_'+(str(re.compile(replusmatch).findall(html)[0]))+'exe'
    downurlpow = r'http://down.360.cn/360sd/360sd_plus_'+(str(re.compile(replusmatch).findall(html)[0]))+'exe'
    localpath = os.getcwd()+r'/installpack'
    if not (os.path.isfile(stdname) and os.path.isfile(powname)):
        if not os.path.isdir('installpack'):
            os.makedirs('installpack')
        urllib.urlretrieve(downurlstd,localpath+'/'+stdname)
        urllib.urlretrieve(downurlpow,localpath+'/'+powname)
    else:
        print '目录中已经是线上最新版杀毒安装程序'

if __name__ =='__main__':
    getLastinstall()
  • 分类于 python
  • 需要 1 分钟阅读时间

python中的OOP

直接上代码，已经在后面有注释了 

 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
#coding:utf8

name = 'yangyanxing'
class Test():
    class kevin():
        var1 = '我是内部类'

    name = 'kvein'
    gae = '26'

    def fun1(self):
        print self.name
        print '我是公共方法'
        self.__fun2() #可以通过公有就去来调用私有方法，在调用的过程中可以进行更改

    def __fun2(self):
        print '我是私有方法'

    @classmethod
    def fun3(self): #可以不通过实例来访问这个类方法
        print '#'*40
        print self.name
        print '我是类方法'

    @staticmethod #静态方法，也是可以不通过实例对象就可以访问的方法但是在定义的时候不用加self
    def fun4():
        print Test.name
        print name #这里的name是全局变量
        Test.fun3()
        print '我是静态方法'

print Test.name #公有属性可以直接方法，不用实例化对象
yang = Test() #实例化一个类
interyang = Test.kevin() #实例化一个内部类
yang.fun1() #方法类里面的公共属性
print interyang.var1 # 访问内部类里的属性
Test.fun3()#访问类方法
Test.fun4()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
#coding:utf8

class Test():
    var1 = '类的公有属性'
    __var2 = '类的私有属性'

    def fun(self):
        self.var2 = '对象的公有属性' # 这里定义了一个对象的公有属性
        self.__var3 = '对象的私有属性'# 这里定义了一个对象的私有属性
        var4 = '函数的局部变量' #这里定义了一个函数的局部变量，这里面的var4只有在函数内部使用

kevin = Test() #实例了一个对象
yang = Test() #又实例了另外一个对象
print kevin.var1
##print kevin.__var2 #这里将无法访问
kevin.fun()
print kevin.var2 #在没有调用fun函数之前是没有var2的
##print kevin.__var3 对象的私有属性是无法调用的
##print yang.var2 #这里因为没有调用yang的fun方法，所以还是无法访问yang里的var2

  • 分类于 python
  • 需要 3 分钟阅读时间

(转)抛砖引玉 正则表达式完成电话号码的匹配

原来地址：http://www.diveintopython.net/regular_expressions/phone_numbers.html

迄今为止，你主要是匹配整个模式，不论是匹配上，还是没有匹配上。但是正则表达式还有比这更为强大的功能。当一个模式确实 匹配上时，你可以获取模式中特定的片断，你可以发现具体匹配的位置。 这个例子来源于我遇到的另一个现实世界的问题，也是在以前的工作中遇到的。问题是：解析一个美国电话号码。客户要能 (在一个单一的区域中) 输入任何数字，然后存储区号、干线号、电话号和一个可选的独立的分机号到公司数据库里。为此，我通过网络找了很多正则表达式的例子，但是没有一个能够完全满足我的要求。 这里列举了我必须能够接受的电话号码：  800-555-1212  800 555 1212  800.555.1212  (800) 555-1212  1-800-555-1212  800-555-1212-1234  800-555-1212x1234  800-555-1212 ext. 1234  work 1-(800) 555.1212 #1234 格式可真够多的！我需要知道区号是 800，干线号是 555，电话号的其他数字为 1212。对于那些有分机号的，我需要知道分机号为 1234。 让我们完成电话号码解析这个工作，这个例子展示第一步。 例 7.10. 发现数字

phonePattern = re.compile(r'^(d{3})-(d{3})-(d{4})$') (1) phonePattern.search('800-555-1212').groups() (2)

  • 分类于 python
  • 需要 1 分钟阅读时间

(转)Python 参数知识（变量前加星号的意义）

原文地址：http://blog.csdn.net/qinyilang/article/details/5484415

**过量的参数

**在运行时知道一个函数有什么参数，通常是不可能的。另一个情况是一个函数能操作很多对象。更有甚者，调用自身的函数变成一种api提供给可用的应用。

对于这些情况，python提供了两种特别的方法来定义函数的参数，允许函数接受过量的参数，不用显式声明参数。这些“额外”的参数下一步再解释。

注意args和kwargs只是python的约定。任何函数参数，你可以自己喜欢的方式命名，但是最好和python标准的惯用法一致，以便你的代码，其他的程序员也能轻松读懂。 ** 位置参数**

在参数名之前使用一个星号，就是让函数接受任意多的位置参数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
>>> def multiply(*args):
...     total = 1
...     for arg in args:
...         total *= arg
...     return total
...
>>> multiply(2, 3)
6
>>> multiply(2, 3, 4, 5, 6)
720
  • 分类于 python
  • 需要 1 分钟阅读时间

Python中用print方法向文件中写入内容

一个小功能，我就是想用print功能实现，不想用write 

1
2
3
4
5
6
import os

os.chdir("/usr/tem")
char="my name is yangyanxing"
f = open("test.txt","w")
print >>f,char

但是Python3中还可以用以下的方式 

1
2
3
4
5
6
import os

os.chdir("/usr/tem")
char="my name is yangyanxing"
f = open("test.txt","w")
print(char,file=f)

  • 分类于 python
  • 需要 3 分钟阅读时间

（转）Python装饰器与面向切面编程

本文用了一个很通俗的例子还一步步的让读者理解Python中的装饰器的概念

原文地址：http://www.cnblogs.com/huxi/archive/2011/03/01/1967600.html

今天来讨论一下装饰器。装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

装饰器入门

需求是怎么来的？

装饰器的定义很是抽象，我们来看一个小例子。

1
2
3
4
def foo():
    print 'in foo()'

foo()
这是一个很无聊的函数没错。但是突然有一个更无聊的人，我们称呼他为B君，说我想看看执行这个函数用了多长时间，好吧，那么我们可以这样做：

1
2
3
4
5
6
7
8
import time
def foo():
    start = time.clock()
    print 'in foo()'
    end = time.clock()
    print 'used:', end - start

foo()
很好，功能看起来无懈可击。可是蛋疼的B君此刻突然不想看这个函数了，他对另一个叫foo2的函数产生了更浓厚的兴趣。

怎么办呢？如果把以上新增加的代码复制到foo2里，这就犯了大忌了~复制什么的难道不是最讨厌了么！而且，如果B君继续看了其他的函数呢？

1.2. 以不变应万变，是变也

还记得吗，函数在Python中是一等公民，那么我们可以考虑重新定义一个函数timeit，将foo的引用传递给他，然后在timeit中调用foo并进行计时，这样，我们就达到了不改动foo定义的目的，而且，不论B君看了多少个函数，我们都不用去修改函数定义了！ 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import time

def foo():
    print 'in foo()'

def timeit(func):
    start = time.clock()
    func()
    end =time.clock()
    print 'used:', end - start

timeit(foo)
看起来逻辑上并没有问题，一切都很美好并且运作正常！……等等，我们似乎修改了调用部分的代码。原本我们是这样调用的：foo()，修改以后变成了：timeit(foo)。这样的话，如果foo在N处都被调用了，你就不得不去修改这N处的代码。或者更极端的，考虑其中某处调用的代码无法修改这个情况，比如：这个函数是你交给别人使用的。

1.3. 最大限度地少改动！

既然如此，我们就来想想办法不修改调用的代码；如果不修改调用代码，也就意味着调用foo()需要产生调用timeit(foo)的效果。我们可以想到将timeit赋值给foo，但是timeit似乎带有一个参数……想办法把参数统一吧！如果timeit(foo)不是直接产生调用效果，而是返回一个与foo参数列表一致的函数的话……就很好办了，将timeit(foo)的返回值赋值给foo，然后，调用foo()的代码完全不用修改！ 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
#-*- coding: UTF-8 -*-
import time

def foo():
    print 'in foo()'

# 定义一个计时器，传入一个，并返回另一个附加了计时功能的方法
def timeit(func):

    # 定义一个内嵌的包装函数，给传入的函数加上计时功能的包装
    def wrapper():
        start = time.clock()
        func()
        end =time.clock()
        print 'used:', end - start

    # 将包装后的函数返回
    return wrapper

foo = timeit(foo)
foo()
这样，一个简易的计时器就做好了！我们只需要在定义foo以后调用foo之前，加上foo = timeit(foo)，就可以达到计时的目的，这也就是装饰器的概念，看起来像是foo被timeit装饰了。在在这个例子中，函数进入和退出时需要计时，这被称为一个横切面(Aspect)，这种编程方式被称为面向切面的编程(Aspect-Oriented Programming)。与传统编程习惯的从上往下执行方式相比较而言，像是在函数执行的流程中横向地插入了一段逻辑。在特定的业务领域里，能减少大量重复代码。面向切面编程还有相当多的术语，这里就不多做介绍，感兴趣的话可以去找找相关的资料。

这个例子仅用于演示，并没有考虑foo带有参数和有返回值的情况，完善它的重任就交给你了 ：）

  1. Python的额外支持 2.1. 语法糖

上面这段代码看起来似乎已经不能再精简了，Python于是提供了一个语法糖来降低字符输入量。 

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

def timeit(func):
    def wrapper():
        start = time.clock()
        func()
        end =time.clock()
        print 'used:', end - start
    return wrapper

@timeit
def foo():
    print 'in foo()'

foo()
重点关注第11行的@timeit，在定义上加上这一行与另外写foo = timeit(foo)完全等价，千万不要以为@有另外的魔力。除了字符输入少了一些，还有一个额外的好处：这样看上去更有装饰器的感觉。

2.2. 内置的装饰器

内置的装饰器有三个，分别是staticmethod、classmethod和property，作用分别是把类中定义的实例方法变成静态方法、类方法和类属性。由于模块里可以定义函数，所以静态方法和类方法的用处并不是太多，除非你想要完全的面向对象编程。而属性也不是不可或缺的，Java没有属性也一样活得很滋润。从我个人的Python经验来看，我没有使用过property，使用staticmethod和classmethod的频率也非常低。 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
class Rabbit(object):

    def __init__(self, name):
        self._name = name

    @staticmethod
    def newRabbit(name):
        return Rabbit(name)

    @classmethod
    def newRabbit2(cls):
        return Rabbit('')

    @property
    def name(self):
        return self._name
这里定义的属性是一个只读属性，如果需要可写，则需要再定义一个setter：

@name.setter
def name(self, name):
    self._name = name
functools模块提供了两个装饰器。这个模块是Python 2.5后新增的，一般来说大家用的应该都高于这个版本。但我平时的工作环境是2.4 T-T

2.3.1. wraps(wrapped[, assigned][, updated]): 这是一个很有用的装饰器。看过前一篇反射的朋友应该知道，函数是有几个特殊属性比如函数名，在被装饰后，上例中的函数名foo会变成包装函数的名字wrapper，如果你希望使用反射，可能会导致意外的结果。这个装饰器可以解决这个问题，它能将装饰过的函数的特殊属性保留。 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
import time
import functools

def timeit(func):
    @functools.wraps(func)
    def wrapper():
        start = time.clock()
        func()
        end =time.clock()
        print 'used:', end - start
    return wrapper

@timeit
def foo():
    print 'in foo()'

foo()
print foo.__name__

首先注意第5行，如果注释这一行，foo.__name__将是'wrapper'。另外相信你也注意到了，这个装饰器竟然带有一个参数。实际上，他还有另外两个可选的参数，assigned中的属性名将使用赋值的方式替换，而updated中的属性名将使用update的方式合并，你可以通过查看functools的源代码获得它们的默认值。对于这个装饰器，相当于wrapper = functools.wraps(func)(wrapper)。

2.3.2. total_ordering(cls): 这个装饰器在特定的场合有一定用处，但是它是在Python 2.7后新增的。它的作用是为实现了至少__lt__、le、gt、__ge__其中一个的类加上其他的比较方法，这是一个类装饰器。如果觉得不好理解，不妨仔细看看这个装饰器的源代码： 

 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
def total_ordering(cls):
    """Class decorator that fills in missing ordering methods"""
    convert = {
        '__lt__': [('__gt__', lambda self, other: other < self),
                   ('__le__', lambda self, other: not other < self),
                   ('__ge__', lambda self, other: not self < other)],
        '__le__': [('__ge__', lambda self, other: other <= self),
                   ('__lt__', lambda self, other: not other <= self),
                   ('__gt__', lambda self, other: not self <= other)],
        '__gt__': [('__lt__', lambda self, other: other > self),
                   ('__ge__', lambda self, other: not other > self),
                   ('__le__', lambda self, other: not self > other)],
        '__ge__': [('__le__', lambda self, other: other >= self),
                   ('__gt__', lambda self, other: not other >= self),
                   ('__lt__', lambda self, other: not self >= other)]
    }
    roots = set(dir(cls)) & set(convert)
    if not roots:
        raise ValueError('must define at least one ordering operation: < > <= >=')
    root = max(roots)       # prefer __lt__ to __le__ to __gt__ to __ge__
    for opname, opfunc in convert[root]:
        if opname not in roots:
            opfunc.__name__ = opname
            opfunc.__doc__ = getattr(int, opname).__doc__
            setattr(cls, opname, opfunc)
    return cls