(1) 类的定义

【类的定义】

类的意义：封装代码（封装变量和函数）

类的名字：驼峰式

类的定义在一个模块中，实例化在另一个模块中

# 在d1.py中的代码
class StudentClass:
    # 在内部可以做什么事情
    # 定义变量和韩式
    name = "cici"
    age = 18

    # 方法需加上self
    def print_file(self):
        print(f"名字是{self.name}")
        print(f"年龄是是{self.age}")

【类的执行】

类的实例化过程

实例化对象的方法

# 在d2.py中的代码
from d1 import StudentClass

# 实例化过程
student1 = StudentClass()
# 调用类的方法
student1.print_file()

输出：
名字是cici
年龄是是18

(2) 浅谈函数与方法的区别

面向对象：设计、 封装

函数：面向过程

类的变量：数据成员

变量

(3) 类与对象

类：数据成员刻画类的特征，类能做的事情（行为）叫做方法。

类的特征的具体值，需要做实例化和传入具体值

可以通过类生成学生abcd，类是模板，可以产生很多对象

# 模板
class StudentClass():
   # 特征
    name = "cici"
    age = 18

	# 行为
    def hace_class(self):
        print("上课")

实例化：类可以生成不同的对象，用模板生成不同的对象（id不同）

class StudentClass:
    name = "cici"
    age = 18

    def hace_class(self):
        print("上课")

student1 = StudentClass()
student2 = StudentClass()
student3 = StudentClass()
print(f"student123的id分别是：{id(student1)} ,{id(student2)} ,{id(student3)}")

输出:
student123的id分别是：2238767201392 ,2238772106320 ,2238772375760

(4) 构造函数

向类传入不同的值，使得对象的特征不相同，需要定义__init__这个构造函数.

实例化的时候，会自动调用__init__方法进行初始化的过程，所以输出了student.

__init__也是可以调用的，然后输出student.

class StudentClass:
    def __init__(self):  # 构造函数
        print("student")

    def hace_class(self):
        print("上课")


student1 = StudentClass()
student1.__init__()

输出：
student
student

__init__只能return None

class StudentClass:
    def __init__(self):
        print("student")

    def hace_class(self):
        print("上课")


student1 = StudentClass()
a = student1.__init__()
print(type(a))

输出：
student
student
<class 'NoneType'>
  

构造函数，让对象变得不同，必须传入对应的参数

__init__初始化对象的特征（属性）

class StudentClass:
    name = "name"
    age = "age"

    def __init__(self, name, age):  #
        name = name
        age = age
        print(f"student name : {name}, age: {age}")

    def hace_class(self):
        print("上课")


student1 = StudentClass("cici", 18)
student2 = StudentClass("daisy", 17)

输出：
student name : cici, age: 18
student name : daisy, age: 17

(5) 区别模块变量与类中的变量

访问类下的对象和方法用点

class StudentClass:
    name = "name"
    age = "age"

    def __init__(self, name, age):  #
        name = name
        age = age
        print(f"student name : {name}, age: {age}")

    def hace_class(self):
        print("上课")


student1 = StudentClass("cici", 18)
student2 = StudentClass("daisy", 17)
print(student1.name)

输出：
student name : cici, age: 18
student name : daisy, age: 17
name

上面的代码中，name依旧是“name”，说明我们传参未改变他原来的值。

类变量和实例变量 不同于 全局变量和局部变量。

使用self.name 保存实例变量的特征值。

class StudentClass:
    name = "name"
    age = "age"

    def __init__(self, name, age):  # 使用self.name 保存实例变量的特征值
        self.name = name
        self.age = age

    def hace_class(self):
        print("上课")


student1 = StudentClass("cici", 18)
student2 = StudentClass("daisy", 17)

print(student1.name)
print(student2.name)
print(StudentClass.name)

输出：
cici
daisy
name

类变量不应该定义不同的变量，不同的特征应该是实例对象定义的。

class StudentClass:
    school_sum = 100

    def __init__(self, name, age):  # 使用self.name 保存实例变量的特征值
        self.name = name
        self.age = age

    def hace_class(self):
        print("上课")


