野路子码农系列（2）Python中的类，可能是最通俗的解说

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

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

P1 起因

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

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

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

P2 什么是类

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

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

P3 开始玩类

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

class Bank_Account:
    pass

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

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

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

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

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

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

返回结果

None
0

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

john_san = Bank_Account() # 签发给张三的账户
john_san.name = 'John San'

wanna_go = Bank_Account() # 签发给王二狗的账户
wanna_go.name = 'Wanna Go'

print(john_san.name)
print(wanna_go.name)

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

John San
Wanna Go

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

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

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

john_san = Bank_Account()
john_san.name = 'John San'

john_san.deposit(100) # 只需传入amt参数，张三存了100
print(john_san.balance)

返回结果：

100

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

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

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

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

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

john_san = Bank_Account()
john_san.name = 'John San'

john_san.deposit(100)
john_san.check_balance()

返回结果

100

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

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

class Bank_Account:
    def __init__(self):
        self.name = None # 户主的名字
        self.balance = 0 # 账户余额
        self.nickname = None # 新建一个实例变量用于记录昵称
        
    def deposit(self, amt):
        # self依然代表实例本身，amt代表存入金额
        self.balance = self.balance + amt
    
    def check_balance(self):
        # 这个函数实际调用时不需要任何参数
        print(self.balance)
        
    def set_nickname(self, name):
        # 设定昵称
        self.nickname = name
    
    def get_nickname(self):
        # 显示昵称
        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），啥意思呢？

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

john_san.balance = 2000

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

john_san.deposit(-1000)

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

一个非常简单的方法就是把self.balance变成私有变量（private），怎么变？变量名字前面加两道下划线：

class Bank_Account:
    def __init__(self):
        self.name = None # 户主的名字
        self.__balance = 0 # 账户余额（前面加两道下划线变为私有变量）
        self.nickname = None # 昵称
        
    def deposit(self, amt):
        # self依然代表实例本身，amt代表存入金额
        self.__balance = self.__balance + amt
    
    def check_balance(self):
        # 这个函数实际调用时不需要任何参数
        print(self.__balance)
        
    def set_nickname(self, name):
        # 设定昵称
        self.nickname = name
    
    def get_nickname(self):
        # 显示昵称
        print(self.nickname) # self.nickname在函数set_nickname与get_nickname中传递昵称数据

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

john_san = Bank_Account()
john_san.name = 'John San'

john_san.__balance

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

john_san = Bank_Account()
john_san.name = 'John San'

john_san.deposit(250)
john_san.check_balance()

返回结果：

250

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

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

class Bank_Account:
    def __init__(self):
        self.name = None # 户主的名字
        self.__balance = 0 # 账户余额（前面加两道下划线变为私有变量）
        self.nickname = None # 昵称
        
    def deposit(self, amt):
        # self依然代表实例本身，amt代表存入金额
        self.__balance = self.__balance + amt
        self.bonus() # 每次存款会获得一次奖励
    
    def check_balance(self):
        # 这个函数实际调用时不需要任何参数
        print(self.__balance)
        
    def set_nickname(self, name):
        # 设定昵称
        self.nickname = name
    
    def get_nickname(self):
        # 显示昵称
        print(self.nickname) # self.nickname在函数set_nickname与get_nickname中传递昵称数据
        
    def bonus(self):
        # 奖励账户余额1%的金额
        self.__balance = 1.01 * self.__balance

我们存款试试：

john_san = Bank_Account()
john_san.name = 'John San'

john_san.deposit(250)
john_san.check_balance()

返回结果：

252.5

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

class Bank_Account:
    def __init__(self):
        self.name = None # 户主的名字
        self.__balance = 0 # 账户余额（前面加两道下划线变为私有变量）
        self.nickname = None # 昵称
        
    def deposit(self, amt):
        # self依然代表实例本身，amt代表存入金额
        self.__balance = self.__balance + amt
        self.__bonus() # 类内依然可以调用，但类外就不行了
    
    def check_balance(self):
        # 这个函数实际调用时不需要任何参数
        print(self.__balance)
        
    def set_nickname(self, name):
        # 设定昵称
        self.nickname = name
    
    def get_nickname(self):
        # 显示昵称
        print(self.nickname) # self.nickname在函数set_nickname与get_nickname中传递昵称数据
        
    def __bonus(self):
        # 现在它变成了私有函数
        self.__balance = 1.01 * self.__balance

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

john_san = Bank_Account()
john_san.name = 'John San'

john_san.__bonus()

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

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

P6 类变量

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

