面向对象（一）--类和对象的介绍

一、面向对象编程与面向过程编程

1、面向过程编程思想

该思想核心是过程，指的是解决问题的步骤，即先干什么再干什么。基于该思想编程就像一条流水线，是一种机械式的思维方式

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

缺点：可扩展性差

应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等

2、面向对象编程思想

该思想核心是对象，对象是特征与技能的结合体。任何事物都可以是对象

优点：可扩展性强

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

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

二、类

1、对象是特征与技能的结合体，而类是一系列对象相同的

特征与技能的结合体

2、类与对象 的区别
（1）对象是具体存在的事物，而对象是抽象的概念

（2）在不同角度总结出来的类与对象是不同的

3、在现实世界，先有对象，然后有类；而在程序中，先有类，然后调用类产生对象

1 stu1
2     school:\'oldboy\'
3     name:\'zs\'
4     age:18
5 
6 stu2
7     school:\'oldboy\'
8     name:\'ls\'
9     age:34

对象

1 class OldboyStudent:
2     school = \'oldboy\'
3 
4     def study(self):
5         print(\'dddd\')
6         return \'dddd\'

类

三、类的使用

1. 类本质就是一个名称空间,或者说是一个用来存放变量与函数的容器 ， 可以用 __dict__来访问名称空间中的名称
2.用途

（1）类的用途之一就是当做名称空间从其内部取出名字来使用,（类名.属性，可以对类中的属性进行增删改查）
（2）类的用途之二是调用类来产生对象

3.调用类产生对象的过程：

（1）创建一个空对象

（2）将值传入并赋初始值　

#1.定义类
class OldboyStudent:
    #相同的特征
    school = \'oldboy\'

    #相同的技能
    def choose_course(self):
        print(\'choosing course\')

# 但其实类体中是可以存在任意python代码的
# 类体代码会在类定义阶段立即执行,会产生一个类名称空间,用来将类体代码执行过程中产生的名字都丢进去,查看方式如下
print(OldboyStudent.__dict__) # 查看类的名称空间
print(OldboyStudent.school) print(OldboyStudent.__dict__[\'school\'])
print(OldboyStudent.choose_course)
OldboyStudent.school=\'OLDBOY\' OldboyStudent.__dict__[\'school\']=\'OLDBOY\'
OldboyStudent.country=\'China\' OldboyStudent.__dict__[\'country\']=\'China\'
del OldboyStudent.country # del OldboyStudent.__dict__[\'country\']
print(OldboyStudent.__dict__)
#2. 后调用类来产生对象

四、对象的使用

1、调用类的过程称之为类的实例化,调用类的返回值称之为类的一个对象/实例

2、为对象定制自己独有的特征，利用__init__方法

3、__init__方法在实例化时就为对象初始自己独有的特征(属性)，不能有返回值，而且会将对象自动传进类

 1 class OldboyStudent:
 2     #相同的特征
 3     school = \'oldboy\'
 4 
 5     def __init__(self, name, age, sex):
 6         self.name = name    #stu1.name=\'李铁蛋\'
 7         self.age = age           #stu1.age=18
 8         self.sex = sex           #stu1.sex=\'male\'
 9 
10     #相同的技能
11     def choose_course(self):
12         print(\'choosing course\')
13 
14 
15 # 调用类，产生对象
16 stu1=OldboyStudent(\'李铁蛋\',18,\'male\')

五、属性（变量和函数）查找

1、先从对象自己的名称空间找,没有则去所属的类中找

xxx=33333
class OldboyStudent:
    school = \'oldboy\'
    # xxx=2222
    yyy=333
    count=0

    def __init__(obj, name, age, sex):
        # print(OldboyStudent.yyy)
        # print(obj.yyy)

        OldboyStudent.count+=1
        obj.name = name #stu1.name=\'李铁蛋\'
        obj.age = age   #stu1.age=18
        obj.sex = sex   #stu1.sex=\'male\'

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

# 1. 属性查找顺序
# stu1=OldboyStudent(\'李铁蛋\',18,\'male\')
# print(stu1.__dict__)
# print(OldboyStudent.__dict__)
# stu1.xxx=111
# print(stu1.__dict__)
# 先从对象自己的名称空间找,没有则去所属的类中找
# print(stu1.xxx)

2、类中定义的变量是所有对象共享的,对象可以来用,类也可以来使用,类一旦改变自己的数据属性的值,所有的对象都能感知到

class OldboyStudent:
    school = \'oldboy\'
    count=0

    def __init__(obj, name, age, sex):
        OldboyStudent.count+=1
        obj.name = name
        obj.age = age
        obj.sex = sex

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



stu1=OldboyStudent(\'李铁蛋\',18,\'male\')
stu2=OldboyStudent(\'赵钢弹\',38,\'female\')
stu3=OldboyStudent(\'刘银弹\',28,\'male\')
print(stu1.count)         # 3
print(stu2.count)         # 3
print(stu3.count)         # 3
print(OldboyStudent.count)        # 3

创建对象个数统计

创建对象个数统计

六、绑定方法

1、类中属性改变

类中定义的变量是类的数据属性,类可以用,对象也可以用,大家都指向同一个内存地址,类变量值一旦改变所有对象都跟着变
类中定义的函数是类的函数属性,类可以用,类来调用就是一个普通的函数,但其实类中定义的函数是给对象用的,而且是绑定给对象用的

2、类的函数: 该传几个参数就传几个

class OldboyStudent:
    school = \'oldboy\'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

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


OldboyStudent.choose_course(stu1,1)

3、绑定方法

绑定给谁就应该由谁来调用,谁来调用就会将谁当做第一个参数(self)自动传入

class OldboyStudent:
    school = \'oldboy\'

    def __init__(self, name, age, sex):
        self.name = name #stu1.name=\'李铁蛋\'
        self.age = age   #stu1.age=18
        self.sex = sex   #stu1.sex=\'male\'

    def choose_course(self,x): #self=stu1
        print(\'%s choosing course\' %self.name)



stu1=OldboyStudent(\'李铁蛋\',18,\'male\')
stu2=OldboyStudent(\'赵钢弹\',38,\'female\')
stu3=OldboyStudent(\'刘银弹\',28,\'male\')

# 1. 类的函数: 该传几个参数就传几个
# print(OldboyStudent.__init__)
# print(OldboyStudent.choose_course)
# OldboyStudent.choose_course(stu1)

# 2. 绑定方法,指向类的函数: 特殊之处是绑定给谁就应该由谁来调用,谁来调用就会将谁当做第一个参数自动传入
# print(stu1.choose_course)
# print(stu2.choose_course)
# print(stu3.choose_course)

# stu1.choose_course(123) #OldboyStudent.choose_course(stu1,123)
# stu2.choose_course(123)
# stu3.choose_course(123)