码迷,mamicode.com
首页 > 其他好文 > 详细

面向对象

时间:2019-09-12 15:11:15      阅读:100      评论:0      收藏:0      [点我收藏+]

标签:初始化   att   字符   oldboy   面向   strong   ==   student   绑定   

一、面向对象和面向过程的优缺点

 面向过程面向对象
优点 复杂问题流程化,进而简单化 可扩展性高
缺点 可扩展性差 编写复杂

二、类与对象


2.1 定义类

一系列共同的属性和方法。eg:人类

class 关键字 类名:
    pass

假设我们要定义学生这样一个类,将下面一段代码中一系列共同的属性和方法提取出来写成代码。

‘‘‘
学生1:
    学校:老男孩
    姓名:李铁蛋
    性别:男
    年龄:18
    方法:
        选课
        学习
学生1:
    学校:老男孩
    姓名:jiayi
    性别:女
    年龄:20
    方法:
        选课
        学习
‘‘‘
---------------------------------------------------------------
class Student:
    school = ‘oldboy‘  #属性
    def choose(self):
        print("这是一个选课的方法")
    def sutdy(self):
        print("这是一个学习的方法")

2.2 类

2.2.1获取类的属性和方法

类.__dict__
#定义一个学生类
class Student:
    school = ‘oldboy‘  #属性
    def choose(self):
        print("这是一个选课的方法")
    def sutdy(self):
        print("这是一个学习的方法")
print(Student.__dict__)
-----------------------------------------------------------------------------------
{‘__module__‘: ‘__main__‘, ‘school‘: ‘oldboy‘, ‘__init__‘: <function Student.__init__ at 0x000001BBBC6E1620>, ‘choose‘: <function Student.choose at 0x000001BBC3912C80>, ‘study‘: <function Student.study at 0x000001BBC3912D08>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Student‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Student‘ objects>, ‘__doc__‘: None}

2.2.2类来调用属性和方法
-通过dict来调用(复杂,不用)

print(Student.__dict__)    #获取到的是一个字典
print(Student.__dict__[‘school‘])  #获取到的是学校这个属性
print(Student.__dict__[‘choose‘])   # 获取到的是一个函数地址,因为没有传参
Student.__dict__[‘choose‘](123)   #调用了choose函数
---------------------------------------------------------------
{‘__module__‘: ‘__main__‘, ‘school‘: ‘oldboy‘, ‘choose‘: <function Student.choose at 0x0000017A47001620>, ‘sutdy‘: <function Student.sutdy at 0x0000017A4E213C80>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Student‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Student‘ objects>, ‘__doc__‘: None}
oldboy
<function Student.choose at 0x0000017A47001620>
这是一个选课的方法   

? -类来调用属性和方法 (类名.属性/函数)

print(Student.school)
Student.choose(123)  #函数一定要传参
-----------------------------------------------------------
oldboy
这是一个选课的方法

2.3产生对象

类加括号,生成对象

对象 = 类名()

stu1=Student()  #学生1就是一个对象

2.4对象

2.4.1对象获取属性和方法

对象.__dict__
stu1=Student()  #产生对象
print(stu1.__dict__)    #此处为空字典是因为他没有是有的属性,还没有定义属性,所以是空字典
-----------------------------------------------------
{}

2.4.2对象调用属性和方法

# 对象.属性/函数 
stu1=Student()
print(stu1.school)
stu2=Student()
print(stu2.school)
-------------------------------------------------------------
oldboy
oldboy

2.5 对象自己的属性和方法

stu1=Student()
stu1.name=‘jiayi‘   #对象自己定义的属性,也就是对象赋属性
stu1.school=‘xxxx‘    #对象自己定义的属性,也就是对象赋属性
print(stu1.name)
print(stu1.school)
print(stu1.__dict__)   #此时查看就不会为空字典
---------------------------------------------------
jiayi
xxxx
{‘name‘: ‘jiayi‘, ‘school‘: ‘xxxx‘}

三、对象的绑定方法


3.1 属性查找顺序

先从对象自身找------>类中找----->报错

3.2 对象赋属性

  • 方式一:
stu1 = Student()
stu1.name = ‘jiayi‘
  • 方式二(通过__init__):
    -在类中定义该方法,方法上写一些参数
    -在对象实例化产生对象时,在括号中传的值,会被传到__init__中
#定义类
class Student:
    school = ‘oldboy‘  #变量表示属性
    # __init__ 看好名字,不是__int__
    def __init__(self,name):
        self.name=name
    def choose(self):
        print("这是一个选课的方法")
    def sutdy(self):
        print("这是一个学习的方法")
        
#产生对象
stu1=Student(‘jiayi‘)
#内部帮我们做了一些事:当我在实例化产生对象的时候,会自动调用__init__方法,完成对象的初始化
print(stu1.name)
stu2=Student(‘ypp‘)
print(stu2.name)
-----------------------------------------------------------
jiayi
ypp

3.3 绑定方法

-定义在类内部的方法:

-类来调用:就是一个普通函数,有几个参数就需要传几个参数

-对象来调用:它叫对象的绑定方法,第一个参数不需要传,自动传递

 #定义类
