面向对象编程猩球崛起

面向对象举例：
**class Student():
name =""
def study(self):
print(self.name,"要学习去… ")
def eat(self):
print(self.name,“要吃饭去…”)

menkai=Student()
menkai.name=“门凯”
menkai.study()
menkai.eat()

cao=Student()
cao.name=“曹义国”
cao.study()
cao.eat()

运行结果：
门凯 要学习去…
门凯 要吃饭去…
曹义国 要学习去…
曹义国 要吃饭去…

类只包含方法
class Dog():
def eat(self):
print(“小狗吃饭”)
def sleep(self):
print(“小狗睡觉”)
d=Dog()
d.eat()
d.sleep()

#人类
class Humen():
def eat(self):
print(“人在吃饭”,id(self))
def study(self):
print(“人在学习”,id(self))
zs=Humen()
zs.eat()
zs.study()
print(id(zs))

ls=Humen()
ls.eat()
ls.study()
print(id(ls))

人在吃饭 35324536
人在学习 35324536
35324536
人在吃饭 35324704
人在学习 35324704
35324704

说明了加入一个zs对象，内存地址都一样，self代表我们输入的对象，不变；self接收的是对象，哪个对象调用传的就是哪个值

class Dog():
def init(self,new_name,new_age):
# self.new_name=“大黄”
self.new_name=new_name # “对象的属性等于值
# self.new_age=2
self.new_age=new_age # 给对象增加属性
def introduce(self):
print(”%s的年龄是:%d"%(self.new_name,self.new_age))

dog=Dog(“大黄”,2)
dog.introduce()

class Dog():
def init(self,new_name,new_age,gender):
self.new_name=new_name # “对象的属性等于值
self.new_age=new_age # 给对象增加属性
self.gender=gender
def introduce(self):
print(”%s的年龄是:%d性别是:%s"%(self.new_name,self.new_age,self.gender))

dog=Dog(“大黄”,2,“男”)
dog.introduce()

dog1=Dog(“小黑”,2,“女”)
dog1.introduce()

大黄的年龄是:2性别是:男
小黑的年龄是:2性别是:女

class Student():
def init(self,name):
self.name=name
def haha(self,age): # 对象属性可以扩展，不仅仅可以写在__init__里面
self.age=age
def hehe(self):
print(self.name,self.age)

zs=Student(“张三”)
zs.haha(19)
zs.hehe() # AttributeError: ‘Student’ object has no attribute ‘age’ # 不写上面那行报错，类里面年龄对象没传

class Teacher():
def init(self,name):
self.name=name
def show(self):
print(self.name,self.age) # 张三 29
zs=Teacher(“张三”)
zs.age=29 # 在外面也可以添加属性
zs.show()

ls=Teacher(“李四”)
print(ls.age) # AttributeError: ‘Teacher’ object has no attribute ‘age’ # 类里面年龄对象没传，虽然类是具有相同特征或行为的，但你没在里面或者外面加上这个对象

class Student():
def init(self, name,age, sex):
self.name=name
self.age=age
self.sex=sex
def show(self):
print(self.name,self.age,self.sex) # age还是那个age，只不过在原来的基础上对其值进行了修改
def setage(self):
self.age=19
zs=Student(“张三”,29,“男”)
zs.show() # 张三 29 男
zs.setage()
zs.show() # 张三 19 男

##__str__方法
class Dog():
def init(self,color,age):
self.color=color
self.age=age
def str(self): # 魔术方法，没有显示调用str方法，但实现了功能，把对象转换为字符串，强制转化为字符串，
print(“hehehehhe”)
return “颜色%s, 年龄%d”%(self.color,self.age)
d=Dog(“红色”,18) # 返回的字符串
print(d) # 颜色红色, 年龄18 # 自动加了str触动了str转换为字符串，默认调用
#b=d
#print(b,type(b)) # 颜色红色, 年龄18 <class ‘main.Dog’>
x=str(d)
print(x,type(x)) # print(d)相当于这两行代码

实例
from math import pi
class Circle():
def init(self,radis):
self.radis=radis
def area(self):
return piself.radisself.radis
def zhouchang(self):
return 2piself.radis
def str(self):
return “我的半径是%.2f,面积是%.2f,周长是%.2f”%(self.radis,self.area(),self.zhouchang()) # 调用方法要记得加括号：写全方法

a=Circle(5)
print(a)

运行结果：
我的半径是5.00,面积是78.54,周长是31.42

class YangRouChuan():
def init(self): # 初始化时间为0，状态生的
self.cook_time=0
self.status=“生的”
def cook(self,cook_time):
self.cook_time+=cook_time
if self.cook_time<=2:
self.status=“生的”
elif self.cook_time<4:
self.status=“半熟”
elif self.cook_time<6:
self.status=“熟了”
else :
self.status=“糊了”
def str(self):
return “烤了{}个小时，状态{}”.format(self.cook_time,self.status)

s=YangRouChuan()
s.cook(2)
print(s)
s.cook(2)
print(s)
s.cook(2)
print(s)

运行状态：
烤了2个小时，状态生的
烤了4个小时，状态熟了
烤了6个小时，状态糊了

猩球崛起

class Person():
def init(self,name,attack,hp):
self.name=name
self.attack_li=attack
self.hp=hp
def attck(self,obj):
obj.hp-=self.attack_li
def str(self):
return “我叫{},我还有{}滴血,我的攻击力是{}”.format(self.name,self.hp,self.attack_li)
class NPC():
def init(self, name, attack, hp):
self.name = name
self.attack_li = attack
self.hp = hp
def attack(self,obj):
obj.hp-=self.attack_li
def str(self):
return “枭雄{},我还有{}滴血,其攻击力是{}”.format(self.name,self.hp,self.attack_li)

r=Person(“诸葛亮”,30,90)
c=NPC(“曹操”,20,100)
r.attck©
c.attack®
print©
print®

枭雄曹操,我还有70滴血,其攻击力是20
我叫诸葛亮,我还有70滴血,我的攻击力是30

买家具：
class House():
def init(self,info,area,address):
self.info=info
self.area=area
self.address=address
self.furniture=[]
def add_furniture(self,f):
self.furniture.append(f)
self.area-=f.area # 买的家具剩余空间

def __str__(self):
    s = "房屋类型:{},房屋面积还有:{},地址:{}".format(self.info, self.area, self.address)
    s1 = "t室内家具有："
    for f in self.furniture:
        s1 = s1 + f.name + ","
    return s + s1

class Furniture():
def init(self,name,area):
self.name = name
self.area = area

h=House(“五室三厅”,400,“北京市”)
f=Furniture(“双人床”,60)
f2=Furniture(“柜子”,30)
h.add_furniture(f)
h.add_furniture(f2)
print(h)
运行结果：
房屋类型:五室三厅,房屋面积还有:310,地址:北京市 室内家具有：双人床,柜子,

class People():
tax=0.09 # 类里面直接包的属性，不属于别的,属于整个类,供类的所有对象使用
def init(self,salary):
self.salary=salary # self.salary属于整个对象
def jiaoshui(self):
return self.salary*People.tax
a=People(100000)
b=People(200000)
#print(a.jiaoshui()) # 9000.0
#print(b.jiaoshui())
a.tax+=0.01 # 在People.tax的基础上加0.01
print("%.2f"%a.tax,id(a.tax)) # 相当于开辟了一个新的变量
print(People.tax,id(People.tax))
People.tax=200 # 全局改变，局部已经修改过了，对局部无影响
print(a.tax)
#delattr(a,“tax”)
#print(a.tax) # 200 # 找不到a去全局找People.tax=200
0.10 3518584
0.09 3518824
0.0999999999999999

class A():
def init(self):
self.tax=0.1
x=A()
print(x.tax) # 0.1
delattr(x,“tax”)
print(x.tax) # 报错，无tax，delattr删除

class A():
books=[“三国”,“西游记”]
def init(self,name):
self.name=name
a=A(“张三”)
b=A(“李四”)
a.books[0]=“水浒传”
print(b.books) # [‘水浒传’, ‘西游记’]
print(A.books) # [‘水浒传’, ‘西游记’]
a.books=[“红楼梦”,“大秦帝国”]
print(a.books) # [‘红楼梦’, ‘大秦帝国’]
print(b.books) # [‘水浒传’, ‘西游记’]
print(A.books) # [‘水浒传’, ‘西游记’]

class People():
tax=0.09 # 类里面直接包的属性，不属于别的,属于整个类,供类的所有对象使用
def init(self,salary):
self.salary=salary # self.salary属于整个对象
def jiaoshui(self):
# return self.salarya.tax # a,b都会改变
return self.salaryself.tax # 只有a会改变

a=People(100000)
b=People(200000)
a.tax=0.08
print(a.jiaoshui()) # 8000.0
print(b.jiaoshui()) # 16000.0 # 18000.0

总结：类属性和实例属性的总结

最后

以上就是淡然哈密瓜为你收集整理的面向对象编程猩球崛起的全部内容，希望文章能够帮你解决面向对象编程猩球崛起所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。