面向对象、查看socketserver源代码执行过程、反射 、异常处理、单例模式

面向对象基础

 1、面向对象不是所有情况都适用

2、面向对象编程

• 　　定义类
  　　class 类名:
                  def  方法1（self,bb）
                  pass
  
  
• 根据类创建对象
  适用对象去执行类中方法

 

class oldboy: #创建类oldboy
    def fetch (self, backend):  #定义方法
        print()
        
    def add_record (self, backend, record):#定义方法
        pass
    
obj = oldboy() #根据类创建对象
obj.fetch() #使用对象去执行类中的方法
obj.add_record()

 

 

封装

class oldboy: #创建类oldboy
    def fetch (self):  #定义方法
        print(self.backend )

    def add_record (self, record):#定义方法
        print(self.backend )

obj1 = oldboy() #根据类创建对象
obj1.backend = "www.Freechen.com" #封装到obj1
obj1.fetch()

obj2 = oldboy() #根据类创建对象
obj2.backend = "www.oldboy.com" #封装到obj2
obj2.fetch()

构造方法:  __init__

　　类+括号 ----》 自动执行类中的 __init__方法：创建了一个类

　　在__init__方法中执行具体的封装的操作

　　__init__ 有一个特殊的名字：构造方法

　　初始化  

 　　__del__ 解释器销毁对象的时候自动调用，特殊名称：析构方法。

========================结果==========================

封装：

　　使用场景：当同一类型的方法具有相同参数时，直接封装到对象即可。

　　使用场景：当类当做模板，创建多个对象，（对象内封装的数据可以不一样）

class foo:
    def __init__(self): #构造方法
        print("init")

obj = foo() #默认执行__init__方法


class foo:
    def __init__(self,bk): #构造方法
        self.name = "alex" #封装
        self.favor = bk  #封装

obj1 = foo("xx") #默认执行__init__方法
r = obj1.name
r2 = obj1.favor
print(r,r2)

class oldboy: #创建类oldboy
    def __init__(self,backend):
        self.name = backend #普通字段
        
    def fetch (self):  #定义方法
        print(self.backend )
        
    def add_record (self, record):#定义方法
        print(self.backend )
        
obj1 = oldboy("alex") #根据类创建对象
ret = obj1.name
print(ret)

 继承：

1、派生类可以继承基类中所有的功能

2、派生类和基类同时存在相同的方法时，优先找派生类。

3、可继承多个类。优先级是：自己----左边----右边

class Animals:
    def  chi(self):
        print(self.name + "吃")

    def he(self):
        print(self.name+"喝")

class Dog(Animals): #继承Animals，Dog是Animals的子类，也叫派生类。Animals 是Dog的父类，也叫基类。
    def __init__(self, name):
        self.name = name

    def jiao(self):
        print(self.name + "汪")
alex = Dog("李杰")
alex.chi()
alex.he()
alex.jiao()

 多继承优先级：python3.5

 

多态：

　　多种形态

面向对象有三大特性：封装、继承、多态。python支持多继承，其他语言不可以。

接口：Python不存在接口

 

一、面向对象进阶

　　成员

　　　　通过类访问的有：静态字段

　　　　通过对象访问：普通字段，类的方法。
　　成员修饰符

　　　　　　出了自己谁也不好使

　　　　　　私有

　　面向对象一些常用特殊方法 __init__ __call__ __delitm__ __dict__  __iter__

　　　　___metaclass__  __new__

二、异常处理

　　　　try :

　　　　　　xxx

　　　　except Execption as e :

　　　　　　print(e)

　　　　try :

　　　　　　xxx

　　　　except Execption as e :

　　　　　　xxx

　　　　else:

　　　　　　xxx

　　　　finally:　　

　　　　　　xxx

三、单例模式

继承：

class A:
    def bar(self):
        self.f1()
    def f1(self):
        print("A")
class B(A):
    def f1(self):
        print("B")
class C:
    def f1(self):
        print("C")
class D(C,B):
    def f1(self):
        print("D")
dd = D()
dd.bar()

 

 

 

 

 派生类执行基类的构造方法：》

class Annimal:
    def __init__(self):
        print("Aninimal的构造方法")
        self.ty = "动物"

class Cat(Annimal):
    def __init__(self):
        print("Cat的构造方法")
        self.n = "猫"
        #执行父类的构造的两种方法，推荐使用super
        super (Cat, self).__init__()  #第一种方法
        Annimal.__init__(self) #第二种方法       
c = Cat()
print(c.__dict__)

查看socketserver源代码执行过程

以字符串的形式去对象、模块中操作成员。

#反射
#以字符串的形式去对象、模块中操作成员。
#反射：类，只能找类里的成员。
#反射：对象，即可找对象，也可以找类的成员。
class Foo:
    def __init__(self,name):
        self.name = name
    def show(self):
        print("show")
obj = Foo("free")
#对象中找
r = hasattr(obj,"name")
print(r)
r = hasattr(obj,"show")
print(r)
r = hasattr(obj,"show")
print(r)

 

 利用反射导入模块、查找类、创建对象、查找对象中的字段

静态字段，在类中：将对象中存在多份一样的内容，放在类中，即静态字段

