Python面向对象

 

===面向对象===

1.面向对象简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 方法：类中定义的函数。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 局部变量：定义在方法中的变量，只作用于当前实例的类。
• 实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类
• 实例化：创建一个类的实例，类的具体对象。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

1.1.Python类语法

class  类名()：#括号可有可无
　　类属性
　　类函数/类方法

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

#类
class BoyFriend():
    #类属性
    height=170
    weight=105
    money="1000W"

    #类函数
    def cooking(self):#（self指实例本身）#会做饭
        print("女朋友会做饭")
    def earn(self):#会赚钱
        print("女朋友会赚钱")

#实例化话对象
by = BoyFriend()
#调用类函数
by.cooking()

#self
self代表类的实例，而非类
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()#隐士实例传递，最终传递self
t.prt()

以上实例执行结果为：

<__main__.Test instance at 0x100771878>
__main__.Test

1.2.实例方法

#类方法智能通过实例调用
t = Test()#实例
t.cooking()

1.3.类方法@classmethod

#类
class BoyFriend():
    #类函数
    height=170
    weight=105
    money="1000W"

    #类函数
    def cooking(self):#会做饭
        print("女朋友会做饭")
    @classmethod#类方法不能调用类里面的属性值
    def earn(self):
        print("女朋友会赚钱")

BoyFriend.earn()#调用成功
BoyFriend.cooking()#报错：TypeError: cooking() missing 1 required positional argument: 'self'

1.4.静态方法@staticmethod

#类
class BoyFriend():
    #类函数
    height=170
    weight=105
    money="1000W"

    #类函数
    def cooking(self):#会做饭
        print("女朋友会做饭")
    #类方法
    @classmethod
    def earn(self):#会赚钱
        print("女朋友会赚钱")
    #静态方法
    @staticmethod#静态方法不能调用类里面的属性值
    def music():
        print("女朋友会唱歌")

BoyFriend.music()#女朋友会唱歌

1.5.类初始化函数

初始化函数再实例化对象的时候调用

class Teacher:
    def __init__(self):#这是初始化函数
        print("这是初始化函数")
    def speak(self):
        print("这是类函数")

t = Teacher()
#打印结果：这是初始化函数

1.6.初始化函数传参

class Teacher:
    def __init__(self,name,age):#初始化函数传参
        self.n = name#将初始化参数赋值给类属性
        self.a = age
    def speak(self):
        print("老师的名字是：{0}，老师的年龄是：{1}".format(self.n,self.a))

t = Teacher("张三","18")#传参必须与类初始化参数一致
t.speak()
#打印结果：老师的名字是：张三，老师的年龄是：18

class Teacher:
    def __init__(self,name="张三",age="18"):#初始化函数传参
        self.n = name#将初始化参数赋值给类属性
        self.a = age
    def speak(self):
        print("老师的名字是：{0}，老师的年龄是：{1}".format(self.n,self.a))

Teacher().speak()#老师的名字是：张三，老师的年龄是：18

2.1.继承

#子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。
#父类有的集成后，子类可以直接拿来用
#父类有，子类也有重名的函数，那么子类的实例优先调用子类的函数
#父类只能调用自己函数和属性

#第一代机器人
class RoboOne():
    def __init__(self,year,name):
        self.year=year#生产日期
        self.name=name#名字

    def xingzou(self):
        print("可以在平地上行走!")

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

#第二代机器人继承第一代机器人的类
class RoboTwo(RoboOne):#集成父类

    def xingzou(self):#子类里面的韩树明与父类函数名重复的时候，就是重写
        print("可以在平地上平稳的行走!")

    def bizhang(self):
        print("可以避开障碍物!")


r = RoboTwo("2022","哇卡哇卡")
r.xingzou()#可以在平地上平稳的行走!
r.bizhang()#可以避开障碍物!
r.biaoshi()#2022年生产的机器人哇卡哇卡，是中国研发的！

