Python【第七天】面向对象基础（1）

总体描述

• 面向过程(怎么做)
  按照解决问题的步骤写代码[根据业务逻辑写代码]
  在思考问题的过程中
  首先分析怎么按照步骤去实现；
  然后将问题解决、拆解若干个步骤，并将这些步骤对应成方法一步一步的
  最终完成功能
  从机算计角度来看，不适合做大项目
• 面向对象(谁来做)
  oop [object oriented programming]
  是一种Python的编程思路
  关注的是设计的思维，关注谁来做
  从机算计角度来看，适合做更大项目的设计

• 类
  就是一个模板，可以包含多个函数，函数里实现一些功能
  具有一组相同或者相似特征【属性】和行为【方法】的一系列对象的集合
  构成：
  名称：类名
  属性：一组数据【特征】
  方法：允许对数据进行操作的方法【行为】
  现实世界 计算机世界
  行为-------->方法
  特征-------->属性
  类的抽象
  具有相同(或者类似)属性和行为的一系列对象的集合都可以抽象出一个类
• 对象
  根据模板【类】创建的实例，即类的实例化，通过实例对象可以执行类中的函数
  类是对象的抽象化，对象是类的一个实例化

定义类和创建对象

创建类的格式：
    class Fool(object):   # 类名采用大驼峰方式【第一个字母大写】命名
        方法列表
创建对象
    对象名 = 类名()

# 类结构    类名  属性  方法
# class 类名:
#     属性
#     方法
class Person:
    '''
    对应人的特征
    '''
    name = '小明'
    age = 18
    sex = '男'
    '''
    对应人的行为  
    '''
    def eat(self):
        print('吃')
        pass
    def run(self):
        print('跑')
        pass
    pass

# 创建对象
# 对象名 = 类名()
xm = Person()
# 调用规则格式
print('{}的年龄是{}，性别是{}'.format(xm.name,xm.age,xm.sex))
xm.eat()
xm.run()

实例方法和属性

实例方法：
    在类的内部使用def 关键字来定义 第一个默认参数是self【名字标识可以是其他的名字，但是这个位置必须被占用】
    实例方法是归于类的实例所有
实例属性：
    定义在方法里面使用self引用【self.属性】的属性
类属性：
    定义在类里面，方法外面的属性称之为类属性

class Person: 
    '''
    对应人的特征
    '''
    name = 'A'  #类属性
    age = 20  #类属性
    '''
    对应人的行为 实例方法
    '''
    def __init__(self):
        self.name = 'B'  #实例属性
        pass
    def eat(parms):
        print('吃')
        pass
    def run(self):
        print('跑')
        pass
    pass

def printInfo():
    '''
    实例方法 
    '''
    pass
x = Person()
x.eat() # 实例方法
x.run()
print('{}的年龄是：{}'.format(x.name,x.age))

__ init __

__init__方法：
    Python自带的内置函数 用双下划线【__】包起来【魔术方法】
    初始化方法 实例化对象的时候自己调用，完成一些初始化设置
    再创建一个对象时默认被调用，不需要手动调用
__init__传参：
    如果init方法里面的属性固定了，每个类创建出来的对象属性都一样
    __init__(self)中，默认有一个参数名字为self
    如果还需要传两个实参x,y，那么应该写成__init__(self,x,y)
    【可将属性当参数在实例化对象的时候传进去】

class People:
    def __init__(self):
        '''
        实例属性的声明
        '''
        self.name = 'B'
        self.sex = '女'
        self.age = 19
        pass
    def eat(self):
        '''
        吃的行为
        '''
        print('喜欢吃榴莲')
        pass
    pass
x = People()
x.name = 'A'  #添加实例属性
x.age = 20  #添加实例属性
x.sex = '女'  #添加实例属性
print('姓名：{} 性别:{} 年龄:{}'.format(x.name,x.sex,x.age))
x.eat()
# x.__init__()
# 如果有n个这个对象 被实例化 就会被添加很多次这样的属性了
y = People()
print('姓名：{} 性别:{} 年龄:{}'.format(y.name,y.sex,y.age))  # 直接输出默认值