student1 = StudentClass("cici", 18)
student2 = StudentClass("daisy", 17)

print(student1.name)
print(student2.name)
print(StudentClass.school_sum)

(6) 类与对象的变量查找顺序

__dict__可以查看保存在对象下所有的变量

class StudentClass:
    name = "name"
    age = "age"

    def __init__(self, name, age):  # 使用self.name 保存实例变量的特征值
        name = name
        age = age


student1 = StudentClass("cici", 18)
print(student1.__dict__)  # __dict__保存对象下所有的变量
print(student1.name)
print(StudentClass.name)

输出：
{}
name
name

class StudentClass:
    name = "name"
    age = "age"

    def __init__(self, name, age):  # 使用self.name 保存实例变量的特征值
        self.name = name
        self.age = age


student1 = StudentClass("cici", 18)
print(student1.__dict__)
print(student1.name)
print(StudentClass.name)

输出：
{'name': 'cici', 'age': 18}
cici
name

查找顺序：实例变量-> 类变量 ->继承，父类里面去寻找

class StudentClass:
    name = "name"
    age = "age"

    def __init__(self, name, age):  
        name = name
        age = age


student1 = StudentClass("cici", 18)
print(student1.__dict__)
print(student1.name)
print(StudentClass.name)
print(StudentClass.__dict__)

(7) self与实例方法

实例方法，第一个参数固定self，调用不需要对self传参。

self可以改成任何自定义的名字，建议用self。

self代表本身，谁调用了这个方法，self就是谁、self代表实例，一个对象。

实例变量和实例方法都是和对象实例相关联的。也是实例可以调用的。

(8) 在实例方法中访问实例变量与类变量

通过 self. 在实例方法里面访问实例变量

class StudentClass:
    school_sum = 100

    def __init__(self, name, age):
        self.name = name
        self.age = age
        print(self.name)  # 读取实例变量
        print(self.__dict__)
        print(name)  # 读取形参内容
        
        # __init__ 是特殊的=的实例方法
        print("通过 self. 在实例方法里面访问实例变量 ： ", self.name)

student1 = StudentClass("cici", 18)
print(StudentClass.school_sum)

通过 self. 在实例方法里面访问类变量

通过 self.__class__. 在实例方法里面访问类变量

通过 类名. 在实例方法里面访问类变量

class StudentClass:
    school_sum = 100

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def have_class(self):
        print(self.school_sum)
        print(self.__class__.school_sum)
        print(StudentClass.school_sum)


student1 = StudentClass("cici", 18)
student1.have_class()

(9) 类方法

实例方法操作类变量

class StudentClass:
    school_sum = 100

    def __init__(self, name, age):
        self.name = name
        self.age = age
        # 实例方法操作类变量
        self.__class__.school_sum += 1
        print(self.__class__.school_sum)


student1 = StudentClass("cici", 18)
student2 = StudentClass("cici", 18)
student3 = StudentClass("cici", 18)
student4 = StudentClass("cici", 18)

输出：
101
102
103
104

类方法定义：方法上加上 @classmethod

cls可以是自定义的名字

类方法不能调用实例变量

class StudentClass:
    school_sum = 100

    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def add_school_sum(cls):
        cls.school_sum += 1
        print(cls.school_sum)

StudentClass.add_school_sum()
StudentClass.add_school_sum()
StudentClass.add_school_sum()
StudentClass.add_school_sum()

输出:
101
102
103
104

实例方法关联的是对象，类方法关联的是类

(10) 静态方法

静态方法定义：方法上加上 @staticmethod

class StudentClass:
    school_sum = 100

    def __init__(self, name, age):
        self.name = name
        self.age = age

    @staticmethod
    def add():
        print("this is a static method")


student1 = StudentClass("cici", 18)
student1.add()
StudentClass.add()

可以被对象和类调用，但是静态方法不能调用实例变量

class StudentClass:
    school_sum = 100

    def __init__(self, name, age):
        self.name = name
        self.age = age

    @staticmethod
    def add():
        print(StudentClass.school_sum)
        print("this is a static method")


student1 = StudentClass("cici", 18)
student1.add()
StudentClass.add()