面向对象编程并类与对象的概念

1、面向过程编程

     核心是过程二字，过程是解决问题的步骤，即先做什么再做什么。

    基于该思想编写程序好像就是在编写一条流水线，是一种机械式的思维方式。

    优点：复杂 的问题流程化，进而简单代

    缺点：可扩展性差。

  2、面向对象   

    核心“对象”二字，对象指的是特征与技能的结合体 。

    基于该思想编写程序就好比在创造一个世界，你就是这个世界的上帝，是一种上帝式的思维方式。

    优点：可扩展性强

    缺点：它编程的复杂性高于面向过程。

面向对象的思想只是提高了程序的扩展性，不是程序设计的全部。对于一个软件质量来说，它还涉及到许多的方面（如发性能，成本，可靠性，安全性，可维护性等）

3、类于对象

    1）类：对象与特征与技能的结合体，那类就是一系列对象相同的特征与技能的结合体。

    2）在现实世界中：一定先有对象，后来随着人类文明的发展总结出类的概念，对象是具体的存在的，而类只是一种抽象概念。

        在程序中：务必保证，先定义类，后调用类来产生对象。（与函数有点相似）

"""
现实生活中的对象：
对象1
    特征：
school='Oldboy'
name='monicx'
age=23
sex='male'
    技能
        学习
        选课
对象2：
    特征：
school='Oldboy'
name='小田'
age=23
sex='male'
    技能
        学习
        选课
现实生活中的老男孩学生类：
   相同的特征：
        school='Oldboy'
   相同的技能：
"""
#程序中的类（变量与函数的集全体）
class OldboyStudent:
    #用变量表示特征
    school='Oldboy'
    #用函数表示技能
    def learn(self):
        print('is learning')
    def choose(self):
        print('choose course....')

    # print('=============')

#注意：在定义类的阶段就会立刻执行类体代码。产生类的名称空间存入类体代码产生的名字。
#名称空间是字典的形式存放。
# print(OldboyStudent.__dict__)
'''
{'__module__': '__main__', 'school': 'Oldboy',
'learn': <function OldboyStudent.learn at 0x00000000021C9950>,
 'choose': <function OldboyStudent.choose at 0x00000000021C99D8>,
  '__dict__': <attribute '__dict__' of 'OldboyStudent' objects>,
   '__weakref__': <attribute '__weakref__' of 'OldboyStudent' objects>,
    '__doc__': None}

'''
# OldboyStudent.__dict__['learn'](123)
print(OldboyStudent.school)#OldboyStudent.__dict__['school']
print(OldboyStudent.learn)
print(OldboyStudent.learn(123))
#‘.’之后的都叫统一属性
OldboyStudent.country='China'#新增一个属性
OldboyStudent.school='博爱'#修改一个属性
print(OldboyStudent.__dict__)

调用类的返回值就是对象。obj=OldboyStudent()

调用类发生了哪些事：

class OldboyStudent:
    #用变量表示特征
    school='Oldboy'
    def __init__(self,x,y,z):#__init__这个函数在调用阶段会自动执行。
        self.name=x #obj.name='monicx'
        self.age=y #obj.age=23
        self.sex=z #obj.sex='男'
obj=OldboyStudent('monicx',23,'男')

1、首先会产生一个空对象

2、会自动触发类内部的__init__函数

3、然后将空对象obj连同调用类时括号内的参数组成（obj,'monicx','23','男'），将这四个参数一起传给__init__函数。

类内部定义的变量是给所有对象共享，所有对象指向的都是同一个内存地址。

类内部定义函数，其实是给对象使用的，而且是绑定给对象用，绑定给不同的对象就是不同的绑定方法。

绑定方法的特殊之处在于，谁来调用，就会将谁当作第一个参数自动传入。

#一、调用类产生类的对象，该对象也可以称为类的一个实例，调用类的过程也称为类的实例化。
class People:
    x=100
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def run(self):
        print('%s is running' %self.name)
#二、调用类发生了哪些事：
# 1、先产生一个空对象
# 2、自动触发类内部__init__函数的执行
# 3、将空对象、以及调用类括号内传入的参数，一同给__init__，为对象独有的属性

obj=People('monicx',23,'male')
obj1=People('lxx',23,'male')
obj2=People('egg',23,'male')

#会产生对象的名称空间，如何查看
print(obj.__dict__)

#对象的操作
print(obj.name) #obj.__dict__
obj.education="清华"
# del obj.name
obj.age=19
print(obj.__dict__)

#:三对象属性的查找顺序：先找对象自己的名称空间
#1、类的数据属性:是给对象用的，而且直接共享给类的所有对象使用的，内存地址都一样
print(People.x)
#2、类的函数属性，也是给对象用的，但绑定给的对象不同，就有不同的绑定方法。同存地址不一样
print(People.run)
# People.run(12321231)
People.run(obj)
print(obj.run)
print(obj1.run)
print(obj2.run)
#四绑定给方法的特殊之处
# 1、绑定给谁就应该由谁来调用。
# 2、谁来调用就把谁当作第一个参数（self）传入
obj.run()
obj1.run()
obj2.run()

# 五、一切皆对象,在Python3当中统一了类与类型的概念，类就是类型
l=list([1,2,3])
print(type(l))
print(type(obj))
l.append(4)