类和对象python

参考和学习书籍《零基础入门学习python》作者小甲鱼

1.对象=属性+方法 2.对象的特征叫属性，对象的行为叫做方法

定义一个类用关键字class():

class Man:
#类名是以大写字母开头
#特征的描述就是属性，从代码层面来看其实就是变量
     hair="10万"
     head=1
     eye=2
     mouth=1
     ear=2
#方法实际就是函数，可以调用这些函数来完成某个操作
     def man(self):
         print('我会说话')
         print('我还会学习python和c语言')
      def run(self):
         print('我会跑步，会走路')
         print("我会计算,1+1=",1+1)
"""
上面定义了对象的特征(属性)，和行为(方法)，但还不是一个完整的对象，上面是定义了类。需要使用类创建对象，这
个对象就是这个类的实例
类就像盖房子使用的图纸，盖好的房子就是对象。创建一个对象叫做类的实例化顾名思义就是按照图纸盖好了实物的房子
"""
#使用类
pot=Man()#实例化一个对象叫做pot
at=Man()#实例化一个对象叫做at
at.eye#调用at对象的眼睛属性
2
pot.eye#调用pot对象的眼睛属性
2
at.man()#调用at对象的man行为
我会说话
我还会学习python和c语言
pot.man()#调用pot对象的man行为
我会说话
我还会学习python和c语言
"""
我的理解
实例化对象，对象可以有很多，类就像是一个工具箱，我们可以有很多的对象用一个类，例如我要用python画一个食草
恐龙，我写了一个画长颈鹿的类，同学写了一个画大象的类，我可以把长颈鹿类实例化给食草恐龙，使用长颈鹿的长脖
子属性，实例化同学的类把大象的身体，腿属性和大象食草的行为给我的食草恐龙
"""
#其实不实例化也可以，可以这样使用类里面的东西
Man().man()
我会说话
玩王者有时我会问侯队友家长
#没有任何引用指向这个实例，最终会被python的垃圾收集机制自动回收

3.self自己的实例化对象就是自己的实例化对象

class A:
     def b():
         print('你好')
a=A()
a.b()
NameError Traceback (most recent call last)
~\AppData\Local\Temp\ipykernel_6080\4161458064.py in <module>
        3 print('你好')
        4 a=A()
        ----> 5 c.b()
        NameError: name 'c' is not defined
#没有self就不能实例化
class A:
   def b(self):
print(self)
a=A()
a.b()
>> <__main__.A object at 0x000001E104005EB0>#类A的实例化对象a
"""
同一个类可以生成无数个对象，当我们调用类里面的一个方法时就通过self传递参数python就知道哪一个对象在调用这
个方法，所以默认的第一个参数就时self,self就是对象本身
"""

4.性质--继承

通过继承创建的类叫做子类，被继承的类叫做父类，基类或超类

class A:
     x=520
     def add(self):
         print("我是类A")
class B(A):#B继承了类A
     pass
b=B()
b.add()
我是类A
b.x
520
#继承属性和方法就是共享
class A:
      x=520
      def add(self):
          print("我是类A")
class B(A):
      x=880
      def add(self):
          print('我是类B')
b=B()
b.x
880
b.add()
我是类B
#要是子类有父类的相同属性和方法名实例化后子类会覆盖父类的属性和方法
#判断某个对象是否属于某个类可以使用isinstance()函数
#检测类是否为某个类的子类可以使用issubclass()函数
print(isinstance(b,B),isinstance(b,A))#b对象是否属于A,B这两个类
True True
print(issubclass(A,B),issubclass(B,A))#这里很明显A不是B的子类
False True

5.多重继承

class A:
      x=520
      def add(self):
          print("我是类A")
class B:
      x=880
      y=250
      def add(self):
          print('我是类B')
class C(A,B):
      pass
c=C()
c.x
520
c.y
250
#继承顺序先左后右，只有在前一个父类找不到时则在后边的父类寻找

6.组合

class Dog:
      def say(self):
        print('汪汪汪')
class Cat:
      def say(self):
        print('喵喵喵')
class Man:
      def say(self):
        print('呵呵')
class Look:
        d=Dog()
        c=Cat()
        m=Man()
        def ay(self):
            self.d.say()
            self.c.say()
            self.m.say()
l=Look()
l.ay()
汪汪汪
喵喵喵
呵呵

7.绑定

class C():
     def a(self):
       print(self)
c=C()
c.a()
<__main__.C object at 0x00000291FB091C70>

类的对象和实例方法进行绑定，因为类的实例对象是千千万万的，但实例对象却是共享类里面的方法，所以当我们 调用实例c.a()的时候实际上的意义是调用类C的a()方法并将实例对象作为参数传进去，进而实现绑定所以类似的代 码就相当于C.a(c)

