Python中对象和类（14）

概念

类：是有一些系列有共同特征和行为事物的抽象概念的总和。
描述一个类：属性 （特征） 方法（行为）
类第一个字母大写。
对象：是由类创造出来的具体实体，可以直接使用的。

类和对象之间的关系

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.如果是重新赋值操作，效果等同：不可修改类型