码迷,mamicode.com
首页 > 编程语言 > 详细

野路子码农系列(2)Python中的类,可能是最通俗的解说

时间:2019-01-20 12:05:17      阅读:217      评论:0      收藏:0      [点我收藏+]

标签:名称   print   pass   现在   set   val   作用   error   erro   

啥叫佩奇?啥叫类?啥叫面向对象?后面两个问题以前在大学里“祖传谭浩强”的时候我经常会有所疑问。老师说着一堆什么public, private,我都是一脸懵逼,啥叫私有?为啥要私有?然后就神游天外了……

后来由于一直接触数据挖掘类的内容,写得那根本不是程序,都是脚本,而且基本上也用不到类这种东西。直到前几天,在一个项目中,我需要对8个分类分别应用同一个模型,我才又回想起了被类支配的恐惧。本文即劫后余生的产物,没有网络上哪些看到想吐的Foo, Bar,只有最通俗易懂的语言。

 

P1 起因

正如上文所说,我需要对8个分类分别应用同一个模型,这8个分类的数据不同,但扔进模型并跑一跑的过程是相似的,除此之外,我可能还需要对每个模型进行一些调参,每个模型还需要在不同的时间段上进行验证(即传入模型的数据不同)。

如果我只用一个脚本的话,面临的问题就是,我需要分别记录这8组参数,不同分类之间的运行调试可能会互相干扰,修改代码也不方便。那有没有方便的方法呢?有啊,懒人福音——类(class)。

注意,本文由于作者水平不行,只说基础内容。

 

P2 什么是类

如果你要我说正经的解释,抱歉,我完全说不出来,毕竟我是野路子码农……但我可以给出一个稍微通俗一些的解释,类是一个容器,里面可以存放数据和操作。

举个例子的话,银行账户可以当成一个类。类里存放有数据,比如名字和金额;类里也存放有操作(即函数),比如余额查询、存钱、取钱。类可以实例化,就像银行账户可以为张三开立,也可以为王二狗开立,大多数情况下,他们之间互不影响。

 

P3 开始玩类

好了,假设我们就把银行账户当成一个类吧:

1 class Bank_Account:
2     pass

我们创建了一个叫Bank_Account的类,pass代表我们什么都没做。这一步就像银行柜员拿出了一张空卡。可是卡里总要有点内容吧?

1 class Bank_Account:
2     def __init__(self):
3         self.name = None # 户主的名字
4         self.balance = 0 # 账户余额

这里我们创建了第一个函数__init__(),这是用来实例化的时候初始化用的,这里我们记录了账户户主的名字,账户的余额。初始化就像拿出一张新卡,新卡没有户主的名字,账户余额是0,很好理解吧?

注意这里的self关键字,这代表了实例化之后东西,听起来可能比较拗口。比如这卡发给张三,那么self就代表张三的账户,发给王二狗,那self就代表王二狗的账户。

柜员把这张卡签发给了张三,但注意,此时里面毛都没有。

1 john_san = Bank_Account() # 这个账户签发给了张三
2 print(john_san.name) # 初始时没有名字
3 print(john_san.balance) # 初始时余额为0

返回结果

None
0

self.name这种前面带self.的我们称之为实例变量,它根据每个实例的不同而不同,我们可以分别设定,实例之间互不影响:

1 john_san = Bank_Account() # 签发给张三的账户
2 john_san.name = John San
3 
4 wanna_go = Bank_Account() # 签发给王二狗的账户
5 wanna_go.name = Wanna Go
6 
7 print(john_san.name)
8 print(wanna_go.name)

john_san和wanna_go虽然同属一个类,但他们的实例变量相互独立,互不影响(这一点很重要)。返回结果:

John San
Wanna Go

好了,张三和王二狗的账户都开好了,可这卡啥事都干不了,我们需要添加一些操作(函数),我们加个存钱函数吧:

