python18-day7

Posted 2020-10-03

什么时候使用面向对象? 当某些函数具有相同参数时,可以使用面向对象的方式,讲参数值一次的封装到对象,以后去对象中取值即可

 

面向对象的特点: 

封装,继承,多态   #多态(意义不大,java等强类型,应用多)

 

类和对象

一 创建类

class 类名:

    def 方法名(self,***):

        pass

二 创建对象

    对象=类名()

 

三 通过对象执行方法

对象.方法名(123)

 

 

self是python会自动传值的参数

构造方法:   __init__()   #自动被执行,   ()中可填参数

 

 

类定义

1. #类通过函数改变
2. class Person:
3. def __init__(self,name,age,money):
4. self.name=name
5. self.age=age
6. self.money=money
7. def shopping(self):
8. self.money=self.money -200
9. print(self.money)
10. long=Person("龙",18,400)
11. hu=Person("虎",18,300)
13. long.shopping()
14. hu.shopping()
15. # 200
16. # 100

计数器

1. class Foo:
2. count=0
3. def __init__(self,name):
4. Foo.count+=1            #写Foo.count Foo代表类
5. self.name=name
7. obj1=Foo("egon1")
8. obj2=Foo("egon2")
9. # print(Foo.count)
10. # print(obj2.count)
12. class Student:
13. tag = "tag值" #灵活性,可增加参数
14. def __init__(self,ID,name,age):
15. self.id=ID
16. self.name=name
17. self.age=age
18. def walk(self):
19. print("%s is waokking"%self.name)
21. s1=Student(1,"egon",18)
22. s2=Student(2,"alex",1000)
23. s1.walk()
24. s2.walk()
25. print(s1.id,s1.name,s1.age,s1.tag)
27. print("用户数量",Foo.count)
28. # egon is waokking
29. # alex is waokking
30. # 1 egon 18 tag值
31. # 用户数量 2

 

 

 

   类的传参可以是另一个类

1. class c1:
2. def __init__(self,name,obj):
3. self.name = name
4. self.obj=obj
6. class c2:
7. def __init__(self,name,age):
8. self.name = name
9. self.age=age
10. def show(self):
11. print(self.age)
13. c2_obj=c2("aa",11) #c2("aa", 11).show() 这样也行
14. c2_obj.show() #显示show函数值
15. #11
16. print(c2_obj.name) #也可以调用变量,显示变量要加print
17. #aa
19. c1_obj=c1("alex",c2_obj) #c1_obj的参数可以是c2_obj函数
20. print(c1_obj.obj.name) #c1_obj.obj.name =c2_obj.name
21. #aa

 

 

继承

继承是一种创建类的方式

 

F2继承F1所有数据

1. class F1:
2. def show(self):
3. print("show")
5. class F2(F1):
6. def bar(self):
7. print("bar your right")
8. obj = F2()
9. obj.bar()
10. #bar your right

 

 

F2继承F1

F2继承了F1的函数 如果F2和F1中有同名函数执行F2函数(子类优先)

1. class F1: #父类,基类
2. def show(self):
3. print("show")
5. def foo(self):
6. print(self.name)
9. class F2(F1): #子类,派生类
10. def __init__(self,name):
11. self.name = name
13. def bar(self):
14. print("bar your right")
16. def show(self):
17. print("F2,show")
18. obj = F2("alex")
19. obj.foo()

父类不变,子类改变

 

1. class Animal:
2. def __init__(self,name,age,sex):
3. self.name=name
4. self.age=age
5. self.sex=sex
6. def eat(self):
7. print("%s eat"%self.name)
9. def takl(self):
10. print("%s say"%self.name)
11. class People(Animal):
12. def __init__(self,name,age,sex,education):
13. Animal.__init__(self,name,age,sex) #这是调用父类初始化
14. self.education=education
16. peo1=People("alex",18,"male","小学")
17. print(peo1.__dict__) #不加__dict__是内存地址

 

 

1. class Animal:
2. def __init__(self,name,age,sex):
3. self.name=name
4. self.age=age
5. self.sex=sex
7. def eat(self):
8. print("eating")
10. def talk(self):
11. print("="*8)
12. print("%s 在干嘛" %self.name)
14. class People(Animal):
15. def __init__(self,name,age,sex,education):
16. Animal.__init__(self,name,age,sex)
17. self.education=education
19. def talk(self):
20. Animal.talk(self)
21. print("%s say hello %s"%(self.name,self.education))
23. class Pig(Animal):
24. def __init__(self,name,age,sex):
25. Animal.__init__(self,name,age,sex)
27. def talk(self):
28. Animal.talk(self) #执行Peple中的tailk子类优先
29. print("%s 哼哼哼"%self.name)
31. class dig(Animal):
32. def __init__(self,name,age,sex):
33. Animal.__init__(self,name,age,sex)
35. def talk(self):
36. Animal.talk(self) #执行Peple中的tailk子类优先
37. print("%s 汪汪汪汪"%self.name)
39. peo1=People("alex",18,"male","小学文凭")
40. pig=Pig("wupeiqi",20,"female")
41. dig=dig("haha",20,"male")
42. #print(peo1.education)
43. peo1.talk()
44. pig.talk()
45. dig.talk()

