python 基础 day8

Posted 2020-07-31

pickle.load:切记，如果写入文件的是类，一定要先导入相关的类

一、上节回顾补充

二、面向对象（下） 成员

　　1、字段 2、方法 3、属性

三、成员修饰符

四、特殊成员

五、面向对象边缘

六、异常处理

七、设计模式之单例模式

 

一、上节回顾补充

　　面向对象基本知识：

　　　　1、类和对象的关系

　　　　2、三大特性： 封装、继承、多态（多种形态、多种类型）

多态：

def func(arg):        #python中不用指定参数arg类型
    print(arg)
func(1)               #可以三数字
func("alex")          #可以三字符串
func([11,22,33,])     #可以三列表

在C#/java中 必须制定参数类型，下面用python的方式举例：

def func(A arg): #必须指定类型 
    print(arg)
                
func(123)
func("alex") #报错（如果不是int类型就报错）
            
class A:
    pass
class B(A):
    pass
class C(A):
    pass
#arg 参数：必须是A类型或A的派生类类型
def func(A arg): #这里必须指定父类A,但arg的类型的类型可以三A、B、C
    print(arg)

 

二、面向对象中 成员

字段:

　　静态字段、普通字段

ps:静态字段在代码加载时已经创建

class foo:
    #字段（静态字段）属于类，用类调用
    cc = 123

    def __init__(self):
        #字段(普通的字段)保存在对象里，用对象调用
        self.name = ‘alex‘  #如果没有创建对象，那么内存里就没有普通字段

一般情况：自己访问自己的字段

class Province:
    country = "中国"

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

hn = Province("河南")
hb = Province("河北")
print(hn.name)  # 在对象里用对象访问
print(Province.country)  # 在类里用类访问
# 在Python里也可以用对象访问静态字段
print(hn.country)

规则：
    普通字段只能用对象访问
    静态字段用类访问（万不得已不要用对象访问）

 

方法： 所有方法属于类（在其他语言里只有两种方法）

1、普通方法：至少一个self,对象执行

2、静态方法：任意参数，没有self,类执行

3、类方法：至少有一个cls参数，由类执行

class Province:
    country = "中国"

    def __init__(self,name):
        self.name = name
    #普通方法，由对象去调用执行（方法属于类）
    def show(self):
        print(self.name)

    #静态方法,由类调用执行（操作1、2、之后变成静态方法）
    @staticmethod #2、加上@staticmethod
    def f1(): #1、参数里去掉self，可以有其他参数
        print("....")

    #类方法（静态方法的一种）
    @classmethod
    def f2(cls): #至少必须有一个参数cls,自动传递参数返回类名
        #cls #类名,()创建对象
        #cls()
        print(cls) #类名<class ‘__main__.Province‘>

    def f3(self):
        return self.name[1]

obj = Province("河南")
obj.show()
Province.f1()
Province.f2()  #<class ‘__main__.Province‘>
ret = obj.f3()
print(ret)     #南 

属性：

　　不伦不类的东西

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

class Page:
    def __init__(self,all_count):
        self.all_count = all_count

    @property   #属性就需要加上property这个方法
    def all_pager(self):
        a1,a2 = divmod(self.all_count,10)
        if a2 == 0:
            return  a1
        else:
            return a1 + 1

    @all_pager.setter  #函数名.setter ,设置
    def all_pager(self,value):      #函数名都和上一个相同
        print(value)

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

#all_pager没有加上属性之前，用下面形式操作
#p = Page(101)
# r = p.all_count #字段
# result = p.all_pager() #方法
# print(result)

#all_pager加上属性之后
p.all_count = 102
del p.all_count  #删除方法的字段
ret = p.all_pager #属性 (属性和方法区别就是少了括号)
print(ret)

p.all_pager = 111 #用属性重新定义
del p.all_pager  #用属性删除，伪删除动作，里面执行什么自己定义的

 另一种属性

class Pager:
    def __init__(self,all_count):
        self.all_count = all_count

    def f1(self):
        return "f1"

    def f2(self,value):
        print(value)

    def f3(self):
        print("f3")

    foo = property(fget=f1,fset=f2,fdel=f3) #还可以按顺序直接给值

p = Pager(101)
ret = p.foo
print(ret)

obj = Pager(110)
obj.foo = "f2"

del obj.foo

#结果
f1
f2
f3

 

三、成员修饰符

　　私有的： 只能类自己本身的成员访问调用，其他类不能访问

　　公有的： pass

class Foo:
    def __init__(self,name,age):
        self.__name = name #加两个下划线，只能在类的内部访问，外部访问不到
        self.age = age

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

class Bar(Foo):
    def f2(self):
        print(self.age)  #这里如果写成self.__name则外面获取obj1.f2()会报错

obj = Foo("alex",13)
#print(obj.__name)  #会报错，外部不能访问

obj1 = Bar("Q",12)
obj1.f2()   #继承也不能执行__name，只能本身类内部访问
obj1.f1()
#print(obj._Foo__name) #(可以取到私有的，不到万不得已不要强制访问)

 

