简明Python教程笔记

15. 解决问题——编写一个Python脚本

    问题：为所有的重要文件创建备份的程序

    设计中应该明确：
   
    1. 需要备份的文件盒目录由一个列表指定。

    2. 本分应该保存在主备份目录中。

    3. 文件备份成为一个zip文件。

    4. zip存档的名称是当前的日期和时间。

    解决方案：

    方案一：

    #!/usr/bin/python
    #Filename: backup_ver1.py

    import os;
    import time;

    #1. 指定要备份的目录和列表
    # 如果要使用Linux，使用source = ['home/backup', r'home/swaroop/bin'];或者类似这样的
    source = [r'G:\backup', r'G:\backup备份.txt'];
   
    # 2. 备份必须存储在主备份目录
    target_dir = r'G:\backup';
   
    # 3. 文件备份为rar文件
    # 4. rar归档文件的名称是当前的日期和时间
    target = target_dir + time.strftime('%Y%m%d%H%M%S') + '.rar';
   
    # 5. 使用rar命令将文件放入rar归档文件中
    rar_command = "rar a '%s' '%s' "  %(target, ''.join(source));
   
    # Run the backup
    if os.system(rar_command) == 0:
        print 'Successful backup to', target;
    else:
        print 'Backup FAILED';

    注解：
   
    获得日期与时间，使用time.strtime()函数获得。

    %Y会被无世纪的年份代替，%m会被01到12之间十进制月份代替，一次类推。

    使用的压缩命令是winrar a f:\backup\backup f:\backuping\201104111705.rar

    字符串的join方法把source列表 转换为一个字符串

    使用os.system函数运行命令，利用这个函数就行是在系统中运行命令一样，即在shell中运行命令，如果成功，则返回0， 否则返回错误号。

    注：在Python中'\'是转义字符，如果要在字符串中使用'\'，则使用'\\'。

    版本二：

    采用一种更加好的文件名机制，使用时间作为文件名，使用当前的日期作为目录名称。这样使得你的备份会以等级结构存储，更加容易管理。并且可以缩短文件的名称长度。

    #!/usr/bin/python
    # -*- coding: cp936 -*-
    #Filename: backup_ver2.py
   
    import os;
    import time;
   
    # 要进行备份的目录和文件放入source中
    source = ['\\backup', '\\backup备份.txt'];
    sourcename = ['backup', 'backup备份.txt'];
   
    # 备份必须存储在主目录中
    target_dir = 'f:\\backup\\';
    source_dir = 'f:\\backuping';
   
    # 文件备份为rar文件
    # 当前的日期是主目录下的子目录
    today = target_dir + time.strftime('%Y%m%d');
   
    # 当前时间是rar归档文件的名字
    now = time.strftime('%H%M%S');
   
    # 如果没有存在，则创建子目录
    if not os.path.exists(today):
        os.mkdir(today);    # 创建目录
   
    print 'Successfully created directory', today;
   
    #备份名称
    i = 0;
    while i < len(source):
        target = today + os.sep + now + sourcename[i] + '.rar';
        print target;
        rar_command = "winrar a %s %s" %(target, source_dir + source[i]);
        if os.system(rar_command) == 0:
            print 'Susccessful backup to', target;
        else:
            print 'Failed to backup file';
        i = i + 1;
    else:
        print 'Backup all file successfully!';
   
    修改的主要部分：使用os.exists函数检验在主备份目录中是否有以当前日期作为名称的目录，如果没有使用os.mkdir函数创建。

    其中的os.sep变量 - 它会根据操作系统给出的目录分隔符，即在Linux下是'\'，在windows下是'\\'，而在mac下是':'。使用os.sep而非直接使用字符，会使我们的程序具有移植性。

    版本三：

    #!/usr/bin/python
    # -*- coding: cp936 -*-
    #Filename: backup_ver3.py
   
    import os;
    import time;
   
    # 要进行备份的目录和文件放入source中
    source = ['\\backup', '\\backup备份.txt'];
    sourcename = ['backup', 'backup备份.txt'];
   
    # 备份必须存储在主目录中
    target_dir = 'f:\\backup\\';
    source_dir = 'f:\\backuping';
   
    # 文件备份为rar文件
    # 当前的日期是主目录下的子目录
    today = target_dir + time.strftime('%Y%m%d');
   
    # 当前时间是rar归档文件的名字
    now = time.strftime('%H%M%S');
   
    # 为文件名加入注释
        comment = raw_input('Enter a coment -->');
   
    if len(comment) == 0:
        comment = "";
    else:
        comment = comment.replace(' ', '_');
   
    print comment;
   
    # 如果没有存在，则创建子目录
    if not os.path.exists(today):
        os.mkdir(today);    # 创建目录
   
    print 'Successfully created directory', today;
   
    #文件名称   
    i = 0;
    while i < len(source):
        target = today + os.sep + now + sourcename[i] + comment + '.rar';
        print target;
        rar_command = "winrar a %s %s" %(target, source_dir + source[i]);
        if os.system(rar_command) == 0:
            print 'Susccessful backup to', target;
        else:
                print 'Failed to backup file';
        i = i + 1;
    else:
        print 'Backup file successful!';
   
   
    raw_input函数得到用户的输入，然后通过len函数找到输入的长度，以检验是否确实输入了东西。

    将输入的注释中的空格换为_以作为文件名称。

    进一步进行改进：

    * 可以从命令行将要备份的文件传递给程序，使用list类的extend方法将他们加入到source列表中去。

    * 最理想的归档的方法是使用zipfile和tarfile，这两个函数是Python标准库中的方法，使用这两个函数，就不需要使用os.system这个函数了，因为这个函数很容易引发错误。

