1. 类和对象****
类、类属性、类方法不需要实例化就可以直接访问
实例相关，如实例属性、实例方法必须实例化后才可以访问
1.1. 类、类属性、实例属性、私有属性****
1.1.1. 定义****
类就是拥有相同属性和功能对象的集合
动物：猫、狗、鸡
人类：吃、喝、睡
1.1.2. 创建****
1. Class 类名称：
2. Class 类名称()：
1.1.3. 类属性(内外部访问）****
定义在类里面的，在方法函数外面的属性，就叫类属性
不需要实例化
# 类
class Dog:
dog_name = '小黑' # 类属性*
**
**# 实例方法
***def eat(self):
print('吃肉')1.1.3.1. 访问****
.类名称.类属性名称
实例.类属性名称
# 类的实例化*
a = Dog()
# 实例 . 类属性名称
*a.dog_name()
Dog是类
a是类实例类属性可以直接访问，不需要实例化
# 类*
class Dog:
dog_name = '小黑' # 类属性
**dog_color = '黑色' # 类属性
**
**# 实例方法
***def eat(self):
print(Dog.dog_name,'吃肉')
def look(self):
print(Dog.dog_color,'看家')
a = Dog() # 类实例化*
a.eat() # 类实例调用实例方法
a.look() # 类实例调用实例方法*
小黑 吃肉
黑色 看家1.1.4. 实例属性（内外部访问）****
1.1.4.1. __init__初始化方法****
在类实例化的时候自动调用，需要实例化
def init(self):
Self：指实例文本，是一个占位符，习惯写法为self比较见名知意
Self == 类实例
1.1.4.2. 定义****
Self.属性名
定义在魔法方法__init__(初始化方法)中
class Dog:
dog_name = '小黑' # 类属性*
**def init(self):
self.dog_color = '黑色' # 实例属性
**
**# 实例方法
***def eating(self):
print(Dog.dog_name,'正在吃骨头...')
print('狗的颜色',self.dog_color)
if name == 'main':
a = Dog()
a.eating()
小黑 正在吃骨头...
狗的颜色 黑色1.1.4.3. 访问****
1. 类里面访问
Self.变量名
2. 类外面访问
类实例.名称
1.1.5. 私有属性（只可内部访问）****
1.1.5.1. 定义****
并不是所有属性都可以被外部访问，不能被外部访问的属性就叫私有属性
只能在类的内部使用
1.1.5.2. 创建****
1.2. 函数调用扩展****
1. 函数名称（）
2. 在类的内部：self.函数名称（）
3. 在类的外面：类实例.函数名称（） == 类（）.函数名称
class Test:
# init 在实例化后自动调用， 自动 执行 ， 执行完之后才会执行其他函数*
**def init(self):
self.name = '20240226'
print(self.name)
# 类方法
***def test01(self):
print('test01方法')
def test02(self):
# 函数调用（类里面*
***self.test01()
if name == 'main':
# 实例化*
**a = Test()
# 类方法 / 函数的调用（类外面）
***a.test01()
a.test02()
20240226
test01方法
test01方法
1.3. 类的特性****
1.3.1. 继承****
如果子类和父类有相同名称的属性或者方法，优先使用子类自己的属性或方法。
使用super调用父类的方法，不管子类有没有实现，都是直接从父类开始查找。
定义：子类继承父类之后，就会拥有父类的属性和方法（私有属性和私有方法不能被继承）
1.3.1.1. 语法****
Def 父类(self):
Pass
Def 子类(父类):
Pass
# 父类*
*class Test01:
def eat(self):
print('吃饭')
def sleep(self):
print('睡觉')
def study(self):
print('学习')
# 子类*
*class Test02(Test01):
pass
if name == 'main':
a = Test02()
a.study()
学习1.3.1.2. Super 子类调用初始方法****
Def 父类(self):
Def init(self):
pass
Pass
Def 子类(父类):
Def init(self):
Super().init()
Pass
# 父类*
class Test01:
def init(self):
self.name = 'Alison'
def eat(self):
print('吃饭')
def sleep(self):
print('睡觉')
def study(self):
print('学习')
# 子类
*class Test02(Test01):
def init(self):
super().init()
if name == 'main':
a = Test02()
a.study()
print(a.name)
学习
Alison1.3.2. 多继承****
一个类继承了多个类就叫多继承，此时他会拥有他继承的所有类方法和属性（私有属性和方法不会被继承）
多继承不建议使用
1.4. 对象****
对象是类的实体（具体）
萨摩耶、金毛
沃尔沃、凯迪拉克
1.5. 封装****
隐藏了对象的属性和实现细节，只对外提供一个使用的接口或者入口
1.6. 多态****
1.7. 实例方法、类方法、静态方法****
1.7.1. 实例方法****
定义在类中，第一个参数【实例对象】，习惯用self来表示他
调用：实例.方法名
class Test01:
name = '大黄'
# 实例方法*
**def test01(self):
print('test01')
# 类方法
**@classmethod
def test02(cls):
print('test02')
if name == 'main':
# 实例化类
**a = Test01()
# 调用实例方法
***a.test01()
test011.7.2. 类方法****
定义再类中，通过@classmethod修饰之后，第一个参数是类本身cls（和self的意义一样）
@classmethod
def test02(cls):
print('test02')调用：调用方法同类属性
类.类方法****
class Test01:
name = '大黄'
# 实例方法*
***def test01(self):
pass
# 类方法*
***@classmethod
def test02(cls):
print('test02')
if name == 'main':
# 调用类属性*
**print(Test01.name)
# 调用类方法 - 调用方法和调用类属性一样
***Test01.test02()
大黄
test021.7.3. 静态方法****
定义在类中，通过@staticmethod修饰后就是静态方法，没有self或者cls占位符
# 静态方法*
*@staticmethod
def test03(self):
pass调用：
类名称.类方法()
类实例.类方法()
1.7.4. 使用场景****
类方法 vs 静态方法 的区别
相同点：都是在类下面，可以通过类直接调用
都是可以被实例调用
不同点：类方法可以使用类的方法和静态方法
静态方法不可以使用类的属性和方法
使用场景：当类不能重复初始化的时候，就可以使用类方法或者实例方法
重复初始化是指：
