随笔 - 22  文章 - 0 评论 - 0 阅读 - 76
< 2025年2月 >
26 27 28 29 30 31 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 1
2 3 4 5 6 7 8

类 对象

# 类 建议用大驼峰命名法
# 类 最基本的作用就是封装
# 类 只负责描述(定义) 不负责执行代码 (类中的方法不执行)  要在外部调用--一般在另外一个模块调用
# 方法和函数的区别:函数是独立的,方法属于类,方法可以调用类中的属性,方面是设计层面的,函数是执行层面的,方法是属于对象的,函数是独立存在的(更加关注的事过程)。
# 变量放在类里面  是一种数据成员    属性
# 方法放在类里面  是一种行为成员




# 类的定义
# class 类名:
#     类属性
#     实例方法
#     类方法
#     静态方法
# 类的实例化
# 对象名 = 类名()
# 对象名.属性名
# 对象名.方法名()

## 在类的内部可以做什么事情呢?
# 1. 定义类属性,用于描述类的特征,类属性属于类,不属于某个具体的对象。


class Student:
    # 类属性
    name = "张三"  # 定义一个类属性,表示学生的名字,初始值为"张三"
    age = 18      # 定义一个类属性,表示学生的年龄,初始值为18
    # 实例方法
    def print_file(self):
        print("姓名:", self.name)  # 输出学生的名字
        print("年龄:", self.age)   # 输出学生的年龄
    # # 类方法
    # @classmethod
    # def eat(cls):  # 定义一个名为eat的方法,参数为cls,通常用于类方法中
    #     print("吃饭")  # 当调用eat方法时,输出字符串"吃饭"
    # # 静态方法
    # @staticmethod
    # def sleep():  # 定义一个名为sleep的函数,用于执行睡觉相关的操作
    #     print("睡觉")  # 在函数内部调用print函数,输出字符串"睡觉",表示执行睡觉动作

student = Student()  # 创建一个Student类的实例对象
student.print_file()  # 调用实例方法print_file,输出学生的名字和年龄

导入模块 实例化类

from d1 import Student
student = Student()  # 创建一个Student类的实例对象
student.print_file()  # 调用实例方法print_file,输出学生的名字和年龄

类是现实世界或思维世界中的抽象概念,是对一类事物的描述或定义,包括它的属性和行为。

对象是类的实例,是一个具体的存在。

类是抽象的,对象是具体的。

类是对象的模板或蓝图,对象是类的实例。

类是对象的集合,对象是类的成员。

类是对象的类型,对象是类的实例。

class Student:
    name = ''
    age = 18
    gender = '男'
    # 行为  特征
    def __init__(self,name,age,gender):
        # 构造函数,用于初始化对象,在创建对象时自动调用,只能返回None
        name = name
        age = age
        gender = gender

    def do_homework(self):  # 定义一个名为do_homework的方法,该方法属于某个类
        print('学习')  # 当该方法被调用时,打印字符串'学习'
    def sleep(self):  # 定义一个名为sleep的方法,该方法属于某个类(通过self参数表示)
        print('睡觉')  # 当调用该方法时,会在控制台输出字符串'睡觉'

student1 = Student('石敢当', '18', '男')  #实例化一个Student对象,并赋值给变量student1
# student2 = Student()  
# student3 = Student()

# print(id(student1))
# print(id(student2))
# print(id(student3))

# 三个对象的id值不同,说明它们是不同的对象,即它们是不同的实例。
# 三个对象的属性值相同,说明它们是同一个类的实例,即它们具有相同的属性和行为。

print(student1.name)  # 输出student1对象的name属性值

类变量 实例变量

# 类变量是类级别的变量,属于类本身,可以通过类名直接访问。
# 实例变量是对象级别的变量,属于对象本身,可以通过对象名直接访问。
# 类变量和实例变量都可以通过类名和对象名来访问,但是类变量只能通过类名来修改,实例变量可以通过对象名来修改。



class Student:
    name = 'jianshen'
    age = 18
    gender = '男'
    # 行为  特征
    def __init__(self,name,age,gender):
        # 构造函数,用于初始化对象,在创建对象时自动调用,只能返回None
        self.name = name
        self.age = age
        self.gender = gender


student1 = Student('石敢当', '18', '男')   
student2 = Student('不敢当', '18', '女') 
print(student1.name,student1.age,student1.gender)  # 实例变量
print(student2.name,student2.age,student2.gender)  # 实例变量
print(Student.name,Student.age,Student.gender)  # 类变量
print('-----------------')
print(student1.__dict__)  # 查看对象的所有属性
print(Student.__dict__)  # 查看类的所有属性

self 与实例变量

# 实例方法创建时必须要有self参数,self代表实例对象本身
# 调用实例方法时 self参数不需要手动传递,python解释器会自动传递

# self 就是调用某一个方法的实例对象,self.name 就是实例对象的name属性

#  在实例方法中访问修改类变量

