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()20240226test01方法test01方法1.3. 类的特性****
1.3.1. 继承****
如果子类和父类有相同名称的属性或者方法，优先使用子类自己的属性或方法。使用super调用父类的方法，不管子类有没有实现，都是直接从父类开始查找。定义：子类继承父类之后，就会拥有父类的属性和方法（私有属性和私有方法不能被继承）1.3.1.1. 语法****
Def 父类(self):PassDef 子类(父类):Pass# 父类*
*class Test01:
def eat(self):
print('吃饭')def sleep(self):
print('睡觉')def study(self):
print('学习')# 子类*
*class Test02(Test01):
passif name == 'main':
a = Test02()
a.study()学习

1.3.1.2. Super 子类调用初始方法****

Def 父类(self):Def init(self):passPassDef 子类(父类):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)学习Alison

1.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()test01

1.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()大黄test02

1.7.3. 静态方法****

定义在类中，通过@staticmethod修饰后就是静态方法，没有self或者cls占位符

# 静态方法*
*@staticmethod
def test03(self):
pass

调用：

类名称.类方法()

类实例.类方法()

1.7.4. 使用场景****

类方法 vs 静态方法 的区别

相同点：都是在类下面，可以通过类直接调用

都是可以被实例调用

不同点：类方法可以使用类的方法和静态方法

静态方法不可以使用类的属性和方法

使用场景：当类不能重复初始化的时候，就可以使用类方法或者实例方法

重复初始化是指：