1.类和对象之封装
#方法1
def Bar():
print "Bar"
def Hello(name):
print "i am %s" %(name)
#方法2
class Foo():
def Bar(self):
print 'Bar'
def Hello(self,name):
print "i am %s" %name
对于数据库的增删改查
####方式1
def fetch(hostname,port,username,password,db):
#1.连接数据库,并且指定hostname、port、username、password、db
#2.打开数据库
#3.操作数据库，向数据库添加内容
#4.关闭数据库
pass
def modify(hostname,port,username,password,db):
#1.连接数据库,并且指定hostname、port、username、password、db
#2.打开数据库
#3.操作数据库，向数据库添加内容
#4.关闭数据库
pass
def remove(hostname,port,username,password,db):
#1.连接数据库,并且指定hostname、port、username、password、db
#2.打开数据库
#3.操作数据库，向数据库添加内容
#4.关闭数据库
pass
def create(hostname,port,username,password,db):
#1.连接数据库,并且指定hostname、port、username、password、db
#2.打开数据库
#3.操作数据库，向数据库添加内容
#4.关闭数据库
pass
#将列表添加到数据库
create([11,22,33])
利用函数式编程，每一次都要将hostname、port、username、password、db传进去然后进行操作
####方式2
#封装：就是变一些变量封装到内存地址里面
#下面我们使用类来实现数据库的增删查改
class Foo:
#这个__init__()称为构造方法，当类实例化的时候就执行
#与函数式编程不同：
##将hostname、port、username、password、db封装到self变量里面,
##当类里面的方法要用到这些参数时，我们直接传self传进去即可，而不用每次1个1个参数传进去
def __init__(self,hostname,port,username,password,db):
self.hostname = hostname
self.port = port
self.username = username
self.password = password
self.db = db
#
def fetch(self):
pass
def remove(self):
pass
def create(self):
pass
def modify(self):
pass
obj1 = Foo(hostname,port,username,password,db)
obj1 = Foo(1.1.1.1,port,username,password,db)
obj2 = Foo(2.2.2.2,port,username,password,db)
obj1.create()
obj1.create()
整个流程：
1.创建Foo类，
（
1.这个步骤包括3步：
1.创建Foo类
2.创建构造函数，将后续要用到的参数封装到self里面；
3.然后创建一系列的方法
）
2.用类Foo创建obj1对象，即将Foo类实例化
（
1.这个过程包括了2步操作 ：
1.将字段hostname、port、username、password、db_name通过Foo(args)传进去，这些字段就被封装到obj1中；
2.然后创建类对象指针，类对象指针指向内存中的Foo类
）
3.当执行obj.create(self)方法时，即调用obj对象中的create(args)方法，
（
1.这个过程包括2步操作：
1.通过obj对象中的类对象指针找到Foo类中，并调用Foo类中的create()方法
2.返回到obj对象中，取出obj对象中的hostname、port、username、password、db_name字段
3.将取到的这些字段传到类中的create()方法中，执行即可
）
注意：
1.对象只封装字段和类对象指针
2.通过对象来执行类中的方法
2.面向对象之继承
0.怎么使用继承，为什么要使用继承？
#1.方法1
class cat:
def eat(self):
pass
def cry(self):
pass
def drink(self):
pass
def walk1(self):
pass
class dog():
def eat(self):
pass
def cry(self):
pass
def drink(self):
pass
def walk2(self):
pass
#方法2:
class animal: #基类
def eat(self):
pass
def cry(self):
pass
def drink(self):
pass
class dog(animal): #派生类，继承父类animal
def walk2(self):
pass
class cat(animal): #派生类，继承父类animal
def walk1(self):
pass
1.经典类和新式类
##python其实开始只有函数式编程--->然后又有了初级类和对象进行编程--->然后又有了高级类和面向对象编程
*****经典类****** *****新式类*****
经典类：
class C:
pass
新式类：
class C(object):
pass
或
class C(object):
pass
class D(C):
pass
【注意：python3.0只支持新式类，java、c#只能继承1个类，不支持继承多个，而python可以继承多个类】
2.新式类和经典类在多继承中的区别（B、C都继承D）
1.新式类在定义中会在基类或其子类中定义继承object这个类，然而经典类不会定义继承object。
2.新式类在执行多继承，会采用广度优先策略，然而经典类采用深度优先策略。（B、C都继承D才是使用深度优先）
那么什么时候使用面向对象编程呢？
1.多个方法要使用同一个变量或多个变量时采用面向对象编程，即在构造函数中封装
2.当通过模板创建1类东西时才使用面向对象编程
