面向对象编程用法介绍

面向过程编程

 核心是过程二字，过程指   的是解决问题的步骤，既先干什么再干什么然后干什么。。。

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

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

缺点：扩展性查看

面向对象编程

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

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

优点：可扩展性强

缺点：编程的复杂度要高于面向过程

类：种类、分类、类别

       对象是特征与技能的结合体，类是一系列对象相似的特征与技能的结合体

       强调：站的角度不同，总结出的类是截然不同的

在现实世界中：先有一个个具体存在的对象，然后随着人类文明的发展才有了分类的概念

在程序中：必须先定义类，后调用类来产生对象

类的应用：

'''
站在老男孩选课系统的角度，先总结现实世界中的老男孩的学生对象
    对象1：
        特征：
            学校='oldboy'
            姓名='耗哥'
            年龄=18
            性别='male'
        技能：
            选课

    对象2：
        特征：
            学校='oldboy'
            姓名='猪哥'
            年龄=17
            性别='male'
        技能：
            选课

    对象3：
        特征：
            学校='oldboy'
            姓名='帅翔'
            年龄=19
            性别='female'
        技能：
            选课

站在老男孩选课系统的角度，先总结现实世界中的老男孩学生类
    老男孩学生类：
        相似的特征：
            学校='oldboy'
        相似的技能
            选课
'''
#1、在程序中先定义类
class OldboyStudent:
    school = 'oldboy'
    def choose_course(self):
        print('is choosing course')
    #print('<<<<')    #类体代码会在定义阶段立即执行，会产生一个类的名称空间

#类的本身其实就是一个容器/名称空间，是用来存放名字，这是类的用途
# print(OldboyStudent.__dict__)  #查看类的内存地址
# print(OldboyStudent.__dict__['school'])
# print(OldboyStudent.__dict__['choose_course']) #查看类中函数的内存地址
# OldboyStudent.__dict__['choose_course'](44)   #执行类中函数的功能
# print(OldboyStudent.school)
# print(OldboyStudent.choose_course)
# OldboyStudent.choose_course(2)

OldboyStudent.country='china'  #在类中增加元素
OldboyStudent.country='CHINA'  #在类中改元素
del OldboyStudent.school   #在类中删元素

#2、后调用类产生对象，调用类的过程，又称为类的实例化，实例化的结果就是类的对象
stu1 =OldboyStudent #调用类会得到一个返回值，该返回值就是类的一个具体存在的对象


3、为对象定制自己独有的属性

# class OldboyStudent:
#     school = 'oldboy'
#     def choose_course(self):
#         print('is choosing course')
#
# stu1= OldboyStudent()  #调用类
# print(stu1 .school)

 #对象的本质也是一个名称空间，对象名称空间是用来存放对象自己独有的名字/属性
 #而类中存放的是对象们共有的属性

 #为对象添加自己独有的属性 三种方式
# stu1 .name= '浩哥'  #添加属性
# stu1 .age = 18
# stu1 .sex= 'male'
# print(stu1 .__dict__ )

# def init(obj,x,y,z):  #函数方式
#     obj.name = x
#     obj.age=y
#     obj.sex=z
# init(stu1 ,'浩哥',18,'male')  #传参
# print(stu1 .__dict__ )    #查看属性

class OldboyStudent:
    school = 'oldboy'
    def __init__(obj, x, y, z): #在调用类时自动触发
        obj.name = x
        obj.age = y
        obj.sex = z
    def choose_course(self):
        print('is choosing course')

#调用类时发生了两件事
#1、创造一个空对象stu1,stu1传给obj
#2、自动触发类中__init__功能的执行，将stu1以及调用类括号内的参数一同传入
stu1 = OldboyStudent('浩哥',18,'male')   #即OldboyStudent__init__(stu1,'浩哥',18,'male')
print(stu1.__dict__ )


4、属性查找

#属性查找
class OldboyStudent:
    school = 'oldboy'
    count=1
    def __init__(self, x, y,z): #在调用类时自动触发
        self.name = x
        self.age = y
        self.sex = z
        OldboyStudent  .count+=1  #统计实例化次数
    def choose_course(self):
        print('is choosing course')
#先从对象自己的名称空间找，没有再去类中找，类中也没有就报错
stu1 = OldboyStudent('浩哥',18,'male')
stu2= OldboyStudent('注哥',22,'male')
print(OldboyStudent.count)
# print(stu1 ,count)

5、绑定方法

class OldboyStudent:
    school = 'oldboy'
    def __init__(self, x, y, z): #在调用类时自动触发
        self.name = x
        self.age = y
        self.sex = z
    def choose_course(self):
        print(' is choosing course')  #拿到名字属性

stu1 = OldboyStudent('浩哥',18,'male')
#类名称空间中定义的数据属性和函数属性都是共享给所有对象用的
#对象名称空间中定义的只有数据属性，是对象所独有的
# print(stu1 .name)
# print(stu1 .school )

#类中定义的函数是类的函数属性，类可以使用，但使用的就是一个普通的函数而已，
# 意味着需要完全遵循函数的参数规则，该传几个值就传几个
#print(OldboyStudent.choose_course)  #类调用函数
#OldboyStudent.choose_course(33)   # is choosing course

#类中定义的函数是共享给所有对象的，对象也可以使用,而且是绑定给对象用的
#绑定的效果：绑定给谁，就应该由谁来调用，谁来调用就会将谁当做第一个参数自动传入
# stu1 .choose_course()   #对象调用函数，绑定关系无需传参数
# print(stu1)
  注意：绑定到对象的方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，self可以是任意名字，但是约定俗成地写出self。


#*****
class OldboyStudent:
    school = 'oldboy'
    def __init__(self, x, y, z): #在调用类时自动触发
        self.name = x
        self.age = y
        self.sex = z
    def choose_course(self,x):  #self是一个对象，将self定为参数，可以灵活调用里面的属性
        print('%s is choosing course'%self.name)  #拿到名字属性

stu1 = OldboyStudent('浩哥',18,'male')
stu1.choose_course(1)   #浩哥 is choosing course

#补充：类中定义的函数，类确实可以使用，但其实类定义的函数大多情况下都是绑定给对象用，
#所以在类中定义的函数都应该自带一个参数self

#小结
#python中统一了类与类型的概念
class  Foo():
    pass

obj = Foo()
print(type(obj))

l= [1,2,3]
l.append(4) = list.append(l,4) #添加元素