目录

• 面向对象编程
  • 面向过程编程
  • 对象
  • 面向对象编程
• 类
  • 什么是类
  • 怎么定义类
  • 定义类发生的事
  • 类的操作
    • 增
    • 删
    • 查
    • 改
• 对象
  • 对象的产生
  • 对象名称空间的产生
  • __init__的使用
  • 调用类发生的事情
• 对象与类的查找顺序
• 对象绑定方法的特殊之处
• python中一切皆对象

面向对象编程

面向过程编程

面向过程编程注重的是步骤，知道先做什么，后做什么，所以面向过程编程的优点就是逻辑清晰，把复杂的问题流程化，进而将它简单化。缺点是它的可拓展性比较差。

对象

在现实中对象可能就是指的是一个一个的物体，在编程中，对象指的是某种特征和技能的结合体

面向对象编程

相比于面向过编程，面向对象编程更注重的对象，这种编程思想就好比是上帝在造物体，是基于上帝的思想进行编程

所以面向对象编程的优点是它的可拓展性比较高，而缺点就是面向对象编程更加复杂

在未来的使用中，要结合两种编程思想才能更好的进行编程

类

什么是类

知道了面向对象编程，就要知道什么是类，

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

怎么定义类

在编程中，要想使用对象就要现有类，定义类就要使用class关键字

定义方式类就是class关键字后面加类名再加冒号：

# 定义一个学生类
class Student：
    pass

要注意的是，在命名类的时候要使用驼峰体

其中类名不仅仅是类的名字，还要通过它去创造对象。

定义类发生的事

1.类在定义时，会产生一个空的名称空间

2.会把类中所定义的所有的名称全部放入这个名称空间中。

与函数不同的事，类在定义阶段就已经产生了名称空间，执行python文件会执行类内部的代码

类的操作

首先定义一个学生类

class Student:
    # 特征
    school = 'zwu'
    # 技能
    def learn(self)
        print('I love study')
    def choose_class(self)
        print('I want learn python')

python \ print(Student) print(Student.__dict__) print(Student.__dict__.get(‘school‘)) print(Student.school) # <class ‘__main__.Student‘> # {‘__module__‘: ‘__main__‘, ‘school‘: ‘zwu‘, ‘learn‘: <function Student.learn at 0x0000027C4669F0D0>, ‘choose_class‘: <function Student.choose_class at 0x0000027C4669F158>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Student‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Student‘ objects>, ‘__doc__‘: None} # zwu # zwu

增

Student.adderss = 'nb'
print(Student.adderss) # nb

# Student.__dict__['address'] = 'nb'
# print(Student.__dict__['address'])

删

del Student.adderss
print(Student.adderss)
# AttributeError: type object 'Student' has no attribute 'adderss'

# del Student.__dict__['school']
# print(Student.__dict__['school'])

查

print(Student.adderss)
# print(OldboyStudent.__dict__.get('school'))

改

Student.address = 'yz'
print(OldboyStudent.school)

对象

再次重复一遍，对象就是特征和方法的结合体

对象的产生

语法是用类名+括号（）调用类产生对象

对象名称空间的产生

类的名称空间在类定义的时候就已经产生，于此相似，对象的名称空间在调用类的时候就已经产生

__init__的使用

我们在使用类名+（）产生对象时，你会发现这样调用生成的对象的属性都是差不多的，这样我们就可以使用__init__函数

__init__会在调用类时，自动触发该函数，作用是给对象初始化某些属性

class Studen:
    school = 'zwu' 
    def learn(self):
        print('learn')
    def __init__(self,name,age,sex): 
        self.name = name
        self.age = age
        self.sex = sex
    # def __init__(self):
        # print('this is __init__')
stu1 = Studen('lk',15,'meal')
print(stu1.name)
# stu1 = Studen()
# stu1.name = 'lk'
# stu1.age = 15
# print(stu1.__dict__)
stu2 = Studen('zz',18,'femeal')
print(stu2.__dict__)

我们可以给__init__函数中给些参数，这样在生成的对象中也会有这些属性

调用类发生的事情

调用类发生的事情
1.首先会产生一个空的对象，就是产生“对象的名称空间”
**2.会自动触发__init_函数
3.会把对象本身以及括号内的参数一并传给_init__函数
总结: 调用类会产生一个对象,调用类的过程叫做类的实例化,产生的对象称之为类的一个实例**

对象与类的查找顺序

class Studen:
    SCHOOL = 'zwu' 
    NAME = 'll'
    def learn(self):
        print('learn')
    def __init__(self,name,age,sex,school): 
        self.name = name
        self.age = age
        self.sex = sex
        self.SCHOOL = school
stu1 = Student('lk',15,meal,'zzu')
print(stu1.SCHOOL)
# zzu

从代码中我们可以看到，即使在类中定义了一个school，但是得到的结果是定义对象时传的值，所以对象与类的查找顺序:
1.对象.属性，若对象本身有，则优先查找对象自己的。
2.若对象本身没有，则去类里面找，若类没有，则报错。

对象绑定方法的特殊之处

我们都知道在类里面会有对象的特征和技能，这个技能可以是一个函数，在定义这个函数的时候，他会自动生成一个参数self，这个函数的特殊之处就在这个self上

class Studen:
    school = 'zwu' 
    def learn(self):
        print('learn')
    def __init__(self,name,age,sex): 
        self.name = name
        self.age = age
        self.sex = sex
stu1 = Studen('lk',15,'meal')
stu2 = Studen('zz',18,'femeal')
stu1.learn()
Student.learn(0)

这里可以发现在使用对象调用函数的时候它可以不给参数

而类调用的使用则在里面给了一个参数（这个参数可以是任意的）

着就引出了这个特殊之处：

类内部的函数主要是给对象用的：

? 当由类调用类内部函数时，该函数就只是一个普通函数，普通函数需要几个参数，就要传几个参数

? 当对象调用类内部函数时，该函数就可以称为对象的绑定方法，不同的对象调用该绑定方法，则会将不用的对象传如该方法中

特殊之处就是：把对象当作第一个参数传给该方法中

python中一切皆对象

目前我刚刚接触对象，还并不了解它的目的，不知道它都能做些什么