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

  • 面向对象编程

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

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

    优点:扩展性强()
    缺点:编程的复杂度提升
    应用场景:需求经常变化的软件,一般需求的变化都集中在用户层,互联网应用,企业内部软件,游戏等都是面向对象的程序设计大显身手的好地方
    面向对象的程序设计并不是全部。对于一个软件质量来说,面向对象的程序设计只是用来解决扩展性
    # 一个学生的数据信息: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、自动触发类内的__init__函数的运行,将空对象当做第一个参数自动传入
      3、返回一个初始化好的对象给obj1
    • 类即类别、种类,是面向对象设计最重要的概念,对象是数据与功能的容器,而类则是一系列对象相似的数据与功能的容器

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

      在现实世界中:先有对象,再有类
      在程序中:务必保证先定义类,后产生对象

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

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

    • 定义类发生的事

      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
      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))  # 查看对象的类型
#print(Student)     # 查看类跟对象类型一样,说明类等同于类型
#print(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)