python整理-day8

1、上节回顾：

　　1、面向对象的基本知识

　　　　　　1、类和对象的关系

　　　　　　2、三大特征

　　　　　　　　封装

　　　　　　　　继承

　　　　　　　　多态：多种类型，多种形态，c#和java都是通过继承来实现多态的

def func(arg):
    print(arg)

func("a")
func(123)
func([11,22,"aa"])

 结果：

a
123
[11, 22, 'aa']

 通过这个程序可以看出，我们在调用func函数的时候，并没有规定传入参数的类型。而在c#和java中，在def func(int arg)里面是要定义参数类型的

如果传入参数的类型不对，将无法进行调用，所以c#和java都是通过继承来实现这个功能的

　　　　

　　　　3、面向中类成员

　　　　　　　　1、字段

　　　　　　　　　　普通字段

　　　　　　　　　　静态字段

　　　　　　　　　　PS：静态字段在代码加载时候，已经创建

我们在上一章学习的时候，类的用法如下：

class Province:
    

    def __init__(self,name):
        self.name=name
        self.country = "中国"

hn=Province("河南")
hb=Province("河北")

 结果：

河南 中国
河北 中国

这样每次创建对象的时候，都会把相同的中国扔到内存里面， 但是我们今天学习了静态字段，我们的程序可以这样来写

class Province:
    country="中国"

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

hn=Province("河南")
hb=Province("河北")
print(hb.name)
print(hb.country)
print(Province.country)

 结果：

河北
中国
中国

 这样就是把“中国”这个字段放到静态字段里面，每次调用累的时候，都会用到这个静态字段，这样就会节省内存

而且大家也会发现，这个静态字段，hn这个对象可以通过自己得到静态字段，也可以通过类直接访问静态字段

但是我们在使用的时候，尽量不要通过类来直接访问这个静态字段

一般情况就是：自己访问自己字段

规则：

　　　　普通字段只能用对象访问

　　　　静态字段用类访问（不到万不得已的时候可以使用对象访问）

 

　　　　　　　　2、方法

　　　　　　　　　　所有的方法属于类

　　　　　　　　　　普通方法：至少一个self有对象去调用执行（方法属于类）

　　　　　　　　　　静态方法：由类去调用，任意参数

　　　　　　　　　　类方法：   至少有一个cls，类执行

普通方法：由对象去调用执行（方法属于类）

class Province:


    def __init__(self,name):
        self.name=name
        self.country = "中国"
        print(self.name,self.country)

hn=Province("河南")

 这种就是普通方法

 

class Foo:
    def __init__(self,name):
        self.name=name

    def show(self):
        print(self.name)

    @staticmethod
    def f1(name):
        print(name)


obj=Foo("heihei")
obj.show()
Foo.f1("haha")

 结果：

heihei
haha

 这个就是静态方法，需要在类里面的某个方法前面添加一个@staticmethod，这样就实现了静态方法

 

class Foo:
    def __init__(self,name):
        self.name=name

    def show(self):
        print(self.name)

    @staticmethod
    def f1(name):
        print(name)
    @classmethod
    def f2(cls,a1):
        print(cls,a1)

obj=Foo("heihei")
obj.show()
Foo.f1("haha")
Foo.f2("oo")

 结果：

heihei
haha
<class '__main__.Foo'> oo

 这个就是类方法，比静态方法，多了一个功能就是自动把类名传进去

参数想传什么就传什么

 

　　　　　　　　3、属性

　　　　　　　　　　　　不伦不类的东西，具有方法的写左行驶，具有字段的访问形式

class Foo:
    def __init__(self,name):
        self.name=name

    @property
    def all_pager(self):
        a1, a2 = divmod(self.name, 10)
        if a2 == 0:
            return a1
        else:
            return a1+1

p=Foo(101)
# p.all_pager #字段
# r=p.all_pager()#方法
# print(r)

ret=p.all_pager
print(ret)

 结果：

11

 让方法以字段的方式去使用

 这是一种使用属性的方法，里面定义了setter和del，在执行的时候直接调用类的方法

class Foo:
    def __init__(self,name):
        self.name=name

    @property
    def all_pager(self):
        a1, a2 = divmod(self.name, 10)
        if a2 == 0:
            return a1
        else:
            return a1+1
    @all_pager.setter
    def all_pager(self,value):
        print(value)

    @all_pager.deleter
    def all_pager(self):
        print("del all_pager")

p=Foo(101)
# p.all_pager #字段
# r=p.all_pager()#方法
# print(r)

ret=p.all_pager
print(ret)

del p.all_pager

结果：

11
del all_pager

 

属性还有另一种存在方式

 

class Foo:
    def f1(self):
        return 123
    def f3(self):
        print("del")

    Foo=property(fget=f1,fdel=f3)
