Python面向对象

**

一.面向对象编程

**
1.官方版：把一组数据结构和处理它们的方法组成对象，把相同行为的对象归纳为类，通过类的封装隐藏内部细节，通过继承实现类的特化和泛化，通过多态实现基于对象类型的动态分派。
2.民间版：所谓编程就是程序员按照计算机的工作方式控制计算机完成各种任务。
程序中的数据和操作数据的函数是一个逻辑上的整体，我们称之为“对象”，而我们解决问题的方式就是创建出需要的对象并向对象发出各种各样的消息，多个对象的协同工作最终可以让我们构造出复杂的系统来解决现实中的问题。

二.类和对象

1.类与对象：类是对象的模板，而对象是类的实例。其中类是抽象的概念，对象是具体的东西。
世间万物皆对象
2.定义类：
（1）关键字：‘class’
例题1：输出“Hello”
代码：

# 1
class class_name(object):
    print('Hello')

if __name__ =="__main__":
    jocker = class_name

# 运行结果：
# Hello

# 2
class class_name(object):
    def __init__(self):
        self.a = 1000
    
    def A(self):
        print(self.a) # self提供了管道
        print('shy aju koi')

if __name__ =="__main__":
    jocker = class_name()  # ()就相当于走了初始化__init__函数
    jocker.A()  # 在类中调用需要使用 "."

# 运行结果：
# 1000
# shy aju koi

注意：
（1）__init__是一个特殊方法用于在创建对象时进行初始化操作。
（2）真正的类需要重写init函数。

例题2.进度条
代码：

# 1：下载进度100%
import time
class Jocker(object):
    def __init__(self):
        pass
    def jindutiao(self):
        for i in range(1,101):
            time.sleep(0.5)
            print('#'*(i),'%d %%'%i)

if __name__ =="__main__":
    Jocker = Jocker()
    Jocker.jindutiao()

# 2：20个#，下载进度还是100%
import time
class Jocker(object):
    def __init__(self):
        self.count = 1
    def jindutiao(self):
        for i in range(0,100):
            time.sleep(0.1)
            if i % 5 ==0:
                res = '#'*self.count
                print('%s %d%%'%(res,(i+5)))
                self.count += 1

if __name__ =="__main__":
    Jocker = Jocker()
    Jocker.jindutiao()

注意：
写在类中的函数，被称之为方法，这些方法就是对象可以接受的消息。

3**.类传参**：
代码：

class Jocker(object):
    def __init__(self,num):
        self.a = num
        print(self.a)

if __name__ =="__main__":
    Jocker =Jocker(10)

# 运行结果：
# 10

4.创建和使用对象
在定义一个类之后，就可以创建对象并给对象发消息。
代码：

def main():
    # 创建学生对象并指定姓名和年龄
    stu1 = Student('骆昊', 38)
    # 给对象发study消息
    stu1.study('Python程序设计')
    # 给对象发watch_av消息
    stu1.watch_av()
    stu2 = Student('王大锤', 15)
    stu2.study('思想品德')
    stu2.watch_av()


if __name__ == '__main__':
    main()

三.访问可见性

对象的属性为私有的或受保护的（不允许外界访问）
对象的方法通常都是公开的。
如果希望属性是私有的，在给属性命名时可以用两个		   下划线作为开头。
如果想访问属性可以通过属性的getter（访问器）和setter（修改器）方法进行对应的操作。

1.公有变量外部可调用
代码：

class class_name:
    def __init__(self):
        self.a = 1000

    def A(self):
        print(self.a)

if __name__=="__main__":
    name = class_name()
    name.A()
    print(name.a)

# 运行结果：
# 1000
# 1000

2.私有变量仅内部可调
代码：

class class_name:
    def __init__(self):
        self.__a = 1000

    def A(self):
        print(self.__a)

if __name__=="__main__":
    name = class_name()
    name.A()
    print(name.a)

# 运行结果：
# AttributeError: 'class_name' object has no attribute 'a'

3.私有函数内部可调
代码：

class class_name:
    def __init__(self):
        self.__a = 1000

    def A(self):
        print(self.a)
        print(self.__B())
    def __B(self):
        print('Hello B')

if __name__=="__main__":
    name = class_name()
    name.A()

# 运行结果：
# AttributeError: 'class_name' object has no attribute 'a'

4.外部调用私有变量
5.面向对象的支柱：封装、继承和多态
封装：隐藏一切可以隐藏的实现细节，只向外界暴露（提供）简单的编程接口。

四.面向对象进阶

1.@property装饰器
代码：

class Person(object):

    def __init__(self, name, age):
        self._name = name
        self._age = age

    @property  #  访问器 - getter方法
    def name(self):
        return self._name

    @property
    def age(self):
        return self._age

    @age.setter  #  修改器 - setter方法
    def age(self, age):
        self._age = age

    def play(self):
        if self._age <= 16:
            print('%s正在玩飞行棋.' % self._name)
        else:
            print('%s正在玩斗地主.' % self._name)

	def main():
	    person = Person('王大锤', 12)
	    person.play()
	    person.age = 22
	    person.play()
	    	
if __name__ == '__main__':
	    main()

# 运行结果：
# 王大锤正在玩飞行棋.
# 王大锤正在玩斗地主

2.练习：
代码：

class A(object):
    def __init__(self):
        self.a = 1000

    def A1(self):
        print('A1')

class B(A):
    def __init__(self):
        A.__init__(self)

    def B1(self):
        print(self.a)
        self.A1()

if __name__ == "__main__":
    b = B()
    b.B1()

# 运行代码：
# 1000
# A1

3.__slots__魔法
限定自定义类型的对象，只对当前类的对象生效，对子类并不起任何作用
代码：

class Joker:
    __slots__ = ('uuu','hhh')
    def __init__(self):
        pass

if __name__ == "__main__":
    joker = Joker()
    joker.uuu = 200000
    print(joker.uuu)

# 运行结果：
# 200000

4.静态方法和类方法
代码：

class Jocker(object):
    
    def __init__(self):
        self.a = 1000
    def A(self):
        print(self.a)

if __name__ == "__main__":
    jocker = Jocker()
    jocker.A()

# 运行结果：
# 1000

方法的第一个参数约定名为cls，它代表的是当前类相关的信息的对象，通过这个参数我们获取和类相关的信息并且可以创建出类的对象