继承组合调用

1. #组合也可以解决代码冗余问题，但是组合反映是一种什么有什么的关系
3. class People:
4. def __init__(self,name,age,sex):
5. self.name=name
6. self.age=age
7. self.sex=sex
9. # class Teacher(People):
10. # def __init__(self,name,age,sex,salary):
11. # People.__init__(self,name,age,sex)
12. # self.salary=salary
13. #
14. # class Student(People):
15. # pass
17. class Date:
18. def __init__(self,year,mon,day):
19. self.year=year
20. self.mon=mon
21. self.day=day
23. def tell(self):
24. print(‘%s-%s-%s‘ %(self.year,self.mon,self.day))
26. class Teacher(People):
27. def __init__(self,name,age,sex,salary,year,mon,day):
28. self.name=name
29. self.age=age
30. self.sex=sex
31. self.salary=salary
32. self.birth=Date(year,mon,day) #组合调用
34. class Student(People):
35. def __init__(self,name,age,sex,year,mon,day):
36. self.name=name
37. self.age=age
38. self.sex=sex
39. self.birth=Date(year,mon,day)
41. t=Teacher(‘egon‘,18,‘male‘,3000,1995,12,31)
42. t.birth.tell()

 

 

 

类查询对象顺序

1. #先查C1的所有父类,有f2,匹配退出,如果没有,再查C1,有f2,匹配退出,都没有报错

2. class C1:
3. def f2(self):
4. print("C1中的f2")
6. class C2:
7. def f2(self):
8. print("C2中的f2")
10. class C3(C1,C2):
11. def f3(self):
12. print("C3中的f3")
14. obj=C3()
15. obj.f2()

 

2种类

经典类:     

深度优先 (python2 ,特定是N条父类连接相同父父类, 第一条生效)

 

新式类:     

广度优先 (python2+python3 特定是N条父类连接相同父父类, 最后一条生效)

#python2中用新式类父父类要加object    例如class C0(object):

多继承

1. #新式类, 特定是N条父类连接相同父父类, 最后一条生效
2. #查询顺序 C3(自己)-C2-C1-C5-C4-C0
3.  
4. class C0:
5. def test(self):
6. print("C0")
8. class C1(C0):
9. # def test(self):
10. # print("C1")
11. pass
13. class C2(C1):
14. # def test(self):
15. # print("C2")
16. pass
17. class C4(C0):
18. # def test(self):
19. # print("C4")
20. pass
22. class C5(C4):
23. # def test(self):
24. # print("C5")
25. pass
27. class C3(C2,C5):
28. # def test(self):
29. # print("C3")
30. pass
32. obj=C3()
33. obj.test()

34. print(C3.mro())     

35. #mro显示执行过程(最后一位提供返回值) 执行C3的test函数,看执行过程

36. #[<class ‘__main__.C3‘>, <class ‘__main__.C2‘>, <class ‘__main__.C1‘>, <class ‘__main__.C5‘>, <class ‘__main__.C4‘>, <class ‘__main__.C0‘>, <class ‘object‘>] 

37.  

 

super调用方法

1.  
2. class Animal:
3. home="oldboy"
4. def __init__(self,name,age,sex):
5. self.name=name
6. self.age=age
7. self.sex=sex
8. def eat(self):
9. print("%s eat"%self.name)
11. def takl(self):
12. print("%s say"%self.name)
13. class People(Animal):
14. def __init__(self,name,age,sex,education):
15. #Animal.__init__(self,name,age,sex) #这是调用父类初始化
16. super().__init__(name,age,sex,) #这是调用父类初始化的另一种方法
17. #super(People,self).__init__(name,age,sex,) #python2写法
18. #print(super().home) #使用super.可直接调用父类的(对象,函数,变量) = print(Animal.home)
19. self.education=education
22. peo1=People("alex",18,"male","小学")
23. print(peo1.__dict__) #不加__dict__是内存地址
24. #{‘name‘: ‘alex‘, ‘age‘: 18, ‘sex‘: ‘male‘, ‘education‘: ‘小学‘}
25. peo1.eat()
26. #alex eat
27. print(People.mro()) #查新式类最后调用
28. #[<class ‘__main__.People‘>, <class ‘__main__.Animal‘>, <class ‘object‘>]
30. #super的另一种含义是直接调用最后一个父类
31. class A:
32. def test(self):
33. super().test() #此时的super是从<class ‘__main__.A‘>后 继续调用mro继续查看,继续则是C(B),得到B父类的test
35. class B:
36. def test(self):
37. print(‘B‘)
39. class C(A,B):
40. pass
42. # a=A()
43. # a.test()
45. print(C.mro())
46. c=C()
47. c.test()
48. #[<class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘object‘>]
49. #B
51.  
52.  

 