class Bank_Account:
    bank_name = 'Bank of XXX' # 类变量，银行的名字
    
    def __init__(self):
        self.name = None # 户主的名字
        self.__balance = 0 # 账户余额（前面加两道下划线变为私有变量）
        self.nickname = None # 昵称

    def deposit(self, amt):
        # self依然代表实例本身，amt代表存入金额
        self.__balance = self.__balance + amt
        self.__bonus() # 类内依然可以调用，但类外就不行了
    
    def check_balance(self):
        # 这个函数实际调用时不需要任何参数
        print(self.__balance)
        
    def set_nickname(self, name):
        # 设定昵称
        self.nickname = name
    
    def get_nickname(self):
        # 显示昵称
        print(self.nickname) # self.nickname在函数set_nickname与get_nickname中传递昵称数据
        
    def __bonus(self):
        # 现在它变成了私有函数
        self.__balance = 1.01 * self.__balance    

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

john_san = Bank_Account()
john_san.name = 'John San'

wanna_go = Bank_Account() 
wanna_go.name = 'Wanna Go'

print(john_san.bank_name)
print(wanna_go.bank_name)

返回结果：

Bank of XXX
Bank of XXX

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

Bank_Account.bank_name = 'Bank of OOO' # 注意，这里是设定类，而不是某个实例

print(john_san.bank_name)
print(wanna_go.bank_name)

返回结果：

Bank of OOO
Bank of OOO

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

Bank_Account.nickname = 'Leese'

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

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

john_san = Bank_Account()
john_san.name = 'John San'

wanna_go = Bank_Account() 
wanna_go.name = 'Wanna Go'

leese = Bank_Account() 
leese.name = 'Leese'
leese.bank_name = 'Leese 666'

print(john_san.bank_name)
print(wanna_go.bank_name)
print(leese.bank_name)

返回结果：

Bank of XXX
Bank of XXX
Leese 666

现在银行改名字了：

Bank_Account.bank_name = 'Bank of OOO' 

print(john_san.bank_name)
print(wanna_go.bank_name)
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。

class Months:
    def __init__(self):
        for i in range(12):
            setattr(self, 'mon_%i'%(i+1), i+1)
            
    def print_months(self):
        for i in range(12):
            print(getattr(self, 'mon_%i'%(i+1)))

我们试试：

mm = Months()
mm.print_months()

返回结果：

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

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

setattr(self, 'new_1', 3)

其实等价于：

self.new_1 = 3

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

getattr(self, 'new_1')

其实等价于：

self.new_1

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

P8 类的优势

假设现在我们有四个客户，张三、李四、王二狗、狗剩，他们各开设一个银行账户，账户能记录他们的名字和账户余额，账户有存钱和查询两个功能。

如果我们采用传统的方法，我们需要定义2×4共8个变量，每个人用一个变量代表名字，一个变量代表余额。我们还需要一个函数，用来实现存钱。

我们给这4个人进行开卡、存入一些钱，然后查账：

name_1 = 'John San'
name_2 = 'Leese'
name_3 = 'Wanna Go'
name_4 = 'Go Some'

balance_1 = 0
balance_2 = 0
balance_3 = 0
balance_4 = 0

def deposit(balance, amt):
    # 存钱函数
    return balance + amt

balance_1 = deposit(balance_1, 100) # 存钱
balance_2 = deposit(balance_2, 200)
balance_3 = deposit(balance_3, 50)
balance_4 = deposit(balance_4, 300)

print(balance_1) # 查账
print(balance_2)
print(balance_3)
print(balance_4)

如果人数不是4个而是40个乃至400个就很容易混淆，户主名字与账户余额不是绑定的，一不小心可能搞错了户主和账户间的对应关系。此外账户余额这类信息想改就改，完全没有安全性可言。

我们来看看利用类来实现的写法：

class Bank_Account:
    def __init__(self):
        self.name = None # 户主的名字
        self.__balance = 0 # 账户余额（

    def deposit(self, amt):
        # 存钱
        self.__balance = self.__balance + amt
    
    def check_balance(self):
        # 查账
        print(self.__balance)
        
john_san = Bank_Account()
john_san.name = 'John San'
john_san.deposit(100)

leese = Bank_Account()
leese.name = 'Leese'
leese.deposit(200)

wanna_go = Bank_Account()
wanna_go.name = 'Wanna Go'
wanna_go.deposit(50)

go_some = Bank_Account()
go_some.name = 'Go Some'
go_some.deposit(300)

john_san.check_balance()
leese.check_balance()
wanna_go.check_balance()
go_some.check_balance()

无论我们开了多少个实例，每个实例的户主名字与账户余额都是绑定的，不会弄错，此外还可以通过私有化达到一定的安全性。

所以不同的情况下，大家可以根据自己的需求选择不同的实现方法。

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