什么是面向对象：
#面向对象
class SQLHelper:
def fetch(self, sq1):
print(sq1)
print(self.hhost) #执行被封装的函数hhost
print(self.uusername) #执行被封装的函数uusername
print(self.pwd) #执行被封装的函数pwd
def create(self, sq1):
pass
def remove(self, nid):
pass
def modify(self, name):
pass
obj = SQLHelper()
obj.hhost = ("cl.star.com") #代表把参数传入 hhost 中封装
obj.uusername = ("Guido") #代表把参数传入 uusername 中封装
obj.pwd = ("123") #代表把参数传入 pwd 中封装
obj.fetch("select*from A") #执行对象obj的fetch方法，将封装的参数传入self中,(" ")中的参数传入sq1
什么时候用面向对象：
当某一些函数具有相同参数时，可以使用面向对象的方式，将参数的值一次性封装在对象里，以后到对象中直接取值。
self是什么：
self是一个python会自动传值得形式参数，哪个对象执行该方法，self就是那个对象。
obj1.fetch("kdi") self = obj1
obj2.fetch("kdi") self = obj2
构造方法：
类中有一个特殊的方法__init__,类（）时对象被建立 __init__就会自动被执行
这个方法可以用来对你的对象做一些你希望的初始化。注意，这个名称的开始和结尾都是双下划线。
class SQLHelper:
def __init__(self, a1, a2, a3): #封装数据
print("自动执行__init__")
self.hhost = a1 #a1 = slkj.com self = obj1
self.uusername = a2 #a2 = Guido self = obj1
self.pwd = a3 #a3 = 123 self = obj1
def fetch(self, sq1): #sq1 = select*from A
pass
def remove(self, nid):
pass
def modify(self, name):
pass
obj1 = SQLHelper("slkj.com", "Guido", 123)
obj1.fetch("select*from A")
类与对象的关系：
两种类型的域——
类的变量和对象的变量，它们根据是类还是对象拥有这个变量而区分。
类的变量：由一个类的所有对象（实例）共享使用。只有一个类变量的拷贝，所以当某个对象对类的变量做了改动的时候，这个改动会反映到所有其他的实例上。
对象的变量：由类的每个对象（实例）拥有。因此每个对象有自己对这个域的一份拷贝，即他们不是共享的，在同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。
面向对象的三大特性：
封装、继承、多态
封装：
class c1:
def __init__(self, name, obj):
self.name = name
self.obj = obj
class c2:
def __init__(self, name, age):
self.name = name
self.age = age
def show(self):
print(self.name)
class c3:
def __init__(self, a1):
self.money = 123
self.aaa = a1
c2_obj = c2("aa", 11) #c2_obj是c2的类,name="aa",age=11
c1_obj = c1("Guido", c2_obj) #c1_obj是c1类型,name="Guido",obj=c2_obj
print(c1_obj.obj.age)
c3_obj = c3(c1_obj) #c1_obj=a1
print(c3_obj.aaa.name,type(c3_obj.aaa.name))
继承：
面向对象编程带来的好处之一就是代码重用，实现这种方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Guido's admirers
class We:
def __init__(self, name):
self.name = name
def li(self):
print("TT", self.name)
class No(We):
def __init__(self, age, name):
We.__init__(self, name)
self.age = age
def MM(self):
print("Good", self.name, self.age)
obj = No("guido", 27)
obj.MM()
执行结果：
Good 27 guido
单继承：
相当于把父类写入子类里
class F1:
def show(self):
print("show")
def foo(self):
print(self.name)
class F2(F1): #子类，派生类
def __init__(self, name):
self.name = name
def bar(self):
print("bar")
def show(self):
print("F2.show")
obj = F2("Guido")
obj.show() #优先执行本类中的同名方法
obj.foo()
class S1:
def F1(self):
self.F2()
def F2(self):
pass
class S2(S1):
def F3(self):
self.F1()
def F2(self):
pass
obj = S2()
obj.F3()
obj1 = S1()
obj1.F1()
#执行过程中子类中没有的方法去父类里找，父类中与子类中同时有的方法，子类中的方法优先执行。
多继承：
class c3(c1,c2)
多态：
多种形态，多种类型
def func(arg):
print(arg)
func(1) #对对象进行封装时数据可以是多种类型
func("Guido")
func([11, 22, 33])
在：c#与java中没有多态，指定形式参数时要指出参数类型，只能通过类的继承增加多态的形式，类与该类的子类。
#此代码只做演示便于理解，不是正确的。
def func(int arg):
func(123)
func("Guido") #报错
class A:
pass
class B(A):
pass
class C(A):
pass
def func(A, arg): #aeg参数：必须是A类型或A的子类型
print(arg)
obj = A(arg)
func(obj)