1 class Bank_Account:
2     def __init__(self):
3         self.name = None # 户主的名字
4         self.balance = 0 # 账户余额
5         
6     def deposit(self, amt):
7         # self依然代表实例本身,amt代表存入金额
8         self.balance = self.balance +amt

存钱函数一共有2个参数,一个是self,即代表实例本身,这个参数在实际调用函数时不必传入,另一个是真正的参数amt,即存入金额。我们调用deposit函数时只需要传入amt即可,self不用管它。

1 john_san = Bank_Account()
2 john_san.name = John San
3 
4 john_san.deposit(100) # 只需传入amt参数,张三存了100
5 print(john_san.balance)

返回结果:

100

我们可以注意到,类中我们定义的这个deposit函数和一般正经的函数还不太一样,别人都有return,它却没有。但别慌,这很正常,因为参数参与的运算结果已经传回给了self.balance,不需要再return了。

 

P4 变量其实是个传参用的记事本

好了,有了存钱的操作之后,我们还想加入一个余额查询的操作,虽然我们可以调用john_san.balance直接查看,但我们还是希望显得像正经人一些。

 1 class Bank_Account:
 2     def __init__(self):
 3         self.name = None # 户主的名字
 4         self.balance = 0 # 账户余额
 5         
 6     def deposit(self, amt):
 7         # self依然代表实例本身,amt代表存入金额
 8         self.balance = self.balance +amt
 9     
10     def check_balance(self):
11         # 这个函数实际调用时不需要任何参数
12         print(self.balance)

注意,此处check_balance这个函数只有类内部数据的传递(self.balance),查个账户余额也不需要传入任何外部参数,所以实际调用时无需任何参数。我们重新让张三存入100,再看看结果。

1 john_san = Bank_Account()
2 john_san.name = John San
3 
4 john_san.deposit(100)
5 john_san.check_balance()

返回结果

100

和之前一模一样,成功啦。这里我们可以看到,类内我们定义的这些实例变量(就是那些self.xxx们)其实就像个记事本,它们主要的作用就是在函数间传递数据。就像之前我们所看到的,self.balance首先在__init__函数中记录了账户余额的数据(也就是0);之后张三调用deposit函数存钱时,self.balance又记录了存钱之后的账户余额数据;而后我们在用check_balance查询账户余额时,self.balance又将之前记录的数据传给这个函数。因此,在类的每个实例中(张三的账户、王二狗的账户),实例变量(self.balance)都扮演着一个内部的记事本的角色。它记录了一些内部数据(账户余额),并在函数中相互传递(存钱 -> 查询余额)。

因此,每当我们内部需要传递一组数据时,我们就需要在__inti__下方登记一个实例变量,这就相当于我们领了一本记事本,用这个本子专门记录某一组内部数据,比如像下面这样:

 1 class Bank_Account:
 2     def __init__(self):
 3         self.name = None # 户主的名字
 4         self.balance = 0 # 账户余额
 5         self.nickname = None # 新建一个实例变量用于记录昵称
 6         
 7     def deposit(self, amt):
 8         # self依然代表实例本身,amt代表存入金额
 9         self.balance = self.balance +amt
10     
11     def check_balance(self):
12         # 这个函数实际调用时不需要任何参数
13         print(self.balance)
14         
15     def set_nickname(self, name):
16         # 设定昵称
17         self.nickname = name
18     
19     def get_nickname(self):
20         # 显示昵称
21         print(self.nickname) # self.nickname在函数set_nickname与get_nickname中传递昵称数据

 

P5 公有还是私有

张三有个仇人李四,他总想对张三做点什么,李四知道张三开了个账户之后,就想通过修改张三的账户余额来使其蒙受损失(可以说很科幻了)。我们来看看我们之前定义的这个类,以及它的变量和函数:

# 变量
self.name
self.balance
self.nickname
# 函数
__init__(self)
deposit(self, amt)
check_balance(self)
set_nickname(self, name)
get_nickname(self)