16. 面向对象编程

    对象可以好似用普通的 属于 对象的变量存储数据。属于一个对象或者是类的变量称为域，对象也可以使用属于类的函数来具有功能。域与方法合称为类的属性。

    域有两种类型—— 属于每个实例/类的对象或者是属于类本身，他们分别称为实例变量和类变量。

    类的方法与普通的函数只有一个区别——它必须有一个额外的第一个参数名称，但是调用的时候不需要调用者为这个参数赋值，Python会自动提供这个值。这个特别的变量指对象本身，按照惯例它的名称是self

    注：虽然可以给这个参数任何名称，但是建议使用self这个名称。使用标准名称，可以让读者迅速识别，一些IDE也有一些支持。
   
    self原理：假如你有一个MyClass类，以及这个类的一个实例MyObject，当调用MyObject.method(arg1, arg2)的时候，这会由Python自动转化为MyClass.method(MyObject, arg1, arg2)。

    1. 简单类的例子
    一个最简单的类的例子：
    #!/usr/bin/python

    #Filename: simplestclass.py

    class Person:
        pass # An empty block

    p = Person();  #一定注意缩进，在Python中缩进就相当于括号的作用
    print p;

    2. 类的方法
    类/对象可以拥有像函数一样的方法，这些方法与函数的区别只是一个额外的self变量。
  
    一个例子：
    #!/usr/bin/python
    #Filename: method.py

    class Person:
        def sayHi(self):
            print 'Hello, how are you?';

    p = Person();
    p.sayHi();      # Also can be written as Person().sayHi();
   
    本例中的self参数必须写入sayHi函数中，但是在执行时不需要给self赋值，系统会自动给它赋值。

    Python的类中，很多方法的名字有特殊的重要意义。
   
    __init__ 方法

   
    该方法在类的一个对象被创建时，马上运行。这个方法用来对你的对象做一些希望的初始化的工作。

    注：改函数名称的开头和结尾都是双下划线。

    #!/usr/bin/python

    # Filename: class_init.py

    class Person:
        def __init__(self, name):
            self.name = name;

        def sayHi( self):
            print 'Hello, my name is ', self.name;

    p = Person('Andy');
    p.sayHi();

       
    本例中给Person类加了一个域 self.name。
   
    其实__init__() 函数就是类的初始化函数，

   

    3. 类的数据

    类的数据其实就是与对象的命名空间绑定的普通变量，这些名称在这些类与对象的前提下有效。

    有两种类型的域： 类的变量和对象的变量，它们根据是类还是对象 拥有这个变量而区分。

    类变量：由一个类的所有对象(实例)共享使用。只有一个类变量的拷贝，当某个对象对类的变量做了改动，
    这个改动会反应到所有其他的实例上。

    对象的变量：由类的每个对象/实例拥有。因此每个对象有自己对这个域的一个拷贝，即它们不是共享的。
    在同一个类的不同的实例中，虽然对象的变量有相同的名称，但是相互不相关。

    #!/usr/bin/python
    #Filename: objvar.py
   
    class Person:
        '''Represents a person.''';
        population = 0;
   
        def __init__(self, name):
            self.name = name;

            print '(Initializing %s)' %self.name;
            # when this person is created, he/she adds to the population
            Person.population += 1;
   
        def __del__(self):
            '''I am dying.'''
            print '%s say bye.' %self.name;
            Person.population -= 1;
   
            if Person.population == 0:
                print 'I am the last one.';
            else:
                print 'There are still %d people left.' %Person.population;

        def sayHi(self):
            '''Greeting by the person.
            Really, that's all it does.'''
       
            print 'Hi, my name is %s.' %self.name;
           
        def howMany(self):
            '''Prints the current population.'''  #文档字符串
            if Person.population == 1:
                print 'I am the only person here.';
            else:
                print 'We have %d persons here.' %Person.population;
   
    Andy = Person('Andy');
    Andy.sayHi();
    Andy.howMany();

    kalam = Person('Abdul Kalam');
    kalam.sayHi();
    kalam.howMany();
   
    Andy.sayHi();
    Andy.howMany();
               
    del Andy;
    del kalam;
   
    population属于Person类，它是一个类的变量，name变量属于对象(使用self赋值)，它是对象的变量。

    只能使用self变量来访问同一个对象的变量和方法，被称为属性访问。

    本程序中可以看到docstring对类和方法同样有用。可以在运行时使用

    Person.__doc__和Person.sayHi.__doc__来分别访问类与方法的文档字符串。

   
    如同__init__()方法，__del__()方法也是一个特殊的方法，它是在对象销毁的时候被调用。

    对象销毁，即对象不再被使用，它所占用的内存将返回给系统。
    在代码中可以调用del obj 来显示销毁对象，否则该对象的销毁由系统来做。

    注：数据成员以双下划线为前缀，例如__privatevar，Python的名称管理体系会有效地把它作为私有变量。

 
    惯例：某个变量只想在类或对象中使用，就应该以单下划线前缀，其他的名称都作为公共的，可以被其他的
    类/对象使用。(与双下划线前缀不同)。
   

    4. 继承

    面向对象的编程带来的主要好处之一是代码的重用，实现这一机制可以通过 继承实现。

    继承可以理解为类之间的类型和子类型的关系。

   
    为了记录师生的信息，如果没有继承，则需要写两个类，每一个类都要将一些变量重新写一遍。

    一个比较好的方法是创建一个共同的类称为 SchoolMember，然后让教师和学生的类 继承这个共同的类

    它们都是这个类的子类型，然后为这些子类型添加专有的属性。

    一个子类型在任何需要父类型的场合可以被替代成父类型，即对象可以被视作父类的实例，这种现象成为多态

    那就就有  父类/超类   子类/导出类  区分。

    #!/usr/bin/python

    #Filename: inherit.py

    class SchoolMember:
        '''Represents any school member.'''
        def __init__(self, name, age):
            self.name = name;
            self.age = age;
            print '(Initialized SchoolMember: %s)'%self.name;
   
        def tell(self):
            '''Tell my details.'''
            print 'Name: %s Age:%s' %(self.name, self.age);

    class Teacher(SchoolMember):
        '''Represents a teacher.'''
        def __init__(self, name, age, salary):
            SchoolMember.__init__(self, name, age);
            self.salary = salary;
            print 'Initialized Teacher: %s'%self.name;

        def tell(self):
            SchoolMember.tell(self);
            print 'Salary: %d' %self.salary;
   
    class Student(SchoolMember):
        '''Represents a student.'''
        def __init__(self, name, age, marks):
            SchoolMember.__init__(self, name, age);
            self.marks = marks;
            print 'Initialized Teacher: %s'%self.name;

        def tell(self):
            SchoolMember.tell(self);
            print 'Marks: %d' %self.marks;

    t = Teacher('Mrs. Shrividya', 40, 30000);
    s = Student('Swaroop', 22, 75);

    print ;

    members = [t, s];
    for member in members:
        member.tell();

   
    实现继承class Teacher(SchoolMember): ，基类的__init__()方法要使用self专门调用

    这一点很重要：Python不会自动调用基类的构造函数，需要我们自己专门调用。
  
    在基类构造方法前加基类名称，使用self和其他的参数进行调用。
   
    在子类名后的元组中列举了不止一个类名，那么则是多继承。

   
