概念
类:是有一些系列有共同特征和行为事物的抽象概念的总和。
描述一个类:属性 (特征) 方法(行为)
类第一个字母大写。
对象:是由类创造出来的具体实体,可以直接使用的。
类和对象之间的关系
1.先有类后有对象
2.类只有一个对象可以有多个
类的设计
类名:大驼峰命名法
属性:描述这类事物的特征
方法:描述这类事物的具体行为
# 定义类
class Dog():
def sleep(self):
print("小狗睡觉奥")
def eat(self):
print("小狗吃饭")
# 创建对象
d = Dog()
d.eat()
d.sleep()
self 变量
self ,这个参数其实就是被创建的实例本身,哪个调用方法或者属性,self就是那个变量
class Human():
def study(self):
print(id(self), "人在学习") # 39506384 人在学习
def eat(self):
print(id(self), "人在吃饭") # 39506384 人在吃饭
zs = Human() # self接收的就是那个对象
zs.study()
zs.eat()
print(id(zs)) # 39506384
init()方法
创建对象的时候自动执行。
可以在 init()方法中做一些初始化操作。
class Student():
def __init__(self,name,age,gender):#创建对象的时候自动执行
self.name=name
self.age=age
self.gender=gender
def show(self):
print("我叫{}年龄{}性别{}".format(self.name,self.age,self.gender))
zs=Student("张三",18,"女")
zs.show()#我叫张三年龄18性别女
ls=Student("李四",20,"男")
ls.show()#我叫李四年龄20性别男
class Student():
def __init__(self,name):
self.name=name
def hehe(self,age):
self.age=age
def haha(self):
print(self.name,self.age)
zs=Student("张三")
zs.hehe(19)
zs.haha()#张三 19
class Teacher():
def __init__(self,name):
self.name=name
def show(self):
print(self.name,self.age)
zs=Teacher("张三")
zs.age=29
zs.show()
ls=Teacher("李四")
#zhe 里错误,因为李四无值# print(ls.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)
def setage(self):
self.age=19
zs=Student("张三",29,"男")
zs.show()#张三 29 男
zs.setage()
zs.show()#张三 19 男
str()方法
打印对象的名称时默认调用的是__str__()方法,此方法返回的是对象的内存地址。
我们可以重写__str__()方法打印对象保存的信息。
class Dog():
def __init__(self,color,age):
self.color=color
self.age=age
def __str__(self):
print("hehhehhehehhehehehehe")
return "颜色%s 年龄%d"%(self.color,self.age)
d=Dog("红色",18)
print(d)
"""
hehhehhehehhehehehehe
颜色红色 年龄18 <class 'str'>
"""
b=d
print(b,type(b))#<class '__main__.Dog'>
"""
hehhehhehehhehehehehe
颜色红色 年龄18 <class '__main__.Dog'>
"""
# print(b[0])#不支持索引
x=str(d)
print(x,type(x))
print(x[0])#变成字符串格式,就支持索引了
"""
hehhehhehehhehehehehe
颜色红色 年龄18 <class 'str'>
颜
"""
class employee():
def __init__(self,name,salary):
self.name=name
self.salary=salary
def __str__(self):
return "姓名%s 工资%d" %(self.name,self.salary)
zs=employee("zhang",10000)#zs就是一个对象
print(zs,type(zs))#姓名zhang 工资10000 <class '__main__.employee'>
x=str(zs)
print(x,type(x))#姓名zhang 工资10000 <class 'str'>
面向对象综合小练习
1.计算圆的面积和周长
from math import pi
#定义一个圆类
class Circle:
def __init__(self,radius):
self.radius=radius
def area(self):
return pi*self.radius*self.radius
def zhouchang(self):
return 2*pi*self.radius
def __str__(self):
return "我的半径是%.2f,周长是%.2f,面积是%.2f。"%(self.radius,self.zhouchang(),self.area())
yuan=Circle(5)
print(yuan)
"""
我的半径是5.00,周长是31.42,面积是78.54。
"""
2.烤羊肉串
class YangRouChuan:
def __init__(self):
self.cooktime=0
self.status="生的"
def cook(self,cook_time):
self.cooktime+=cook_time
if self.cooktime<2:
self.status="生的"
elif self.cooktime<4:
self.status="半熟"
elif self.cooktime<6:
self.status="熟了"
else:
self.status="糊了"
def __str__(self):
return "烤了%d个小时,状态%s"%(self.cooktime,self.status)
rouchuang=YangRouChuan()
rouchuang.cook(2)
print(rouchuang)
rouchuang.cook(3)
print(rouchuang)
rouchuang.cook(3)
print(rouchuang)
"""
烤了2个小时,状态半熟
烤了5个小时,状态熟了
烤了8个小时,状态糊了
"""
3.猩球崛起
class Person:
#有姓名,攻击力,生命值hp
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)
#对手
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,100)
n=NPC("曹操",20,100)
r.attack(n)
n.attack(r)
print(r)
print(n)
"""
人类诸葛亮,我还有80滴血,我的攻击力是30
枭雄曹操,我还有70滴血,我的攻击力是20
"""
4.买家具
class Hourse:
#有户型,面积,地址
def __init__(self,info,area,address):
self.info=info
self.area=area
self.address=address
self.furniture=[]
def add_furniture(self,furniture):
self.furniture.append(furniture)
self.area-=furniture.area
def __str__(self):
s= "户型:{},面积:{},地址{}".format(self.info,self.area,self.address)
s1="\t 室内家具有:"
for furniture in self.furniture:
s1=s1+furniture.name+','
return s+s1
class Furniture():
def __init__(self,name,area):
self.name=name
self.area=area
h=Hourse("G型",400,"街区")
f=Furniture("床",60)
f2=Furniture("柜",30)
h.add_furniture(f)
h.add_furniture(f2)
print(h)
类属性和实例属性
实例属性:在实例对象中定义的属性
类属性(静态属性):在类对象(也就是类)中定义的属性,并且多个实例对象共享一份类属性。
类属性的使用方式:
类名 . 类属性
对象名 . 类属性
注意:
1.对于不可变数据类型来说:对象名. 静态属性名称=值 是给对象中添加属性名称,而不是进行修改。
2.对于可变数据类型来说:
如果对象是修改可变数据类型变量中的数据,都有影响。
如股是重新给可变数据类型变量赋值,这是给对象添加属性。
#定义一个不可变数据类型变量language 可变courses
class Course:
language="chinese"
courses=['python']
def money(self):
print("价格上调了")
#调用
#1.类对象调用
print(Course.language)#chinese
#2.实例对象调用
c=Course()
print(c.language)#chinese
#类对象修改静态属性
#1.不可变数据类型
Course.language='pyton'
d=Course()
print(d.language)#pyton
#2.可变数据类型
Course.courses.append("java")
print(d.courses)#['python', 'java']
#使用实例对象修改不可变静态属性的值
f=Course()
f.language="c++"#注意这是给对象自己添加属性,不会改变类中属性
print(f.language)#c++
g=Course()
print(g.language)#pyton
#使用实例对象修改 可变数据类型 的元素值
class Course:
language="chinese"
#定义一个列表可变数据类型
lst=["a",'b']
python=Course()
java=Course()
python.lst[0]='hh'
#可变数据类型
#1.修改元素,所有都会改变
print(Course.lst)#['hh', 'b']
print(python.lst)#['hh', 'b']
print(java.lst)#['hh', 'b']
#2.重新赋值,给当前的对象添加属性不会影响到类对象中的数据
python.lst=['zs','ls']
print(Course.lst)#['hh', 'b']
print(python.lst)#['zs', 'ls']
print(java.lst)#['hh', 'b']
类属性:
不可修改类型:
对象属性只要赋值,那么此对象用的属性就是自己的属性,不会在用同名的类属性。类属性的变化不会在影响到此对象
可修改类型:
1.修改内部属性的值,只是修改不是赋值,那么此修改会影响到所有对象以及类属性
2.如果是重新赋值操作,效果等同:不可修改类型