python复习帖

模块使用

模块是Python组织代码的基本方式

一个Python脚本可以单独运行，也可以导入到另一个脚本中运行，当脚本被导入运行时，我们将其称为模块（module）

所有的.py文件都可以作为一个模块导入

模块名称与脚本的文件名相同，例如我们编写了一个名为hello.py的脚本，则可以在另一个脚本中用import hello语句来导入它

包（模块的集合）：

Python的模块可以按照目录组织为包

创建一个包的步骤：

-创建一个名字为包名的目录

-在该目录下创建一个__init__.py文件

-根据需要，在该目录下存放脚本文件或已编译的扩展及子包

-import pack.m1,pack.m2,pack.m3

编写一个脚本（block.py），统计一个文件的行数，单词数，字符数：

#!/usr/bin/python

def wordCount(s):

    chars = len(s)

    words = len(s.split())

    # lines = len(s.split('\n'))

    lines = s.count('\n')

    print lines,words,chars

s = open('/etc/passwd').read()

wordCount(s)

新建一个block2.py文件，只写入一句import block，执行block2.py文件，结果和执行block.py文件一致

模块是一个可导入的python脚本文件

包是一些按目录组织的模块和子包，目录下有__init__.py文件，此文件可存放包的信息

导入模块和包的语法：

--import，import as（取别名，如：from day02.block import wordCount as wc）

--from...import...     如：from day02 import block（import day02.block），

                              如果想直接使用函数 from 包名.模块名 import 函数名/类名

面向对象介绍

面向过程和面向对象编程：

--面向过程编程：函数式编程，C程序等（shell）

--面向对象编程：C++，Java，Python等，主要思想是：封装，继承，多态

类和对象：

-类：是对事物的抽象，比如：人类，球类

-对象：是类的一个实例，如：足球，篮球

实例说明：球类可以对球的特征和行为进行抽象，然后可以实例化一个真实的球实体出来

类定义：

类把需要的变量和函数组合成一起，这种包含称为“封装”

class A（object）：

类的结构：

class 类名：

         成员变量 - 属性

         成员函数 - 方法

#!/usr/bin/python

class People(object):

    color = 'yellow'

    def think(self):     #类的方法中至少有一个参数self，表示类自己（有其他参数的话继续添加在后面）

        self.color = "black"

        print "I am a %s" % self.color

        print "I am a thinker"

ren = People()     #实例化（创建对象），将类赋值给变量

print ren.color     #使用对象.属性进行访问

ren.think()           #对象.方法进行调用

类的属性

类的属性又可以叫做成员变量

类的方法又可以叫做成员函数

对象的创建：

创建对象的过程称之为实例化，当一个对象被创建后，包含三个方面的特性：对象句柄，属性和方法

句柄用于区分不同的对象

对象的属性和方法与类中的成员变量和成员函数对应

obj = MyClass（）//创建类的一个实例（对象），通过对象来调用方法和属性

类的属性按使用范围分为公有属性和私有属性，类的属性范围取决于属性的名称

公有属性：在类中和类外都能调用的属性

私有属性：不能在类外及被类以外的函数调用，定义方式：以“__”双下划线开始的成员变量就是私有属性

                可以通过instance._classname__attribute方式访问（如：instance._People__age），一般仅作测试用

内置属性：由系统在定义类的时候默认添加的，由前后双下划线构成，__dict__，__module__

类的方法

方法的定义和函数一样，但是需要self作为第一个参数

类方法为：

-公有方法：在类中和类外都能调用的方法

#!/usr/bin/python

class People(object):

    color = 'yellow'

    __age = 30

    def think(self):

        self.color = "black"

        print "I am a %s" % self.color

        print "I am a thinker"

        print self.__age

    def test(self):

        self.think()

ren = People()

ren.test()

-私有方法：不能被类的外部调用，在方法前面加上“__”双下划线就是私有方法

#!/usr/bin/python