class Student:
    sum = 0
    # 行为  特征
    def __init__(self,name,age,gender):
        # 构造函数,用于初始化对象,在创建对象时自动调用,只能返回None
        self.name = name
        self.age = age
        self.gender = gender
        print(name,age,gender)      #这个写法是不对的,这里打印出来的是形参
        print(self.name,self.age,self.gender)  # 访问实例变量必须要加self
        self.__class__.sum += 1  #  调用一次增加1
        print(Student.sum)  #在实例方法中访问类变量
        print('当前班级的总数为:' + str(self.__class__.sum))     #在实例方法中访问实例变量
    def study(self):
        print(self.name + '正在学习')
        self.__class__.sum += 1  #  调用一次增加1
        print('在study方法中 : 当前班级的总数为:' + str(self.__class__.sum))
student1 = Student('石敢当', '18', '男')
student2 = Student('石敢当', '18', '男')
student3 = Student('石敢当', '18', '男')
student2.study() 

实例方法访问类变量

# 构造方法与实例方法调用不同


class Person:
    count = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age
        Person.count += 1

    def show(self):
        print('姓名:', self.name, '年龄:', self.age)

    def show_count(self):
        print('人数:', Person.count)


p1 = Person('张三', 18)

类方法

#  操作和类相关的变量


# 操作和对象无关的变量还是用类方法比较好


class Student:
    count = 0

    def __init__(self, name, age):
        self.name = name
        self.age = age
        Student.count += 1

    @classmethod   # 使用 @classmethod 装饰器将 get_count 方法声明为类方法
    def get_count(cls):  # 定义一个名为 get_count 的方法,接收一个参数 cls,通常用于类方法
         cls.count +=1   # 返回 cls(类)的 count 属性的值
         print('学生人数为:' + str(cls.count))
    
    @staticmethod  # 使用 @staticmethod 装饰器将 get_count1 方法声明为静态方法
    def get_count1():  # 定义一个名为 get_count 的方法,接收一个参数 cls,通常用于类方法
        count = 1  # 返回 cls(类)的 count 属性的值
        print('学生人数为WWW:' + str(count))
    
student1 = Student('张三', 18)
student2 = Student('张三', 18)
Student.get_count()  # 类名.类方法名()  调用类方法
student1.get_count()  # 对象也可以调用类方法  但是不建议这么操作
Student.get_count1() 
student2.get_count1()  # 对象也可以调用类方法  但是不建议这么操作

成员可见性

# 私有变量
class Student:
    sum = 0
    def __init__(self,name,age,gender):
        # 初始化方法,用于创建对象时设置初始状态
        self.name = name
        # 将传入的name参数赋值给对象的name属性
        self.age = age
        # 将传入的age参数赋值给对象的age属性
        self.__gender = gender
    def marking(self,score):
        if score < 0 or score > 100:
            print('请输入正确的成绩')
        else:
            self.__score = score
            print(self.name +'同学本次考试成绩为:'+ str(self.__score))

student1 = Student('石敢当', '18', '男')
student1.marking(100) # 类变量的修改建议通过方法来实现
student1.marking(1000)
student1.score = -1 # 可以直接修改实例变量
print(student1.__dict__) # {'name': '石敢当', 'age': '18', 'score': -1} # 查看成员变量
r = student1.score
print(r)

student2 = Student('石敢当', '18', '男') # {'name': '石敢当', 'age': '18'}
print(student2.__dict__)

print(student1._Student__score) # 可以通过这种方式访问私有变量


# 在方法名前加两个下划线,表示私有变量,只能在类内部访问,外部无法访问
# def __marking(self,score):

继承

# 继承
# 子类继承父类,子类可以继承父类的属性和方法
# 子类可以重写父类的方法
# 子类可以调用父类的方法
# 子类可以添加自己的属性和方法
# 子类可以调用父类的构造方法

#  继承  避免我们定义重复的变量和方法
#  封装
#  多态
class Human:
    sum = 0
    def __init__(self,name,age):
        self.name = name
        self.age = age
        Human.sum += 1

继承

from d9 import Human

class Student(Human):
    def __init__(self,school,name,age):  # 定义一个初始化方法,用于创建对象时进行初始化操作
        self.school = school
        super(Student,self).__init__(name,age)   # 调用父类的初始化方法  这里不需要传self参数
        # Human.__init__(self,name,age) # 调用父类的初始化方法 用类调用的 这里要加上传入self 不建议使用
        self.sum += 1
        
student1 = Student('北京大学', 'haha',19) #实例化对象
print(student1.name)
print(student1.age)
print(student1.sum)
Student.sum



#  子类调用父类的方法
# 1.直接调用
# 2.通过父类名调用
# 3.通过super()函数调用
# 4.通过super()函数调用父类的其他方法

# 如果子类方法和父类方法同名 则会优先调用子类方法
posted on   Martinl_it  阅读(2)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 没有源码,如何修改代码逻辑?
· PowerShell开发游戏 · 打蜜蜂
· 在鹅厂做java开发是什么体验
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战
点击右上角即可分享
微信分享提示