class Provice:
    #静态字段，在类中：将对象中存在多份一样的内容，放在类中，即静态字段
    country = "China"
    def __init__(self,name):
        #普通字段，在对象中
        self.name = name
    #普通方法，类中
    def show(self):
        print("show")
hebei = Provice("河北")
henan = Provice("河南")

静态字段、静态方法，用类来调用

class Provice:
    #静态字段，在类中：将对象中存在多份一样的内容，放在类中，即静态字段
    country = "China"
    def __init__(self,name):
        #普通字段，在对象中
        self.name = name
    #普通方法，类中
    def show(self):
        print("show")
    #静态方法
    @staticmethod
    def xo():
        print("xo")

print (Provice.country)
Provice.xo()

类方法：

class Provice:
    #静态字段，在类中：将对象中存在多份一样的内容，放在类中，即静态字段
    country = "China"
    def __init__(self,name):
        #普通字段，在对象中
        self.name = name
    #普通方法，类中
    def show(self):
        print("show")
    #类方法，必须有一个参数，
    @classmethod
    def xxoo(cls):
        print("xxoo")
    #静态方法
    @staticmethod
    def xo():
        print("xo")

Provice.xo()
Provice.xxoo()

类的特性：

#特性，访问时将方法伪造成一种字段

class Provice:
  
    @property
    def end(self):
        temp = "%s sb"%self.name
        return temp

obj = Provice("Free")
print( obj.end)

 给特性方法，设置值

class Provice:
    #静态字段，在类中：将对象中存在多份一样的内容，放在类中，即静态字段
    country = "China"
    def __init__(self,name):
        #普通字段，在对象中
        self.name = name
    #普通方法，类中
    def show(self):
        print("show")
    #类方法，必须有一个参数，
    @classmethod
    def xxoo(cls):
        print("xxoo")
    #静态方法
    @staticmethod
    def xo():
        print("xo")
    def start(self):
        temp = "%s sb"%self.name
        return temp
    #特性，访问时将方法伪造成一种字段
    @property
    def end(self):
        temp = "%s sb"%self.name
        return temp
    @end.setter
    def end(self,value):
        print(value)
        self.name = value
obj = Provice("Alex")
print(obj.end)
obj.end = "123"
print(obj.end)

 

 

#__成员修饰符，只有内部成员才可以访问它，私有的只有自己可以访问，子类也不可以访问。

class Foo:
    xo = "xo"
    __ox = "ox" #__成员修饰符，只有内部成员才可以访问它

    def f1(self):
        print("F1")
        print(Foo.__ox) #内部访问私有静态字段
obj = Foo()
print(Foo.xo)
# print(Foo.__ox)
obj.f1()

成员修饰符：公有、私有

 

__call__

class Foo:
    def __init__(self):
        print("init")

    def __call__(self, *args, **kwargs):
        print("call")
r = Foo() 
r()#调用__call__
Foo()()#调用__call__

__getitem__方法

class Foo:
    def __init__(self):
        print("init")

    def __call__(self, *args, **kwargs):
        print("call")

    def  __getitem__(self, item):
        print(item)
r = Foo()
r()#调用__call__
Foo()()#调用__call__
r["k1"]  #中括号执行__getitem__方法。

r = Foo()       #执行__init__方法
r()             #执行__call__方法
r["k1"]         #执行__getitem__方法
r["k1"] =123    #执行__setitem__方法
del r["k2"]     #执行__delitm__方法

 

class Foo:
    '''
        我是类的注释
    '''
    def __init__(self):
        print("init")

    def __call__(self, *args, **kwargs):
        print("call")

    def  __getitem__(self, item):
        print(item)
obj = Foo()
print(obj.__dict__)
print(Foo.__dict__)

基本异常处理：

inp = input("Please:")
try:
    num = int(inp)
    print(num)
except  Exception as e:
    print("数据类型有误")

inp = input("Please:")
try:
    num = int(inp)
    print(num)
except ValueError as e: #捕捉值错误，捕捉到之后停止执行，没有捕捉到，继续往下执行。
    print("值错误")
except  Exception as e: #捕捉所有的错误
    print("数据类型有误")

 主动触发异常

try:
    print("123")
    raise Exception("出错了") # 主动触发异常
except Exception as e:
    print(e)

其他异常结构

 

 __str__方法

class Foo:
    def __init__(self,arg):
        self.xo = arg

    def __str__(self):
        return self.xo

obj = Foo('出错了……')
print(obj)

断言

assert  1==1  assert 条件。条件成立往下执行，条件不成立报错。

单例模式

GoF设计模式

大话设计模式

 

设计模式一：单例模式：只有一个实例：静态方法+静态字段。

所有的实例中封装的内容相同时，用单例模式。

====================应用========================

创建Web站点并应用单例模式

#python 2.7

from wsgiref.simple_server import make_server

def RunServer(environ,start_response):
    start_response(status='200 OK', headers=[('Content-Type', 'text/html')])
    url = environ['PATH_INFO']


    return "Oldboy1"


if __name__ == '__main__':
    httpd = make_server('',8000,RunServer)
    print ("Serving HTTP on prot 8000....")
    httpd.serve_forever()