#一切皆对象，可以简单地将“对象”理解为“某个东西”

#“对象”之所以称之为对象，是因为它具有属于它自己的“特征”和“行为”

#面向过程指的是变量和函数。“散落”在各种文件中，或者在文件的各个位置，相互没有联系，函数与变量没有相关性，非常不利于维护，设计模式不清晰。

#为此才有面向对象概念的诞生。

#面向对象指的是相关的变量和函数都“封装”在对象里面，以对象为单位来管理代码。好处在于变量和函数的相关性清晰，便于维护，设计模式也比较清晰；程序员可以配合“继承”来提高代码的可重用性，加强合作开发。

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

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

#类：是一类事物的抽象概念，不是真实存在的，描绘的是这类事物的共性，例如人、动物、家具。

#实例：某类事物的具体个体，是该类事物的具体表现，它是具体存在的，例如tuple老师是人中的一个，加菲猫是猫中的一种。

class Person: #创建一个名字叫人的类

    pass    #占位符

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

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

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

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、找不到，转到类中查找变量

class Person:

    pass

p1=Person()

p2=Person()

p1.var='变量1'

print(p1.var)  #输出变量

print(Person.var) #AttraribileError，类中间找不到，不会转到实例中去找

print(p2.var) #p2中找没有，转到Person中去找也没有

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

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，用来表示调用这个方法的实例对象本身

#方法总是定义在类中，但却叫“实例方法”，因为它在该类所有实例缩共有的行为

#首先，我们用面向过程的方法来做

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)