2.2.子类中调用父类中函数

#第一代机器人
class RoboOne():
    def __init__(self,year,name):
        self.year=year#生产日期
        self.name=name#名字

    def xingzou(self):
        print("可以在平地上行走!")

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

#第二代机器人继承第一代机器人的类
class RoboTwo(RoboOne):

    def xingzou(self):#子类里面的韩树明与父类函数名重复的时候，就是重写

        print("可以在平地上平稳的行走!")

    def bizhang(self):
        #子类中调用父类的方法（调用子类未重写的方法）
        self.biaoshi()
        print("可以避开障碍物!")


r = RoboTwo("2022","卢卡卢卡")
r.bizhang()
# 打印结果：

2022年生产的机器人卢卡卢卡，是中国研发的！
可以避开障碍物!

2.3.多继承

继承多个父类

#继承多个父类时父类中函数重名，根据排序先后进行调用（就近原则）

#初始化函数根据就近原则进行传参

class Father():#父类
    def __init__(self,name,car):
        self.name=name
        self.car=car
        
    def zuojia(self):
        print("{0}的座驾是{1}".format(self.name,self.car))
    def computer(self):
        print("有一台Mac！")

class WangSir():#老王，为什么是老王，这是个迷！！！！
    def __init__(self,name,car):
        self.name=name
        self.car=car

    def zuojia(self):
        print("{0}的座驾是{1}".format(self.name,self.car))
    def Money(self):
        print("有500W")

class Son(WangSir,Father):#继承两个父类
    def age(self):
        print("我满18岁了！")


s = Son("李刚","法拉利")
s.zuojia()#
s.age()
s.computer()
s.Money()
打印：

李刚的座驾是法拉利
我满18岁了！
有一台Mac！
有500W

2.4.练习一

# 1）创建一个类名为User的类
# 2）其中包含属性first_name和last_name
# 3）还有用户简介通常会存储的其他几个属性，均是自定义，请放在初始化函数里面
# 4）在类User中定义一个名为describe_user()的方法，它打印用户信息摘要
# 5）再定义一个名为greet_user()的方法，它向用户发出个性化的问候
# 6）创建多个表示不同用户的实例，并将每个实例都调用上述两个方法
class User():
    def __init__(self,first_name,last_name,*args):
        self.first_name=first_name
        self.last_name=last_name
        self.args=args

    def describe_user(self):
        print("问候新冠肺炎！！！！")

    def greet_user(self):
        print("{0}{1}的简介：{2}".format(self.first_name,self.last_name,self.args))

u = User("张","三","喜欢打雪仗","喜欢狗刨式","喜欢掉冰窟窿")
u.describe_user()
u.greet_user()

2.5.练习二

#人和机器人猜拳
#1）函数1：选择角色1曹操，2张飞，3刘备
#2）函数2：角色猜拳1剪刀，2石头，3布，玩家输入一个1-3的数字
#3）函数3：电脑出拳，随机产生1个1-3的数字，提示电脑出拳结果
#4）函数4：角色和机器出拳对战，对战结束后，最后出示本局对战结果...赢...输,然后提示用户是否继续？按y继续，按n结束
#5）最后结束的时候输出结果，角色赢几局，电脑输几局，平局几次，游戏结束

import random#随机数

