目录
面向过程编程的核心就是过程,过程指的是解决问题的步骤,也就是按照固定的顺序进行,执行程序,就好比流水线一样
面向对象编程的核心就是对象二字,对象就是特征与技能的结合体
基于面向对象编程的思想编程,就好比在创造一个世界,你是这个世界的主人,想怎么写就怎么写
对象就是特征与技能的结合体,我们可能有身高,体重,每个人的身高体重各不相同,但是都是有相似的特征的,就可以说我们是一类,而你和选课系统又不一样,因此
类就是:一系列对象相似的特征与技能的结合体
在现实生活中,我们先有的对象,然后才慢慢有了分类的概念
就按我们的选课系统来讲,首先我们得先有学生对象:
对象一:
特征:
对象二:
特征:
语法:class 类名(类名需要使用驼峰体)
class OldBoyStudent:
school = 'oldboy'
def course(self):
print('is choosing course')
print(OldBoyStudent.__dict__)
{'__module__': '__main__', 'school': 'oldboy', 'course': <function OldBoyStudent.course at 0x00000207C4524D08>, '__dict__': <attribute '__dict__' of 'OldBoyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'OldBoyStudent' objects>, '__doc__': None}
__dict__
就是这个类里面的元素静态函数、类函数、普通函数、全局变量以及一些内置的属性都是放在类__dict__里的
print(OldBoyStudent.__dict__['school'])
print(OldBoyStudent.school)
oldboy
oldboy
OldBoyStudent.course(123)
is choosing course
OldBoyStudent.country = 'china' # 把country这个元素也放到OldBoyStudent这个类里面去了
print(OldBoyStudent.country)
print(OldBoyStudent.__dict__)
china
{'__module__': '__main__', 'school': 'oldboy', 'course': <function OldBoyStudent.course at 0x00000207C4524D08>, '__dict__': <attribute '__dict__' of 'OldBoyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'OldBoyStudent' objects>, '__doc__': None, 'country': 'china'}
调用类就会有一个返回值,该返回值就是类的一个具体的对象
stu1 = OldBoyStudent()
print(stu1.school)
print(stu1.country)
oldboy
china
stu2 = OldBoyStudent()
stu2.name = 'hades'
print(stu2.school)
print(stu2.country)
print(stu2.name)
print(stu1.name) # 报错,stu1这个对象根本就没有name这个变量名
oldboy
china
hades
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-13-c770dcc4850e> in <module>
4 print(stu2.country)
5 print(stu2.name)
----> 6 print(stu1.name) # 报错,stu1这个对象根本就没有name这个变量名
AttributeError: 'OldBoyStudent' object has no attribute 'name'
如此可以证明每一个对象之间是相互独立的,互不干扰,但如果类的属性发生变化,所有的对象也会发生变化,就如上面OldBoystudent.country = ‘china‘
,所有的类的对象都具备了这个属性
class Student:
school = 'oldboy'
def choose_course(self):
print('is choosing course')
stu1 = Student()
stu2 = Student()
stu3 = Student()
print(stu1.__dict__)
print(stu2.__dict__)
{}
{}
stu1.name = 'hades'
stu1.age = 27
stu1.weigth = 120
print(stu1.__dict__)
print(stu2.__dict__)
{'name': 'hades', 'age': 27, 'weigth': 120}
{}
stu2.name = 'bonnie'
stu2.age = 16
stu2.weight = 90
print(stu2.__dict__)
{'name': 'bonnie', 'age': 16, 'weight': 90}
class Student:
school = 'oldboy'
def __init__(self,name,age,weight):
"""类在实例化的时候自动触发"""
self.name = name
self.age = age
self.weight = weight
def choose_course(self):
print(f'{self.name}is choosing course')
try:
stu1 = Student()
except Exception as e:
print(e)
__init__() missing 3 required positional arguments: 'name', 'age', and 'weight'
stu1 = Student('hades',27,120)
print(stu1.__dict__)
{'name': 'hades', 'age': 27, 'weight': 120}
__init__
功能的执行,将stu1以及调用类括号内的参数一同传入函数的查找顺序为:就近原则,从当前位置向外进行查找,如果当前位置为局部名称空间,则是局部—-》全局——》内置
类的查找顺序为:先从自己的名称空间进行查找,如果找不到,就去类的名称空间进行查找,如果还是找不到就会报错
class Student:
school = 'oldboy'
count = 0
def __init__(self,name,age,weight):
self.name = name
self.age = age
self.weight = weight
Student.count += 1
def choose_course(self):
print(f'{self.name}is choosing course')
stu1 = Student('hades',27,120)
print(stu1.count)
stu2 = Student('bonnie',16,90)
print(stu1.count)
print(stu2.count)
stu3 = Student('zhu',2,150)
print(Student.count)
1
2
2
3
print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
{'name': 'hades', 'age': 27, 'weight': 120}
{'name': 'bonnie', 'age': 16, 'weight': 90}
{'name': 'zhu', 'age': 2, 'weight': 150}
class Student:
school = 'oldboy'
def __init__(self,name,age,weight):
self.name = name
self.age = age
self.weight = weight
def choose_course(self):
print(f'{self.name} is choosing course')
def func(self):
print('from func')
类的名称空间中定义的属性和函数都是这个类的对象共有的,所有的对象都会有这些属性
对象的名称空间中的属性只是这个对象独有的,属于这个对象私有物品,是不会和其他对象进行分享的
stu1 = Student('hades',27,120)
stu2 = Student('bonnie',16,90)
stu3 = Student('zhu',2,150)
print(stu1.name)
stu1.choose_course()
print(stu2.age)
print(stu3.weight)
hades
hades is choosing course
16
150
类中定义的函数是共享给所有对象的,对象也可以使用,而且是绑定给对象用的
绑定的效果:绑定给谁,就应该由谁来调用,谁来调用就会将谁当作第一个参数自动传入
print(id(stu1.choose_course))
print(id(stu2.choose_course))
print(id(stu3.choose_course))
print(id(Student.choose_course)) # 不相同
2232380939208
2232380939208
2232380939208
2232383095672
stu1.choose_course()
stu2.choose_course()
stu3.choose_course()
hades is choosing course
bonnie is choosing course
zhu is choosing course
class Foo:
pass
obj = Foo()
lis1 = [1,2,3]
lis2 = list([4,5,6])
print(type(obj))
print(lis1)
print(lis2)
print(type(lis))
<class '__main__.Foo'>
[1, 2, 3]
[4, 5, 6]
<class 'list'>
lis2.append(7)
print(lis1)
print(lis2)
[1, 2, 3]
[4, 5, 6, 7]
class Student:
school = 'oldboy'
def __init__(self,name,age,weight):
self.name = name
self.age = age
self.weight = weight
def choose_course(self):
print(f'{self.name} is choosing course')
def func(self):
print('from func')
stu1 = Student('hades',27,120)
stu1.choose_course()
hades is choosing course
Student.choose_course(stu1)
hades is choosing course
lis = [1,2,3]
lis.append(4)
print(lis)
list.append(lis,5)
print(lis)
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
对象和函数一样,可以引用、作为返回值、作为参数、作为容器元素
在类里面封装了一大堆特征/数据,然后又封装了一大堆方法(方法用来专门用来操控这些数据的),并且在这基础上对于不同对象,这些属性和方法有不一样
原文:https://www.cnblogs.com/Hades123/p/11060668.html