p=Foo()
r=p.Foo
print(r)

del p.Foo

 结果：

123
del

 fget、fset、fdel这些名字可以随便起名，但是顺序必须要和我程序里面的顺序相同

 

　　　　　　　　　　4、成员修饰符

　　　　　　　　　　　　　　公有

　　　　　　　　　　　　　　私有：只能类本身成员内部可以访问

class Foo:
    def __init__(self,name):
        self.__name=name

    def __show(self):
        print(self.__name)

    @staticmethod
    def __ha():
        print("haha")

    def f1(self):
        self.__show()
    def f2(self):
        Foo.__ha()

p=Foo("wzc")
p.f1()
p.f2()

 结果：

wzc
haha

 私有：__name这种就是私有，无法被外部访问，继承也无法访问，只有本身可以访问

　　　　　　　　　　5、特殊成员

　　　　　　　　　　　　__init__

　　　　　　　　　　　　__doc__

　　　　　　　　　　　　__call__

　　　　　　　　　　　　__str__

　　　　　　　　　　　　__dict__,获取所有字段信息，获取对象中封装的所有数据

　　　　　　　　　　　　__getitem__

　　　　　　　　　　　　__settiem__

　　　　　　　　　　　　__delitem__

　　　　　　　　　　　　等等

析构方法，在垃圾回收机制之前执行

对象后面加（），执行的是call方法

类后面加（），执行init方法

　　

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __del__(self):
        pass
    def __call__(self, *args, **kwargs):
        print("call")
    def __str__(self):
        return "str"
    def __getitem__(self, item):
        return 123
    def __setitem__(self, key, value):
        print("setitem")
    def __delitem__(self, key):
        print("delitem")


p=Foo("wzc",18)
p()

print(p)

print(p.__dict__)

ret=p['ad']
print(ret)

p['haha']=111

del p['k']

 结果：

call
str
{'age': 18, 'name': 'wzc'}
123
setitem
delitem

 

 

切片的应用

class Foo:
    def __getitem__(self, item):
        print(type(item))
        return 123
    def __setitem__(self, key, value):
        print(type(key),type(value))

    def __delitem__(self, key):
        print(type(key))

obj=Foo()

ret=obj[1:4:2]
obj[1:4]=[11,22,33,44]

 结果：

<class 'slice'>
<class 'slice'> <class 'list'>

 

iter方法

class Foo:
    def __iter__(self):
        #return iter([111,11,22,33])
         yield 1
         yield 2

obj=Foo()

for item in obj:
    print(item)

 结果：

1
2

 　　　　　　　　　　6、面向对象，相关联的其他边缘性的知识

　　　　　　　　　　　　　--isinstance 是不是有类创建的对象

　　　　　　　　　　　　　--issunclass是不是父类的子类

　　　　　　　　　　　　　--继承与2.7

　　　　　　　　　　　　　--应用：

　　　　　　　　　　　　　　　　自定义类型，对字典进行补充，有序字典

　　　　　　　　　　　　　　　　源码的扩展

 

class BAR:
    def f1(self):
        pass

class FOO(BAR):
    def f2(self):
        pass

obj=FOO()
ret=isinstance(obj,BAR)

print(ret)

r=issubclass(FOO,BAR)
print(r)

 结果：

Ture
Ture

 

使用super来执行父类的方法

class Foo1:
    def f1(self):
        print("c1.f1")


class Foo2(Foo1):
    def f1(self):
        ret=super(Foo2,self).f1()
        print("c2.f1")


obj=Foo2()
obj.f1()

 结果：

c1.f1
c2.f1

 c1.fi(self)也可以直接调用，但是不推荐使用

　　　　　　　　　　7、异常处理

try:
    pass

except ValueError as ex:
    print(ex)

except Exception as ex:
    print(ex)

else:
    pass

finally:
    pass

 这个是一个异常处理的程序，我们会发现异常处理的执行方式是从上往下走，这也就是异常处理的捕获顺序

上面这个程序的执行顺序是：

一条线是：
try==》else==》finally
另一条线：
try错误==》except没生效的话==》except==》finally 

try里面如果那里出错了，就会跳出执行except，后面的不会被执行

 

如果想要测试的话，可以使用 raise 来主动错误进行测试

 

　　　　　　　　　　8、设计模式之单例模式

可以用类方法和静态方法来实现，一般用类方法来实现

class Foo:

    instance=None

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

    @classmethod
    def get_instance(cls):
        if cls.instance:
            return cls.instance
        else:
            obj=cls("wzc")
            cls.instance=obj
            return obj

obj1=Foo.get_instance()
print(obj1)

obj2=Foo.get_instance()
print(obj2)

 结果：

<__main__.Foo object at 0x101176be0>
<__main__.Foo object at 0x101176be0>