抽象类

#一个抽象类有多个子类，因而多态的概念依赖于继承

1. #主要作用:函数规范 , 只要是调用这个父级的read函数 子级也必须用read
2. import abc #利用abc模块实现抽象类
4. class All_file(metaclass=abc.ABCMeta):
5. all_type=‘file‘
6. @abc.abstractmethod #定义抽象方法，无需实现功能
7. def read(self):
8. ‘子类必须定义读功能‘
9. pass
10. #定义其他抽象类就继续仿照read写
12. class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
13. def read(self):
14. print(‘文本数据的读取方法‘)
17. class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
18. def read(self):
19. print(‘进程数据的读取方法‘)
21. guolm=Txt()
22. qiqi=Process()
24. #规范了必须用read函数, 如果把guolm的类中read函数名改变,就会报错
25. #Can‘t instantiate abstract class Txt with abstract methods read
27. guolm.read()
28. qiqi.read()
30. print(guolm.all_type)
31. print(qiqi.all_type)
33. # 文本数据的读取方法
34. # 进程数据的读取方法
35. # file
36. # file

 

 

多态和多态性

多态

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承

#多态:调用父类有共同的参数,返回子类又增加各自子类的变化

多态性

多态性是指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同功能的函数。

1. import abc
   
2. class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
3. @abc.abstractmethod #抽象
4. def talk(self):
5. pass
7. class People(Animal): #动物的形态之一:人
8. def talk(self):
9. print(‘say hello‘)
11. class Dog(Animal): #动物的形态之二:狗
12. def talk(self):
13. print(‘say wangwang‘)
15. class Pig(Animal): #动物的形态之三:猪
16. def talk(self):
17. print(‘say aoao‘)
19. People=People()
20. People.talk()
22. Dog=Dog()
23. Dog.talk()
25. Pig=Pig()
26. Pig.talk()
27. # say hello
28. # say wangwang
29. # say aoao

 

 

 

 

封装

 

1 类把某些属性和方法隐藏起来(或者说定义成私有的,)只在类的内部使用,外部无法访问,或者留下少量接口(函数)供外部访问

隐藏封装

在内部使用__ 会调用值 在外部不成立

1. #类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
2. #这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
3. #这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。

4.  
5. #在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。
6. class People:
7. def __init__(self,name,age,sex):
8. self.__name=name
9. self.__age=age
10. self.__sex=sex
11. def tell_info(self):
12. #print("人的名字是:%s,\n人的性别是:%s,\n人的年龄是:%s "%(self.__name,self.__age,self.__sex))
13. return "人的名字是:%s,人的性别是:%s,人的年龄是:%s "%(self.__name,self.__age,self.__sex)
14. p=People("alex",18,"male")
15. print(p.tell_info()) #显示结果
16. #人的名字是:alex,人的性别是:18,人的年龄是:male
18. print(p.__dict__) #显示p的字典状态
19. #{‘_People__name‘: ‘alex‘, ‘_People__age‘: 18, ‘_People__sex‘: ‘male‘}

父子类函数同名,调用父类函数

1.  
2. class Parent:
3.    __x=1

4. def foo(self):
5. print("from parent.foo")
6. self.__bar() #值是完整文件名_parent__foo__bar, 相当于指定调用
7. def __bar(self):
8. print("from parent.bar")
10. class Sub(Parent):
11. def bar(self):
12. print("from Sub.bar")
13. s=Sub()
14. s.foo()
15. #from parent.foo #from parent.bar


16. print(Parent.__dict__)      #看Parent的所以含义
    #{‘__module__‘: ‘__main__‘, ‘_Parent__x‘: 1, ‘foo‘: <function Parent.foo at 0x101448598>, ‘_Parent__bar‘: <function Parent.__bar at 0x1014486a8>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Parent‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Parent‘ objects>, ‘__doc__‘: None}
    

 

super

根据mro查找

父类改变 子类只需要改变类调用 不需要改子类函数

1. class Foo1: #父类名改变
2. def test(self):
3. print("from foo.test")
4. class Bar(Foo1): #子类名改变,不需要改子类的test函数
5. def test(self):
6. #Foo.test(self) 相对于如下
7. super(Bar,self).test() #使用super,父类改变 子类只需要改变类调用 不需要子类改函数
8. print("bar222")
9. a=Bar()
10. a.test()
11. #from foo.test #bar222

 

