Python之路_Day8

Python之路_Day8_课堂笔记

---

前期回顾

---

本期内容

一、作业

要点：

二、上节内容回顾和补充

面向对象三大特性：

多态

三、面向对象中成员

字段

方法

属性

四、成员修饰符

五、特殊成员

__init__

__doc__

__call__

__setitem__

...

六、面向对象其他知识

- isinstance

- issubclass

- 继承 2.7

- 应用：

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

源码的扩展

七、异常处理

八、设计模式之单例模式

类方法

静态方法

---

一、作业

要点：

1、封装，对象中嵌套对象

2、pickle，load：切记，一定要先导入相关的类

---

二、上节内容回顾和补充

面向对象基本知识：

1、类和对象的关系

2、三大特性：

封装

继承

3、多态：多种形态，多种类型

python的多态

def func(arg):

print(arg)

func(1)

func("sandler")

func([11,22,33])

C#/Java的多态

def func(int arg):

print(arg)

func(123)

func("sandler")    # 报错

---

三、面向对象中类成员

1、字段

class Foo:

# 字段（静态字段）

CC = 123

def __init__(self):

# 字段（普通的字段）

self.name = 'sandler'

def show(self):

print(self.name)

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
class Province:
    country = '中国'
    def __init__(self,name):
        self.name = name
hn = Province('河南')
print(hn.name)
print(Province.country)
print(hn.country)

一般情况下，自己访问自己的字段

规则：

普通字段只能用字段访问

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

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

2、方法

所有的方法属于类

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

至少一个self，通过对象执行

静态方法，由类调用执行

任意参数，由类执行（对象执行）

类方法，由类调用执行

至少一个cls，类执行（对象执行）

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
class Province:
    country = '中国'
    def __init__(self,name):
        self.name = name
        # 普通方法，由对象去调用执行（方法属于类）
    def show(self):
        print(self.name)
    @staticmethod
    def f1(arg1,arg2):
        # 静态方法是有类调用执行（当方法内部不需要对象中封装的值时，可以将方法携程静态方法）
        print(arg1,arg2)
    @classmethod
    def f2(cls):
        # 类方法，由类执行
        print(cls)
Province.f1(11,22)
Province.f2()

3、属性

属性是个不伦不类的东西

