8.26 day23

面对对象和面对过程

在此之前，无论是ATM，还是购物车，我们用的都是简单的面向过程，那么面向过程和面向对象进行比较，又有哪些优缺点呢？

面向过程

优点:复杂问题流程化,进而简单化
确定:可扩展性差

面向对象

优点：可扩展性高

缺点：编写复杂

类与对象

对象是属性和方法的结合体

类是一系列共同的属性和方法

程序中的类和现实中的类是类似的，现实中的家禽类，鸟类都是一些相似的，有共同的生物的集合，而程序中的类的作用也是如此，可以将有相同的方法或者属性的对象放到类中

当然，现实中和程序里的类还是有不小区别的，比如说，现实中肯定是先有对象接下来才有类，因为你需要将那些对象归到类中。而程序中则恰好相反，必须得定义类，随后再生成对象

类的定义

有如下俩个学生：

'''
学生1:
    学校:哈佛大学
    姓名:李铁蛋
    性别:女
    年龄:18
    方法:
        选课
        学习
学生1:
    学校:哈佛大学
    姓名:李钢蛋
    性别:男
    年龄:48
    方法:
        选课
        学习

'''

有如上俩个学生，可以发现，他们的学校是一样的，方法也是一样的，都是选课和学习，那么该如何定义类呢？

首先，定义类的方式为：class(关键字) + 类名:

class Student:
    #变量表示属性
    school = '哈佛大学'
    def choose(self):
        print("选课....")
    def study(self):
        print('学习')

生成对象

生成对象其实很简单，就是类加括号

stu1 = Student()

获取属性和方法，通过.获取

print(stu1.school)    # '哈佛大学'
print(stu1.choose)    # choose方法的内存地址

查看类中的属性和函数

首先我们可以使用__dict__方法来以字典的形式输出类中的属性和方法

print(Student.__dict__)

结果为：
{'__module__': '__main__', 'school': 'oldboy', 'choose': <function Student.choose at 0x000001E5A5753A60>, 'study': <function Student.study at 0x000001E5A5753AE8>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}

既然如此，我们肯定也可以通过从字典中根据key值来检索value值从而可以获取方法：

print(Student.__dict__['school'])    # '哈佛大学'
Student.__dict__['choose'](123)    # 选课...
Student.choose(123)    # 选课...
print(Student.school)    # '哈佛大学'

获取对象的属性和方法

stu1 = Student()
print(stu1.school)    # '哈佛大学'
# 对象来调用方法,第一个参数不用传
print(stu1.choose)    # choose内存地址
stu2=Student()
print(stu2.school)    # '哈佛大学'

对象自己的属性和方法

如果某个类中的对象，它的某个属性需求和类中的不同，那该怎么办？这时只要对象中自己定义就可以了，这种改变并不会影响到类

属性查找顺序：先从对象自身找------>类中找----->没有则报错

stu1=Student()
stu1.name='nick sb'
stu1.school='xxxx'
# print(stu1.xxx)    # 报错
print(stu1.school)    # 'xxxx'
print(stu1.__dict__)    # 对象的属性和方法以字典形式表达

如果没有定义对象的话，直接print(stu1.__dict__)会得到空字典

向对象中放属性的方式

方式一

stu1=Student()
stu1.name='李铜蛋'

方式二：

通过__init__方法

class Student:
    #变量表示属性
    school='oldboy'
    
    def __init__(self,name):
        self.name=name
    def choose(self):
        print("选课....")
    def study(self):
        print('学习')

产生对象：

对象
# stu1=Student()    # 报错
stu1=Student('nick')
#内部帮我们做了一些事:当我在实例化产生对象的时候,会自动调用__init__方法,完成对象的初始化
print(stu1.name)
stu2=Student('jason')
print(stu2.name)

绑定方法

定义在类内部的方法

如果类来调用，就是一个普通的函数，有几个参数就需要传几个参数

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

class Student:
    #变量表示属性
    school='oldboy'
    def __init__(x,name):
        x.name=name
    def choose(self):
        print("选课....")
    def study(self):
        print('%s学会了python'%self.name)

stu1=Student('张全蛋')
stu1.study()
stu1=Student('李铁蛋')
stu1.study()

结果为：

张全蛋学会了python
李铁蛋学会了python

一切皆对象

在Python中，无论是字符串还是列表，都是对象

比如一个列表：

l1=[1, 2, 3]

它也可以这样打：

l1=list([1, 2, 3])
l2=list([5, 7, 8])

对比一下类和对象，有没有发现这俩者及其类似吗

再想一下列表的内置方法：

list.append(l1, 9)

有没有发现和类里的方法的调用方式一模一样

其实你点开列表的内置方法，就会发现就是类里的一个个__init__

类的初步实战：人狗大战

#人狗大战
#定义一个狗类
class Dog:
    type_dog='藏獒'
    def __init__(self,name,aggressivity,hp=100):
        self.name=name
        self.aggressivity=aggressivity
        self.hp=hp
    def bite(self,target):
        #当期狗的攻击力:self.aggressivity
        #人的血量:target.hp
        target.hp-=self.aggressivity
        print('''
        狗的品种:%s
        %s狗咬了一下%s人,
        人掉血:%s
        人的血量剩余:%s
        '''%(self.type_dog,self.name,target.name,self.aggressivity,target.hp))
#人类
class Human:
    def __init__(self,name,aggressivity,hp=100):
        self.name=name
        self.aggressivity=aggressivity
        self.hp=hp
    def bite(self,target):
        target.hp-=self.aggressivity
        print('''
        %s人咬了一下%s狗,
        狗掉血:%s
        狗的血量剩余:%s
        '''%(self.name,target.name,self.aggressivity,target.hp))


#实例化产生狗对象
# dog1=Dog('旺财',10)
dog1=Dog('旺旺财',10,200)
nick=Human('nick',50)
dog1.bite(nick)
print(nick.hp)
dog1.bite(nick)
print(nick.hp)
nick.bite(dog1)