面向对象

'''
1.面向过程与面向对象
    过程：程序流程化，可拓展性差
    对象：程序流程多样化，可拓展性强
    变量|函数=》属性|方法
    区别：前者可以直接使用
    后者：通过所属者的点语法调用
2.拥有名称空间的对象：有__dict__属性，该属性就是指向对象的名称空间
    --文件|包（__init__.py文件）|函数|类
    --可以为__dict__属性添加值，简化为.语法，也可以对__dict__整体赋值一个字典
3.类与对象
    --类是抽象的，不是真是存在的：具有相同特征和技能个体的集合人的抽象
    --对象巨象的，是真实存在的：具有特征和行为的实际个体（类的实际体现，实例化）
4.类与对象的语法
class 类名：
    代码块（一堆属性和方法）
对象名=类名（）
类会随着所属文件的加载而加载（执行内部所有的代码），形成类的名称空间
1.每一个实例化出来的对象及类都有自己的名称空间
2.类与对象都可以通过点语法来拓展新功能
3.提前在类中的属性与方法，在对象一产生就可以使用这些属性和方法
4.对象查找属性的顺序：先找自身的，如果没有就找类的（只有访问权限，没有修改权限）

'''
# #对象独有的名称空间
# class Student:
#     def __init__(self,name,sex):
#         self.name=name
#         self.sex=sex #通常建议参数名和新增的属性同名
#
# stu=Student('sybil','male')#实例化对象
# print(stu.name)
# print(stu.sex)
#
# '''
# __init__方法会在实例化对象时被调用
# 1.会为实例化的对象形成空的名称空间
# 2.就是第一个方法，可以被传参，在类名（实参）这种方式下调用并传参__init__(self,形参)
# 重点：在方法内部，形参拿到了实参值，利用self.属性名=形参=实参，给对象的名称空间添加属性
# '''
# #类中方法的第一个默认参数：对象方法
# class A:
#     #对象方法
#     def tesr(self,num):
#         print('dsfsd')
# a=A()
# # 调用方法
# a.tesr(10)
# #一级优化
# A.tesr(a,10)
# #实现原理
# A.__dict__['tesr'](a,10)
#
# #总结：对象a传递给self，数字10传递给num
# #重点：方法的第一个参数一定是调用该方法的对象
#
# #类中@classmethod修饰的方法：类方法
#
# class Tool:
#     @classmethod
#     def add(cls,n1,n2):
#         return n1+n2
# #不建议
# tool=Tool()
# tool.add(100,200)#默认第一个传入自己的自身所属类-tool.__class__
# #建议
# Tool.add(10,20)#默认传入的第一个参数是类自己-Tool
#
# #属性与方法的总结
# class Oldboy:
#     #属于类的属性
#     name='老男孩'
#     #属于对象的属性
#     def __init__(self,name):
#         self.name=name
#
#     #属于对象的方法
#     #需求：获取校区的名字
#     def get_school_name(self):
#         return self.name
#
# #先创建校区
# shanghai=Oldboy('上海校区')
# shenzheng=Oldboy('深圳校区')
# #类要调用对象的方法，必须手动把要操作的对象手动输入，不建议使用
# print(Oldboy.get_school_name(shenzheng))
# #对象使用对象的方法，直接调用，建议使用
# print(shanghai.get_school_name())
# print(shenzheng.get_school_name())

#封装：对外隐藏类中的一些属性和方法的实现细节
#优点：外界不可以直接访问，让内部的属性与方法具有安全保障

#封装：对外隐藏类中一些属性与方法的实现细节
#优点：外界不能直接访问，让内部的属性与方法具有安全保障
class A:

    #类的属性：_开头的属性，在外界不能通过cord|_get_money直接访问：

#对外隐藏了     注意是一个_

    # cord='01012300'
# print(A.cord)#01012300
#     _cord='01012300'
# print(A.cord)#type object 'A' has no attribute 'cord'


    #类的方法：_开头的方法，在外界不能通过get_money|_get_money来访问

    #对外隐藏了

    # @classmethod
    # def get_money(cls):
    #     print('输入密码，取出100块零花钱')
# A.get_money()#输入密码，取出100块零花钱
#     @classmethod
#     def _get_money(cls):
#         print('取出100块零花钱')
#这个时候发现.不出来get_money了，就是隐藏了

    #对象的方法：一般的实现需求都是，这些方法只在内部使用
#     def test(self):
#         print('钱多多')
# a=A()
# a.test()
#     def _test(self):
#         print('钱多多')
# a=A()
#这个时候a.不出来test，说明被隐藏
    #对象的属性：封装目的
    #对象的属性值一般都来源于外界，外界有权利再次访问的
    #封装的目的不是让外界无法访问，而是不让其直接访问，但是可以在完成安全处理后再访问
    #如何做到外界还是通过变量名来对属性进行取值赋值，但是走的方法间接拿到的值
    #_money被封装，但是外界还是可以通过对象.money进行取值赋值操作
    def __init__(self,money):
        self.money=money#对象的方法
        #取值
        # @property #在外界可以对 对象.money进行取值
        @property
        def money(self):
            print('走的方法拿的值')
            return self.money

a=A(100)
print(a.money(100))