class People(object):

    color = 'yellow'

    __age = 30

    def __talk(self):

        print "I am talking with Tom"

    def test(self):

        self.__talk()

ren = People()

ren.test()

-类方法：被classmethod()函数处理过的函数，能被类所调用，也能被对象所调用（是继承的关系），（需要哪些东西才加载哪些东西，动态的，类方法占用资源很少）

#!/usr/bin/python

class People(object):

    color = 'yellow'

    __age = 30

    def __talk(self):

        print "I am talking with Tom"

    def test(self):

        print "Testing..."

    cm = classmethod(test)

People.cm()

-静态方法：相当于“全局函数”，可以被类直接调用，可以被所有实例化对象共享，通过staticmethod()定义，静态方法没有“self”参数（会将类中所有的东西都加载到内存，占用资源较多，但是速度比动态方法更快）

因为没有self参数，所以访问内中其他成员的时候，可以通过类直接访问，如People.color

#!/usr/bin/python

class People(object):

    color = 'yellow'

    __age = 30

    def __talk(self):

        print "I am talking with Tom"

    def test():

        print "Testing..."

    sm = staticmethod(test)

People.sm()

装饰器（只对其下一个方法起作用）：

-@classmethod

-@staticmethod

#!/usr/bin/python

class People(object):

    @classmethod

    def test(self):

        print "This is class method"

    @staticmethod

    def test1():

        print "This is static method"

People.test()

People.test1()

self参数：用于区分函数和类的方法（必须有一个self），self参数表示执行对象本身

类的内置方法

内部类：在类的内部定义的类，主要目的是为了更好的抽象现实世界

例子：汽车是一个类，汽车的底盘、轮胎也可以抽象为类，将其定义到汽车类中，则形成内部类，更好的描述汽车类，因为底盘、轮胎是汽车的一部分

内部类的实例化方法：

-1.直接使用外部类调用内部类

     object_name = outclass_name.inclass_name()

#!/usr/bin/python

class People(object):

 

    class Chinese(object):

        print "I am chinese"

ren = People.Chinese()

-2.先对外部类进行实例化，然后再实例化内部类

     out_name = outclass_name()

     in_name = out_name.inclass_name()

     in_name.method()

#!/usr/bin/python

class People(object):

    class Chinese(object):

        print "I am chinese"

ren = People()

chin = ren.Chinese()

__str__(self)

#!/usr/bin/python

class People(object):

    color = 'yellow'

    __age = 30

    def __str__(self):

        return "This is People class"

ren = People()

print ren

构造函数和析构函数：

-构造函数：用于初始化类的内部状态，Python提供的构造函数是__init__()

                  __init__()方法是可选的，如果不提供，Python会给出一个默认的__init__方法

#!/usr/bin/python

class People(object):

    color = 'yellow'

    __age = 30

    def __init__(self,c = 'red'):

        self.color = c

ren = People()          #括号中没有传值，便使用默认值red，如果有值则使用传的值

print ren.color          #red

print People.color     #yellow

-析构函数：用于释放对象占用的资源，Python提供的析构函数是__del__()

                  __del__()也是可选的，如果不提供，Python会在后台提供默认的析构函数

#!/usr/bin/python

class People(object):

    color = 'yellow'

    __age = 30

    def __init__(self,c = 'red'):

        self.color = c

        self.think()

        self.fd = open('/etc/hosts')

    def think(self):

        self.color = "black"

        print "I am a %s" % self.color

        print "I am a thinker"

        print self.__age

    def __del__(self):     #del在脚本最后才执行

        print "del ..."

        self.fd.close()

ren = People()

print ren.color

print People.color

print "main end"

Python垃圾回收机制：gc模块的collect()可以一次性收集所有待处理的对象（gc.collect）

类的继承

继承是面向对象的重要特性之一

继承关系：继承是相对两个类而言的父子关系，子类继承了父类的所有公有属性和方法

继承实现了代码

