编程思想之面向对象
今日学习总结：
注意：编程思想仅仅是一门思想，与任何的技术无关。
一、面向过程编程思想
核心是‘过程’二字，过程指的是解决问题的步骤，即先干什么后干什么。
基于该编程思想编写程序，就好比在设计一条工厂流水线，一种机械式的思维方式
优点：将复杂的问题流程化，进而简单化。
缺点：牵一发而动全身，程序的可扩展性差。
二、面向对象编程思想：（注意：要将自己当做一个上帝）
核心是‘对象’二字，对象指的是‘特征与技能’的结合体。
基于该编程思想编写程序，就好比在创造世界，一种‘上帝式’的思维方式。
优点：编程可扩展性高
缺点：编写程序的复杂程度比面向过程高
1. 怎样创造对象 ：
01、什么是类：一系列对象 相同的特征与技能 的结合体。
类是指类型、类别。
--在现实生活中：先有一个个的对象，经过社会的文明发展，随之总结出类。
--在程序中：必须先有类，再通过调用类，产生对象。
02、如何写类：
先从现实世界中通过一个个对象总结出类，然后再定义类，后调用类产生对象
ps:对象指的是‘特征与技能’的结合体，类指的是一系列“对象之间相同的特征”
03、如何定义类：定义类名的规范：驼峰体命名法
定义语法：（class 关键字：是帮你产生类的
class 类的名字：
--对象之间相同的特征 ：称为属性（attribute）
--对象之间相同的技能 ：称为方法(def learn）
04、定义类的例子：
class OldboyStudent: #OldboyStudent是类名，指向的是类的内存地址。 school='oldboy' def learn(self): print(self) print('learning...') print(learn) #<function OldboyStudent.learn at 0x00000000028489D8> 是函数名指向的地址 print(OldboyStudent) #<class '__main__.OldboyStudent'> 这是类名指向的地址。 OldboyStudent() #这是一个对象，是在调用类的时候产生的 print(OldboyStudent()) #<__main__.OldboyStudent object at 0x00000000024FC748> print(OldboyStudent.__dict__) #查看类的名称空间，是一个字典 #{'__module__': '__main__', 'school': 'oldboy', 'learn': <function OldboyStudent.learn at 0x00000000028489D8>, # '__dict__': <attribute '__dict__' of 'OldboyStudent' objects>, # '__weakref__': <attribute '__weakref__' of 'OldboyStudent' objects>, '__doc__': None}
05、查看类的名称空间： 类名._ _dict_ _
print(OldboyStudent.__dict__) #查看类的名称空间，是一个字典
class OldboyStudent: #OldboyStudent是类名，指向的是类的内存地址。 school='oldboy' def learn(self): print(self) #123 print('learning...') OldboyStudent.__dict__['learn'](123) #表示把字典中learn的值去取来 加（123）表示调
06、类的名称空间和类的名称空间
- 函数的名称空间：
在调用函数时产生，函数调用结束后销毁。
- 类的名称空间:
在定义阶段时产生，会将类中所有的名字，扔进类的名称空间中。
2、对象的产生：在调用类时产生对象，在调用类时发生的事情：
第一步：产生一个空对象的名称空间
第二步：自动触发类内容_ _init_ _方法的执行
第三步：会将对象本身当做第一个参数，以及调用类括号内所有的参数并传给_ _init_ _
01、类名 + () 调用类产生对象
02、类的名称空间在定义时产生，对象的名称空间在调用类时产生。
03、调用类产生对象的过程称之为类的实例化，对象称之为类的一个实例。
04、对象的绑定方法：由对象来调用类内部的函数，对象的绑定方法特殊之处: 会将对象当做第一个参数传给该方法。
例子：
class Student: school = 'oldboy' def __init__(self, name, sex, age): # stu1, 'tank', 'male', 17 print(self.__dict__) #查看当前对象的名称空间 # 给对象添加新的属性 self.name = name # stu1.x = 'tank' self.sex = sex # stu1.y = 'male' self.age = age # stu1.z = 17 print(self.__dict__) #查看给对象添加新属性后的 对象的名称空间 def learn(self): print(self) print('learning...')
05、查看对象的名称空间：对象名._ _dict_ _
print(obj.__dict__) #{} #查看类的名称空间，是一个字典 ,默认是个空的。obj 是调用类名时产生的 对象名。
class OldboyStudent: #OldboyStudent是类名，指向的是类的内存地址。 school='oldboy' def learn(self): print('learn...') obj=OldboyStudent() #这是一个对象，是在调用类的时候产生的 print(obj) print(obj.__dict__) #{} #查看类的名称空间，是一个字典.
06、 想要在调用类时，为对象传入对象独有 特征。（# 注意: 凡是在类内部定义的，__开头或者__结尾的方法都有特殊的意义。）
00、用 def __init__(self, 形参1, 形参2, ...):
11、调用类时: 会将对象当做第一个参数，与括号内所有的参数一并传给__init__()
22、在类内部定义的方法，在调用类时触发，会自动将对象本身当做第一个参数自动传入, 与括号内所有的参数一并传给__init__()。
例子：
class Student: # 学校 ----> attribute --->>属性 school = 'oldboy' # 学习技能 ----> method --->> 方法 def learn(self): print(self) #<__main__.Student object at 0x000000000BAFC6A0>
print('learning...')
stu1 = Student()
print(stu1) #<__main__.Student object at 0x000000000BAFC6A0>
print(stu1.learn()) #learn() 的小括号里不用传参数了，因为stu1.learn()中的 stu1当做实参传给self了
# 在类内部定义的方法，在调用类时触发，会自动将对象本身当做第一个参数自动传入,
例子：
class Student: # 学校 ----> attribute --->>属性 school = 'oldboy' def __init__(self, name, sex, age): # _ _init_ _的用途是给对象 添加属性 print(self.__dict__) #{} # 给对象添加新的属性 self.name = name # stu1.x = 'tank' self.sex = sex # stu1.y = 'male' self.age = age # stu1.z = 17 # 查看当前对象的名称空间 print(self.__dict__) #{'name': '坦克', 'sex': 'male', 'age': 18} # 查看类的名称空间 print(Student.__dict__) #{'__module__': '__main__', 'school': 'oldboy', # '__init__': <function Student.__init__ at 0x00000000028489D8>, 'learn': <function Student.learn at 0x000000000BB72730>, #'__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None} stu1 = Student('tank','female',18) print(stu1) #<__main__.Student object at 0x000000000BAFC6A0> #也可以直接给对象添加属性，比较麻烦一点 stu1.name = '江鹏' stu1.sex = 'female' stu1.age = 84 print(stu1.name, stu1.sex, stu1.age) #江鹏 female 84
三、实例化：既是产生对象
调用类产生对象的过程称之为类的实例化，对象称之为类的一个实例。
class Foo: def __init__(self, x, y, z): self.x = x self.y = y self.z = z foo_obj = Foo(10, 20, 30) print(foo_obj) #<__main__.Foo object at 0x00000000025DCEB8> print(foo_obj.__dict__) #{'x': 10, 'y': 20, 'z': 30} 这是实例化
四、对象名字的查找顺序：
1.对象.属性，会先找对象自己的。
2.若对象没有，会去找类的。
3.若类没有，则会报错。
例子：
class People: country = 'China' name = 'jason' def __init__(self, name, age, sex): self.name = name self.age = age self.sex = sex def run(self): print('running...') obj1 = People('tank', 17, 'male') print(obj1.name) # tank 找对象自己的name属性 print(obj1.country) # China 对象没有，找类中的属性 # print(obj1.jason) # 对象没有，类也没有，就会报错! print(obj1.__dict__) obj1.country = '中国' # 给对象的名称空间添加 country='中国' 属性 print(obj1.__dict__) print(People.__dict__) print(obj1.country)
例子：
class Student: name = '张全蛋' def __init__(self, name): self.name = name def learn(self): print('learning...') stu1 = Student('赵铁柱') #stu1是类对象 print(stu1.name) # 结果 赵铁柱，因为对象.属性，会先找对象自己的 stu1.learn() #表示把类对象中的 learn函数名的地址拿了出来，加上（），表示调用函数了 print(stu1.learn() ) #None 因为learn函数没有返回值，默认返回的是None 结果： 赵铁柱 learning... learning... None
五、类与对象
需要强调的是：在程序中，必须要事先定义类，然后再调用类产生对象（调用类拿到的返回值就是对象）。产生对象的类与对象之间存在关联，这种关联指的是：对象可以访问到类中共有的数据与功能，所以类中的内容仍然是属于对象的，类只不过是一种节省空间、减少代码冗余的机制，面向对象编程最终的核心仍然是去使用对象。
六、类属性与对象属性
1.类属性：在类中定义的名字，都是类的属性，有两种属性：
01、数据属性：类中定义的变量是类的数据属性，是共享给所有对象用的，指向相同的内存地址
02、函数属性：类中定义的函数是类的函数属性，类可以使用，但必须遵循函数的参数规则，有几个参数需要传几个参数
可以通过__dict__访问属性的‘值’，比如Student.__dict__[‘school’]
2.对象属性：操作对象的属性也是一样
类去调用函数时，需要传参
对象去调用函数时，不需要传参。因为绑定到对象的方法特殊之处：绑定给谁就应该由谁来调用，谁来调用，就会将’谁’本身当做第一个参数自动传入
可以通过__dict__访问属性的‘
七、属性的绑定方法：
1、对象的名称空间里只存放着对象独有的属性，而对象们相似的属性是存放于类中的。对象在访问属性时，会优先从对象本身的__dict__中查找，未找到，则去类的__dict__中查找
2、类中定义的函数主要是给对象使用的，而且是绑定给对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法，内存地址各不相同
3、绑定到对象的方法特殊之处在于，绑定给谁就应该由谁来调用，谁来调用，就会将’谁’本身当做第一个参数自动传入（方法__init__也是一样的道理）
print(stu1.learn() ) #None 因为learn函数没有返回值，默认返回的是None
八、python中 一切皆对象
1.python的八大数据类型都是类
2.定义数据类型的值时，内部自动调用响应的类，然后产生对象。
浙公网安备 33010602011771号