python基础（08类和对象）

python系列文章目录

python基础（01变量&数据类型&运算符）
python基础（02序列共性）
python基础(03列表和元组)
python基础（04字符串&字典）
python基础（05集合set）
python基础（06控制语句）
python基础（07函数）

---

---

前言

类和对象看这一篇就够了！！

---

一、对象基础概念

类：

模板

实例：

通过类创建出来的对象叫做类的实例

属性：

• 对象名.属性1（）可直接调用属性
• 私有属性：__属性名

方法：

• 只能通过对象调用，不能通过类直接调用
• 对象名.方法1（）调用
• 私有方法：__方法名
• 私有方法不会被子类继承

二、定义类

1.例子1

• 有属性a,b,c
• get_a方法求：a+b+c
• get_b方法求：abc
• 实例两个对象test1、test2

class demo:
    def __init__(self,a,b,c):
        self.a=a
        self.b=b
        self.c=c
    def get_a(self):
        return self.a+self.b+self.c
    def get_b(self):
        return self.a*self.b*self.c


test1=demo(1,2,3)
print(test1.get_a())

test2=demo(4,5,6)
print(test2.get_b())
---------------------------------->
6
120

2.例子2

• Car类名
• object是它继承的类
• init()创建对象实例时默认调用，初始化一些属性
• self创建实例的本身

class Car(object):
 pass

class Car(object):
    def __init__(self, brand, age):
        self.brand = brand
        self.age = age
    def broke(self):
        print(self.brand, '在刹⻋')

    def add(self):
        print(self.brand, '在加速')

三、实例化类

• 实例名=类名()

car1=Car('宝马',2)
car1.broke()         #宝马 在刹⻋
print(car1.brand)    #宝马
print(car1.broke())  #宝马 在刹⻋   None(默认返回值)

car2=Car('迪奥',8)  
car2.add()           #迪奥 在加速
print(car2.age)      #8
print(car2.add())    #迪奥 在加速   None（默认返回值）

四、继承

例子：定义一个Mini_car,继承Car

class Mini_car(Car):
     def __init__(self, brand, age , weight)

1.继承

方法一：

 #继承car 的 __init__()
          Car.__init__(self, brand, age)

方法二：

#继承car 的 __init__()
          Car.__init__(self, brand, age)

2.重构

 # 重构父类的方法
    def add_speed(self):
        print(self.brand, "在加速ing")
   创建新方法
    def zairen(self):
        print(self.brand,"我能载2个人")

3.例子

class Mini_car(Car):
     def __init__(self, brand, age , weight):
#         # 继承car 的 __init__()
#         # Car.__init__(self, brand, age)
         super(Mini_car, self).__init__(brand, age)
         self.weight = weight
#
#     # 重构父类的方法
     def add_speed(self):
         print(self.brand, "在加速ing")
#  创建新方法
     def zairen(self):
         print(self.brand,"我能载2个人")

五、经典类、新式类

1.经典类

• python2中的
• 反之
• 左到右遍历，深度优先

2.新式类

• python3中的
• 有任意内置类型派生出来的类 str list dic object
• 左到右遍历，广度优先

问题：多重继承，C读取哪个foo、bar

• python2:A1的foo，A2的bar(左到右，深度优先，B1–>A1(foo)–A2(bar)–>B2)
• python3:A1的foo，B2的bar（左到右，广度优先，B1–>B2(bar)–>A1—>A2(foo)）

class A1:
    def foo(self):
        print( 'A1foo')

class A2:
    def foo(self):
        print( 'A2foo')

    def bar(self):
        print('A2bar')

class B1(A1,A2):
    pass

class B2(A1, A2):
    def bar(self):
        print('B2bar')

class C(B1, B2):
    pass

六、多态

1.基础概念

• 多态：一种事物有多种形态，一个抽象类（不能实例化）的多个子类
• 多态性：1个接口，多个实现

class tran:
    def say_speed(self):
        pass

class car(tran):
    def say_speed(self):
        print( '100km/h')