四、特殊成员

 

构造方法 __init__
析构方法 __del__ 　：垃圾清除之前自动执行 类的__del__方法(有就执行没有不执行)

 __call__ :对象加括号，就会自动执行__call__方法

__str__:直接打印对象，就会自动执行__str__方法

__getitem__:获取

__setitem__：设置

__delitem__：删除

class F:
    #构造方法
    def __init__(self,name,age):
        self.name =name
        self.age =age
    #析构方法
    def __del__(self):
        pass

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


    def __str__(self):
        return "%s" % self.name

    def __getitem__(self, item):
        # print(item.start)#obj[1:2] 中的1
        # print(item.stop)#2
        # print(item.step) #步长
        return "getitem"

    def __setitem__(self, key, value):
        #key.star key.stop key.step
        return "setitem"

    def __delitem__(self, key):
        # key.star key.stop key.step
        print("del item")
p = F("QL",12)
print(p.__class__) #<class ‘__main__.F‘>

obj = F("QL",15)
#语法对应关系
ret = obj["ad"] # 自动执行getitem方法，自动赋值给item
ret1 = obj[1:2] #切片 会执行getitem方法
print(ret1)
obj[1:4] = [11,22,33,44,55,66,] #自动执行setitem方法
del obj[1:3] #自动执行 delitem
print(obj) #直接打印对象，就会自动执行__str__方法
obj()   #对象加括号，就会自动执行__call__方法
# #ret = obj["k1"] = 111 #自动执行setitem方法
# #print(ret)
#
# del obj["k1"]  #自动执行delitem方法



obj() #加上__call__方法才能执行（对象后加括号）

#F()() ＃也可以写成这样

print(obj) #不加str会输出内存地址<__main__.F object at 0x0000000000726630>,加上__str__会友好显示，str里返回什么就输出什么

#__dict__ #获取对象中封装的数据 【重要】
ret = obj.__dict__
print(ret) #{‘age‘: 12, ‘name‘: ‘QL‘}

#print(F.__dict__)#获取类中的成员

 __iter__

class F1():
    def __iter__(self): #iter是生成器(里面有yield就是生成器)
        #yield 1
        #yield 2
        return iter([11, 22, 33, ])

obj = F1()
for item in obj:#默认不可以迭代，加上iter方法才可以迭代
    print(item)#默认执行iter方法，迭代iter返回值

 

五、面向对象边缘

　　- insinstance 查看某个对象是不是某个类创建的

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

class A:
    pass

class B(A):
    pass

obj = A()
ret = isinstance(obj,B)

class Bar:
    pass

class Foo(Bar):
    pass

obj = Foo()
#obj,Bar(obj类型和obj类型的父类)的实例
ret2 = isinstance(obj,Bar) #查看obj是不是Bar创建的
print(ret2) #True
ret1 = issubclass(Bar,Foo)# 查看Bar 是不是Foo的子类
print(ret1) #False

 主动执行父类方法：

class C1:

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

class C2(C1):

    def f1(self):
        # # 主动执行父类的f1方法
        super(C2,self).f1()
        print("c2.f1")

        #C1.f1(self) #不建议使用，用上面的super方法

obj1 = C2()
obj1.f1()

 有序字典

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) #继承父类的setter
#结果
{‘k1‘: 123, ‘k2‘: 456}

 六、异常处理

while True:
    num1 = input(‘num1:‘)
    num2 = input(‘num2:‘)
    try:
        li = [11, 22]
        print(‘li[100]‘) #indexerro
        num1 = int(num1)
        num2 = int(num2)
        result = num1 + num2


    except ValueError as ex:  #只捕获ValueError错误 从上往下捕获
        print(‘ex‘)
    except IndexError as ex:
        print(‘ex‘)
    except Exception as ex:  # ex 是Exception的一个对象,Exception捕获所有错误
        print(‘ex‘)  # str

 完整代码块

try:
    pass
except ValueError as ex:
    print(ex)
except Exception as ex:
    print(ex)
else:  #上面不报错执行else
    pass
finally: #不管报不报错都执行finally
    pass

 主动触发异常

try:
    raise Exception(‘主动错误一下‘) #self.message = ‘主动错误一下’
    print(1234)
except ValueError as ex:
    print(ex)
except Exception as ex:#__str__,return self.message
    print(ex)
else:  #上面不报错执行else
    pass
finally: #不管报不报错都执行finally
    pass

 断言

assert 1==1 #如果条件成立不报错

assert 1==2 #如果条件不成立报错

p = obj()
p.start() #在执行start之前先执行一个 p.status == False,就可以在start中写入(assert p.staus == False)

 

七、设计模式之单例模式（23种，推荐书《goF设计模式》）

　　单例模式： 用来创建单个实例

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("alex") #一般是固定值，也可以传参
            cls.instance = obj #对象赋值给instance
            return obj
obj1 = Foo.get_instance()
print(obj1)
obj2 = Foo.get_instance()
print(obj2)

 

谁来访问都创建一个，比较浪费，不如只创建一个，都来访问这一个。