我们看到除了__init__前后有下划线,长得比较奇怪以外,其他的都跟平时我们定义的变量和函数差不多,这些都是公有的(public),啥意思呢?

意思就是变量可以直接指定值

1 john_san.balance = 2000

方法,或者说函数可以直接调用

1 john_san.deposit(-1000)

对张三的账户来说,这是件非常危险的事情!任何人都可以直接修改他的账户余额,包括李四。我们必须把某些重要的东西保护起来,不让外部随便修改。

一个非常简单的方法就是把self.balance变成私有变量(private),怎么变?变量名字前面加两道下划线:

 1 class Bank_Account:
 2     def __init__(self):
 3         self.name = None # 户主的名字
 4         self.__balance = 0 # 账户余额(前面加两道下划线变为私有变量)
 5         self.nickname = None # 昵称
 6         
 7     def deposit(self, amt):
 8         # self依然代表实例本身,amt代表存入金额
 9         self.__balance = self.__balance +amt
10     
11     def check_balance(self):
12         # 这个函数实际调用时不需要任何参数
13         print(self.__balance)
14         
15     def set_nickname(self, name):
16         # 设定昵称
17         self.nickname = name
18     
19     def get_nickname(self):
20         # 显示昵称
21         print(self.nickname) # self.nickname在函数set_nickname与get_nickname中传递昵称数据

账户余额balance变为私有变量之后,我们就无法从外部接触到这个变量了,不信你可以试试:

1 john_san = Bank_Account()
2 john_san.name = John San
3 
4 john_san.__balance

会抛出一个AttributeError,说Bank_Account这个类没有__balance这个属性。这样一来账户余额再也无法从外部直接查看和修改了,只能通过类内部的函数间接查看和修改(比如调用deposit或check_balance)。这样一来,我们有效地保护了账户余额这个变量不会被乱改或者错改。

1 john_san = Bank_Account()
2 john_san.name = John San
3 
4 john_san.deposit(250)
5 john_san.check_balance()

返回结果:

250

在实际应用的过程中,我们可能会遇到这样一种情况:我跑了一个分类器,我希望得到训练时的概率最大值(比如0.9),而我又希望后续预测过程中以这一概率的50%作为阈值。假设我们将最大概率记录在self.max_proba中,我们有可能会因为误操作或者贪图方便,直接指定了max_proba的值,当我们回头又需要训练时得到的max_proba时,我们会发现它已经被我们自己更改了,得从头开始训练模型,而这可能非常耗时。因此,若我们把max_proba变为私有变量,那就不会存在这一问题了,因为我们无法从外部直接修改它,也就避免了不必要的麻烦。

当然,函数也是类似的道理,假设我们定义了一个新的函数bonus,它的作用是奖励账户余额的1%。我们在deposit函数中调用它,也就意味着每次用户存款之后,银行都会给予他(她)账户余额1%的金额作为奖励(这银行吃枣药丸……)。

 1 class Bank_Account:
 2     def __init__(self):
 3         self.name = None # 户主的名字
 4         self.__balance = 0 # 账户余额(前面加两道下划线变为私有变量)
 5         self.nickname = None # 昵称
 6         
 7     def deposit(self, amt):
 8         # self依然代表实例本身,amt代表存入金额
 9         self.__balance = self.__balance + amt
10         self.bonus() # 每次存款会获得一次奖励
11     
12     def check_balance(self):
13         # 这个函数实际调用时不需要任何参数
14         print(self.__balance)
15         
16     def set_nickname(self, name):
17         # 设定昵称
18         self.nickname = name
19     
20     def get_nickname(self):
21         # 显示昵称
22         print(self.nickname) # self.nickname在函数set_nickname与get_nickname中传递昵称数据
23         
24     def bonus(self):
25         # 奖励账户余额1%的金额
26         self.__balance = 1.01 * self.__balance