class Person:
    def __init__(self,name,sex,age):
        '''
        实例属性的声明
        '''
        self.name = name
        self.sex = sex
        self.age = age
        pass
    def eat(self,fruit):
        '''
        吃的行为
        '''
        print('{}喜欢吃{}'.format(self.name,fruit))
        pass
    pass
z = Person('C','男',18) #【可将属性当参数在实例化对象的时候传进去】
z.eat('香蕉')
print('姓名：{} 性别:{} 年龄:{}'.format(z.name,z.sex,z.age))

self

self：
    self和对象指向同一个内存地址，可以认为self就是对象的引用【实例对象】
    相当于Java中的 this
self传参：
    self 可以理解为对象自己
    某个对象调用其方法时，Python解释器会把这个对象作为第一个参数传递给self
    所以开发者只需要传递后面的参数即可

class Person:
    '''
    定义类
    '''
    def __init__(self,age):
        '''
        实例属性的声明
        '''
        self.name = 'B'
        self.age = age
        pass
    def eat(self,name,fruit):
        '''
        实例方法
        '''
        print('{} 年龄是{} 喜欢吃{}'.format(name,self.age,fruit))
        # print('self = %s',id(self))
        pass
    pass

x = Person(12)
# print('x = %s',id(x))
x.eat('A','水果')

魔术方法

魔术方法：
    内置好的特定的方法，方法名是'__XXX__'在进行特定的操作时，会自动被调用
举例：
    __init__方法：
        初始化一个类，在创建实例对象为其赋值时使用
    __str__方法：
        在将对象转换成字符串str(对象)测试的时候，打印对象的信息
    __new__方法：
        创建并返回一个实例对象，调用了一次，就会得到一个对象
    __class__方法：
        获得已知对象的类(对象.__class__)
    __del__方法：
        对象在程序运行结束后进行对象销毁的时候调用这个方法，来释放资源
__new__和__init__函数的区别：
    __new__
        类的实例化方法 必须要返回该实例 否则对象创建不成功
        至少有一个参数是cls 代表要实例化的类 此参数在实例化时由Python解释器自动提供
    __init__
        用来做数据属性的初始化工作 也可以认为是实例的构造方法
        接受类的实例 通过self并对其构造
    __new__函数执行要早于__init__函数

• __ str __

class Animal:
    def __init__(self,name,colour):
        self.name = name
        self.colour = colour
        pass
    def __str__(self):
        return '名字：{} 颜色{}'.format(self.name,self.colour)
        pass 
    pass
dog = Animal('A','red')
print(dog)  #直接输出对象

• __ new __

class Animal:
    def __init__(self,name,colour):
        self.name = name
        self.colour = colour
        print('-------__init__-------函数的执行')
        pass
    def __str__(self):
        '''
        打印对象 自定义对象 是内容格式的
        '''
        return '名字：{} 颜色{}'.format(self.name,self.colour)
        pass 
    def __new__(cls,*args,**kwargs):
        '''
        创建对象实例的方法
        每调用一次，就会生成新的对象
        cls 是 class 的缩写
        '''
        print("-------__new__-------函数的执行")
        return object.__new__(cls)  # 在这里是真正创建对象实例的
        pass
    pass
# 真正实例化过程中，第一个被执行的函数是__new__函数，不是__init__函数
dog = Animal('A','red')
print(dog)  #直接输出对象

析构方法

概述：
    当一个对象被删除或者被销毁时，Python解释器也会默认调用一个方法
    【没有写，也会有这个方法】
    这个方法为__del__()方法，也成为析构方法

总结：
    当整个程序脚本执行完毕后会自动调用__del__方法
        当在某个作用域下面，没有被使用【引用】的情况下
        解析器会自动的调用此函数 来释放内存空间
    当对象被手动销毁时自动调用__del__方法
    一般用于资源回收利用__del__方法销毁对象回收内存等资源

class Person:
    def __init__(self,name):
        print('__init__方法被调用')
        self.name = name
        pass
    def __del__(self):
        print('__del__方法被调用')
        print('{}对象被彻底清理掉了'.format(self.name))
        pass
    def __str__(self):
        return '__str__方法被调用'
        pass
    pass
a = Person('A')
print(a)
del a  # 即使手动删除对象 也会执行析构函数
print('程序等待中---------')
b = Person('B')