17. 输入/输出

    程序与用户交互，从用户得到输入，然后打印结果。分别使用raw_input和print方法实现。

    还可以使用str(字符串)类进行输出，可以参考help(str)

    文件

    创建一个file类的对象打开一个文件，分别用file类的read、readline或write方法来读写文件。

    文件操作完毕，调用close方法，关闭文件。

    #!/usr/bin/python
    #Filename: using_file.py

    poem='''\
    Programming is fun
    When the work is done
    if you wanna make your work also fun:
    use Python!
    ''';

    f = file('poem.txt', 'w'); # open for 'w'riting

    f.write(poem); # write text to file

    f.close(); # close the file

    f = file('poem.txt');
    # if no mode is specified, 'r'ead mode is assumed by default

    while True:
        line = f.readline();
        if len(line) == 0: # Zero length indicates EOF
            break;

        print line,       # Notice comma to avoid automatic newline added by Python

    f.close(); # close the file
 
    通过指定希望打开的文件和模式来创建一个file类的实例，

    模式可以为读模式('r')、写模式('w')、追加模式('a')，更多的模式可以参考help(file)文档了解。

    文件使用完毕后，一定调用close方法关闭文件。

    不指定文件模式，则是按照读模式打开。使用readline方法读取一行，这一行包含行尾的换行符。
 
    返回值为空字符串时，表明到达了文件的结尾。

    在print语句上使用逗号可以消除自动换行。

   

    持久地存储对象，Python提供了一个标准的模块，pickle，使用它可以在文件中存储任何Python对象，之后可以把它从文件中完整读取出来。
 
    还有一个类似的模块，成为cPickle，它是使用C语言写的，比pickle模块要快很多。

    #!/usr/bin/python
    #Filename: pickling.py

    import cPickle as p;

    #import pickle as p

    shoplistfile = 'shoplist.data';

    shoplist = ['apple', 'mango', 'carrot'];

    f = file(shoplistfile, 'w');

    p.dump(shoplist, f); # dump the object to a file

    f.close();

    del shoplist;

    f = file(shoplistfile);
    storedlist = p.load(f);

    print storedlist;
  
    import .. as 语法，一种便利的使用方法，以便于可以使用更短的模块名称。他还以简单地通过一行就切换到另外一个模块中(cPickle或者pickle)。

    调用存储器模块的dump函数将对象存储到打开的文件中。通过load函数返回来取得对象。

