Python 基础 Day04

面向对象

把一组数据结构和处理它们的方法组成对象（object），把相同行为的对象归纳为类（class），通过类的封装（encapsulation）隐藏内部细节，通过继承（inheritance）实现类的特化（specialization）和泛化（generalization），通过多态（polymorphism）实现基于对象类型的动态分派。

类和对象

简单的说，类是对象的蓝图和模板，而对象是类的实例。类是抽象的概念，而对象是具体的东西。在面向对象编程的世界中，一切皆为对象，对象都有属性和行为，每个对象都是独一无二的，而且对象一定属于某个类（型）。当我们把一大堆拥有共同特征的对象的静态特征（属性）和动态特征（行为）都抽取出来后，就可以定义出一个叫做“类”的东西。

定义类

__init__是一个特殊方法用于在创建对象时进行初始化操作

class name(object):
    def __init__(self):
        self.a = 100
    def A(self):
        print(self.a)
if __name__ == "__main__":
    LYT = name()
    LYT.A()

说明：写在类中的函数，我们通常称之为（对象的）方法，这些方法就是对象可以接收的消息。

访问可见性问题

1. 属性和方法的访问权限只有两种，也就是公开的和私有的。
2. 私有变量,变量名前面加"__"
3. 如果非要使用私有变量,那么可以使用dir(class())去查看它真正的名字.
4. 私有变量/函数,在类内部可以直接调用.
5. 如果你想体现一个变量/函数特别重要你可以使用"_"

练习

#进度条:非常重要，一定要会哦
import time
class LYT(object):
    def __init__(self):
        self.count = 1
    def jidutiao(self):
        for i in range (0,100):
            time.sleep(0.1)
            print('%d%%\r'%(i+1),end="",flush=True)
            if i % 5 == 0:
                res = '#' *self.count
                print('%s %d%%'%(res,(i+5)),end="",flush=True)
                self.count += 1
                print()


if __name__ == "__main__":
    LYT = LYT()
    LYT.jidutiao() 
结果显示：
# 5%
## 10%
### 15%
#### 20%
##### 25%
###### 30%
####### 35%
######## 40%
######### 45%
########## 50%
########### 55%
############ 60%
############# 65%
############## 70%
############### 75%
################ 80%
################# 85%
################## 90%
################### 95%
#################### 100%

注：1. init 的功能：作用于当你需要公共变量的时候、初始化。
2. 类中打印变量：print(self.count)。
3. 类中调用函数：self.函数名。
4. 若要变成公有的加self印记
5. LYT = LYT() ()相当于类的初始化。
6. 若想在外部调用self.count LYT.count"

class LYT(object):
    def __init__(self,path):
        self.path = path
        self.count = 0
    def read(self):
        with open(self.path,mode='r') as f:
            lines = f.readlines()
            for line in lines:
                new_line = line.strip('\n')
                for i in new_line:
                    if i.isupper():
                        self.count += 1
        print("the upper word is %d" %self.count)

if __name__ == "__main__":
    path = 'C:/Users/admin/Desktop/test.txt'
    LYT = LYT(path)
    LYT.read()
        
结果显示：
the upper word is 28

面向对象进阶

@property装饰器

使用@property包装器来包装getter和setter方法。

1. 访问器 - getter方法
2. 修改器 - setter方法

__slots__魔法

如果我们需要限定自定义类型的对象只能绑定某些属性，可以通过在类中定义__slots__变量来进行限定。需要注意的是__slots__的限定只对当前类的对象生效，对子类并不起任何作用。

class LYT(object):
    def __init__(self):
        self.a = 100

if __name__ == "__main__":
    lyt = LYT()
    lyt.a = 100000
    print(lyt.a)

    # 类的动态绑定
    lyt.a = 50000
    print(lyt.a)
    
结果显示：
100000
50000

class LYT(object):
    def __init__(self):
        self.__a = 100

    @property
    def a(self):
        return self.__a

if __name__ == "__main__":
    name = LYT()
    print(name.a)
    
结果显示：
100

静态方法和类方法

1. 静态方法和类方法都是通过给类发消息来调用的。
2. 也可以通过给类发消息来调用对象方法但是要传入接收消息的对象作为参数。

class LYT_(object):
    def __init__(self):
        self.a = 10000
    @staticmethod
    def A():
        print('hahahahaha')

if __name__ == "__main__":
    lyt = LYT_ ()
    lyt.A()

结果如下：
hahahahaha