python3 - 面对对象-类与对象

'''
面向过程的编程思想：
    针对过程，即解决问题的步骤，是机械式的思维方式
    优点：
        复杂的问题流程化，进而简单化。
    缺点：
        牵一发而动全身，可扩展性差
    应用： 一旦完成基本很少更改的场景，例：linux内核

面向对象的编程思想：
    针对对象，即对象是特征与技能的结合体，更注重对显示世界的模拟
    优点：
        程序的扩展性强。修改某一对象，立刻反应在整个体系中
    缺点：
        1.编程的复杂度高于面向过程。
        2.无法和面向过程设计一样精准的预测问题的处理流程和结果。
    应用：需求经常变化的软件，一般需求的变化集中在用户层，互联网应用，企业内部软件，游戏等
'''

'''
对象：
    特征与技能的结合体，在程序中，特征用变量表示，技能用函数表示
类：
    类别，种类，一系列对象相似的特征和技能的结合体
    类体中科院存在任意python代码
    且类体代码会在类定义阶段立即执行，同时产生一个类名称空间，放入类体中产生的名字：
        __dict__查看类内部名称对应空间
    
    访问类内名字方式：类名.名字
类总结： 1.类的本质就是一个名称空间，用来存放变量和函数
        2.类的用途之一：是当做名称空间从其内部取出名字使用
        3.类的用途之二：是调用类来产生对象
        
注意：程序中，先有类再有对象即，先定义类再调用类产生对象

'''
'''
在python3中统一了类与类型的概念，即 一切皆是对象
（在python旧版本中，内置对象基于类型，自定义对象基于类，所以可以创建类但不能创建类型）

#类型dict就是类dict
>>> list
<class 'list'>

#实例化的到3个对象l1,l2,l3
>>> l1=list()
>>> l2=list()
>>> l3=list()

#三个对象都有绑定方法append,是相同的功能,但内存地址不同
>>> l1.append
<built-in method append of list object at 0x10b482b48>
>>> l2.append
<built-in method append of list object at 0x10b482b88>
>>> l3.append
<built-in method append of list object at 0x10b482bc8>

#操作绑定方法l1.append(3),就是在往l1添加3,绝对不会将3添加到l2或l3
>>> l1.append(3)
>>> l1
[3]
>>> l2
[]
>>> l3
[]
#调用类list.append(l3,111)等同于l3.append(111)
>>> list.append(l3,111) #l3.append(111)
>>> l3
[111]
'''


# ----------------------

# 类的创建
class Student:
    # 相同特征
    school = 'college'

    # 相同的技能
    def info(self, name1, age1, sex1):
        self.name = name1
        self.age = age1
        self.sex = sex1

    def choose_course(self):
        print('choose course')

    # print('student')


class Student2:
    # 相同特征,
    school = 'college'

    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, name1, age1, sex1):
        self.name = name1
        self.age = age1
        self.sex = sex1

    # 相同的技能
    def choose_course(self):
        print('choose course')

    # print('student2')


# print(Student.__dict__)
# print(Student.__dict__['school'])  # 不推荐
# print(Student.school)
#
# Student.school = 'university'  # 修改属性
# print(Student.school)
#
# Student.country = 'china'  # 增加属性
# print(Student.country)
#
# del Student.country  # 删除属性
# print(Student.country)
# ---------------------------------------------
'''
# 类的专有方法：
    __init__: 构造函数，在生成对象时调用
    __del__: 析构函数，释放对象时使用
    __repr__: 打印，转换
    __setitem__: 按照索引赋值
    __getitem__: 按照索引获取值
    __len__: 获得长度
    __cmp__: 比较运算
    __call__: 函数调用
    __add__: 加运算
    __sub__: 减运算
    __mul__: 乘运算
    __div__: 除运算
    __mod__: 求余运算
    __pow__: 乘方
'''
# -----------------------------------------------
# 调用类产生对象

# 调用类的过程称之为类的实例化，调用类的返回值称之为类的对象（实例）
# 实例化过程：
#     1.产生空对象并返回
#     2.执行__init__方法，将对象连通调用类括号内指定参数一同传入

# __init__功能：在对象创建时，为其初始化所需的特征。注：不能有返回值

# stu1 = Student()
# stu2 = Student()
# print(stu1, stu2)
# print(stu1.__dict__, stu2.__dict__)  # 创建对象私有属性命名空间，初始为{}

# 注意：可以通过 对象.类属性名 的方式修改原定值，但是不推荐修改类中属性
# stu1.school = 'university'
# print(stu1.school, stu2.school)

# 添加对象的内置属性

# 方法1 直接赋值 增加参数
# stu1.name, stu1.age, stu1.sex = 'name1', 18, 'male'
# print(stu1.__dict__)

# 方法2 在类中定义函数，调用类内函数进行赋值
# stu1.info('name1', 18, 'male')
# print(stu1.__dict__)

# 方法3 使用__init__在创建实例自动调用的特征，进行自动赋值
# stu3 = Student2('name3', 38, 'female')
# print(stu3.__dict__)
# ------------------------------------------
# 访问对象的属性和行为
# 对象.名字 的查找顺序：
#   1.从自己的名称空间找 （对象名.__dict__）
#   2.类的名称空间找 （对象所属类名.__dict__）

x = '全局中的变量x'


class Student3:
    # 相同特征,
    school = 'college'
    y = '类中的变量y'
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    c = 0

    # 定义构造方法
    def __init__(self, name1, age1, sex1, z):
        print('访问全局中变量：', x)
        print('访问类中的公有属性（不可修改类中的值）：', self.y)
        print('访问类中的公有属性2 count记录被调用次数 0开始(可修改类中的值)：', Student3.c)
        print('访问对象中的变量：', z)
        Student3.c += 1
        self.name = name1
        self.age = age1
        self.sex = sex1

    # 相同的技能
    def choose_course(self):
        print('choose course')


# stu4 = Student3('name4', 48, 'female', 'zzzzzz')

# 类中的属性默认对外公开和使用
# 对象.公有属性 = 新的属性值 ---》 将键值对加入对象的私有__dict__中，并不改变类中公有属性值
# 类.公有属性 = 新的属性值 ---》 将原公有属性的值进行修改，所有引用的对象等都会更改

# 在__init__中获取类中公有属性的值并进行更改
# 实现调用增加次数，并保存到公有属性
# s1 = Student3(1,1,1,1)
# s2 = Student3(2,2,2,2)
# s3 = Student3(3,3,3,3)

# ---------------------------------------------
# 类中的普通函数
#   类中的普通函数，绑定给对象使用，自己使用： 类.类内函数名（），对象使用： 对象名.类内函数名（）

# 注意：类中的普通函数是对象的绑定函数
#       绑定函数：指向类的函数，绑定对象自动传值，不需要在进行传参操作
class Student4:
    # 相同特征,
    school = 'college'
    y = 123

    # 定义构造方法
    def __init__(self, name1, age1, sex1):
        self.name = name1
        self.age = age1
        self.sex = sex1

    # 类的普通函数，对象的绑定函数
    def choose_course(self, y):
        print('%s choose course' % self.name, y)


# stu1 = Student4('name1', 18, 'female')
# stu2 = Student4('name2', 18, 'female')
# # 类调用普通函数，需要传参
# Student4.choose_course(stu1, 111)
# # 对象调用绑定函数，对象内属性 self.name 不需要传参
# stu2.choose_course('yyyy')