python基础之初识类与对象

python 类与对象

• 关键字 class

• 类的语法

  class 类名: #类名的规范：首字母大写，由数字字母下划线组成，遵循驼峰命名
      类属性 #写在类里面的变量
      类方法 #写在类里面的函数
  

• 类、对象

  概括一个抽象事物具备的共同的属性和方法，相当于一个抽象事物的模版

  #一个男友类，不是具体的某个人，是抽象的一类人，他们共同的属性和方法
  class BoyFriend:
  #类属性
  height=175 #身高175
  weight=130 #体重130
  money="500万" #存款500万
  
  #类中的函数/方法
  def cooking(self):
      print("男友要会做饭!") #会做饭
  
  def earn(self):
      print("男友月薪3w!") # 会挣钱
  
  def print_self(self): # 测试，打印self用
      print(self)
  

  实例即对象，具体的一个例子 格式:类名()

  bf=BoyFriend() #创建对象
  print(bf) #打印实例 ，输出是：<__main__.BoyFriend object at 0x100f8b950>
  #实例/对象具有类里面所有属性和方法的使用权限
  bf.print_self() #打印self，输出是：<__main__.BoyFriend object at 0x100f8b950>
  print(bf.height)
  print(bf.money)
  bf.cooking()
  

  self即实例本身，表示只有实例本身可以调用方法，类里面的方法都必须带self这个参数

  参数中第一个参数是self，说明这个方法是实例方法,意味只有实例可以调用

• 类中的方法

  类中的方法总共有3种：

  • 实例方法

  • 类方法 @classmothod

  @classmethod
  def print_clsmothod(cls): #cls，类本身
      print("这是类方法，有啥不一样")
      
  #调用时,可以不用创建实例，格式:类名.类方法名()
  BoyFriend.print_clsmothod()
  # 创建实例也可以调用
  

  • 静态方法@staticmethod

  @staticmethod
  def print_static():
      print("传不传参数都可以，跟普通函数一样")
  
  #调用
  BoyFriend.print_static()
  
  

  总结：

  实例方法：必须创建实例后才能调用

  类方法、静态方法可以直接通过类名.方法名()被调用，也可以创建实例调用

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

  什么时候定义为静态方法、类方法？当你的某个函数与其他的类函数、类属性没有太大的关系，但是又必须写在这个类里，如计数。

• 初始化函数

  class BoyFriend:
      #类函数
      def __init__(self,name,age):
          self.name=name #把传入的name，赋值给实例本身
          self.age=age
  
      def cooking(self):
          print(str(self.name)+"会做饭!")
  
      def earn(self):
          print(str(self.name)+"月薪3w!")
  #创建实例，必须按照初始化的参数个数传入值，self不用传
  bf1 = BoyFriend("王大", 14)
  bf2 = BoyFriend("王二", 19)
  bf3 = BoyFriend("王三", 29)
  #调用
  bf1.earn()
  bf2.cooking()
  bf3.earn()
  

  控制台输出：

  王大月薪3w!
  王二会做饭!
  王三月薪3w!
  

  • 初始化函数不能有return

  • 什么时候用初始化函数？

    1.想用就用

    2.提高复用性，如果某个属性值是多个函数共用的，可以使用初始化函数

python继承

面向对象语言的一个特点就是继承。
继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

继承

# 继承
class RobotOne: #第一代机器人
    def __init__(self,year,name):
        self.year=year
        self.name=name

    def walking(self):
        print("只能在平地行走，遇到障碍物会摔倒 ")

    def robot_info(self):
        print("{0}年产生的机器人{1}，是中国自主研发的".format(self.year,self.name))

class RobotTwo(RobotOne): #第二代机器人，继承于第一代机器人
    def walking(self): #重写
        print("平地上平稳行走")

    def avoid(self):  #拓展
        self.robot_info()  #在子类的函数中调用父类的函数
        print("可以避开障碍物")

r1=RobotOne(2018,"哈利路亚") 
r1.robot_info() #2018年产生的机器人哈利路亚，是中国自主研发的
r1.walking() #只能在平地行走，遇到障碍物会摔倒 
r2=RobotTwo(2019,"CHINA") 
r2.robot_info() #2019年产生的机器人CHINA，是中国自主研发的
r2.walking() #平地上平稳行走
r2.avoid() #2019年产生的机器人CHINA，是中国自主研发的
           #可以避开障碍物

