面向对象，类与对象，__nit__方法，属性查找，隐藏属性

* 面向对象程序

一、面向对象的程序理解

面向对象编程 ---核心是对象二字，对象就一个用来盛放数据与功能的容器，基于该思想编写程序就创造一个个的容器

优点: 扩展性强

缺点: 编程的复杂度提升

应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方

二、类与对象

类即类别、种类，是面向对象设计最重要的概念，对象是特征与技能的结合体，而类则是一系列对象相似的特征与技能的结合体

在现实世界中：先有对象，再有类

在程序中：务必保证先定义类，后产生对象

定义类发生的事： 1、立刻运行类体代码 2、将运行过程中产生的名字都丢到类的名称空间中

调用类发生的事情： 1、创造一个对象的字典，用来存放对象独有的数据 2、将对象与类建立好关联

#在程序中，务必保证：先定义（类），后使用（产生对象）
PS:
  1. 在程序中特征用变量标识，技能用函数标识
  2. 因而类中最常见的无非是：变量和函数的定义

#程序中的类
class OldboyStudent:
    school='oldboy'
    def learn(self):
        print('is learning')
        
    def eat(self):
        print('is eating')
    
    def sleep(self):
        print('is sleeping')
  

#注意：
  1.类中可以有任意python代码，这些代码在类定义阶段便会执行
  2.因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过OldboyStudent.__dict__查看
  3.对于经典类来说我们可以通过该字典操作类名称空间的名字（新式类有限制），但python为我们提供专门的.语法
  4.点是访问属性的语法，类中定义的名字，都是类的属性

#程序中类的用法
.:专门用来访问属性，本质操作的就是__dict__
OldboyStudent.school #等于经典类的操作OldboyStudent.__dict__['school']
OldboyStudent.school='Oldboy' #等于经典类的操作OldboyStudent.__dict__['school']='Oldboy'
OldboyStudent.x=1 #等于经典类的操作OldboyStudent.__dict__['x']=1
del OldboyStudent.x #等于经典类的操作OldboyStudent.__dict__.pop('x')

#程序中的对象
#调用类，或称为实例化，得到对象
s1=OldboyStudent()
s2=OldboyStudent()
s3=OldboyStudent()

#如此，s1、s2、s3都一样了，而这三者除了相似的属性之外还各种不同的属性，这就用到了__init__
#注意：该方法是在对象产生之后才会执行，只用来为对象进行初始化操作，可以有任意代码，但一定不能有返回值
class OldboyStudent:
    ......
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    ......

s1=OldboyStudent('李坦克','男',18) #先调用类产生空对象s1，然后调用OldboyStudent.__init__(s1,'李坦克','男',18)
s2=OldboyStudent('王大炮','女',38)
s3=OldboyStudent('牛榴弹','男',78)

#程序中对象的用法
#执行__init__,s1.name='牛榴弹'，很明显也会产生对象的名称空间
s2.__dict__
{'name': '王大炮', 'age': '女', 'sex': 38}

s2.name #s2.__dict__['name']
s2.name='王三炮' #s2.__dict__['name']='王三炮'
s2.course='python' #s2.__dict__['course']='python'
del s2.course #s2.__dict__.pop('course')

在程序中：先定义类，后产生对象

三、____init__方法

调用类的过程

1、先创造一个空对象

2、自动触发类内的__init__函数的运行，将空对象当做第一个参数自动传入

3、返回一个初始化好的对象给obj1

 __init__方法
# 强调：
#   1、该方法内可以有任意的python代码
#   2、一定不能有返回值
class People:
    country='China'
    x=1

    def __init__(obj, name, age, sex): #obj=obj1,x='egon',y=18,z='male'
        # if type(name) is not str:
        #     raise TypeError('名字必须是字符串类型')
        obj.name = name
        obj.age = age
        obj.sex = sex

    def run(self):
        print('----->', self)

# obj1=People('egon',18,'male')
obj1=People(3537,18,'male')

# print(obj1.run)
# obj1.run() #People.run(obj1)
# print(People.run)

四、属性查找

类有两种属性：数据属性和函数属性

1. 类的数据属性是所有对象共享的

2. 类的函数属性是绑定给对象用的

   class Student:
       school = "上海校区"
       #            空对象, "egon", 18, "male"
       def __init__(self, x, y, z):
           self.name = x  # 空对象.name = "egon"
           self.age = y   # 空对象.age = 18
           self.gender = z  # 空对象.gender = "male"
   
       def tell_info(self):
           print('my name is %s my age is %s my gender is %s' % (self.name, self.age, self.gender))
   
   
       def func(self):
           pass
   
   obj1 = Student("egon",18,"male")
   obj2 = Student("tom",19,"female")
   

对象.属性的查找顺序: 先从对象的字典里找，再从类的字典里找

print(obj1.name)  # obj1.__dict__["name"]
print(obj1.school)
print(obj1.tell_info)

类.属性：从类自己的字典里找

print(Student.school)
print(Student.__init__)
print(Student.tell_info)

类中的数据属性是直接共享给所有对象用的

tudent.school = 'XXXXX'
obj1.school = 'YYYYY'
print(Student.school,id(Student.school))
print(obj1.school,id(Student.school))
print(obj2.school,id(Student.school))

类中的函数类可以可用，如果类来调用就是一个普通函数，该怎么传参就怎么传但其实类中的函数是给对象用，对象来调用就是一个绑定方法，绑定方法的特点是会将调用当做第一个参数自动传入

print(Student.tell_info)
Student.tell_info(obj1)
Student.tell_info(obj2)

print(obj1.tell_info)
obj1.tell_info()
obj2.tell_info()

Student.func()
obj1.func()

五、隐藏属性

class People:
    __country = "China"  # _People__country = "china"

    def __init__(self,name,age):
        self.__name = name  # self._People__name = name
        self.__age = age

    def __func(self):  # _People__func
        print('xx')

    def tell_name(self):
        print(self.__name)  # self._People__name

print(People._People__country)
print(People._People__func)

print(People.__dict__)
obj1 = People("egon",18)
print(obj1.__dict__)

--开头的属性的特点：

1、并没有真的藏起来，只是变形的

2、该变形只在类定义阶段、扫描语法的时候执行，此后__开头的属性都不会变形

3、该隐藏对外不对内

obj1.__gender = "male"
print(obj1.__dict__)
print(obj1.__gender )

obj1.tell_name()

为何要隐藏属性

1、隐藏数据属性为了严格控制类外部访问者对属性的操作

2、隐藏函数属性为了隔离复杂度

class People:

    def __init__(self,name,age):
        self.__name = name  # self._People__name = name
        self.__age = age

    def tell_info(self):
        print("<%s:%s>" %(self.__name,self.__age))

    def set_info(self,name,age):
        if type(name) is not str:
            print("名字必须是字符串")
            return
        if type(age) is not int:
            print("年龄必须是数字")
            return
        self.__name = name
        self.__age = age

obj1 = People("egon",18)

obj1.tell_info()
obj1.set_info("tom",28)
obj1.tell_info()

obj1.set_info(123123123123,28)
obj1.tell_info()