一、三大编程范式
编程范式即编程的方法论，标识一种编程风格
三大编程范式：
1.面向过程编程（流水线式）
优点：极大的降低了程序的复杂度
缺点：应用场景固定住了，可扩展性差
2.函数式编程
特点：
a、不修改外部传来值的状态
b、精简，可读性差
c、模仿数学里的函数
3.面向对象编程（是用来解决程序的可扩展性的）
优点：解决了程序的可扩展性
缺点：可控性差
二、面向对象设计与面向对象编程
1、面向对象设计
面向对象设计(Object oriented design)：将一类具体事物的数据和动作整合到一起，即面向对象设计
示例：
def school(name,addr,type):
def init(name, addr, type):
sch = {
‘name‘: name,
‘addr‘: addr,
‘type‘: type,
‘kao_shi‘: kao_shi,
‘zhao_sheng‘: zhao_sheng,
}
return sch
def kao_shi(school):
print(‘%s 学校正在考试‘ %school[‘name‘])
def zhao_sheng(school):
print(‘%s %s 正在招生‘ %(school[‘type‘],school[‘name‘]))
return init(name,addr,type)
s1=school(‘oldboy‘,‘沙河‘,‘私立学校‘)
print(s1)
print(s1[‘name‘])
s1[‘zhao_sheng‘](s1)
s2=school(‘清华‘,‘北京‘,‘公立学校‘)
print(s2)
print(s2[‘name‘],s2[‘addr‘],s2[‘type‘])
s2[‘zhao_sheng‘](s2)
2、面向对象编程
面向对象编程(object-oriented programming):用定义类+实例/对象的方式去实现面向对象的设计
示例：
#对象：学校----->归类
#共有的特征：商标为etiantian
#共有的技能：招生
#独有的特征：地址不一样，老师们，课程
class School:
tag=‘etiantian‘
def __init__(self,addr):
self.addr=addr
self.teacher_list=[]
self.course_list=[]
def zhaosheng(self):
pass
三、类和对象
关于类和对象：
在日常生活中，一般是先有对象，再有类的概念（比如：先是有很多人，才有了人类的概念），但是在编程语言里，是先有的类，再有的对象
类：把一类事物的相同的特征和动作整合到一起就是类，类是一个抽象的概念
对象：就是基于类而创建的一个具体的事物（具体存在的），也是特征和动作整合到一起
def定义函数是面向对象
class定义类是面向对象
1、类的相关知识：
（1）、声明类：
class 类名（类名规范，尽量首字母大写）：
‘类的文档字符串’
类体（类里面的函数）
类名（），类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征
示例：
class Student:
country="china"
def __init__(self,id,name,age,sex):
self.id=id
self.name=name
self.age=age
self.sex=sex
def search_sore(self):
print("good")
def study(self):
print("well")
s1=student("123","xuyuanyuan","18","girl")
（2）、关于经典类和新式类
需要注意的是：在python2中，需要区分经典类和新式类，在python3中，没有经典类，都是新式类
经典类：类名后面直接是冒号（示例：class test：）
新式类：类名后面有括号和object（凡是继承了object的类都是新式类）（示例：class test（object））
#在python2中，新式类 class B(object):pass class C(B):pass print(B.__bases__) print(C.__bases__) #在python2中，经典类 class D:pass print(D.__bases__) # 在python3中，所有的类都是新式类 class A:pass print(A.__bases__)
（3）类属性：特征（变量）和技能（函数）
类是用来描述一类事物，类的对象指的是这一类事物中的一个个体
是事物就要有属性，属性分为
a：数据属性：就是变量
b：函数属性：就是函数，在面向对象里通常称为方法
注意：类和对象均用点来访问自己的属性
示例：
定义一个学生的类：
class Student:
country = ‘China‘
def __init__(self, ID, NAME, SEX, PROVINCE):
self.id = ID
self.name = NAME
self.sex = SEX
self.province = PROVINCE
def search_score(self):
print(‘tell score‘)
def study(self): #self=s1
print(‘study‘,self)
#类的用法:实例化，属性引用
s1 = Student(‘371818181818181‘, ‘cobila‘, ‘female‘, ‘shanxi‘)#实例化
s1.id=‘371818181818181‘
s1.name=‘cobila‘
s1.sex=‘female‘
s1.province=‘shanxi‘
Student.__init__(s1,‘371818181818181‘,‘cobila‘,‘female‘,‘shanxi‘)#属性引用
print(Student.country)
类有两种作用：属性引用和实例化
属性引用（类名.属性）
实例化（__init__与self）类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征
a、有两种方式查dir(类名)：查出的是一个名字列表类名.__dict__:查出的是一个字典，key为属性名，value为属性值
示例：类的“增”、“删”、“改”、“查”
class student:
country="china"
def __init__(self,id,name,age,sex):
self.id=id
self.name=name
self.age=age
self.sex=sex
def search_sore(self):
print("good")
def study(self):
print("well")
s1=student("123","xuyuanyuan","18","girl")
##查看类的数据属性
print(s1.country)
print(student.country)
print(student.__dict__)
#
# ##增加类的数据属性
student.location="Asia"
print(student.location)
# ##删除类的数据属性
del student.location
print(student.__dict__)
# ##修改类的数据属性
student.country="CHINA"
print(student.country)
b：特殊的类属性
类名.__name__# 类的名字(字符串) 类名.__doc__# 类的文档字符串 类名.__base__# 类的第一个父类(在讲继承时会讲) 类名.__bases__# 类所有父类构成的元组(在讲继承时会讲) 类名.__dict__# 类的字典属性 类名.__module__# 类定义所在的模块 类名.__class__# 实例对应的类(仅新式类中) 2、对象的相关知识（1）对象是由类实例化而来的，对象也称实例对象/实例只有一种作用：属性引用（数据属性即变量），没有函数属性关于对象调用，用以下示例
class student:
country="china"
def __init__(self,id,name,age,sex):
self.id=id
self.name=name
self.age=age
self.sex=sex
def search_sore(self):
print("good")
def study(self):
print("well")
s1=student("123","xuyuanyuan","18","girl")
print(s1.name)
print(s1.id)
print(s1.sex)
（2）实例属性
实例属性和查看实例属性的方法如下：
同样是dir和内置__dict__两种方式
示例：
class student:
country="china"
def __init__(self,id,name,age,sex):
self.id=id
self.name=name
self.age=age
self.sex=sex
def search_sore(self):
print("good")
def study(self):
print("well")
s1=student("123","xuyuanyuan","18","girl")#实例化
print(s1.__dict__)#查看对象
示例：类的“增”、“删”、“改”、“查”
class student:
country="china"
def __init__(self,id,name,age,sex):
self.id=id
self.name=name
self.age=age
self.sex=sex
def search_sore(self):
print("good")
def study(self):
print("well")
s1=student("123","xuyuanyuan","18","girl")#实例化
##关于对象
#增
s1.weight=100
print(s1.weight)
##删
del s1.sex
print(s1.__dict__)#查看属性字典是否删除成功
##改
s1.age=20
print(s1.age)
##查
print(s1.name)
print(s1.age)
print(s1.__dict__)
总结：
1.其实你会发现，实例化就是 类名()，然后返回的结果是一个对象，加上括号是不是跟函数运行很像，函数运行完了有返回值，是不是很像，没错，就是一样的。
2.函数又作用域的概念，其实类也有作用域的概念，二者一样
3.你可以把class当做最外层的函数，是一个作用域
4.实例化会自动触发init函数的运行，最后返回一个值即实例，我们要找的实例属性就存放在init函数的局部作用域里
5.类有类的属性字典，就是类的作用域，实例有实例的属性字典，即实例的作用域
6.综上，一个点代表一层作用域，obj.x先从自己的作用域找，自己找不到去外层的类的字典中找，都找不到，就会报错
7.在类中没有使用点的调用，代表调用全局变量。
关于类和对象名称空间的查看（即作用域）：
示例：
class Teacher:
def __init__(self,name,sex,level):
self.name=name
self.sex=sex
self.level=level
self.course_list=[]
def teach(self):
pass
t1=Teacher("tom","man","A")
print(Teacher.__dict__)#类的名称空间查看
print(t1.__dict__)#对象的名称空间查看
执行结果是：
{‘__module__‘: ‘__main__‘, ‘__init__‘: <function Teacher.__init__ at 0x000000000282A9D8>, ‘teach‘: <function Teacher.teach at 0x000000000282AA60>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Teacher‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Teacher‘ objects>, ‘__doc__‘: None}
{‘name‘: ‘tom‘, ‘sex‘: ‘man‘, ‘level‘: ‘A‘, ‘course_list‘: []}
补充：
.的方式调用的是属性，要么跟类有关，要么跟实例有关
不加.就跟类没关，跟实例没关。