• 020python-类与对象

     1、类与对象：

    类 是一种抽象的概念:具有某一类共同属性和特性的事物

    类一般包含属性以及方法，但不是都必须包含的

    类的划分标准：由写代码的人来定

    类的语法： 关键字：class

    类名规范：数字、字母、下划线组成，不能以数字开头，首字母大写，驼峰命名

    类属性：放在类里面的变量值

    类方法/类函数：写在类里面的函数

    属性和方法只能实例调用

    class类名:

            类属性

            类方法/类函数

    # 创建一个男朋友类： 

    1. class BoyFriend:
    2.     #类属性
    3.     height=175
    4.     weight=130
    5.     money='会赚钱'
    6.  
    7.     #类函数/类方法
    8.     # self是一个固定的占坑符，类里面的方法都必须带self这个参数
    9.     # 传这个参数说明这是一个类方法/函数，实例可以调用
    10.     def msg(self):
    11.         print(self)
    12.  
    13.     def cooking(self):   #self是实例本身，传递实例
    14.         print(self.money+'会做饭的男盆友')
    15.  
    16.     def earn(self):
    17.         print('会赚钱的男盆友')

    2、类里面的方法分为三种

    （1）实例方法：意味着这个方法只能实例来调

    1-1创建实例： 实例/对象 具体的一个例子 类名()

    实例具有类里面的所有属性和方法的使用权限

    调用属性 > 实例.属性名

    调用方法/函数 > 实例.函数/方法名() ,def开头的才是函数

    1. class BoyFriend:
    2.     #类属性
    3.     height=175
    4.     weight=130
    5.     money='会赚钱'
    6.  
    7.     #类函数/类方法
    8.     # self是一个固定的占坑符，类里面的方法都必须带self这个参数
    9.     # 传这个参数说明这是一个类方法/函数，实例可以调用
    10.     def msg(self):
    11.         print(self)
    12.  
    13.     def cooking(self):   #self是实例本身，传递实例
    14.         print(self.money+'会做饭的男盆友')
    15.  
    16.     def earn(self):
    17.         print('会赚钱的男盆友')
    18.  
    19. #创建一个实例/对象，一个具体的例子：类名()
    20. BoyFriend()
    21.  
    22. #用变量bf存储实例
    23. bf=BoyFriend()
    24.  
    25. #打印类 <__main__.BoyFriend object at 0x00000214A8234820>，object是一个实体对象，0x00000214A8234820是内存地址，说明创建的对象存在内存地址里
    26. print(bf)
    27.  
    28. print('*'*30)
    29.  
    30. # 调用msg函数/方法并打印，可以看出self就是实例本身，也就是说实例本身在调用这个函数/方法且self参数可以修改
    31. bf.msg()
    32.  
    33. #调用属性：实例.属性名
    34. bf.height
    35.  
    36. #调用函数/方法：实例.函数名/方法名()
    37. bf.cooking()

     1-2：不创建实例，直接以类对象进行访问  > 此种方法不推荐使用

    1. # 创建一个男朋友类：
    2. class BoyFriend:
    3.     #类属性
    4.     height=175
    5.     weight=130
    6.     money='会赚钱'
    7.  
    8.     def cooking(self):   #self是实例本身，传递实例
    9.         print(self.money+'会做饭的男盆友')
    10.  
    11.  
    12. #不创建实例，直接以类对象进行访问
    13. BoyFriend.cooking()

    此时运行报错TypeError: BoyFriend.cooking() missing 1 required positional argument: 'self'

     在1-1中打印self可以看到“self是实例本身，传递实例”，要解决TypeError: BoyFriend.cooking() missing 1 required positional argument: 'self'问题，需要在函数中传递实例

    1. # 创建一个男朋友类：
    2. class BoyFriend:
    3.     #类属性
    4.     height=175
    5.     weight=130
    6.     money='会赚钱'
    7.  
    8.     def cooking(self):   #self是实例本身，传递实例
    9.         print(self.money+'会做饭的男盆友')
    10.  
    11.  
    12. #1、创建实例
    13. bf=BoyFriend()
    14. #2、不创建实例，直接以类对象进行访问，函数名中传递实例
    15. BoyFriend.cooking(bf)   #显示的传递实例
    16.  
    17. #3、创建实例
    18. bf=BoyFriend()
    19. bf.cooking()   #隐藏的传递实例

    以上可以看出，传递实例分为隐藏式的传递和显示的传递，创建实例，使用实例调用属性（方法）属于隐藏的传递，不使用实例，直接以类对象进行访问，在函数名中传递实例属于显示传递

     （2）类方法

    @classmethod可以直接调用，同时实例也可以

    类方法不可以调用类里面的属性值，如果要参数请自己传递

    1. class BoyFriend:
    2.     #类属性
    3.     height=175
    4.     weight=130
    5.     money='会赚钱'
    6.  
    7.     @classmethod  # 类方法
    8.     def swimming(cls):
    9.         print('男盆友还要回游泳')
    10.         # 类方法不可以调用类里面的属性值，如果要参数请自己传递
    11.         # print(self.money+'男盆友还要回游泳')   #报错NameError: name 'self' is not defined
    12.  
    13. #类方法类名调用
    14. BoyFriend.swimming()
    15.  
    16. #实例调用
    17. b=BoyFriend()  
    18. b.swimming()

    3、静态方法

    @staticmethod  可以直接调用，同时实例也可以

    静态方法不可以调用类里面的属性值，如果要参数请自己传递

    1. class BoyFriend:
    2.     #类属性
    3.     height=175
    4.     weight=130
    5.     money='会赚钱'
    6.  
    7.     @staticmethod  #静态方法
    8.     def sing():
    9.         print( '男朋友还可以会唱歌来哄女朋友开心的呦')
    10.         # 静态方法不可以调用类里面的属性值，如果要参数请自己传递
    11.         #print(self.money+'男朋友还可以会唱歌来哄女朋友开心的呦')   #报错NameError: name 'self' is not defined
    12.  
    13. BoyFriend.sing()   #静态方法类名调用
    14.  
    15. bf=BoyFriend()
    16. bf.sing()    #实例调用

    4、 总结：

    （1）相同点：

    实例方法self、类方法cls、静态方法（普通方法，可传可不传），实例和类名都可以直接调用

    （2）不同点：

    1.静态方法和类方法不可以调用类里面的属性值，如果要参数请自己传递

    2.什么时候去定义为静态方法和类方法？

    当你的某个函数与其他的类函数、类属性没有任何关系的时候就可以定义静态方法和类方法

    3、初始化函数

    1、初始化函数

    什么是初始化函数？

    class 类:
        def __init__(self):
            print('实例化成功！')

    实例 = 类()

    初始化函数的意思是，当你创建一个实例的时候，这个函数就会被调用。上面的代码在执行实例 = 类()的语句时，就自动调用了__init__(self)函数。

    初始化函数的写法是固定的格式：中间是“init”，这个单词的中文意思是“初始化”，然后前后都要有【两个下划线】，然后__init__()的括号中，第一个参数一定要写上self，不然会报错。

    同时，这个初始化函数照样可以传递参数

    1. 初始化函数
    2. class TestingEngineer:
    3.     #类属性
    4.     # name='暖暖'
    5.     # age=28
    6.     # height=150
    7.     # weight=100
    8.  
    9.     # 初始化函数（将固定值的类属性写为初始化函数，可以随时修改值）
    10.     def __init__(self,name,age,height,weight):   #实例方法
    11.         self.name=name
    12.         self.age=age
    13.         self.height=height
    14.         self.weight=weight
    15.  
    16.     #类方法
    17.     def work_experience(self):
    18.         # print(self.name+'今年'+self.age+'岁,'+'体重'+self.weight+',身高'+self.height+',具有五年的测试工作经验')
    19.         print('{0}今年{1}岁,体重{2},身高{3},具有五年的测试工作经验'.format(self.name,self.age,self.weight,self.height))
    20.  
    21.     def tool(self):
    22.         print('{0}今年{1}岁,体重{2},身高{3},可以使用jmeter、python等工具'.format(self.name,self.age,self.weight,self.height))
    23.  
    24. # 初始化函数
    25. t1=TestingEngineer('暖暖','28','150','100')
    26. t1.work_experience()

    2、所有函数里面的方法，类函数里面都可以有

    1. class TestingEngineer:
    2.     #初始化函数
    3.     def __init__(self,name,age,height,weight):   #实例方法
    4.         self.name=name
    5.         self.age=age
    6.         self.height=height
    7.         self.weight=weight
    8.  
    9.     #类方法
    10.     # language位置参数,lines默认参数，位置参数要在默认参数前面
    11.     def coding(self,language,lines=1000):
    12.         print('会{0}语言,已经写了{1}行'.format(language,lines))
    13.  
    14.     #不定长参数
    15.     def cooking(self,*agr):
    16.         for item in agr:
    17.             # print('{0}会做{1}'.format(self.name,item))
    18.             print(self.name+'会做{0}'.format(item))
    19.  
    20.     # 返回值
    21.     def play(self,play_game):
    22.         return(self.name+'会玩{0}'.format(play_game))   #返回值
    23.  
    24. # 如果类里面有初始化函数，创建实例的时候，就必须要在实例里面传递对应的参数值
    25. 实例存储到变量里面去调用
    26. t=TestingEngineer('华华','28','159','100')
    27. t.coding('python')
    28. 直接创建实例调用方法
    29. TestingEngineer('华华','28','159','100').coding('python')
    30.  
    31. t.cooking('西红柿鸡蛋','清炒西蓝花')
    32.  
    33. #打印出输出的返回值数据
    34. print(t.play('王者荣耀'))

     3、初始化函数可以给出默认值或者直接将值写死

    1. class TestingEngineer:
    2.     # 初始化函数没有return返回值
    3.     # 实例方法，初始化函数可以有默认值参数，一般不传动态参数和不定长参数
    4.     def __init__(self,name,age=25):   
    5.         self.name=name
    6.         self.age=age
    7.         self.height=160    #身高写死
    8.  
    9.     #类方法
    10.     def work_experience(self):
    11.         print('{0}今年{1}岁,身高{2},具有五年的测试工作经验'.format(self.name,self.age,self.height))
    12.  
    13. t=TestingEngineer('华华','180')
    14. t.work_experience()

     4、类函数之间可以相互调用

    1. class TestingEngineer:
    2.     def __init__(self,name,age,height,weight):   #实例方法
    3.         self.name=name
    4.         self.age=age
    5.         self.height=height
    6.         self.weight=weight
    7.  
    8.     #类方法
    9.     #不定长参数
    10.     def cooking(self,*agr):
    11.         for item in agr:
    12.             # print('{0}会做{1}'.format(self.name,item))
    13.             print(self.name+'会做{0}'.format(item))
    14.  
    15.     # language位置参数,lines默认参数，位置参数要在默认参数前面
    16.     def coding(self,language,*args,lines=1000):
    17.         # 函数之间可以相互调用
    18.         # self.cooking() #可以不传参
    19.         # self.cooking('蛤蜊汤')   #此时参数是写死的
    20.         self.cooking(*args)  #不想写死可以在该函数中传不定长参数
    21.         print('会{0}语言,已经写了{1}行'.format(language,lines))
    22.  
    23. t=TestingEngineer('joy','23','180','120')
    24. t.coding('python','巴巴鱼','草鱼')

  • 相关阅读:
    计算机毕业设计ssm+vue 菜谱制作小程序
    Linux 常用工具（yum、vim、gcc、gdb、git）
    【数据挖掘】2020奇安信秋招算法方向试卷3 笔试题解析
    Go的简单入门：写一个Web应用
    高防CDN：游戏应用抵御DDoS攻击的坚固堡垒
    第十四届蓝桥杯第一期模拟赛题解[官方模拟赛]
    【2023研电赛】商业计划书命题：基于三维视觉感知的可重构智能表面通信设计
    【笑小枫的SpringBoot系列】【十四】SpringBoot发送邮件
    代码源每日一题div1 平方计数
    Mapbox-gl 关闭所有Popup，以及关闭按钮出现黑色边框bug
  • 原文地址：https://blog.csdn.net/weixin_47481102/article/details/126352439