# 猜拳
class Guess():
    #选择角色
    def role(self):
        num = input("请选择角色(1曹操，2张飞，3刘备)请输入：")
        print("选择角色：{0}".format(self.role_obtain(num)))
        print("************ 游戏开始 ************")
        print()
        self.DuelWar(self.role_obtain(num))#调用对战
        # print("角色：{0}，猜拳游戏马上开始!".format())
    #角色出拳
    def person_guess(self):
        guess = input("请出拳（1剪刀，2石头，3布）请输入：")
        return int(guess)
    #电脑出拳
    def computer_guess(self):
        num = random.randint(1,3)#随机1-3
        return int(num)

    #角色转换(数字转角色)
    def role_obtain(self,num):
        try:
            dict = {"1":"曹操","2":"张飞","3":"刘备"}
            return dict[str(num)]
        except Exception as e:
            print("角色转换(数字转角色)异常：{0}".format(e))

    #出拳转换
    def boxing_obtain(self,num):
        try:
            dicts = {"1":"剪刀", "2":"石头", "3":"布"}
            return dicts[str(num)]
        except Exception as e:
            print("出拳转换异常：{0}".format(e))

    #对战
    def DuelWar(self,role_name):
        contin = "y"
        num=0#局数
        person_num = 0#角色赢数
        computer_num=0#电脑输数
        even = 0#平局数
        while contin=="y":
            num+=1#
            print("************ 第 {0} 局 ************".format(num))
            person_x = self.person_guess()#角色出拳
            computer_x = self.computer_guess()#电脑出拳
            #判断角色赢
            if (person_x==1 and computer_x==3) or (person_x==2 and computer_x==1) or (person_x==3 and computer_x==2):

                print("第{0}局 >>>>>>>>>>>>{1}>{2} ：赢".format(num,self.boxing_obtain(person_x),self.boxing_obtain(computer_x)))
                print()
                person_num+=1
            #判断平局
            elif person_x== computer_x:
                print("第{0}局 >>>>>>>>>>>>{1}>{2} ：平局".format(num,self.boxing_obtain(person_x),self.boxing_obtain(computer_x)))
                print()
                even+=1
            #判断电脑输
            else:
                print("第{0}局 >>>>>>>>>>>>{1}>{2} ：输".format(num,self.boxing_obtain(person_x),self.boxing_obtain(computer_x)))
                print()
                computer_num += 1
            yn = input("游戏是否继续：（y继续，n结束）")
            print()
            if yn=="y":
                continue
            else:
                print("*"*30)
                print("猜拳结束：\n{0}赢{1}局\n电脑输{2}局\n平局{3}次".format(role_name,person_num,computer_num,even))
                print("*" * 30)
                break
if __name__ == '__main__':
    g = Guess()
    g.role()
执行结果：

2.6.练习三

#按照一下要求定义一个游乐园门票类，并创建实例调用函数，完成儿童和大人的总票价统计（人数不定，有你输入的人数个数来决定）
#1）平日票价100元
#2）周末票价为平日票价120%
#3）儿童半价

class AmusementTicket():#游乐园门票类
    #初始化 定义三个参数，星期/大人数/儿童数
    def __init__(self,sunday,adult,youngster):
        self.sunday=sunday#星期
        self.adult=int(adult)#成年人数   转为int类型
        self.youngster=int(youngster)#儿童数   转为int类型

    #获取票价函数
    def ticket_price(self):
        price = 0
        if self.sunday=="周六" or self.sunday=="周日":
            price+=self.adult * (100 * 1.2)
            price+=self.youngster * (100 * 1.2 * 0.5)
        else:
            price += self.adult * (100 * 1)
            price += self.youngster * (100 * 1 * 0.5)

        return price#返回总票价

sunday=input("请今天周几(格式为（周一/周日...)：")
adult=input("请输入成人数：")
youngster=input("请输入儿童数：")
price = AmusementTicket(sunday,adult,youngster).ticket_price()
print(price)

运行结果：

3.超继承

#超继承
class Fu():
    def __init__(self,a,b):
        self.a=a
        self.b=b
    def jia(self):
        print("这是父类的加法：a + b = {0}".format(self.a+self.b))

class Zi(Fu):
    def jian(self):#拓展
        print("这是子类的减法...")
    def jia(self):#重写
        super(Zi,self).jia()#超继承
        print("这是子类的加法：a + b = {0}".format(self.a+self.b))

if __name__ == '__main__':
    Zi(5,6).jia()

打印结果：

这是父类的加法：a + b = 11
这是子类的加法：a + b = 11