[面向对象：类与对象、属性查找、一切皆对象]

• 面向对象编程

  核心是对象二字，对象就是盛放相关数据与功能的容器，也可以说是把数据与功能整合到一起的产物

  基于该思想编写程序就是在创造一个个的容器

  优点：扩展性强（）

  缺点：编程的复杂度提升

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

  面向对象的程序设计并不是全部。对于一个软件质量来说，面向对象的程序设计只是用来解决扩展性

  # 一个学生的数据信息：name，age，gender
  name = ‘geng‘
  age = 18
  gender= ‘male‘
  
  
  # tell_info 功能
  def tell_info():
      print(‘my name is %s my age is %s my gender is %s‘ %(name,age,gender))
  
  tell_info()
  # my name is geng my age is 18 my gender is male
  
  # 此时若想执行查看个人信息的功能，需要同时拿来两样东西，一类是功能，另外一类则是数据，然后才能执行，非常麻烦
      
         
  # 把数据和功能整合放到一个容器中，在增加多个学生信息    
  def tell_info(student):
      print(‘my name is %s my age is %s my gender is %s‘ %(student["name"],student["age"],student["gender"]))
      
  student = {
      "school":"上海校区",      
      "name":"geng",
      "age":18,
      "gender":"male",
      "tell_info":tell_info
  }
  
  student["tell_info"](student)
  
  
  student1 = {
      "school":"上海校区",
      "name":"yang",
      "age":19,
      "gender":"female",
      "tell_info":tell_info
  }
  
  student1["tell_info"](student1)
  
  
  # 可以看出两个容器有相同的地方，只有是同一类才能总结出相似的东西
  
  

--------------------------------------------------------------------------------------------------------------------------------------------------------

• 类与对象

  • 类即类别、种类，是面向对象设计最重要的概念，对象是数据与功能的容器，而类则是一系列对象相似的数据与功能的容器

    那么问题来了，先有的一个个具体存在的对象（比如一个具体存在的人），还是先有的人类这个概念，这个问题需要分两种情况去看

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

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

    这与函数的使用是类似的，先定义函数，后调用函数，类也是一样的，在程序中需要先定义类，后调用类

    不一样的是，调用函数会执行函数体代码返回的是函数体执行的结果，而调用类会产生对象，返回的是对象

  • 定义类发生的事

    1、会立刻运行类体代码

    2、将运行过程中产生的名字都丢到类的名称空间中

    class Student:  # 类的命名应该使用“驼峰体”
        school = "上海校区"  # 数据
    
        def tell_info(student): # 功能
            print(‘my name is %s my age is %s my gender is %s‘ % (student["name"], student["age"], student["gender"]))
    
    # 类体最常见的是变量的定义和函数的定义，但其实类体可以包含任意Python代码，类体的代码在类定义阶段就会执行，
    # 因而会产生新的名称空间用来存放类中定义的名字，可以打印Student.__dict__来查看类这个容器内盛放的东西
    
    # print(Student.__dict__)
    
    

  • 调用类发生的事情

    1、创造一个对象的字典，用来存放对象独有的数据

    2、将对象与类建立好关联

    class Student:
        school = "上海校区"  # 共有数据
    
    obj1 = Student()  # 每实例化一次Student类就得到一个学生对象
    obj2 = Student()
     #该方法会在对象产生之后自动执行，专门为对象进行初始化操作，可以有任意代码，但一定不能返回非None的值
    def init(self,x,y,z):
        self.name = x
        self.age = y
        self.gender = z
    
    init(obj1,"geng",18,"male")  # 重新实例学生
    init(obj2,"yang",19,"female")
    
    # 至此，我们造出了两个对象与一个类，对象存放各自独有的数据，类中存放对象们共有的内容
    
    print(obj1.__dict__)
    # {‘name‘: ‘geng‘, ‘age‘: 18, ‘gender‘: ‘male‘}
    
    print(obj2.__dict__)
    # {‘name‘: ‘yang‘, ‘age‘: 19, ‘gender‘: ‘female‘}
    
    print(Student.__dict__)
    # {‘__module__‘: ‘__main__‘, ‘school‘: ‘上海校区‘, ‘__dict__‘: <attribute ‘__di
    
    

    • 调用类的过程

      1、先创造一个空对象

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

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

    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(student):
            print(‘my name is %s my age is %s my gender is %s‘ % (student["name"], student["age"], student["gender"]))
    
    
    obj1 = Student("egon",18,"male")  # Student.__init__(空对象,"egon",18,"male")
    obj2 = Student("tom",19,"female")
    
    
    print(obj1.__dict__)
    print(obj2.__dict__)
    print(Student.__dict__)
    
    
    

-------------------------------------------------------------------------------------------------------------------------------------------

• 属性查找

对象的名称空间里只存放着对象独有的属性，而对象们相似的属性是存放于类中的。对象在访问属性时，会优先从对象本身的__dict__中查找，未找到，则去类的__dict__中查找

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)

obj1.school = "XXX"
print(obj1.school)  # xxx 说明优先从对象字典里找


# 类.属性：从类自己的字典里找（类中属性之所以可以自己调，其实是因为类的属性是为对象准备的）
print(Student.school)
print(Student.__init__)
print(Student.tell_info)

# 类中的数据属性是直接共享给所有对象用的，指向相同的内存地址
Student.school = ‘XXXXX‘
obj1.school = ‘YYYYY‘
print(Student.school,id(Student.school)) # 上海校区 1994529963920
print(obj1.school,id(Student.school))    # 上海校区 1994529963920
print(obj2.school,id(Student.school))    # 上海校区 1994529963920


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

• 一切皆对象（补充概念）

• 说python中一切皆对象，所有的东西全都是对象。在python3当中统一了类型与类的概念，如整型、浮点型、列表、字典、元组等这都是类型，一个类型可以称之为一个类，类就等同于类型

# 自定义类型：Student

class Student:
    n = 0

    def __init__(self, name, age, gender):
        Student.n += 1
        self.name = name
        self.age = age
        self.gender = gender

    def choose(self):  # self = obj1
        print(‘hello %s‘ %self.name)  # obj1.name


obj1 = Student("egon1", 18, "male")
print(type(obj1))  # 查看对象的类型
# <class ‘__main__.Student‘>
print(Student)     # 查看类跟对象类型一样，说明类等同于类型
# <class ‘__main__.Student‘>
print(list)
# <class ‘list‘>

obj1.choose()
# hello egon1
Student.choose(obj1)
# hello egon1

# 内置类型：list
l1 = list([1,2,3])
# print(l1)
# l1.append(4)
list.append(l1,4)
print(l1)