继承可以重用已经存在的数据和行为，减少代码的重复编写。Python在类名后使用一对括号来表示继承关系，括号中的类即为父类

class Myclass（ParentClass）

#!/usr/bin/python

class People(object):

    color = 'yellow'

    def think(self):

        print "I am a %s" % self.color

        print "I am a thinker"

class Chinese(People):

    pass

cn = Chinese()

print cn.color

cn.think()

如果父类定义了__init__方法，子类必须显式调用父类的__init__方法：ParentClass.__init__（self，[args...]）

如果子类需要扩展父类的行为，可以添加__init__方法的参数

#!/usr/bin/python

class People(object):     #传统的定义风格可以省略（object）

    color = 'yellow'

    def __init__(self,c):

        self.dwell = 'Earth'

    def think(self):

        print "I am a %s" % self.color

        print "I am a thinker"

class Chinese(People):

    def __init__(self):

        People.__init__(self,'red')     #本行代码还可以使用super函数，super(Chinese,self).__init__('red')

    pass

cn = Chinese()

print cn.color

多重继承：Python支持多重继承，即一个类可以继承多个父类

语法：class class_name（Parent_c1,Parent_c2...）

注意：当父类中出现多个自定义的__init__方法时，多重继承只执行第一个类的__init__方法，其他不执行

#!/usr/bin/python

class People(object):

    color = 'yellow'

    def __init__(self):

        self.dwell = 'Earth'

    def think(self):

        print "I am a %s" % self.color

        print "My home is %s" % self.dwell

class Martian(object):

    color = 'red'

    def __init__(self):

        self.dwell = 'Martian'

class Chinese(People,Martian):     #默认调用第一个父类（People）的__init__构造函数，如果想要使用其他的便需要进行显式调用

    #def __init__(self):

        #Martian.__init__(self)     #显式调用

    pass

cn = Chinese()

cn.think()

类的属性总结

#!/usr/bin/python

#coding:utf8

var6 = '全局变量 var6'

class MyClass(object):

    var1 = '类属性，类的公有属性 var1'

    __var2 = '类的私有属性 __var2'

    def func1(self):

        self.var3 = '对象的公有属性 var3'

        sesslf.__var = '对象的私有属性 __var4'

        var5 = '函数的局部变量'

    def func2(self):

        print self.var1  #可以访问

        print self.__var2  #可以访问

        print self.var3  #不能访问，除非先执行一次mc.func1()

        print self.__var4  #不能访问，除非先执行一次mc.func1()

        print self.var5  #不能访问

        print var6  #可以访问

mc = MyClass()

print mc.var1  #可以访问，公有属性

print mc.__var2  #不能访问，私有属性

print mc._MyClass__var2  #仅供测试访问使用

mc.func1()

print mc.var3  #没有执行mc.func1()之前无法访问

print mc.__var4  #不能访问，私有属性

print mc.var5  #不能访问，函数的局部变量

print MyClass.var1  #可以访问

print MyClass.__var2  #不能访问

print MyClass.var3  #不能访问

mc.func2()

类的方法总结

#!/usr/bin/python

#coding:utf8

class MyClass(object):

    name = "Test"

    def __init__(self):    #内置方法

        self.func1()

        self.__func2()

        self.classFun()

        self.staticFun()

    def func1(self):

        print self.name,

        print "我是公有方法"

    def __func2(self):

        print self.name,

        print "我是私有方法"

    def classFun(self):

        print self.name,

        print "我是类方法"

    def staticFunc(self):

        print self.name,

        print "我是静态方法"

mc = MyClass()

#mc.func1()  #可以调用

#mc.__fun2()  #不能调用（可以在类内部调用）

#MyClass.classFun()  #不能调用（可以在方法上边加上一个装饰器@classmethod）

#MyClass.staticFun()  #不能调用（可以在方法上面加上一个装饰器@staticmethod,并且将self.name改为MyClass.name,通过类名进行调用，同时将括号中的self参数去掉）