我们存款试试:

1 john_san = Bank_Account()
2 john_san.name = John San
3 
4 john_san.deposit(250)
5 john_san.check_balance()

返回结果:

252.5

然而,这又存在一个安全性问题,如果张三是内心险恶之人,他可以多次反复调用bonus函数,不断获得奖励而根本不用存钱,这家银行岂不是药丸得更快了?如何避免这一点呢?我们将bonus转为私有函数,同样也是前面加两根下划线:

 1 class Bank_Account:
 2     def __init__(self):
 3         self.name = None # 户主的名字
 4         self.__balance = 0 # 账户余额(前面加两道下划线变为私有变量)
 5         self.nickname = None # 昵称
 6         
 7     def deposit(self, amt):
 8         # self依然代表实例本身,amt代表存入金额
 9         self.__balance = self.__balance + amt
10         self.__bonus() # 类内依然可以调用,但类外就不行了
11     
12     def check_balance(self):
13         # 这个函数实际调用时不需要任何参数
14         print(self.__balance)
15         
16     def set_nickname(self, name):
17         # 设定昵称
18         self.nickname = name
19     
20     def get_nickname(self):
21         # 显示昵称
22         print(self.nickname) # self.nickname在函数set_nickname与get_nickname中传递昵称数据
23         
24     def __bonus(self):
25         # 现在它变成了私有函数
26         self.__balance = 1.01 * self.__balance

现在我们把bonus变成了私有函数,只有类内的其他函数能用调用它,而我们在外部是无法调用的,不信可以试试:

1 john_san = Bank_Account()
2 john_san.name = John San
3 
4 john_san.__bonus()

同样会抛出一个AttributeError,说Bank_Account这个类没有__bonus这个属性。这样一来,我们就避免了张三利用漏洞作弊的可能。

除此之外,私有化也能让你的自动补全变得更为简洁,我们可能有很多预处理函数或者中间变量,它们的作用只是完成一些中间步骤,并将结果传入最终处理的函数中,我们可能并不希望按下Tab时会看到这些东西,会有些混乱。那么在确定没问题的情况下,我们可以将它们全部私有化,那它们也不会出现在自动补全里了。

 

P6 类变量

之前我们说的那些带self.的变量都称为实例变量,那我们也会听到类变量,类变量又是什么鬼呢?

 1 class Bank_Account:
 2     bank_name = Bank of XXX # 类变量,银行的名字
 3     
 4     def __init__(self):
 5         self.name = None # 户主的名字
 6         self.__balance = 0 # 账户余额(前面加两道下划线变为私有变量)
 7         self.nickname = None # 昵称
 8 
 9     def deposit(self, amt):
10         # self依然代表实例本身,amt代表存入金额
11         self.__balance = self.__balance + amt
12         self.__bonus() # 类内依然可以调用,但类外就不行了
13     
14     def check_balance(self):
15         # 这个函数实际调用时不需要任何参数
16         print(self.__balance)
17         
18     def set_nickname(self, name):
19         # 设定昵称
20         self.nickname = name
21     
22     def get_nickname(self):
23         # 显示昵称
24         print(self.nickname) # self.nickname在函数set_nickname与get_nickname中传递昵称数据
25         
26     def __bonus(self):
27         # 现在它变成了私有函数
28         self.__balance = 1.01 * self.__balance    

我们在__init__()函数之前加了一个变量,这个变量的名字前面没有self.,它是直接属于Bank_Account这个类的变量,在这里就是银行的名字。每个签发的账户都会有这个属性,而且一模一样。这和实例变量的初始化并没有什么区别。

1 john_san = Bank_Account()
2 john_san.name = John San
3 
4 wanna_go = Bank_Account() 
5 wanna_go.name = Wanna Go
6 
7 print(john_san.bank_name)
8 print(wanna_go.bank_name)