具有方法的写作形式，具有字段的访问形式，

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
class Pager:
    def __init__(self,all_count):
        self.all_count = all_count
    @property
    def all_pager(self):
        a1,a2 = divmod(self.all_count , 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 = Pager(101)
ret = p.all_pager
print(ret)  # 获取
p.all_pager = 111   # 设置
del p.all_pager # 删除

属性的另一种表达方式：

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
class Pager:
    def __init__(self,all_count):
        self.all_count = all_count
    def f1(self):
        return 123
    def f2(self,value):
        pass
    def f3(self):
        pass
    foo = property(fget=f1,fset=f2,fdel=f3)
p = Pager(101)
result = p.foo
print(result)   # 自动调用f1
p.foo = 'sandler'   # 自动调用f2
del p.foo   # 自动调用f3

---

四、类成员修饰符

公有：

内部和外部都可以访问的字段

私有：

只能类自己本身成员可以访问

只有内部可以访问的字段，在字段前加两个下划线表示私有字段，无法继承

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
# 成员修饰符
class Foo:
    __cc = "123"
    def __init__(self,name):
        self.__name = name
    def f1(self):
        print(self.__name)
    @staticmethod
    def f3():
        print(Foo.__cc)
# print(Foo.__cc)
obj = Foo("san")
obj.f3()
Foo.f3()
class Foo:
    __cc = "123"
    def __init__(self,name):
        self.__name = name
    def f1(self):
        print(self.__name)
class Bar(Foo):
    def f2(self):
        print(self.__name)
# obj = Bar("san")
# obj.f2()
# obj.f1()

强制访问私有，一般不可以使用

print(obj._Foo__name)

---

五、特殊成员

__init__

构造方法，创建对象时自动执行

__del__

析构方法，当对象在内存中被释放时，自动触发执行    

注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

__doc__

表示类的描述信息

__module__

表示当前操作的对象在那个模块

__class__

表示当前操作的对象的类是什么

__call__

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
class Foo:
    
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def __call__(self, *args, **kwargs):
        print('call')
        
    def __str__(self):
        return '%s - %d' %(self.name,self.age)
    
obj = Foo()
obj()

__dict__

获取对象中的所有字段数据

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __call__(self, *args, **kwargs):
        print('call')
    def __str__(self):
        return '%s - %d' %(self.name,self.age)
obj1 = Foo('san' , 18)
obj2 = Foo('yuli' , 19)
ret = obj1.__dict__
print(ret)

__str__

如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __call__(self, *args, **kwargs):
        print('call')
    def __str__(self):
        return '%s - %d' %(self.name,self.age)
obj1 = Foo('san' , 18)
obj2 = Foo('yuli' , 19)
print(obj1)
print(obj2)
ret = str(obj1)
print(ret)

__getitem__、__setitem__、__delitem__

用于索引操作，如字典。以上分别表示获取、设置、删除数据

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __call__(self, *args, **kwargs):
        print('call')
    def __str__(self):
        return '%s - %d' %(self.name,self.age)
    def __getitem__(self, item):
        print('getitem')
    def __setitem__(self, key, value):
        print('setitem')
    def __delitem__(self, key):
        print('delitem')
obj = Foo('san' , 19)
ret  = obj['aa']    # getitem
print(ret)
obj['k1'] = 111 # setitem
del obj['k1']   # delitem

__getslice__、__setslice__、__delslice__

该三个方法用于分片操作

注：该三个方法在Python3中已经弃用，Python3中直接使用__getitem__,__setitem__,__delitem__

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __call__(self, *args, **kwargs):
        print('call')
    def __str__(self):
        return '%s - %d' %(self.name,self.age)
    def __getitem__(self, item):
        # item.start    item.stop   item.step
        print(type(item))
        return 123
    def __setitem__(self, key, value):
        # key.start    key.stop   key.step
        print(type(key),type(value))
    def __delitem__(self, key):
        # key.start    key.stop   ikeytem.step
        print(type(key))
obj = Foo('san' , 19)
ret = obj[1:4:2]
obj[1:4] = [11,22,33,44]
del obj[1:4]

__iter__

用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
class Foo:
    def __iter__(self):
        return iter([11,22,33,44])
obj = Foo()
for item in obj:
    print(item)

__new__,__metaclass__

---

六、面向对象其他知识

- isinstance    # 查看某个类是不是

- issubclass    # 查看某个类是不是子类

- 继承 2.7

- 执行父类构造方法

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
# 执行父类的构造方法
class C1:
    def f1(self):
        print('C1.f1')
class C2(C1):
    def f1(self):
        super(C2,self).f1() # 执行父类的f1
        print('C2.f1')
obj = C2()
obj.f1()

- 应用：

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

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
# 有序字典
class MyDict(dict):
    def __init__(self):
        self.li = []
        super(MyDict,self).__init__()
    def __setitem__(self, key, value):
        self.li.append(key)
        super(MyDict,self).__setitem__(key,value)
    def __str__(self):
        temp_list = []
        for key in self.li:
            value = self.get(key)
            temp_list.append("'%s',%s" %(key,value,))
        temp_str = "{"+",".join(temp_list)+"}"
        return temp_str
obj = MyDict()
obj['k1'] = 123
obj['k2'] = 456
print(obj)

源码的扩展

---

七、异常处理

---

八、设计模式之单例模式（23种，goF设计模式）

单例模式

用来创建单个实例

#!/usr/bin/env python
# -.- coding: utf-8 -.-
# By sandler
# 单例模式
class Foo:
    instance = None
    def __init__(self,name):
        self.name = name
    @classmethod
    def get_instance(cls):
        # cls 类名
        if cls.instance:
            return cls.instance
        else:
            obj = cls("san")
            cls.instance = obj
            return obj
obj1 = Foo.get_instance()
print(obj1)
obj2 = Foo.get_instance()
print(obj2)

类方法

静态方法

---

---

来自为知笔记(Wiz)