18. 异常

    程序出现某些异常的状况时候，异常就发生了。最常见的是如果要读取文件时候，文件不存在，或者运行时不小心删除了，再访问就会出现异常。

    错误：如果有错误，源码是无法执行的，并且会打印出错误的地方。

    try ... except

    >>> S = raw_input('Enter something-->');
    Enter something-->

    Traceback (most recent call last):
      File "<pyshell#0>", line 1, in <module>
        S = raw_input('Enter something-->');
    EOFError: EOF when reading a line
   
    EOFError Python引发了一个成为EOFError的错误，这个错误基本上是意味着它发现了一个不期望的文件尾。
    (这个文件尾是由Ctrl-d引起的)

    异常处理：
 
    使用try ... except语句来处理异常。通常将语句放在try-块中，而把我们的错误处理语句放在except-块

    例子：
    #!/usr/bin/python
    #Filename : try_except.py

    import sys;

    try:
        s = raw_input('Enter something -->');
    except EOFError: # catch EOFError
        print '\nWhy did you do an EOF on me?';
        sys.exit(); # exit the program

    except:   # Catch any error
        print '\n Some error/exception occurrd.';
        # here, we are not exiting the program

    print 'Done';

    except从句可以专门处理单一的错误或异常，或者一组包括在圆括号内的错误/异常。如果没有给出错误或
    异常的名称，它会处理所有的错误和异常。对于每一个try从句，至少有一个相关联的except从句。

    如果某个错误或异常没有被处理，默认的Python处理器就会被调用。它会终止程序，并且打印一个消息。

    也可以使用try...catch块关联一个else从句。当没有异常的时候，else从句将被执行。

    引发异常：
  
    使用raise语句引发异常，还需要指明错误/异常的名称或伴随异常触发的异常对象。引发的错误或异常
    应该分别从一个Error或Exception类直接或间接导出类。

    #!/usr/bin/python
    #Filename: raising.py

    class ShortInputException(Exception):
        '''A user-defined exception class.'''

        def __init__(self, length, atleast):
            Exception.__init__(self);

            self.length = length;
            self.atleast = atleast;

    try:
        s = raw_input('Enter something-->');
        if len(s) < 3:
           raise ShortInputException(len(s), 3);
        #Other work can continue as usual here

    except EOFError:
        print '\nWhy did you do an EOF on me?';
    except ShortInputException, x:
        print 'ShortinputExcetion: The input was of length %d, was excepting at least %d' %(x.length, x.atleast);
    else:
        print 'No exception was raised.';

    此处创建了一个自己的异常类型，可以使用预定义的异常/错误。新的异常类型ShortInputException，两个域

    length是给定的输入的长度，atleast则是程序期望的最小的长度。

    使用finally
    #!/usr/bin/python
    #Filename: finally.py

    import time

    try:
        f = file('poem.txt');
        while True:
            line = f.readline();
            if len(line) == 0:
                break;
            time.sleep(2);

            print line;
   
    finally:
        f.close();
        print 'Clean up... closed the file';
   

    使用time.sleep(2)故意让程序休眠2秒，这样可以有时间按下ctrl-c。

    按下ctrl+c后，程序中断，出发KeyboardInterrupt异常被触发，程序退出，但是退出之前，finally从句依然要被执行。

 

