python如何对一个属性或方法进行封装_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)