面向对象基础

编程的三种思想：

1.  面向过程编程：根据业务逻辑从上到下垒代码
2.  函数式：将某些功能封装到函数中，需要使用相应的功能变调用函数
3.  面向对象：把函数根据功能或者其他进行分类或者封装

面向对象的思想

•  对象是有具体的属性和方法的实例
•  类是具有相同的属性和方法的一类事物

利用面向对象编程

　1. 定义一个类

 

class 类名:#类名首字母大写
    属性 = "功能"#---类的属性：静态属性，不是必须要定义的，当多有的对象都用的时候去定义
    def __init__(self,参数):#--self是不需要传的
        # __init__这里是定义了一个该类对象共有的属性
        # 这里的属性是对象属性，
        self.key = 参数   # 这里self.key就相当于字典的key,参数就相当于value

    def 方法(self):       # 类里面的方法本质上就是函数--函数必须要传一个参数self
        pass              # 类的方法就是动态属性

print(类名.属性)
# 实例化一个对象，实例化的时候就是自动的除法__init__方法
# --实例化，对象就是实例
对象 = 类名("参数")  #---参数是传到__init__函数里

对象.函数名()
# 调用成功，传入的self就是对象，
# 当用一个对象去调用它的方法的时候，会自动传入一个参数，这个参数就是对象本身

# 类里边凡是用def去定义的都是动态属性或者叫方法
# 静态属性，所有的对象共有的属性，可以直接调用
# 对象属性,是属于某一个对象的，只能在实例化之后对象调用

 

　2.　小结：

     　类名--调用类属性，查看类方法
     　　 对象名--调用对象属性，调用类属性（尽量不要）
        　 对象名调用方法   --方法也叫动态属性

　3.　　示例1

class Person:  # 定义了一个人类
    role = "person"  # 人类的属性就是人，静态属性，可以不定义，可以直接调用

    def __init__(self, name, sex, aggr=200):  # 定义一些关于人类对象共有属性的函数，里面都是对象属性
        self.name = name  # 名字
        self.sex = sex  # 性别
        self.aggression = aggr  # 攻击力
        self.blood = 20000  # 血量

    def attack(self, person):  # 定义了一个攻击的函数，这是定义了方法，对象实例化后才能去调用它，动态属性
        person.blood = person.blood - self.aggression  # self攻击person，person被攻击，所以他的血量要减少，
        print("%s攻击%s" % (self.name, person.name))  # 打印一个self攻击person


alex = Person("alex", "male")  # 对象的实例化
egon = Person("egon", "male", 300)  # 对象的实例化
alex.attack(egon)  # 调用攻击函数alex攻击egon
print(alex.blood, egon.blood)
egon.attack(alex)  # 调用攻击函数egon攻击alex
print(egon.blood, alex.blood)

 

　4.输出如下信息
　　　　小明，10岁，男，上山去砍柴
　　　　小明，10岁，男，开车去东北
　　　　小明，10岁，男，最爱大保健
　　　　老李，90岁，男，上山去砍柴
　　　　老李，90岁，男，开车去东北
　　　　老李，90岁，男，最爱大保健
　　　　老张…

class Person:
    def __init__(self,name,age,sex="男"):
        self.name = name
        self.age = age
        self.sex = sex
    def kanchai(self):
        print("%s,%s岁,%s,上山去砍柴"%(self.name,self.age,self.sex))
    def kaiche(self):
        print("%s,%s岁,%s,开车去东北"%(self.name,self.age,self.sex))
    def baojian(self):
        print("%s,%s岁,%s,最爱大保健"%(self.name,self.age,self.sex))

xiaoming = Person("小明",10)
xiaoming.kanchai()
xiaoming.kaiche()
xiaoming.baojian()
laozhang = Person("老张",90)
laozhang.kanchai()
laozhang.baojian()
laozhang.kaiche()

 

　　5.　　计算圆的面积和周长

 

from math import pi    # 得到精确地π值
class Circle:
    rloe = "circle"
    def __init__(self,r):
        self.r = r
    def length(self):
        return 2*pi*self.r
    def area(self):
        return pi*self.r*self.r


val = Circle(10)
val_l = val.length()
print(val_l)
val_s = val.area()
print(val_s)

 

　　6.　　人狗大战第一版

 

class Person:
    role = "preson"
    def __init__(self,name,sex,aggression=200):
        self.name = name
        self.sex = sex
        self.aggr = aggression
        self.blood = 20000
    def attack(self,person):
        print("%s attack %s"%(self.name,person.name))
        person.blood = person.blood - self.aggr


class Dog:
    role = "dog"
    def __init__(self,name,sex,aggression=50):
        self.name = name
        self.sex = sex
        self.aggr = aggression
        self.blood = 20000
    def bite(self,person):
        print("%s bite %s"%(self.name,person.name))
        person.blood = person.blood - self.aggr


alex = Person("alex","male",250)
egon = Dog("egon","公",500)

while alex.blood:
    alex.attack(egon)
    egon.bite(alex)
    print(alex.blood,"%s阵亡"%(alex.name))
    print(egon.blood)

 

　　7.　　人狗大战进阶版

 

class Person:
    role = "preson"
    def __init__(self,name,sex,aggression=200):
        self.name = name
        self.sex = sex
        self.aggr = aggression
        self.blood = 2000
    def attack(self,dog,n):
        dog.blood = dog.blood - self.aggr
        print("%s 第%d次攻击 %s,%s的血还有%s"%(self.name,n,dog.name,dog.name,dog.blood))
        if dog.blood<=0:
            print("很遗憾，%s is game over"%dog.name)

class Dog:
    role = "dog"
    def __init__(self,name,breed,aggression=50):
        self.name = name
        self.breed = breed
        self.aggr = aggression
        self.blood = 2000
    def bite(self,person,m):
        person.blood = person.blood - self.aggr
        print("%s 第%d次咬 %s,%s的血还有%s"%(self.name,m,person.name,person.name,person.blood))
        if person.blood<=0:
            print("很遗憾，%s is game over"%person.name)


def player_choice(play_person,play_dog):
    n = 0
    m = 0
    while True:
        choice = input("请选择人或狗攻击：")
        if choice.strip() == "人":
            n += 1
            play_person.attack(play_dog,n)
        elif choice.strip() == "狗":
            m += 1
            play_dog.bite(play_person,m)
        elif choice.strip().lower() == "q":
            print("即将退出游戏，请稍等...")
            break
        else:
            print("输入的角色名错误")


def player():
    play_person_name = input("play_person_name:")
    play_person_sex = input("play_person_sex:")
    play_person_aggression = int(input("play_person_aggression:"))

    play_person = Person(play_person_name,play_person_sex,play_person_aggression)

    play_dog_name = input("play_dog_name:")
    play_dog_breed = input("play_dog_sex:")
    play_dog_aggression = int(input("play_dog_aggression:"))

    play_dog = Dog(play_dog_name,play_dog_breed,play_dog_aggression)

    player_choice(play_person,play_dog)


player()

 

 组合