python面向对象编程；

1.类和对像引言

类： 是一类事物的抽像概念(模型),不是真的存在的。用来描绘该类事物共同的特征和行为。 
例如: 船模型，车模型，飞机模型
作用：用来封装一类事物的共同特征(属性)和行为(方法，函数)
类属性： 这个类事物的共同特征(这个类的每个对像都有这个属性，而且属性值是一样的)
类属性的定义：直接定义在类里面的变量
比如：猫类的共同特征： 四条腿，长尾巴，两只眼情

实例对像： 某类事物的具体个体，是该类事物的具体表现，是真实存在的。
例如：泰坦尼克号 就是一艘具体的船

2.类的定义

1.关键字: class
语法：
    方式1： class 类名:
    方式2： class 类名(object):
说明：方式1和方式2定义类都是一样的，没有任何区别，只是写法不一样

python里的class定义类为什么括号有object?
你可以把object理解为⼀个很⼤的类，然后加括号表⽰继承object⾥


2.定义类属性:
    代码示例：
    class Cat(object):     # 定义一个猫类
        leg = "四条腿"
        tail = "长尾巴"


3.对像属性(实例属性)：这一类事物都可能会有这个属性，属性值有可能不一样
对像属性的定义:
   方式1 ：通过对像进行赋值
   方式2 : 通过初化方法__init__进行定义
   通过类创建出来的，拥有这个类所有的特征和行为

4.通过类创建对像： obj = 类名()
    代码示例：
    c1 = Cat()  # 创建对像c1
    c2 = Cat()  # 创建对像c2


5.类属性的访问
1.类可以直接访问类属性
2.该类的实例对像也可以访问类属性
    self :代表对像本身

class Cat:
    attr1 = "喵"       #  类属性
    attr2 = "有毛"     #  类属性
    attr3 = "爱吃鱼"   #  类属性

    def __init__(self,name,age,sex): #初始化函数，在创建对象时会自动调用。
        self.name = name  #不能写成name=name,那个name是局部变量,属局部变量赋值，不是属性设置。
        self.age = age
        self.sex = sex

    def skill1(self):     # 类方法
        print("抓老鼠")

    def skill2(self):
        print("爬树")

c1 = Cat("叮当猫",6,"公")   #实例化对象。
c1.attr1                   #对象调用类属性。

c1.small_name = '小花猫'   # 通过对像添加属性。
print(c1.small_name)

3.公有属性、_私有属性、__私有属性

通过下面的代码，可以看到：
1.公有属性，通过对象和类都可以访问。
2.单下划线私有属性也可通过对象和类访问（尽量不用，修好改删除容易出问题）。
3.双下划线私有属性在类外面不能访问。
class TestClass:
    attr = 100    # 公有属性
    _attr = 10    # 私有属性
    __attr = 20   # 私有属性
    
    def func(self):
        print(self._attr)     # _私有属性在类里面可以被访问
        print(self.__attr)    #__私有属性在类里面可以被访问

t1 = TestClass()

print(t1.attr)                #实例化对象访问公有属性
print(TestClass.attr)         #类直接访问公有属性
print(t1._attr)               #实例化对象访问_私有属性
print(TestClass._attr)        #类直接访问_私有属性
print(t1.__attr)              #报错，实例化对象不可以访问__私有属性
print(TestClass.__attr)       #报错，类直接不可以访问__私有属性  

4.类方法、静态方法、对象方法。

1.对象方法(也叫实例方法):
通过对象去调用的: 对象.方法名(); 不能通过类去访问
通过下面这段代码，可以发现对象可以调用类方法，而类不能直接访问对象方法
代码示例：
    class TestClass:
    
        def func(self):      # 对象方法
            print("方法测试")
            
    t1 = TestClass() 
    t1.func()                # 对象可以使用对象方法

    TestClass.func()        # 报错，类不能直接访问对象方法


2.类方法: 
定义：使用装饰器 @ classmethod，第一个参数必表面是当前类对象，该参数名一般约定为"cls", 通过他来传递类的属性和方法(不能传实例的属性和方法)。
如果方法以类为主体去调用，方法内部不会涉及到对象属性或对象方法的使用，那么该方法就定义为类方法。
代码示例：
    class TestClass:
    
        @classmethod           # 类方法,需要用装饰器classmethod
        def func2(cls):
            print("这个是类方法：classmethod 之方法之一"),

    t1 = TestClass()
    t1.func2()                #实例化对象可以调用 类方法
    TestClass.func2()         #类也可以调用 类方法

3.静态方法
定义： 使用装饰器 @ staticmethod，参数随意，没有self和cls参
应用场景： 方法内部不会使用类属性和类方法，也不会涉及到对象属性和对象方法
class TestClass:

    @staticmethod   # 静态方法
    def func3():
        print("这是一个静态方法")


思考：三种方法的应用场景（在什么情况下用对象方法，什么情况下用类方法，什么情况下用静态方法)？