返回结果:

Bank of XXX
Bank of XXX

现在银行突然改名字了,我们看一下结果:

1 Bank_Account.bank_name = Bank of OOO # 注意,这里是设定类,而不是某个实例
2 
3 print(john_san.bank_name)
4 print(wanna_go.bank_name)

返回结果:

Bank of OOO
Bank of OOO

这就相当省心了,我们无需一个一个实例地去改,直接改类变量的值就行了。我们也可以试试修改实例变量,例如:

1 Bank_Account.nickname = Leese

你会发现什么都没有发生……

当然,还要注意的是,如果某个实例已经改过类变量了,那么同意更改类变量的时候,这个实例上就不会发生任何事情。比如李四这厮把自己账户的银行名称私自改成李四666:

 1 john_san = Bank_Account()
 2 john_san.name = John San
 3 
 4 wanna_go = Bank_Account() 
 5 wanna_go.name = Wanna Go
 6 
 7 leese = Bank_Account() 
 8 leese.name = Leese
 9 leese.bank_name = Leese 666
10 
11 print(john_san.bank_name)
12 print(wanna_go.bank_name)
13 print(leese.bank_name)

返回结果:

Bank of XXX
Bank of XXX
Leese 666

现在银行改名字了:

1 Bank_Account.bank_name = Bank of OOO 
2 
3 print(john_san.bank_name)
4 print(wanna_go.bank_name)
5 print(leese.bank_name) # 神马都没发生

返回结果:

Bank of OOO
Bank of OOO
Leese 666

你看,李四账户的银行名称并没有发生变化,李四真的6。

 

P7 setattr与getattr

这一段可能说起来就没那么通俗了,正常情况下,我们在类内可以用赋值语句直接指定变量的值,可以方便的更改和查看变量。那么如果现在我有一个循环,生成了12个变量需要储存,要怎么办呢?我一个个手写?如果是2000个变量呢?那岂不是手写到天明……

我们可能会想到用循环,那么怎么在类内循环调用不同名字的变量呢?eval()是行不通的,我们需要使用setattr和getattr(attr就是attribute的意思)。

举个例子,在下面这个类中,我们初始化了12个实例变量,代表12个月,它们的名字是mon_1, mon_2, ... , mon_12,我们将它们的值对应设成1~12。

1 class Months:
2     def __init__(self):
3         for i in range(12):
4             setattr(self, mon_%i%(i+1), i+1)
5             
6     def print_months(self):
7         for i in range(12):
8             print(getattr(self, mon_%i%(i+1)))

我们试试:

1 mm = Months()
2 mm.print_months()

返回结果:

1
2
3
4
5
6
7
8
9
10
11
12

这样我们就能通过循环和%占位符生成、修改与查看多个变量了。我们通过setattr来修改这些变量,而用getattr来查看这些变量。其中setattr有3个参数,第一个一般就是self,表示实例本身,第二个是个字符串,代表变量的名字,第三个代表设定的值。举例来说:

1 setattr(self, new_1, 3)

其实等价于:

1 self.new_1 = 3

而getattr有2个参数,第一个一般就是self,表示实例本身,第二个是个字符串,代表变量的名字。

1 getattr(self, new_1)

其实等价于:

1 self.new_1

实际应用过程中,我们可能在k折中训练了k个模型,我们想暂时保存起来,之后预测的时候再调用。我们可以通过循环和setattr来将模型保存在实例变量中,然后在需要的时候通过getattr来调用这些模型。

 

以上就差不多是Python类的入门内容了,实际我也暂时只接触了这么多,继承之类的还暂时没有遇到,希望这篇说的还算容易理解。继续加油,野路子码农~

 

野路子码农系列(2)Python中的类,可能是最通俗的解说

标签:名称   print   pass   现在   set   val   作用   error   erro   

原文地址:https://www.cnblogs.com/silence-gtx/p/10293359.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!