zoukankan      html  css  js  c++  java

  • python18-day7

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

    面向对象的特点: 

    封装,继承,多态   #多态(意义不大,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, 人的性别是:%s, 人的年龄是:%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文件
      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. 另一种方法 效果相同
      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
  • 相关阅读:
    拉普拉斯矩阵
    正定矩阵 和 半正定矩阵
    Random Walk
    论文解读（DGI）《DEEP GRAPH INFOMAX》
    python安装easyinstall/pip出错
    pip国内源设置
    在Jupyter Notebook添加代码自动补全功能
    [BUUCTF]PWN——bjdctf_2020_babystack2
    [BUUCTF]REVERSE——[BJDCTF 2nd]8086
    [BUUCTF]PWN——jarvisoj_tell_me_something
  • 原文地址：https://www.cnblogs.com/Gavinkwok/p/7387998.html
Copyright © 2011-2022 走看看