面向对象初识

面向过程编程

核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么然后干什么。。。
基于该思想编写程序好比在设计一条流水线，是一种机械式的思维方式

优点：复杂的问题流程化、进而简单化
缺点：扩展性差

面向对象编程

核心对象二字，对象是特征与技能的结合体
基于该思想编写程序就好比是在创造一个世界，你就是这个世界的上帝，是一种上帝式的思维方式

优点：可扩展性强
缺点：编程的复杂度要高于面向过程

类

类：种类、分类、类别
对象是特征与技能的结合体，类是一系列对象相似的特征与技能的结合体
强调：站的角度不同，总结出的类是截然不同的

在现实世界中：先有的一个个具体存在的对象，然后随着人类文明的发展才了分类的概念
在程序中：必须先定义类，后调用类来产生对象

假设要写一个选课系统

站在选课系统的角度，先总结现实世界中的学生对象

对象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(OldboyStudent.__dict__)
print(OldboyStudent.__dict__['school'])
print(OldboyStudent.__dict__['choose_course'])
OldboyStudent.__dict__['choose_course']()


print(OldboyStudent.school) #OldboyStudent.__dict__['school']
print(OldboyStudent.choose_course) #OldboyStudent.__dict__['choose_course']


#查
OldboyStudent.choose_course(111)

#增,改
OldboyStudent.country='China' #OldboyStudent.__dict__['country']='China'
OldboyStudent.country='CHINA' #OldboyStudent.__dict__['country']='China'

#删
del OldboyStudent.school

print(OldboyStudent.__dict__)

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

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

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

class OldboyStudent:
    school='oldboy'


    def __init__(obj, x, y, z): #会在调用类时自动触发
        obj.name = x #stu1.name='耗哥'
        obj.age = y  #stu1.age=18
        obj.sex = z #stu1.sex='male'

    def choose_course(self):
        print('is choosing course')

调用类时发生两件事
1、创造一个空对象stu1
2、自动触发类中__init__功能的执行，将stu1以及调用类括号内的参数一同传入

stu1=OldboyStudent('耗哥',18,'male') #OldboyStudent.__init__(stu1,'耗哥',18,'male')
stu2=OldboyStudent('猪哥',17,'male')
stu3=OldboyStudent('帅翔',19,'female')

print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)

属性查找

在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常  

编写一个学生类，产生一堆学生对象，要求有一个计数器（属性），统计总共实例了多少个对象 

class OldboyStudent:
    school='oldboy'
    count=0

    def __init__(self, x, y, z): #会在调用类时自动触发
        self.name = x #stu1.name='耗哥'
        self.age = y  #stu1.age=18
        self.sex = z #stu1.sex='male'
        OldboyStudent.count+=1

    def choose_course(self):
        print('is choosing course')


# 先从对象自己的名称空间找，没有则去类中找，如果类也没有则报错
stu1=OldboyStudent('耗哥',18,'male')
stu2=OldboyStudent('猪哥',17,'male')
stu3=OldboyStudent('帅翔',19,'female')

print(OldboyStudent.count)
print(stu1.count)
print(stu2.count)
print(stu3.count)

绑定方法

#改写
class OldboyStudent:
    school='oldboy'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def choose_course(self):
        print('%s is choosing course' %self.name) #新增self.name

    def eat(self):
        print('%s is eating' %self.name)

    def sleep(self):
        print('%s is sleeping' %self.name)


s1=OldboyStudent('耗哥',18,'male')
s2=OldboyStudent('猪哥',17,'male')
s3=OldboyStudent('帅翔',19,'female')

类中定义的函数（没有被任何装饰器装饰的）是类的函数属性，类可以使用，但必须遵循函数的参数规则，有几个参数需要传几个参数

OldboyStudent.choose_course(s1) #耗哥 is choosing
OldboyStudent.choose_course(s2) #猪哥 is choosing
OldboyStudent.choose_course(s3) #帅翔 is choosing

类中定义的函数（没有被任何装饰器装饰的）,其实主要是给对象使用的，而且是绑定到对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法

强调：绑定到对象的方法的特殊之处在于，绑定给谁就由谁来调用，谁来调用，就会将‘谁’本身当做第一个参数传给方法，即自动传值（方法__init__也是一样的道理）

s1.choose_course() #等同于OldboyStudent.choose_course(s1)
s2.choose_course() #等同于OldboyStudent.choose_course(s2)
s3.choose_course() #等同于OldboyStudent.choose_course(s3)

注意：绑定到对象的方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，self可以是任意名字，但是约定俗成地写出self。

类即类型

在python3中统一了类与类型的概念，类就是类型

class OldboyStudent:
    school='oldboy'

    def __init__(self, x, y, z): #会在调用类时自动触发
        self.name = x #stu1.name='耗哥'
        self.age = y  #stu1.age=18
        self.sex = z #stu1.sex='male'

    def choose_course(self,x):
        print('%s is choosing course' %self.name)

stu1=OldboyStudent('耗哥',18,'male')
# stu1.choose_course(1) #OldboyStudent.choose_course(stu1,1)
# OldboyStudent.choose_course(stu1,1)

l=[1,2,3] #l=list([1,2,3])
# print(type(l))
# l.append(4) #list.append(l,4)
list.append(l,4)
print(l)