class Student:
    school = ‘oldboy‘  #变量表示属性
    # __init__ 看好名字,不是__int__
    def __init__(self,name):
        self.name=name
    def choose(self):
        print("这是一个选课的方法")
    def sutdy(self):
        print("这是一个学习的方法")

        
stu1=Student(‘李铁蛋‘)
stu1.study()
-------------------------------
李铁蛋

3.4 一切皆对象

python中,字典,列表字符串....都是对象

类即类型 eg:字典类

#类实例化产生对象
ll=list([1,2,3])
#对象调用对象的绑定方法,修改对象自己
ll.append(5)
print(ll)
print(type(ll))
--------------------------------------------------------------
[1, 2, 3, 5]
<class ‘list‘>

四、锐雯大战盖伦大战小游戏


import random
#诺克萨斯类
class Noxus:
def __init__(self,name,
aggressivity=54,
life_value=414,
money=1600,
armor=3,
grade=1):
self.name=name
self.aggressivity=aggressivity+grade*2.75
self.life_value=life_value+grade*86
self.money=money
self.armor=armor
def attack(self,enemy):
damage_value=self.aggressivity-enemy.armor
enemy.life_value-=damage_value
print(f‘‘‘
{r1.name}普通攻击了{g1.name}
造成了{damage_value}伤害
{g1.name}还剩{enemy.life_value}血量
‘‘‘)
#德玛西亚类
class Demacia:
def __init__(self,name,
aggressivity=58,
life_value=455,
money=500,
armor=10,
grade=1):
self.name=name
self.aggressivity=aggressivity+grade*3.5
self.life_value=life_value+grade*96
self.money=money
self.armor=armor
def attack(self,enemy):
damage_value=self.aggressivity-enemy.armor
enemy.life_value-=damage_value
print(f‘‘‘
{g1.name}普通攻击了{r1.name}
造成了{damage_value}伤害
{r1.name}还剩{enemy.life_value}血量
‘‘‘)

class BlackCleaver:
def __init__(self,price=475,aggrev=9,life_value=100):
self.price=price
self.aggrev=aggrev
self.life_value=life_value
def update(self,obj):
obj.money-=self.price #减钱
obj.aggressivity+=self.aggrev #加攻击
obj.life_value+=self.life_value #加生命值
def fire(self,obj): #这是该装备的主动技能,喷火,烧死对方
obj.life_value-=100 #假设火烧的攻击力是100
print(‘锐雯和盖伦会随机攻击,会随机施放装备主动,满级为18级‘)
r_grade_choice=int(input(‘请输入锐雯的等级‘))
r_money_choice=int(input(‘请输入锐雯的金钱‘))
g_grade_choice=int(input(‘请输入盖伦的等级‘))
g_money_choice=int(input(‘请输入盖伦的金钱‘))
r1=Noxus(‘锐雯‘,grade=r_grade_choice,money=r_money_choice)
g1=Demacia(‘盖伦‘,grade=g_grade_choice,money=g_money_choice)
b1=BlackCleaver()
def fight():
while True:
i=random.randint(1,5)
if r1.life_value<0 or g1.life_value<0:
break
if i %2==0:
r1.attack(g1)
if i==2:
r1.b1.fire(g1)
print(f‘‘‘
{r1.name}施放装备主动
造成了100伤害
{g1.name}还剩{g1.life_value}血量
‘‘‘)
else:
g1.attack(r1)
if i==1:
g1.b1.fire(r1)
print(f‘‘‘
{g1.name}施放装备主动
造成了100伤害
{r1.name}还剩{r1.life_value}血量
‘‘‘)
if r1.life_value<0:
print(‘Demacia victory‘)
elif g1.life_value<0:
print(‘Noxus victory‘)

print(f‘锐雯的攻击力,生命值,金钱{r1.aggressivity,r1.life_value,r1.money}‘)
print(f‘盖伦的攻击力,生命值,金钱{g1.aggressivity,g1.life_value,g1.money}‘)
choice=input(‘是否购买多兰之刃(¥475),攻击力9点/把,生命值100/把,主动技能喷火造成真实伤害100点,y/n‘)
if choice==‘y‘:
while True:
if r1.money > b1.price:
r1.b1=b1
b1.update(r1)
else:
break
while True:
if g1.money > b1.price:
g1.b1=b1
b1.update(g1)
else:
break
print(f‘购买后锐雯的攻击力,生命值,金钱{r1.aggressivity,r1.life_value,r1.money}‘)
print(f‘购买后盖伦的攻击力,生命值,金钱{g1.aggressivity,g1.life_value,g1.money}‘)
fight()
elif choice==‘n‘:
while True:
i=random.randint(1,5)
if r1.life_value<=0 or g1.life_value<=0:
break
if i %2==0:
r1.attack(g1)
else:
g1.attack(r1)
if r1.life_value<=0:
print(‘Demacia victory‘)
elif g1.life_value<=0:
print(‘Noxus victory‘)

面向对象

标签:初始化   att   字符   oldboy   面向   strong   ==   student   绑定   

原文地址:https://www.cnblogs.com/lulingjie/p/11511855.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!