class C():
     def a(self):
       print(self)
c=C()
c.a()
C.a(c)
<__main__.C object at 0x00000291FB0B6D90>
<__main__.C object at 0x00000291FB0B6D90>
class C():
      def a(self):
        print(self)
c=C()
d=C()
d.x=250
d.y=110
print(d.x)
250
print(d.y)
110
#对象c是访问不了x，y的因为是对象d的x，y
c.x=500
c.y=1024
print(c.x)
500
print(c.y)
1024
print(c.__dict__)
{'x': 500, 'y': 1024}
print(d.__dict__)
{'x': 250, 'y': 110}
class C():
     def a(self,v):
       self.x=v
c=C()
c.a(1024)
print(c.__dict__)
{'x': 1024}
class C():
      x=10
      def a(self,v):
         x=v
c=C()
c.a(1010)#只是在函数内部创建了一个局部变量x，然后赋值为1010，它跟类和对象的x属性没有关系，只能通过类来修
改
print(c.x)
10
print(C.x)
10
C.x=1010
print(c.x)#通过类C修改过来的所以实例化的对象是可以访问的
1010
print(c.__dict__)
{}

在实例中，除了类的方法是共享的之外，实例的属性却可以是自己的 最小的类(可当字典使用)

class Class():
      pass
cl=Class()
cl.a=123
cl.b=800
cl.c=1919
cl.d=[1,2,3,4,5]
cl.ch="chang"
ass=cl.__dict__
print(ass)
{'a': 123, 'b': 800, 'c': 1919, 'd': [1, 2, 3, 4, 5], 'ch': 'chang'}

8.构造函数

构造函数使用--init--方法

class C():
      def __init__(self,x,y):
        self.x=x
        self.y=y
      def add(self):
          return self.x+self.y
      def mul(self):
          return self.x*self.y
c=C(2,3)
print(c.add())
print(c.mul())
c.__dict__
>>5
>>6
>>{'x': 2, 'y': 3}

8.重写

class C():
      def __init__(self,x,y):
        self.x=x
        self.y=y
      def add(self):
         return self.x+self.y
      def mul(self):
         return self.x*self.y
c=C(2,3)
# print(c.add())
# print(c.mul())
# c.__dict__
class D(C):
     def __init__(self,x,y,z):
        C.__init__(self,x,y)
        self.z=z
     def add(self):
        return C.add(self)+self.z
     def mul(self):
        return C.mul(self)*self.z
d=D(2,3,4)
print(d.add())
print(d.mul())
d.__dict__
>>9
>>24
>>{'x': 2, 'y': 3, 'z': 4}

9.super()

class A():
def __init__(self):
print('我是类a')
class B1(A):
def __init__(self):
A.__init__(self)
print('我是类b1')
class B2(A):
def __init__(self):
A.__init__(self)
print('我是类b2')
class C(B1,B2):
def __init__(self):
B1.__init__(self)
B2.__init__(self)
print("我是类c")
c=C()
我是类a
我是类b1
我是类a
我是类b2
我是类c
class A():
def __init__(self):
print('我是类a')
class B1(A):
def __init__(self):
super().__init__()
print('我是类b1')
class B2(A):
def __init__(self):
super().__init__()
print('我是类b2')
class C(B1,B2):
def __init__(self):
super().__init__()
print("我是类c")
c=C()
C.mro()
我是类a
我是类b2
我是类b1
我是类c

10.访问限制

在类的内部可以定义属性和方法，在外部可以随时调用，为了防止类内部的某些属性和方法不被修改

在python中可以通过@property(装饰器)将一个方法转化为属性,从而实现用于计算的属性将方法转化后可以将小括号去掉，这样会让代码看起来简洁

语法：

@property
def methodname(self):
    block

class Cl:
    def __init__(self, w,h):
        self.w= w
        self.h=h
    @property
    def add(self):
        return self.w*self.h
r = Cl(10,10)
print(r.add)
执行结果>>100
#通过@property转换后属性不能重新赋值，如果对其赋值则会报错

在 Python 中，在默认情况下，创建的类属性或者实例是可以在类体外进行修改的，如果想要限制其不能在类体外修改，可以将其设置为私有的，但设置为私有后，在类体外也不能获取它的值。如果想要创建一个可以读取，但不能修改的属性，那么可以使用@property 实现只读属性。

class MyClass:
    def __init__(self,name):
        self.__name=name
    @property
    def word(self):
        return self.__name
my = MyClass('我喜欢python')
print(my.word)
my.name='我不喜欢python'
print(my.word)
>>我喜欢python
>>我喜欢python