python进阶01 面向对象、类、实例、属性封装、实例方法

python进阶01 面向对象、类、实例、属性封装、实例方法

一、面向对象

　　1、什么是对象

#一切皆对象，可以简单地将“对象”理解为“某个东西”
#“对象”之所以称之为对象，是因为它具有属于它自己的“特征”和“行为”

　　2、面向过程和面向对象

#面向过程指的是变量和函数。“散落”在各种文件中，或者在文件的各个位置，相互没有联系，函数与变量没有相关性，非常不利于维护，设计模式不清晰。
#为此才有面向对象概念的诞生。
#面向对象指的是相关的变量和函数都“封装”在对象里面，以对象为单位来管理代码。好处在于变量和函数的相关性清晰，便于维护，设计模式也比较清晰；程序员可以配合“继承”来提高代码的可重用性，加强合作开发。

#面向对象：就是从事物的内部联系，与事物与事物间的外部联系来考虑我们的代码设计的

二、类和实例

#类与实例，是现实对象在代码中的体现，它们也提供了专门的变量空间

　　类和实例都是对象

　　1、类和实例的区别

#类：是一类事物的抽象概念，不是真实存在的，描绘的是这类事物的共性，例如人、动物、家具。
#实例：某类事物的具体个体，是该类事物的具体表现，它是具体存在的，例如tuple老师是人中的一个，加菲猫是猫中的一种。

　　2、创建类，实例

class Person: #创建一个名字叫人的类
    pass    #占位符

p=Person() #创建实例p，实例出一个具体的人（类的实例化）

　　3、如何确定类和实例之间的关系

　　　　利用isinstance判别函数

class Person：
    pass

class Dog:
    pass

p1=Person() #p1,p2是人类
p2=Person()
P3=Dog()  #p3是狗类

print(p1 is p2) #False ，p1，p2虽然都是人类，但是p1不等同于p2

print(isinstance(p1,Person)) #True，判断p1是不是人类
print(isinstance(p2,Dog))    #False，判断p2是不是狗类
print(isinstance(p3,(Person,Dog)))  #True，判断p3是不是属于人类或狗类，符合一种就是True

三、属性封装

#属性表示的是实例的特征，通常标识了一个实例，因此通常存在于实例中

　　类和实例都是独立存放变量的空间

　　1、运算符 “.”

　　　　用于进行变量空间的运算

class Person:
    var1='变量1'
print(Person.var1) #输出直接封装在类中的变量var1(变量1)

Person.var2='变量2'
print(Person.var2) #输出后来封装在类中的变量var2（变量2）

p=Person() #类的实例化
print(p.var1) #虽然实例p中找不到var1，但根据属性查找规则，在Person类中能够找到，所以仍然能够寻找到var1
print(p.var2)

#属性查找规则：查找变量->在实例中查找-->1、找到了，就可输出；2、找不到，转到类中查找变量

　　2、实例是一个独立存放变量的空间

class Person:
    pass

p1=Person()
p2=Person()
p1.var='变量1'
print(p1.var)  #输出变量
print(Person.var) #AttraribileError，类中间找不到，不会转到实例中去找
print(p2.var) #p2中找没有，转到Person中去找也没有

　　一个实例的“特征”，就是“属性”

四、实例方法

#实例方法是一个类中所有实例公共的行为。因此，通常不会在每个实例中存放一个，而是存在与类中

　　1、什么是实例方法

　　　　封装在类中的一种特殊的函数

class Person：
    def fun():
        print('做些什么')
Person.fun()

p=Person()
p.fun() #TypeError,多传入一个参数

class Person:
    def fun(self):
        print('参数'，self)
Person.fun('直接通过类调用')

p=Person()
print(p)
p.fun()  #默认传入了p这个实例本身

　　　　实例方法就是实例的行为

class Person:
    def eat(self):
        print('{name}eating...'.format(name=self.name))

p1=Person()
p1.name='Tuple'
p2=Person()
p2.name='Budong'

p1.eat()#相当于Person.eat(p1),就是直接传入了p1这个参数
p2.eat()

# 将name变量与eat函数这两个相关对象通过封装深度的绑定在了类和实例中

　　　　实例方法的调用过程与self

#  实例.方法(参数) -->类.方法（实例，参数） 就是直接将实例传入了函数
#  通常，将默认会传入的那个参数命名为self，用来表示调用这个方法的实例对象本身
#方法总是定义在类中，但却叫“实例方法”，因为它在该类所有实例缩共有的行为

四、作业

　　设计一个银行业务相关的简单程序，让它具有：1、创建账户；2、存款；3、提款；4、展示子账户信息等基本功能

#首先，我们用面向过程的方法来做
def account(name,number,balance): #创建账户函数，将输入的账户名，账号，余额返回到一个字典
    return {'name':name,'number':number,'balance':balance}

def deposit(acct,amount): #存款函数
    if amount<=0:#存款数为负数不得进行存款
        print('余额不得负数')
    else:
        acct[balance]+=amount #利用字典完成存款

def withdraw(acct,amount): #取款函数
    if amount>acct[balance]:
        print('取款额不得大于余额')
    else:
        acct[balance]-=amount

def desc(acct): #查询函数
    return '{name}:{balance}'.format(name=acct[name],balance=acct[balance])#返回一个账户名和余额的字符串

#用“类”来代替没有语义的“字典”
class Account:
    pass

def account(name,number,balance):
    acct=Account()
    acct.name=name
    acct.number=number
    acct.balance=balance
    return acct

def deposit(acct,amount): #存款函数
    if amount<=0:#存款数为负数不得进行存款
        print('余额不得负数')
    else:
        acct.balance+=amount #利用实例完成存款

def withdraw(acct,amount): #取款函数
    if amount>acct.balance:
        print('取款额不得大于余额')
    else:
        acct.balance-=amount

def desc(acct): #查询函数
    return '{name}:{balance}'.format(name=acct.name,balance=acct.balance)#返回一个账户名和余额的字符串

#既然如此，为啥不直接放到类里面呢,这便是用过“面向对象”的思路来设计
class Account:

    def account(self,name,number,balance):
        self.name=name
        self.number=number
        self.balance=balance
        return self

    def deposit(self,amount): #存款函数
        if amount<=0:
            print('余额不得负数')
        else:
            self.balance+=amount 

    def withdraw(self,amount): #取款函数
        if amount>acct.balance:
            print('取款额不得大于余额')
        else:
            self.balance-=amount

    def desc(self): #查询函数
        return '{name}:{balance}'.format(name=self.name,balance=self.balance)