说明：

• 通过继承创建的新类称为“子类”或“派生类”

• 被继承的类称为“基类”、“父类”或“超类”

• 继承的类是否要用到初始化函数，看是否从父类继承初始化函数，如果父类有初始化函数，只能在父类的基础上拓展初始化函数，使用超继承super(子类名).__init__(self,父类参数,拓展的参数……)

• 父类有的，继承后我都有，可以直接拿来用

• 父类有，我也有的重名的函数，子类的实例优先调用自己的

• 子类里的函数名和父类函数名重复的时候，叫做重写

• 父类没有，子类有的函数，叫拓展，父类无法调用

• 如何在子类的函数中，调用父类的方法self.父类方法名()

多继承

实际应用较少，但是面试经常会问，作为了解

class RobotOne:  # 第一代机器人
    def __init__(self, year, name):
        self.year = year
        self.name = name

    def walking(self):
        print("只能在平地行走，遇到障碍物会摔倒 ")

    def robot_info(self):
        print("{0}年产生的机器人{1}，是中国自主研发的".format(self.year, self.name))

class RobotTwo():  # 第二代机器人，不继承于第一代
    def __init__(self, name):
        self.name = name

    def walking(self):
        print("平地上平稳行走")


class RobotThree(RobotOne, RobotTwo):  # 第三代机器人，继承于第一代机器人和第二代机器人
    def jumping(self):
        print(self.name + "可以单脚跳跃了")

class RobotFour(RobotTwo,RobotOne):  # 第四代机器人，继承于第一代机器人和第二代机器人
    def running(self):
        print(self.name + "可以跑了")

r3 = RobotThree(2020, "Super") #RobotOne是第一个爸爸，所以参数按RobotOne
r3.jumping() 
r3.walking() #两个父类有同名函数，就近原则，输出：只能在平地行走，遇到障碍物会摔倒 
r4=RobotFour("Happy") #RobotTwo是第一个爸爸，所以参数按RobotTwo
r4.running() 
r4.walking() #平地上平稳行走

说明

• 多继承的子类具有两个父类的属性和方法

• 两个父类有同名函数，就近原则，实例化时哪个父类离得近就调用哪个父类的参数：

  • class RobotThree(RobotOne, RobotTwo): RobotOne离得近
  • class RobotFour(RobotTwo,RobotOne): RobotTwo离得近

• 若想调用robot_info方法，但是没有传入year就会报错。

  • 目前没有别的办法，写的时候注意参数的个数
  • 也可以对方法进行重写

超继承

class MathMethod:
    def __init__(self,a,b):
        self.a=a
        self.b=b

    def add(self):
        return (self.a+self.b)

    def reduce(self):
        return(self.a-self.b)

class MathMethod_1(MathMethod):
    def division(self): #拓展
        return(self.a/self.b)

    def add(self): #重写
        return ("这是重写加法")

    def reduce(self):
        super(MathMethod_1,self).reduce() #超继承，父类的方法
        return (self.a-self.b-10) #在父类的方法上加上代码

MathMethod_1(5,6).reduce()

• super() 函数

super() 函数是用于调用父类(超类)的一个方法

super(MathMethod_1,self).add()，其中super(子类名,self)通过子类名找到父类，再调用父类的add方法

作业

按照要求定义一个游乐园门票类，并创建实例调用函数：

1.完成对儿童和大人的总票价统计

2.平日价100元，周末价为平日价的120%

3.儿童半价

class TicketTatal:

    def __init__(self,children,adult,dayType):
        #孩子人数
        self.children=children
        #成年人数
        self.adult=adult
        #天类型 workday weekend
        self.dayType=dayType

    def business(self):
        if self.dayType=="workday":
            tatal=self.adult*100+self.children*100*0.5
        else:
            tatal=self.adult*120+self.children*120*0.5
        return tatal

d1=TicketTatal(10,50,"weekend")
print(d1.business())

d2=TicketTatal(10,50,"workday")
print(d2.business())