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类东西时才使用面向对象编程
##类成员：实际上就是类里面的方法和字段、属性，统称为类的成员
为什么会定义属性：就是把方法伪造、修饰成1个字段，
#属性与方法的区别：
1.属性在定义时要在上方加装饰器，即@property
2.属性调用时不用加括号，即obj.attribute
3.属性是方法的1种，只是我们对方法进行改造，然后访问调用的时候以字段的形式访问
示例：
class Person(object):
def __init__(self):
self.name = name
self.age = age
def func(self): #这是定义方法
return "123"
@property
def attribute(self): #这才是定义属性
return "123"
obj = Person('jachy',21)
obj.attribute #调用属性
obj.func() #调用方法
***静态字段和普通字段的区别：
1.静态字段保存在类里面
2.普通字段保存在对象里面
如下图：
示例：
class Person(object):
name = "jachy" #这种就是静态字段，保存在类中
def __init__(self,name,age):
self.name = name #这种就是普通字段，保存在对象之中
self.age = age
obj = Person("lilin",21)
obj.name #访问普通字段 ，通过对象来访问
Person.name #访问静态字段，通过类来访问
#类方法、静态方法、普通方法
class Province(object):
def __init__(self):
pass
def f1(self): #定义普通方法，调用时将对象obj赋给self
pass
@classmethod #定义类方法：用classmethod来装饰
def f2(cls): #参数用cls而不用self,cls全称是class，调用时将自身Province赋给cls（只能用cls参数）
pass
#类里面定义静态方法=====函数
@staticmethod #定义静态方法，用@staticmethod来修饰
def f3(arg1,arg2): #定义静态方法，参数可以随便写
pass
#普通方法的访问
obj=Province()
obj.f1() #触发者是对象obj
#类方法的访问
Province.f2() #触发者是类Province
#静态方法的访问
Province.f3() #触发者是类Province
类方法和静态方法（他们俩访问时无需创建对象，其调用者是类；而普通方法访问是必须创建对象，其调用者是对象）
1.类方法里面只能传1个参数
2.静态方法相当于是函数
属性（python熟悉用得非常少，因为它不太完善，新式类中才使用属性）
为什么要有属性？为了把方法伪造、“修饰”成1个字段，只能有1个self参数
定义属性的2种表达方式：1.通过装饰器来设置属性；2.直接执行property(func)方法
**********定义属性：方法1***************
class Pager:
def __init__(self,current_page):
self.current_page = current_page
self.per_items = 10
@property
def start(self):
val = (current_page - 1) * self.per_items
return val
@property
def end(self):
val = self.current_page * self.per_items
return val
图1：定义属性的方式1
###########调用######################
p = Pager(3)
p.start #调用属性
p.stop #调用属性
"""
在连接数据库中时采用属性来定义范围
select * from a limit p.start:p.stop
"""
********定义属性：方式2************
##分2步：
1.在即定义1个方法get_bar()
2.在定义1个变量，如这里BAR = property(get_bar),将方法的指针或地址传给property()即可
class Foo:
def get_bar(self):
return "jachy"
BAR = property(get_bar) #给get_bar方法定义装饰器
#调用
obj = Foo()
result = obj.BAR
print result
图2：定义属性的方式2
在类后面加括号和在对象后面加括号的区别？
1.在对象后面加括号，如obj()表示调用对应类中的__call__方法
2.在类后面加括号，如Foo("jachy")表示实例化1个类
图1：
图2：
__dict__函数的使用
图1.对象名.__dict__的使用（写cmdb的使用常用）：其实就是输出对象内部的字段并以字典的形式保存下来
图2：类名.__dict__的使用：其实就是输出类里面存储的字段或方法
__str__函数的使用
图1：当没有定义__str__方法时，直接输出obj对象，其实就是输出obj对象在内存中的地址
图2：当在类中定义了__str__方法之后，输出对象obj就是调用obj对象对应类中的__str__方法的返回值
