面向过程编程：
核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么后干什么。。。
基于该思想编写程序就好比在设计一条流水线，是一种机械式的思维方式
优点：复杂的问题流程化，进而简单化
缺点：功能扩展性差
面向对象编程：
核心是对象二字，对象是特征与功能的结合体
基于该思想在编写程序就好比在创造一个世界，世界万物都是对象，你就是这个世界的上帝
对象是特征与功能的结合体，类就是一系列对象相似的特征与技能结合体 站在不同的角度，总结出的类也是截然不同的
在现实世界中一定是先有一个个具体存在的对象，然后随着人类文明地发展而总结出了不同的类
在程序中务必先定义类，后调用类来产生对象
在现实世界中总结对象----》抽取相似之处，得到现实世界中的类----》定义为程序中的类----》调用类，产生程序中的对象
站在老男孩选课系统的角度：
现实世界中的老男孩学生对象：
对象1：
特征：
学校='oldboy'
姓名='耗哥'
年龄=18
性别='male'
技能：
选课
对象2：
特征：
学校='oldboy'
姓名='猪哥'
年龄=17
性别='male'
技能：
选课
对象3：
特征：
学校='oldboy'
姓名='帅翔'
年龄=19
性别='female'
技能：
选课
站在老男孩选课系统的角度，先总结现实世界中的老男孩学生类
老男孩学生类：
相似的特征：
学校='oldboy'
相似的技能
选课
'''
1、先定义类
class OldboyStudent:
school='oldboy'
def choose_course(self):
print('is choosing course')
#强调：类定义阶段会立刻执行类体代码，会产生类的名称空间，将类体代码执行过程中产生的名字都丢进去
# print(OldboyStudent.__dict__)
# 类本质就是一个名称空间/容器，从类的名称空间中增/删/改/查名字
# python为我们提供专门访问属性（名称空间中的名字）的语法，点后的都是属性
# OldboyStudent.school #OldboyStudent.__dict__['school']
# OldboyStudent.x=1 #OldboyStudent.__dict__['x']=1
# OldboyStudent.school='Oldboy' #OldboyStudent.__dict__['school']='Oldboy'
# del OldboyStudent.x #del OldboyStudent.__dict__['x']
# 类中定义的函数是类的函数属性，类可以使用，但使用的就是一个普通的函数而已，意味着需要完全遵循函数的参数规则，该传几个值就传几个
# OldboyStudent.choose_course(123)
#2、后调用类产生对象，调用类的过程称之为实例化，实例化的结果称为类的一个实例或者对象
stu1=OldboyStudent()
stu2=OldboyStudent()
stu3=OldboyStudent()
# print(stu1)
# print(stu2)
# print(stu3)
# print(OldboyStudent.school)
# OldboyStudent.school='OLDBOY'
# print(stu1.school)
# print(stu2.school)
# print(stu3.school)
02 为对象定制自己独有的属性
class OldboyStudent:
def choose_course(self):
print('is choosing course')
stu2=oldboyStudent()
stu3=oldboyStudent()
# print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)
stu1.age=18
stu1.sex='male'
# print(stu1.name,stu1.age,stu1.sex)
# print(stu1.__dict__)
stu2.name='猪哥'
stu2.age=17
stu2.sex='male'
stu3.name='帅翔'
stu3.age=19
stu3.sex='female'
class OldboyStudent:
school='oldboy'
def choose_course(self):
print('is choosing course')
stu2=OldboyStudent()
stu3=OldboyStudent()
def init(obj,x,y,z):
obj.name=x
obj.age=y
obj.sex=z
# stu1.name='耗哥'# stu1.age=18
# stu1.sex='male'
init(stu1,'耗哥',18,'male')
# stu2.name='猪哥'
# stu2.age=17
# stu2.sex='male'
init(stu2,'诸哥',17,'male')
# stu3.name='帅翔'
# stu3.age=19
# stu3.sex='female'
init(stu3,'帅翔',19,'female')
print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
'''
class OldboyStudent:
school='oldboy'
def __init__(obj,x,y,z):
obj.name=x
obj.age=y
obj.sex=z
def choose_course(self):
print('is choosing course')
#调用类时发生两件事
#1、创造一个空对象stu1
#2、自动触发类中__init__功能的执行，将stu1以及调用类括号内的参数一同传入
stu1=OldboyStudent('jammy',18,'male')
stu2=OldboyStudent('猪哥',17,'male')
stu3=OldboyStudent('帅翔',19,'female')
stu1=OldboyStudent('耗哥',18,'male') #OldboyStudent.__init__(stu1,'耗哥',18,'male')
stu2=OldboyStudent('猪哥',17,'male')
stu3=OldboyStudent('帅翔',19,'female')
print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
03 属性查找
school='oldboy'
count=0
def __init__(self,x,y,z):
self.name=x
self.age=y
self.sex=z
def choose_course(self):
print('is choosing course')
stu1=OldboyStudent('jammy',18,'male')
stu2=OldboyStudent('猪哥',17,'male')
stu3=OldboyStudent('帅翔',19,'female'
print(OldboyStudent.count)
print(stu1.count)
print(stu2.count)
print(stu3.count)
04 绑定方法
class OldboyStudent:
school='oldboy'
def __init__(self,x,y,z):
self.name=x
self.age=y
self.sex=z
def choose_course(self,x):
print('%s is choosing course'%self.name)
stu1=OldboyStudent('耗哥',18,'male')
stu2=OldboyStudent('猪哥',17,'male')
stu3=OldboyStudent('帅翔',19,'female')
print(stu1.name)
print(stu1.school)
# 类中定义的函数是类的函数属性，类可以使用，但使用的就是一个普通的函数而已，意味着需要完全遵循函数的参数规则，该传几个值就传几个
# OldboyStudent.choose_course(123)
# 类中定义的函数是共享给所有对象的，对象也可以使用，而且是绑定给对象用的，
#绑定的效果：绑定给谁，就应该由谁来调用，谁来调用就会将谁当作第一个参数自动传入
# print(id(stu1.choose_course))
# print(id(stu2.choose_course))
# print(id(stu3.choose_course))
以上三种Id都指向同一个内存地址
# print(id(OldboyStudent.choose_course))
类调用的类函数属性指向的内存地址与对象对应的类函数属性不同
# 补充：类中定义的函数，类确实可以使用，但其实类定义的函数大多情况下都是绑定给对象用的，所以在类中定义的函数都应该自带一个参数self
05 类即类型
class OldboyStudent:
school='oldboy'
def __init__(self,x,y,z):
self.age=y
self.sex=y
def choose_course(self,x):
stu1=OldboyStudent('耗哥',18,'male')
# stu1.choose_course(1) #OldboyStudent.choose_course(stu1,1)
# OldboyStudent.choose_course(stu1,1)
列表范例：
l=[1,2,3] #l=list([1,2,3])
# print(type(l))
# l.append(4) #list.append(l,4)
list.append(l,4)
print(l)
06 小结
clss foo:
def __init__(self,host,port,db,chartset):
self.host=host
self.port=port
self.db=db
self.chartset=chartset
def exc1(self,sql)
conn=connect(self.host, self.port, self.db, self.charset)
conn.execute(sql)
return xxx
def exc2(self,proc_name)
conn=connect(self.host, self.port, self.db, self.charset)
conn.execute(sql)
return xxx
def bar:
def __init__(self,x,y,z,a,b,c)
self.x=x
self.y=y
self.z=z
self.a=a
self.b=b
self.c=c
def exec3(self,xxx)
pass
def exc4(self,yyy)
pass
obj1=foo('1.1.1.1',3306,'db1','utf-8')#自定义对应参数的值
obj1.exc1('select * from t1')
obj1.exc1('select * from t2')
obj1.exc1('select * from t3')
obj1.exc1('select * from t4')
obj2=foo('1.1.1.2',3306,'db1','utf-8')##自定义对应参数的值
obj2.exc1('select * from t4')
07 继承与派生
继承是一种新建类的方式，新建的类称之为子类，被继承的类称为父类
继承的特性是，子类会遗传父类的属性
强调：继承是类与类之间的关系
继承的好处就是可以减少代码的冗余
3.如何用继承
在Python中支持一个类同时继承多个父类
在Python3中
如果一个类没有继承任何类，那默认继承object灯
在python2中：
如果一个类没有继承任何类，不会继承object类
但凡继承了object的类以及该类的子类，都是新式类
经典类
没有继承object的类以及该类的子类，都是经典类
class parent1:
pass
class parent2:
pass
class sub1(parent1,parent2):
pass
print(sub1.__bases__)
# print(Parent1.__bases__)
# print(Parent2.__bases__)
08 继承的应用
派生：子类中新定义的属性，子类在使用时始终以自己的为准
class OldboyPeople:
school='oldboy'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
class OldboyStudent(OldboyPeople):
def choose_course(self)：
print('%s is choosing course'%self.name)
class OldboyTeacher(OldboyPeople):
def __init__(self,name,age,sex,level):
# self.name=name
# self.age=age
# self.sex=sex
OldboyPeople.__init__(self.name,age,sex)
self.level=level
def score(self,stu_obj,num)
print('%s is scoring'%self.name)
stu_obj.score=num
stu1=OldboyStudent('耗哥',18,'male')
tea1=OldboyTeacher('egon',18,'male',10)stu1=OldboyStudent
#对象查找属性的顺序：对象自己-》对象的类-》父类-》父类。。。
# print(stu1.school)
# print(tea1.school)
# print(stu1.__dict__)
# print(tea1.__dict__)
tea1.score(stu1,99)
print(stu1.__dict__)
# 在子类派生出的新功能中重用父类功能的方式有两种：
#1、指名道姓访问某一个类的函数：该方式与继承无关
#对象查找属性的顺序：对象自己-》对象的类-》父类-》父类。。。代码量
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.f1()
class Bar(Foo):
def f1(self):
print('Bar.f1')
obj=Bar()
obj.f2()
# '''
# Foo.f2
# Bar.f1
# '''