19. Python的标准库

    sys模块

    sys.argv的用法
   
    #!/usr/bin/python
    #Filename: cat.py
   
    import sys
    def readfile(filename):
        '''Print a file to standard output'''
        f = file(filename);
        while True:
            line = f.readline();
            if len(line) == 0:
                break;
            print line;
        f.close(); # don't close the file before finished.
   
    #script start from here
    if len(sys.argv) < 2:
        print 'No action specified.'
        sys.exit();
   
    if sys.argv[1].startswith('--'):
        option = sys.argv[1][2:];
   
        #fetch sys.argv[1],but without the first two characters
        if option == 'version':
            print 'Version 1.2'
        elif option == 'help':
            print '''\
        This program prints files to standard output.
        Any number of files can be specified.
        Options include:
        --version: Prints the version number
        --help:Display this help'''
        else:
        print 'Unknow option';
       
        sys.exit();
   
    else:
        for filename in sys.argv[1:]:
            readfile(filename);
   
    sys.argv列表中至少有一个项目，sys.argv[0]中保存的是当前运行的程序的名称。
    对指定的参数，是--version 或 --help将打印相应的一些信息

    使用sys.exit()方法退出程序

    更多sys内容：

    sys.version字符串提供的是安装的Python的版本信息。sys.version_info元组则提供一个更简单的版本信息。如下：

    >>> import sys;
    >>> sys.version
        '2.7.2 (default, Jun 12 2011, 15:08:59) [MSC v.1500 32 bit (Intel)]'
    >>> sys.version_info
        sys.version_info(major=2, minor=7, micro=2, releaselevel='final', serial=0)

    sys的标准输入输出项目：

    sys.stdin  sys.stdout  sys.stderr

    对应于标准输入输出，与标准错误流

    OS模块

    os.sep 取代操作系统的特定的路径分隔符。

    os.name 字符串显示正在使用的平台，不如Window 为nt Linux/unix为 posix。

    os.getcwd()获得当前工作目录，即当前Python脚本的工作的目录路径

    os.getenv() 和 os.putenv()：放别用来读取和设置环境变量

    os.listdir()：返回指定目录下的所有的文件和目录名

    os.remove()： 删除一个文件

    os.system()： 用来运行shell命令

    os.linesep()： 给出当前平台使用的行终止符，例如windows使用'\r\n', Linux使用'\n'等

    os.path.split() 返回一个路径的目录名和文件名

    os.path.isfile() 和 os.path.isdir() ： 分别判断是否是文件和目录

    os.path.existe() 判断目录或文件是否存在。

20. 更多的Python的内容

    特殊的方法：

    __init__(self, ...): 这个方法在新建对象恰好要被返回使用之前调用

    __del__(self): 恰好在对象被删除之前调用

    __str__(self): 在对对象使用print语句或是使用str()的时候调用

    __It__(self, other): 当使用小于 运算符(<)的时候调用。类似地，对于所有的运算符(+, > 等等)都有特殊方法

    __getitem__(self, key): 在使用x[key]索引操作符的时候调用

    __len__(self): 对对象使用内建的len()函数时调用

    将元组和字典作为函数参数：

    #!/usr/bin/python
    # Filename: tupleAsPara.py
   
    def powersum(power, *args):
        total = 0;
        for i in args:
            total += pow(i, power);
   
        return total;
   
    print powersum(2, 3, 4);
   
    print powersum(2, 10);

    由于args变量前有*前缀，所有多余的函数参数都会作为一个元组存储在args中。

    如果使用**前缀，多余的参数则会被作为一个字典的键值对，存入args。

    exec和eval语句：

    exec语句用来执行存储在字符串或文件中的python语句。

    可以生成一个Python代码的字符串，然后使用exec语句执行这些语句。

    例如：

    exec 'print "hello world"';

    eval语句用来计算存储在字符串中有效的Python表达式，例如：

    eval('2*3');

   
    assert语句：

    assert语句用来声明某个条件是真的。如果条件为假，则会引发错误，AssertionError错误。