引言
python中的 类 可是非常重要的知识点，非常多的同学 用不好，不会用，更不知道什么时候用。
这篇文章我将告诉你一些类的应用场景，帮助你理解它。
一、全局变量
我们都学过全局变量，它非常好用，可以在整个代码中畅通无阻地使用。
但这里需要明确的是，全局变量如果仅作为获取，是符合 代码友好 的，例如下面：
代码友好
RESULT = 0
def show_result():
print(RESULT)
if __name__ == '__main__':
show_result()全局变量 的书写习惯是用 全部大写 来说明。
但如果我们进行了全局变量的改变，那么我劝你不要这么做，这样做虽然可以，但对你的代码习惯来讲没有好处。
代码不友好
RESULT = 0
def add():
global RESULT
RESULT += 1
if __name__ == '__main__':
add()
print(RESULT)为什么会 代码不友好 ？因为你得写 global 关键字，否则会与 同名局部变量 产生冲突。
RESULT = 0
def add():
RESULT = 0
RESULT += 1
print(RESULT) # 这里输出 1
if __name__ == '__main__':
add()
print(RESULT) # 这里输出 0类的优化代码
当你发现使用的全局变量需要进行改变的时候，你可以立马想到用 类 来实现，来看看代码：
class Calculate:
def __init__(self):
self.result = 0
def add(self):
self.result += 1
if __name__ == '__main__':
c = Calculate()
c.add()
print(c.result)
c.add()
print(c.result)我们将全局变量变成了类的变量，这就是类的使用场景之一。
二、单一功能汇总
现在我们正在开发一个比较常用的工具，你写了比较多的函数，例如下方：
普通代码
def str_to_bytes(string):
pass
def str_to_time(string):
pass
def add(x, y):
pass
def str_to_name(string):
pass我们有很多函数，总结发现有不少函数是关于字符串的，因此我们可以将相应字符串的函数全部结合到一个类中。
类的优化代码
class StrUtil:
def str_to_bytes(self, string):
pass
def str_to_time(self, string):
pass
def str_to_name(self, string):
pass
def add(x, y):
pass
if __name__ == '__main__':
str_util = StrUtil()
str_util.str_to_name('字符串')
str_util.str_to_time('字符串')
str_util.str_to_name('字符串')创建完类，你可能发现调用方式不好用，和函数没啥区别，现在你可以通过继承 str 来迭代你的类：
class StrUtil(str):
def str_to_bytes(self):
pass
def str_to_time(self):
pass
def str_to_name(self):
pass
def add(x, y):
pass
if __name__ == '__main__':
StrUtil('字符串').str_to_bytes()
StrUtil('字符串').str_to_time()
StrUtil('字符串').str_to_name()上面就是我们类的 迭代优化方式，它是从一个基础类慢慢演化，然后变成一个成熟又好用的类。
三、局部变量多次调用
这个情形其实类似全局变量，不过差别在于这次是局部变量，而不是全局变量，例如下面的代码。
代码不友好
def step(x):
return x + 1
def sub(x):
return x - 5
def times(x):
return x * 10
def process():
x = 10
x = step(x)
x = sub(x)
x = times(x)
return x
if __name__ == '__main__':
res = process()
print(res)类的优化代码
class Calculate:
def __init__(self, x):
self.x = x
def step(self):
self.x += 1
def sub(self):
self.x -= 5
def times(self):
self.x *= 10
def process(self):
self.step()
self.sub()
self.times()
if __name__ == '__main__':
c = Calculate(10)
c.process()
print(c.x)四、结尾
我们总结一下，今天文章里面所述的场景：
- 遇到全局变量修改使用类
- 遇到功能可以汇总了，使用类
- 遇到局部变量多次运算，使用类
本篇文章只是一个开始，当你逐步通过上面的场景来归纳类的时候，你慢慢会对类更加熟悉，最终可以随心所欲设计类。