美文网首页
学学python2(面向对象OOP）

学学python2(面向对象OOP）

作者: 鱼丸_a47d | 来源:发表于2018-12-17 21:56 被阅读0次

    面向对象：

    oop

    • 接触到任意一个任务，首先想到的是任务这个世界的构成，是由模型构成的
    • 几个概念
      • OO： 面向对象
      • OOA: 面向对象的分析
      • OOD: 面向对象的设计
      • OOI：面向对象的实现
      • OOP: 面向对象的编程
      • A> D > I 面向对象的实现过程

    类与对象

    • 类：抽象名词，代表一个集合，共性的事物 eg学生一类人，有共性，有性别、姓名、爱好
    • 对象：具象的事物，单个个体，eg ，某个学生，明月
    • 类与对象之间的关系：
      • 一个是抽象，代表一大类事物；一个是具象，代表的是一个个体
    • 类中的内容：
      • 表明事物的特征，即属性（变量）
      • 表明事物的功能或动作，即成员方法（函数）

    类的基本实现

    类的命名

    • 遵守变量命名的规范
    • 大驼峰（又一个或者多个单词组成，每个单词首字母大写，单词与单词直接相连）
    • 尽量避开与系统命名相似的命名（Eg pass）

    声明一个类

    • class
    • 类的属性与方法，不能使用课堂1的知识
    • 成员属性定义可以直接使用变量赋值，如果没有，另为none

    访问对象成员

    • 使用"." 点操作符

    obj.成员属性/成员方法

    • 可以通过默认内置变量检查类与对象的所有成员
      • 对象所有成员的检查
        dict 前后两个下划线
        obj.dict
      • 类的所有成员
        dict前后两个下划线
        class_name.dict 
    #定义一个的类
class student():
    #一个空类，pas代表直接跳过
    #此处pass必须有
    psss
#定义一个对象
mingyue= student()

    # 在定义一个类，用来描述听Python的学生
class PythonStudent():
    # 用None给不确定的值赋值
    name = None
    age = 18
    course = "Python"
    # 需要注意
    # 1. def doHomework的缩进层级
    # 2. 系统默认由一个self参数
    def doHomework(self):
        print("I 在做作业")
        # 推荐在函数末尾使用return语句
        return None
# 实例化一个叫yueyue的学生，是一个具体的人
yueyue = PythonStudent()
print(yueyue.name)
print(yueyue.age)
# 注意成员函数的调用没有传递进入参数
yueyue.doHomework()

    类与对象的成员分析

    • 类和对象都可以存储成员，成员可以归类所有，也可以归对象所有
    • 创建对象的时候，类中的成员不会放入对象当中，而是得到一个空对象，没有成员
    • 通过对象对类中成员重新赋值或者通过对象添加成员时，对应成员会保存在对象中，而不会修改类成员
    class A():
    name = "dana"
    age = 18    
    # 注意say的写法，参数由一个self
    def say(self):
        self.name = "aaaa"
        self.age = 200
# 此案例说明
# 类实例的属性和其对象的实例的属性在不对对象的实例属性赋值的前提下，
# 指向同一个变量  
# 此时，A称为类实例
print(A.name)
print(A.age)
print("*" * 20)
# id可以鉴别一个变量是否和另一个变量是同一变量
print(id(A.name))
print(id(A.age))
print("*" * 20)
a = A()
print(a.name)
print(a.age)
print(id(a.name))
print(id(a.age))
-----------

dana
18
********************
140666260313176
93936169025280
********************
dana
18
140666260313176
93936169025280
------------------
print(A.name)
print(A.age)

print("*" * 20)

# id可以鉴别一个变量是否和另一个变量是同一变量
print(id(A.name))
print(id(A.age))

print("*" * 20)
a = A()
# 查看A内所有的属性
print(A.__dict__)
print(a.__dict__)

a.name = "yaona"
a.age = 16
print(a.__dict__)

print(a.name)
print(a.age)
print(id(a.name))
print(id(a.age))
-------------------
dana
18
********************
140666260313176
93936169025280
********************
{'__module__': '__main__', 'name': 'dana', 'age': 18, 'say': <function A.say at 0x7fef6a799730>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
{}
{'name': 'yaona', 'age': 16}
yaona
16
140666251554240
93936169025216

    Self

    • self在对象的方法中表示当前对象本身，如果通过对象调用一个方法，那么该对象会自动传入到当前方法 的第一个参数中
    class Student():
    name = "dana"
    age = 18
    
    # 注意say的写法，参数由一个self
    def say(self):
        self.name = "aaaa"
        self.age = 200
        print("My name is {0}".format(self.name))
        print("My age is {0}".format(self.age))
        
    def sayAgain(s):
#self并不是关键字，只是一个用于接受对象的普通参数，理论上可以用任何一个普通变量名代替      
        print("My name is {0}".format(s.name))
        print("My age is {0}".format(s.age))
          
yueyue = Student()
yueyue.say()
yueyue.sayAgain()
-----------------------
My name is aaaa
My age is 200
My name is aaaa
My age is 200
    • 方法中有self形参的方法成为非绑定类的方法，可以通过对象访问， 没有self的是绑定类的方法， 只能通过类访问
    • 使用类访问绑定类的方法时， 如果类方法中需要访问当前类的成员，可以通过 class成员名来访问
    class Teacher():
    name = "dana"
    age = 19
    
    def say(self):
        self.name = "yaona"
        self.age = 17
        print("My name is {0}".format(self.name))
        # 调用类的成员变量需要用 __class__
        print("My age is {0}".format(__class__.age))
    def sayAgain():
        print(__class__.name)
        print(__class__.age )
        print("Hello, nice to see you again")
        
t = Teacher()
t.say()
# 调用绑定类函数使用类名
Teacher.sayAgain()
---------------------
My name is yaona
My age is 19
dana
19
Hello, nice to see you again

    class A():
    name = " liuying"
    age = 18
    
    def __init__(self):
        self.name = "aaaa"
        self.age = 200
        
    def say(self):
        print(self.name)
        print(self.age)
        
class B():
    name = "bbbb"
    age = 90
    
a = A()
# 此时，系统会默认把a作为第一个参数传入函数
a.say()
   
# 此时，self被a替换
A.say(a)
# 同样可以把A作为参数传入
A.say(A)

# 此时，传入的是类实例B，因为B具有name和age属性，所以不会报错
A.say(B)

# 以上代码，利用了鸭子模型
-----------------------
aaaa
200
aaaa
200
 liuying
18
bbbb
90

    面向对象的三大特征

    • 封装
    • 继承
    • 多态

    封装

    - 封装就是对对象成员进行访问限制
    • 封装的三个级别（公开public、受保护的protected、私有的private）
      • 判别对象的位置（对象内部、对象外部、子类中）
    • 私有：
      - 私有成员是最高级别的封装，只能在当前类或对象中访问
      - 在成员前面添加两个两个下划线即可
      • Python的私有不是真私有，是一种成为name mangling的改名策略 可以使用对象._classname_attributename访问
    class Person():
                # name是共有的成员 
                name = "liuying"
                # __age就是私有成员
                __age = 18
                
p = Person()
# name是公有变量
print(p.name)
# __age是私有变量
print(p.__age)
-----------------
liuying
19
----------------
# name mangling技术
print(Person.__dict__)

p._Person__age = 19
print(p._Person__age)

{'__module__': '__main__', 'name': 'liuying', '_Person__age': 18, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
19
    • 受保护的
      • 受保护的封装是将对象成员进行一定级别的封装，然后，在类中或者子类中都 可以进行访问，但是在外部不可额以
      • 封装方法： 在成员名称前天机爱一个下划线即可
    • 公开的
      • 公共的封装实际对成员没有任何操作，任何地方都可以访问

    继承

    • 继承就是一个类可以获得另外一个类中的成员属性和成员方法
    • 继承与被继承的概念：
      • 被继承的类叫父类，也叫基类，也叫超类
      • 用于继承的类，叫子类，也叫派生类
      • 继承与被继承一定存在一个 is-a 关系
    • 继承的特征
      • 所有的类都继承自object类，即所有的类都是object类的子类
      • 子类一旦继承父类，则可以使用父类中除私有成员外的所有内容
    
class Person:
    name ="noname"
    age=18
    __score=0
    _petname="sec"
    def sleep(self):
        print("sleeping")
class Teacher(Person):
    teacher_id=34
    def make_test(self):
        print("attention")
t=Teacher()
print(t.name)
print(t._petname)
# print(t.__score)
t.sleep()
print(t.teacher_id)
t.make_test()
------------
noname
sec
sleeping
34
attention
    • 子类继承父类后并没有将父类成员完全赋值到子类中，而是通过引用关系访问调用
    • 子类中可以定义独有的成员属性和方法
    • 子类中定义的成员和父类成员如果相同，则优先使用子类成员
    class Person():
    name = "NoName"
    age = 18
    __score = 0 # 考试成绩是秘密，只要自己知道
    _petname = "sec" #小名，是保护的，子类可以用，但不能公用
    def sleep(self):
        print("Sleeping ... ...")
 
        
#父类写在括号内
class Teacher(Person):
    teacher_id = "9527"
    name = "DaNa"
    def make_test(self):
        print("attention")
        
t = Teacher()
print(t.name)
---------------
DaNa
    • 子类如果想扩充父类的方法，可以在定义新方法的同时访问父类成员来进行代码重用， 可以使用 [父类名.父类成员] 的格式来调用父类成员，也可以使用super().父类成员的 格式来调用
    #人由工作的函数， 老师也由工作的函数，但老师的工作需要讲课
class Person():
    name = "NoName"
    age = 18
    __score = 0 # 考试成绩是秘密，只要自己知道
    _petname = "sec" #小名，是保护的，子类可以用，但不能公用
    def sleep(self):
        print("Sleeping ... ...")
    def work(self):
        print("make some money")
class Teacher(Person):
    teacher_id = "9527"
    name = "DaNa"
    def make_test(self):
        print("attention")
    def work(self):
        Person.work(self)
        #super().work()
        self.make_test()
t=Teacher()
t.work()
---------
make some money
attention
    • 继承变量函数的查找顺序
      • 优先查找自己的变量
      • 没有则查找父类
      • 构造函数如果本类中没有定义，则自动查找调用父类构造函数
      • 如果本类有定义，则不在继续向上查找
    • 构建函数
    class Dog():
    # __init__就是构造函数
    # 每次实例化的时候，第一个被自动的调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self):
        print("I am init in dog")
# 实例话的时候，括号内的参数需要跟构造函数参数匹配
kaka = Dog()
----------------
I  am init in dog
    • 是一类特殊的函数，在类进行实例化之前进行调用
    • 如果定义了构造函数，则实例化时使用构造函数，不查找父类构造函数
    • 如果没定义，则自动查找父类构造函数 
    class Animel():
    def __init__(self):
        print("Animel")

class PaxingAni(Animel):
    def __init__(self):
        print(" Paxing Dongwu")

class Dog(PaxingAni):
    # __init__就是构造函数
    # 每次实例化的时候，第一个被自动的调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self):
        print("I am init in dog")
        
# 实例话的时候，自动调用了Dog的构造函数
# 因为找到了构造函数，则不在查找父类的构造函数
kaka = Dog()

# 猫没有写构造函数
class Cat(PaxingAni):
    pass

# 此时应该自动调用构造函数，因为Cat没有构造函数，所以查找父类构造函数
# 在PaxingAni中查找到了构造函数，则停止向上查找
c = Cat()
-----------------
I am init in dog
 Paxing Dongwu
    • 如果子类没定义，父类的构造函数带参数，则构造对象时的参数应该按父类参数构造
    class Animel():
    def __init__(self):
        print("Animel")

class PaxingAni(Animel):
    def __init__(self, name):
        print(" Paxing Dongwu {0}".format(name))

class Dog(PaxingAni):
    # __init__就是构造函数
    # 每次实例化的时候，第一个被自动的调用
    # 因为主要工作是进行初始化，所以得名
    def __init__(self):
        print("I am init in dog")
        
# 实例化Dog时，查找到Dog的构造函数，参数匹配，不报错      
d = Dog()

class Cat(PaxingAni):
    pass

# 此时，由于Cat没有构造函数，则向上查找
#  因为PaxingAni的构造函数需要两个参数，实例化的时候给了一个，报错
c = Cat()

I am init in dog

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-23-160de1fa11e4> in <module>()
# 此时，由于Cat没有构造函数，则向上查找
#  因为PaxingAni的构造函数需要两个参数，实例化的时候给了一个，报错
 c = Cat()
-------------
I am init in dog
TypeError: __init__() missing 1 required positional argument: 'name'

    class Animel():
    def __init__(self):
        print("Animel")

class PaxingAni(Animel):
    pass

class Dog(PaxingAni):
    pass
        
# 实例化Dog时，查找到Dog的构造函数，参数匹配，不报错      
d = Dog()

class Cat(PaxingAni):
    pass

# 此时，由于Cat没有构造函数，则向上查找
#  因为PaxingAni的构造函数需要两个参数，实例化的时候给了一个，报错
c = Cat()
------------------
Animel
Animel
    • super
      • super不是关键字， 而是一个类
      • super的作用是获取MRO（MethodResolustionOrder）列表中的第一个类
      • super于父类直接没任何实质性关系，但通过super可以调用到父类
      • super使用两个方法,参见在构造函数中调用父类的构造函数
    class A():
    pass
class B():
    pass
print(A.__mro__)
print(B.__mro__)
--------------
(<class '__main__.A'>, <class 'object'>)
(<class '__main__.B'>, <class 'object'>)
    • 单继承与多继承
      • 单继承：每个类只能继承一个类
      • 多继承： 每个类允许继承多个类
    # 子类可以直接拥有父类的属性和方法，私有属性和方法除外
class Fish():
    def __init__(self,name):
        self.name = name
    def swim(self):
        print("i am swimming......")
        
class Bird():
    def __init__(self, name):
        self.name = name
        
    def fly(self):
        print("I am flying.....")

class Person():
    def __init__(self, name):
        self.name = name
        
    def work(self):
        print("Working........")
        
        

        
# 单继承的例子      
class Student(Person):
    def __init__(self, name):
        self.name = name
stu = Student("yueyue")
stu.work()
        
        
# 多继承的例子  
class SuperMan(Person, Bird, Fish):
    def __init__(self, name):
        self.name = name


class SwimMan(Person, Fish):
    def __init__(self, name):
        self.name = name
        
s = SuperMan("yueyue")
s.fly()
s.swim()
--------------------
Working........
I am flying.....
i am swimming......

    菱形继承/钻石继承问题

    class A():
    def __init__(self):
        print("A")

class B(A):
    def __init__(self):
        print("B")
        
class C(B):
    pass
c = C()
--------
B
    • 多个子类继承自同一个父类，这些子类由被同一个类继承，于是继承关系图形成一个菱形图谱
    • 关于多继承的MRO
      • MRO就是多继承中，用于保存继承顺序的一个列表
      • MRO列表的计算原则：
        - 子类永远在父类前面
        - 如果多个父类，则根据继承语法中括号内类的书写顺序存放
        -如果多个类继承了同一个父类，孙子类中只会选取继承语法括号中第一个父类的父类
    • 构造函数
      • 在对象进行实例化的时候，系统自动调用的一个函数叫构造函数，通常此函数用来对实例对象进行初始化
      • 构造函数一定要有，如果没有，则自动向上查找，按照MRO顺序，直到找到为止
    # 构造函数的调用顺序 - 1

# 构造函数的调用顺序 - 1
# 如果子类没有写构造函数，则自动向上查找，知道找到位置
class A():
    def __init__(self):
        print("A")

class B(A):
    def __init__(self):
        print("B")
        
class C(B):
    pass

# 此时，首先查找C的构造函数
# 如果没有，则向上按照MRO顺序查找父类的构造函数，知道找到为止
c = C()
-----------------
B
---------------------
# 构造函数的调用顺序 - 2
class A():
    def __init__(self):
        print("A")

class B(A):
    def __init__(self, name):
        print("B")
        print(name)
        
class C(B):
    pass
c = C()
----------------
TypeError: __init__() missing 1 required positional argument: 'name'
-----------
# 构造函数的调用顺序 - 3
class A():
    def __init__(self):
        print("A")

class B(A):
    def __init__(self, name):
        print("B")
        print(name)
        
class C(B):
    # c中想扩展B的构造函数，
    # 即调用B的构造函数后在添加一些功能
    # 由两种方法实现
    
    '''
    # 第一种是通过父类名调用
    def __init__(self, name):
        # 首先调用父类构造函数
        B.__init__(self, name)
        # 其次，再增加自己的功能
        print("这是C中附加的功能")
    '''  
        
    # 第二种，使用super调用
    def __init__(self, name):
        # 首先调用父类构造函数
        super(C, self).__init__(name)
        # 其次，再增加自己的功能
        print("这是C中附加的功能")
        

# 此时，首先查找C的构造函数
# 如果没有，则向上按照MRO顺序查找父类的构造函数，知道找到为止
# 此时，会出现参数结构不对应错误
c = C("我是C")
--------------------
B
我是C
这是C中附加的功能
------------

    多态

    • 多态就是同一个对象在不同情况下有不同的状态出现
    • 多态不是语法，是一种设计思想
    • 同一种事物的多种形态，动物分人类、狗类、猪类
    • Mixin设计模式
      • 主要采用多继承对类的功能进行扩展（简单功能的增加，而非）
    • 使用多继承来实现Mixin
      • 表示某一个单一的功能
      • 职责必须单一，如果由多个功能，则写多个mixin
      • ximin 不能依赖于子类的实现
      • 子类即使没有继承这个mixin类,也照样能够工作，知识缺少了某个功能
    class Person():
                name = "liuying"
                age = 18

                def eat(self):
                    print("EAT.......")
                    
                def drink(self):
                    print("DRINK......")
                    
                def sleep(self):
                    print("SLEEP.....")
                
class Teacher(Person):
                def work(self):
                    print("Work")

class Student(Person):
                def study(self):
                    print("Study")
                    

class Tutor(Teacher, Student):
                pass

t = Tutor()
             
print(Tutor.__mro__)
print(t.__dict__)
print(Tutor.__dict__)

print("*"*20)
class TeacherMixin():
                def work(self):
                    print("Work")

class StudentMixin():
                def study(self):
                    print("Study")
                    
class TutorM(Person, TeacherMixin, StudentMixin):
                pass
tt = TutorM()
print(TutorM.__mro__)
print(tt.__dict__)
print(TutorM.__dict__)
———————
(<class '__main__.Tutor'>, <class '__main__.Teacher'>, <class '__main__.Student'>, <class '__main__.Person'>, <class 'object'>)
{}
{'__module__': '__main__', '__doc__': None}
********************
(<class '__main__.TutorM'>, <class '__main__.Person'>, <class '__main__.TeacherMixin'>, <class '__main__.Studen
    • issubclass函数 ：检测一个类是否另一个类的子类
    class A():
    pass

class B(A):
    pass

class C():
    pass

print( issubclass(B, A))
print( issubclass(C, A))
print( issubclass(B, object))
—————-
True
False
True
——————
# isinstance
class A():
    pass

a = A()

print(isinstance(a, A))
print(isinstance(A, A))
——————
True
False
————-
# hasattr
class A():
    name = "NoName"
    
a = A()
print(hasattr(a, "name" ))
print(hasattr(a, "age" ))
——————
True
False

    类的相关函数

    • isinstance函数：检测一个对象是否是另一个类的实例
    • hasattr :检测一个对象是否有成员
      XXX
    • getattr: get attribute
    • setattr: set attribute
    • delattr:delete attribute
    • dir:获取对象的成员列表

    类的成员描述符（属性）

    • 类的成员描述符是为了对类的成员属性而进行相关操作为创建的一种方式
    class Student():
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
        # 如果不想修改代码
        self.setName(name)
        
    # 介绍下自己
    def intro(self):
        print("Hai, my name is {0}".format(self.name))
        
    def setName(self, name):
        self.name = name.upper()
        
s1 = Student("LIU Ying", 19.8)
s2 = Student("michi stangle", 24.0)

s1.intro()
s2.intro()
-----------------------------
Hai, my name is LIU YING
Hai, my name is MICHI STANGLE
    • get：获取属性
    • set: 修改或者
    • delete: 删除属性的操作
    • 使用类的成员操作符
      • 使用property 函数
        • property函数：
    • 无论哪种修饰符都是对成员属性进行相应的控制
      • 类的方法：适用于多个类中的共同的属性共用一个修饰符
      • 属性修饰符： 适用于当前类，可以控制一个类中的一个属性

    property(fget, fset, fdel, doc)

    # peroperty案例
# 定义一个Person类，具有name，age属性
# 对于任意输入的姓名，我们希望都用大写方式保存
# 年龄，我们希望内部统一用整数保存
# x = property(fget, fset, fdel, doc)
class Person():
    '''
    这是一个人，一个高尚的人，一个脱离了低级趣味的人
    他还他妈的有属性
    '''
    # 函数的名称可以任意
    def fget(self):
        return self._name * 2
    
    def fset(self, name):
        # 所有输入的姓名以大写形式保存
        self._name = name.upper()
        
    def fdel(self):
        self._name = "NoName"
    
    name = property(fget, fset, fdel, "对name进行下下操作啦")
p1 = Person()
p1.name = "TuLing"
print(p1.name)
----------------
TULINGTULING

    类的内置属性

    dict:以字典的方式显示类的成员组成
    doc: 获取类的文档信息
    name:获取类的名称，如果在模块中使用，获取模块的名称
    bases: 获取某个类的所有父类，以元组的方式显示

    类的魔方函数

    • 魔术方法就是不需要人为调用的方法，基本是在特定的时刻自动触发
    • 操作类
      • init: 构造函数
      • new: 对象实例化方法，此函数较特殊，一般不需要使用
      • call: 对象当函数使用的时候触发
      • str: 当对象被当做字符串使用的时候调用
      • repr: 返回字符串，跟str具体区别请百度
    • 属性操作相关
    • getattr: 访问一个不存在的属性时触发
    • setattr: 对成员属性进行设置的时候触发

    就是

    相关文章

      网友评论

          本文标题：学学python2(面向对象OOP）

          本文链接：https://www.haomeiwen.com/subject/ezcckqtx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|学学python2(面向对象OOP）|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！