class ship(tran):
    def say_speed(self):
        print('50km/h')


class fly(tran):
    def say_speed(self):
        print('200km/h')

-------------------------------------->>>
a=car()
b=ship()
c=fly()

def demo(obj):
    obj.say_speed()

demo(a)
demo(b)

2.特点

• 多态是方法的多态，属性没有多态
• 多态的存在有2个必要的条件：继承、方法重写

七、类变量&实例变量

1.类变量

定义：

定义在类里面，实例方法外的变量， 属于所有的实例，共享的属性

例子：

 class Car:
     # 类变量
     max_speed = 100
     #实例变量
     def __init__(self,brand,age):
         self.brand = brand
         self.age = age

使用：

1.类来访问类变量（推荐）

 print(Car.max_speed)

2.实例对象来访问类变量（不推荐）

print(car1.max_spend)

3.类不能访问实例变量（不能）

print(Car.brand)报错

4.修改类变量的值，会影响到所有的实例变量

Car.max_speed = 150

5.实例对象对类变量进行赋值，不会修改类变量的值， 本质上是在给该对象定义新的实例变量(添加了一个属性)

car1.max_speed =200
#再次修改类变量的值，对car1不影响了，因为同名时，优先访问实例变量

6.实例变量 可以和类变量同名，访问的是 实例变量

例如：实例对象给类变量进行赋值，相当于给这个实例对象新增加了一个同名的实例变量，那么这个实例对象再去访问这个变量，其实访问的是实例变量

2.实例变量

定义在实例方法（self）里面的 每个实例唯一的

八、类方法&实例方法&静态方法

1.实例方法

1.定义

第一个参数必须是self

2.调用方法

• 只有实例对象可以调用；类对象不能调用
• 实例对象对这三种方法都可调用

3.方法的归属

• 实例方法归属于实例对象

4.使用场景

• 只有实例对象可以使用

2.类方法

1.定义

使用 修饰符 @classmethod 定义， 且第一个参数必须是 cls

@classmethod
    def class_func(cls):
      print("这是类方法")

2.调用方式

• 类和实例都能调用

3.方法的归属

• 类方法归属于类对象
• 类方法适用于方法中只涉及到类变量的方法

4.使用的场景

适用于方法中只涉及到类变量的方法

 class Car:
     # 类变量
     max_speed = 100

     @classmethod
     def modify_maxSpeed(cls,speed):
         cls.max_speed = speed

通过类方法对类变量进行更改

class Car:
    # 类变量
    max_speed = 100
    #类方法
    @classmethod
    def modify_maxSpeed(cls,speed):
       cls.max_speed=speed


car1= Car()
car2=Car()
print(car1.max_speed) #调用了类变量  100
print(car2.max_speed)#100
Car.modify_maxSpeed(150) #调用了类方法，改变了类变量的值为150
print(car1.max_speed)  #150
print(car2.max_speed)  #150

3.静态方法

1.定义

使用 修饰符 @staticmethod 定义, 参数随意， 没有 self 和 cls

    @staticmethod
    def static_func():
        print("这是静态方法")

2.调用方法

类和实例都能调用

3.方法的归属

静态方法归属于类和实例对象

4.使用场景

• 无法访问类属性，实例属性，相当于一个独立的方法，跟类没啥关系
• 放在一个类的作用域里面的函数而已

   class Car:
    # 类变量
    max_speed = 100
    #类方法
    @classmethod
    def modify_maxSpeed(cls,speed):
       cls.max_speed=speed

    # 实例方法
    def __init__(self, brand, age):
        self.brand = brand
        self.age = age
    #静态方法
    @staticmethod
    def print_message():  #静态方法不能传self、cls
        print(f"这两汽车是{self.brand},最大速度是{cls.max_speed}")#静态方法无法访问类属性、实例属性，此处调用就会报错
        
        
ar1=Car("宝马",2)
ar2=Car("奥迪",8)

ar1.print_message()  #报错
ar2.print_message()  #报错

---

总结

一定要动手敲一遍！！