内置装饰器

内置的装饰器有三个：staticmethod(静态类方法) classmethod, 类方法  property

 

staticmethod,(静态类方法)

基本上跟一个全局函数相同，一般来说用的很少

 

classmethod

• classmethod 是一个函数修饰符，它表示接下来的是一个类方法，而对于平常我们见到的则叫做实例方法。 类方法的第一个参数cls，而实例方法的第一个参数是self，表示该类的一个实例。 
  
• 普通对象方法至少需要一个self参数，代表类对象实例
• 类方法有类变量cls传入，从而可以用cls做一些相关的处理。并且有子类继承时，调用该类方法时，传入的类变量

1. staticmethod+classmethod实例
2. setting.py文件
3. 1. host="192.168.1.1"
   2. port=3004
    
5. import setting
6. import uuid
8. class Mysql:
9. def __init__(self,host,port):
10. self.host=host
11. self.port=port
12. self.id=self.create_id()
14. @classmethod      #绑定方法,绑定给class类
15. def from_conf(cls): #cls=Mysql()
16. return cls(setting.host)
17.                              #setting是模块,setting.host中host是模块变量
19. def func(self): #绑定给object对象
20. pass
22. @staticmethod         #非绑定方法,变成普通函数,不绑定给类或对象
23. def create_id():
25. return str(uuid.uuid1())
27. conn_one=Mysql("1.1.1.1",3306)
28. conn_tow=Mysql.from_conf()
29. print(conn_one.host)
30. print(conn_tow.host)
31. #1.1.1.1
32. #192.168.1.1
33. print(Mysql.from_conf) #这是显示绑定类
34. #<bound method Mysql.from_conf of <class ‘__main__.Mysql‘>>
35. print(Mysql.func) #这是显示绑定对象
36. #<function Mysql.func at 0x101c287b8>
37. print(conn_one.id) #这是显示非绑定方法
38. #5da84770-81dc-11e7-9569-48bf6be5ec1a

 

property

计算bmi(健康状态)

1. #定义好数值,外部传参 可修改数值
2. class People:
3. def __init__(self,name,weight,height):
4. self.name=name
5. self.weight=weight
6. self.height=height
7. @property #类似装饰器,装饰下边
8. def bmi(self):
9. return self.weight / (self.height ** 2)
10. p=People("egon",75,1.80)
11. p.height=1.84        #外部可改传参
12. print(p.bmi)
13. #22.152646502835537

 

封装之更改和删除

1. class People:
2. def __init__(self,name,permmission=False):      #permmission=False 定义默认值 用于增加权限  
3. self.name=name
4. self.permmission=permmission
5. @property                                        #继承
6. def name(self):
7. return self.__name
9. @name.setter    #装饰器增加增加功能
10. def name(self,value):
11. if not isinstance(value,str):
12. raise TypeError("名字必须是字符串类型")
13. self.__name=value
15. @name.deleter    #装饰器增加删除功能
16. def name(self):
17. if not self.permmission:     #permminsion值为False   
18. #这样写permmission值必须为True 加not为False, 而设置是permminsion值就是False
19. raise PermissionError("不允许的操作")
20. del self.__name
21. p=People("egon")
22. p.permmission=True
23. del p.name
25. 另一种方法 效果相同
26. 1. class People:
    2. def __init__(self,name,permmission=False):
    3. self.name=name
    4. self.permmission=permmission
    6. def get_name(self):
    7. return self.__name
    9. def set_name(self,value):
    10. if not isinstance(value,str):
    11. raise TypeError("名字必须是字符串类型")
    12. self.__name=value
    14. def del_name(self):
    15. if not self.permmission:
    16. raise PermissionError("不允许的操作")
    17. del self.__name
    18. name=property(get_name,set_name,del_name)
    19. p=People("egon")
     
27.  

 

 

设计模式之单例模式(23,goF设计模式)

单例模式

    用来创建单个实例

 

 

练习:

1 对象调用class 显示调用次数

1. #Foo是类
2. #self是对象自己
3. class Foo:
4. count=0
5. def __init__(self,x,y,z):
6. self.x=x
7. self.y=y
8. self.z=z
9. def aa(self):
10. Foo.count+=1
11. return Foo.count
13. obj1=Foo("guolm",18,"linux")
14. obj2=Foo("wy",28,"linux")
15. obj3=Foo("haha",38,"yw")
16. print(obj1.aa())
17. print(obj2.aa())
18. print(obj3.aa())
19. print(obj3.aa())
20. # 1
21. # 2
22. # 3
23. # 4