python面向对象继承

基础
公有私有
继承
组合
魔法函数
- 魔法函数概述
- 构造函数魔法函数
- 运算类魔法函数
OO : 面向对象
OOA ：面向对象的分析
OOD : 面向对象的设计
OOI ：XXX的实现
OOP ：XXX的编程
OOA -> OOD -> OOI :面向对象的实现过程

类和对象的概念

类，抽象名词，代表一个集合，共性的事物
对象：具象的事物，单个个体
类和对象的关系
- 一个抽象，代表一类事物
- 一个具象，代表某一个个体

类中的内容，应该具有两个内容

表明事物的特征，叫做属性（变量）
表明事物功能或动作，称为成员方法（函数）

类的基本实现

类的命名
大驼峰原则
尽量避开跟系统命名相似的命名

如何声明一个类

必须用class关键字
类由属性和方法构成，其他不允许出现
成员属性定义可以直接使用变量赋值，如果没有值，可以使用None

#定义一个类
class Student():
    pass
#定义一个对象
liziqiang = Student()

#再定义一个类，用来描述学习python的学生
class PythonStudent():
    #用None给不确定的值赋值
    name = None
    age = 4
    course = "Python"
    
    def dHomework(self):
        print("zuozuoye")
        return None

#实例化一个对象
lizi = PythonStudent()
print(lizi.name)
print(lizi.age)
print(lizi.course)
lizi.dHomework()

None
4
Python
zuozuoye

#访问对象成员

使用点操作符
对象.成员属性
对象.方法

可以通过默认内置变量检查类和对象的所有成员

对象所有成员检测
dict前后各有两个下划线
对象.dict
类的所有成员
class_name.dict

lizi.__dict__
PythonStudent.__dict__

mappingproxy({'__module__': '__main__',
              'name': None,
              'age': 4,
              'course': 'Python',
              'dHomework': <function __main__.PythonStudent.dHomework(self)>,
              '__dict__': <attribute '__dict__' of 'PythonStudent' objects>,
              '__weakref__': <attribute '__weakref__' of 'PythonStudent' objects>,
              '__doc__': None})

类和对象的成员分析

类和对象都介意存储成员，成员可以归类所有，也可以归对象所有
类存储成员时，使用的是与类关联的对象
独享成员函数是存储在当前对象中
对象访问一个成员时，如果对象中没有该成员，尝试访问类中的同名成员，如果对象中有词成员，一定使用对象中的成员
创建对象的时候，类中的成员不会放入对象当中，而是得到一个空对象，没有成员
通过对象对类中成员重新赋值或者通过对象添加成员时，对应成员会保存在对象中，而不会修改类成员

class A():
    name = "lizi"
    age = 18
    
    def B():
        self.name = "aaa"
        self.age = 23
        
print(A.name)
print(A.age)
print(id(A.name))
print(id(A.age))

a = A()
print(a.name)
print(a.age)
print(id(a.name))
print(id(a.age))

a.name = "qqqq"
print(a.name)
print(id(a.name))
print(id(A.name))

#说明，当没有给对象的属性赋值时，对象和类的属性指向同一个id，当给赋值以后，就重新分配了内存，这个时候就和类的属性的id不同了

lizi
18
2475878126456
1883663968
lizi
18
2475878126456
1883663968
qqqq
2475878224928
2475878126456

#关于self

self在对象的方法中表示当前对象本身，如果通过对象调用一个方法，那么该对象会自动传入到当前方法的第一个参数中
self不是关键字，只是一个用于接受对象的普通参数，理论上可以用任何一个普通变量代替
方法中只有self形参的方法称为非绑定类的方法，可以通过对象使访问，没有self的方法称为绑定类的方法，只能通过类来访问
使用类访问绑定类的方法时，如果类方法中需要访问当前类的成员，可以通过__class__成员名来访问

class A():
    name = "lizi"
    age = 18
    
    def B(self):
        self.name = "aaa"
        self.age = 23
        print("my name is {0}".format(self.name))   #此时的self = 对象C，self本身不是关键字，用其他字母代替完全没问题
        print("my age is {0}".format(self.age))

C = A()
C.B()

my name is aaa
my age is 23

class A():
    name = "lizi"
    age = 18
    
    def B(self):
        self.name = "aaa"
        self.age = 23
        print("my name is {0}".format(self.name))   #此时的self = 对象C，self本身不是关键字，用其他字母代替完全没问题
        print("my age is {0}".format(self.age))   #此时访问的年龄是方法的年龄不是类的年龄
        
    def C():
        print("helo, nice to see you again")
        
D = A()
D.B()
A.C()
D.C()  #不可调用，只能通过上边的类名来访问

my name is aaa
my age is 23
helo, nice to see you again



---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-4-72a99c7026ec> in <module>()
     15 D.B()
     16 A.C()
---> 17 D.C()


TypeError: C() takes 0 positional arguments but 1 was given

class A():
    name = "lizi"
    age = 18
    
    def B(self):
        self.name = "aaa"
        self.age = 23
        print("my name is {0}".format(self.name))   #此时的self = 对象C，self本身不是关键字，用其他字母代替完全没问题
        print("my age is {0}".format(__class__.age))  #此时访问的是类的年龄，不是方法的年龄
    def C():
        print(__class__.name)
        print(__class__.age)
        print("helo, nice to see you again")
        
D = A()
D.B()
A.C()
D.C()

my name is aaa
my age is 18
lizi
18
helo, nice to see you again



---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-6-538682ae8e46> in <module>()
     16 D.B()
     17 A.C()
---> 18 D.C()


TypeError: C() takes 0 positional arguments but 1 was given

#关于self的案列
class A():
    name = "lizi"
    age = 99
    addr = "ffff"
    def __init__(self):
        self.name = "liziqiang"
        self.age = 18
    def B(self):
        print(self.name)
        print(self.age)

        
class C():
    name = "llll"
    age = 23
    
a = A()
a.B()

A.B(a)  #此时self被a替换

A.B(A)   #只要括号中的参数是有类的属性的就不报错，此时返回的是累的属性

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

liziqiang
18
liziqiang
18
lizi
99
llll
23

面向对象的三大特性

封装：就是对对象的成员进行访问限制
- 封装的三个级别：
  - 公开,public
  - 受保护的，protected
  - 私有的，private
  - public，protected，private不是关键字
判别对象的位置
- 对象外部
- 对象内部
- 子类中
私有
- 私有成员是最高级别的封装，只能在当前类或者对象中访问
- 在成员前面添加两个下划线即可,python的私有不是真私有，通过name mangling技术还是可以访问的。

class person():
    name = "lzi"  #  #name是共有成员
    __age = 19    #  age是私有成员
    
A = person()
print(A.name)
print(A.__age)   #想要在类的外边访问私有成员，不可以

lzi



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-18-d527e434b390> in <module>()
      5 A = person()
      6 print(A.name)
----> 7 print(A.__age)   #想要在类的外边访问私有成员，不可以


AttributeError: 'person' object has no attribute '__age'

class person():
    name = "lzi"  #  #name是共有成员
    __age = 19    #  age是私有成员
    
A = person()
print(A.name)
A._person__age = 2222
print(A._person__age)   #name mangling 访问私有变量

lzi
2222

Python系统学习第十课

python面向对象继承

类和对象的概念

类中的内容，应该具有两个内容

类的基本实现

如何声明一个类

可以通过默认内置变量检查类和对象的所有成员

类和对象的成员分析

面向对象的三大特性

猜你喜欢