一、类和对象
#创建类,类名为mail
class mail:
#【方法】
def email(self,mail,neirong):
print("收件人: ",mail,"
内容: ",neirong)
return True #如果不定义返回值，默认为None
#【调用】
obj = mail() #创建对象，对象名obj
obj.email('Admin','你好,请查收附件表格。') #通过对象执行方法
注：当执行obj = mail()时，类对象指针将obj指向了类mail。
二、面向对象
概念：面向对象是一种编程方式，需要类和对象来实现。
类就是一个模板，模板里包含多个函数，函数里实现一些功能。
对象是根据类创建的一个实例，通过实例对象可以执行类中的函数。
面向对象也是对函数或事物进行分类和封装。
面向对象三大特性：
封装，继承，多态
1.函数式编程和面向对象编程对比
函数式编程
def add(host,username,passwd):
print(host,username,passwd,"add")
def remove(host,username,passwd):
print(host,username,passwd,"remove")
def modify(host,username,passwd):
print(host,username,passwd,"modify")
def select(host,username,passwd):
print(host,username,passwd,"select")
#执行函数
add('host.com','admin','123')
remove('host.com','admin','123')
modify('host.com','admin','123')
select('host.com','admin','123')
面向对象编程
class SQLHelper:
def fetch(self, sql):
print(self.hhost)
print(self.uuserane)
print(self.pwd)
def create(self, sql):
pass
def remove(self, nid):
pass
def modify(self, name):
pass
obj1 = SQLHelper()
#以下定义的值被封装到对象obj1中,在类中可以直接调用。
obj1.hhost = "c1.salt.com"
obj1.uuserane = "alex"
obj1.pwd = "123"
obj1.fetch("select * from A")
2.什么情况下适合使用面向对象？
当某一些函数具有相同参数时，可以使用面向对象的方式，将参数值一次性的封装到对象，以后去对象中取值即可。
三、self是什么？
self是一个python会自动给传值的参数。 哪个对象执行方法，self就是谁。 obj1.fetch(.....) self = obj1
四、构造函数
类中有一个特殊的方法,叫__init__方法。
当python解释器遇到类名加()时,会自动执行这个类的init方法
class S1:
def __init__(self):
print('自动执行init')
obj = S1()
五、封装
封装：将内容封装到某个地方，以后再去调用被封装在某处的内容
将内容封装到某处
从某处调用被封装的内容
对象可以封装任何类型的数据
1.封装字符串
class sql:
def __init__(self,a,b,c): #构造方法，通过类创建对象时自动执行
print("自动执行init")
self.hhost = a
self.uusername = b
self.ppasswd = c
def create(self,sql):
print(self.uusername)
def select(self,sql):
print(self.ppasswd)
obj1 = sql('admin.com','admin',123) #将三个值分别封装到obj1(self) a,b,c属性中
obj1.select("select * from S")
#调用
print(obj1.hhost)
print(obj1.uusername)
print(obj1.ppasswd)
2.封装对象
#把对象c2_obj封装到c1_obj对象中，并赋值给c1类中的obj属性
class c2:
def __init__(self,name,age):
self.name = name
self.age = age
#方法里面没有返回值，默认返回none
def show(self):
print('c2')
c2_obj = c2('c2',11)
c1_obj = c1('c1',c2_obj)
print(c1_obj.name,c1_obj.obj.name)
3.多层封装
class c1:
def __init__(self,name,obj):
self.name = name
self.obj = obj
#把对象c2_obj封装到c1_obj对象中，并赋值给c1类中的obj属性
class c2:
def __init__(self,name,age):
self.name = name
self.age = age
#方法里面没有返回值，默认返回none
def show(self):
print('c2')
class c3:
def __init__(self,name,age):
self.name = name
self.age = age
c2_obj = c2('c2',11)
c1_obj = c1('c1',c2_obj)
c3_obj = c3('c3',c1_obj)
c3_obj.age.obj.show()
六、继承与多继承
1.继承
子类可以继承父类的内容。
#子类继承父类的所有功能，相当于在子类中又复制了一份方法
#子类 ==> 父类 派生类 ==> 基类
class F1:
def show(self):
print('F1')
def foo(self):
print(self.name)
class F2(F1):
def __init__(self):
self.name = 1234
def showtime(self):
print('F2')
obj = F2()
obj.show() #打印结果 F1
obj.foo() #打印结果 1234
#如果子类和父类中有相同的方法，优先调用子类自己的方法。
class S1:
def F1(self):
self.F2()
def F2(self):
print('S1.F2')
class S2(S1):
def F3(self):
self.F1()
def F2(self):
print('S2.F2')
obj = S2()
obj.F3()
多继承
#多继承，查找方法
#查找方法的顺序根据传入参数的顺序
class A:
def A(self):
print('再找我')
class B(A):
def B(self):
print('先找我')
class C:
def __init__(self):
print('我是在创建对象时默认执行的')
def C(self):
print('都不行，再找我')
class D(B,C):
def D(self):
self.A()
obj = D()
obj.A()
#当多个子类拥有相同的父类时，方法是如何去查找和使用的
#当多个子类拥有相同的父类时,
class A0:
def A0(self):
print('A0')
class A1(A0):
def A1(self):
print('A1')
class A2(A0):
def A2(self):
print('A2')
class A3(A1):
def A3(self):
print('A3')
class A4(A2):
def A4(self):
print('A2')
class A5(A3,A4):
def A5(self):
print('A5')
obj = A5()
obj.A0()
#
class A:
def some(self):
print('打印我')
class D:
def forever(self):
self.run()
class C(D):
def __init__(self):
print('init2')
def run(self):
self.some()
class B(C):
def __init__(self):
print('init')
def some(self):
print('打印我？')
class E(A,B):
def __init__(self):
pass
obj = E()
obj.forever()