Python面向对象编程（一）

第1个：面向对象基础

1、python 支持 函数式 + 面向对象 编程

2、函数式编程实现发送邮件功能

 1     def mail (mail,message):
 2         print ("发送")
 3         return True
 4         
 5     mail("lalala", "好")
 6    -------------------------------
 7     面向对象：类，对象
 8     #创建类
 9     class foo：
10         #方法
11         def mail (self,mail,message):
12             print ("发送")
13             return True
14     #创建对象        
15     obj = foo()
16     #通过对象执行方法
17     obj.mail("lalala", "好")


第2个：面向对象编程和函数式编程对比

    创建类，类里边是方法
    创建对象
    对象调用类里的方法
    
函数式：

1     def fetch(host,usernam,password,sql):
2         pass
3     def create(host,usernam,password,sql):
4         pass
5     def remove(host,usernam,password,sql):
6         pass
7     remove(127.0.0.1,sa,sa,select * from user;)


面向对象：

 1     class sqlhelp:
 2         def fetch(self,host,usernam,password,sql):
 3             pass
 4         def create(self,host,usernam,password,sql):
 5             pass
 6         def remove(self,host,usernam,password,sql):
 7             pass
 8     obj = sqlhelp()
 9     obj.fetch(.......)
10    --------------------------------------------
11     class sqlhelp:
12         def fetch(self,sql):
13             pass
14         def create(self,sql):
15             pass
16         def remove(self,sql):
17             pass
18     obj = sqlhelp()
19     #把host,usernam,pwd封装到对象里
20     obj.host="127.0.0.1"
21     obj.usernam="lala"
22     obj.pwd="lalala"
23     
24     obj.fetch("select * from user")
25     !#方法中的self就相当于obj定义的host,usernam,pwd三个值

什么时候用面向对象？
    有共同的参数，且将参数值一次性封装到对象，以后在对象中取值
    
第3个：面向对象中对象和类的关系

    self是什么鬼？
    self是一个python自动会给传值的参数
    
    那个对象执行方法，self就是谁！
    
第4个：面向对象之构造方法

 1     class sqlhelp:
 2         
 3         def __init__(self):
 4             print("自动执行init")
 5         
 6         def fetch(self,sql):
 7             pass
 8         
 9     obj = sqlhelp()  #创建对象=类名() ，在方法中自动执行一个init函数
10     -------------------------------------------
11     class sqlhelp:
12         
13         def __init__(self,a1,a2,a3):
14             print("自动执行init")
15             self.host=a1
16             self.user=a2
17             self.pwd=a3
18         
19         def fetch(self,sql):
20             pass
21         
22     obj = sqlhelp("xietong.live","sa","123456")
23     obj.fetch("select * from user")

  
    类中有一个特殊的方法init，类() 自动被执行。
    init方法为 构造方法！
    
第5个：面向对象之应用场景实例

 1     class person：
 2         def __init__(self,name,age,money):
 3             self.name=name
 4             self.age=age
 5             self.money=money
 6         
 7         def shop(self):
 8             self.money=self.money-2
 9         
10     la= person("hk",26,1000)
11     la.shop()
12     print(la.money)

   
面向对象三大特性：封装、继承、多态（python没有意义）
上边的例子为特性之一的：封装。

第6个：面向对象之对象中封装对象

    自带类：str,list,dict,tuple,set
    自定义类：
    class foo：
        def bar(self):
            pass

 1 class c1:
 2     def __init__(self,name,obj):
 3         self.name=name
 4         self.obj=obj
 5 class c2:
 6     def __init__(self, name, age):
 7         self.name = name
 8         self.age = age
 9     def show(self):
10         print(self.name)
11 
12 c2_obj = c2("aa",11)
13 print(c2_obj.name)
14 print(c2_obj.age)
15 c1_obj = c1("kk",c2_obj)
16 print(c1_obj.name)
17 print(c1_obj.obj.age) #c1_obj.obj = c2_obj


第7,8个：面向对象之对象中封装对象2,3

 1 class c1:
 2     def __init__(self,name,obj):
 3         self.name=name
 4         self.obj=obj
 5 class c2:
 6     def __init__(self, name, age):
 7         self.name = name
 8         self.age = age
 9     def show(self):
10         print(self.name)
11 
12 class c3:
13     def __init__(self,money,aaa):
14         self.money = money
15         self.aaa= c1_obj
16 
17 
18 c2_obj = c2("aa",11)
19 print(c2_obj.name)
20 print(c2_obj.age)
21 
22 c1_obj = c1("kk",c2_obj)
23 print(c1_obj.name)
24 print(c1_obj.obj.age) #c1_obj.obj = c2_obj
25 
26 c3_obj = c3(1000,c1_obj)
27 print(c3_obj.aaa.obj.name) #c3_obj.aaa = c1_obj
28                            #c3_obj.aaa.obj = c2_obj
29                            #c2_obj.name = a
30 print(c3_obj.aaa.obj.show()) #返回为None，因为方法中没有返回值

                      

第9,10个：面向对象之单继承

1、可以多继承。

2、继承是把上边的东西拿下来。

3、如果本类中存在，自己的优先执行。

 1 class f1: #父类、基类
 2 　　def show(self):
 3　　　　 print("show")
 4 　　def foo(self):
 5 　　　　print(self.name)
 6 class f2(f1): #子类、派生类
 7 　　def __init__(self,name):
 8 　　　　self.name = name
 9 
10 　　def bar(self):
11 　　　　print("bar")
12 
13 　　def show(self):
14 　　　　print("f2show")
15 
16 obj=f2("alex")
17 obj.foo()
18 #print(obj.show())

----------------------------------
重要！阅读源码会经常用到。

 1 class s1:
 2 　　def f1(self):
 3 　　　　self.f2()
 4 　　def f2(self):
 5 　　　　pass
 6 
 7 class s2(s1):
 8 　　def f3(self):
 9 　　　　self.f1()
10 '''
11 def f1(self):
12 self.f2() #拷贝的s1里的f1.self等于obj=s2,执行自己的f2
13 '''
14 　　def f2(self):
15 　　　　print(123)
16 
17 #obj = s1()
18 #obj.f1() #执行s1里的f1、f2
19 
20 obj = s2()
21 obj.f3() #执行s2里的f3，把s1里的f1拿下来了，再执行本类中的f2，输出结果为123

 

第11,12个：面向对象之多继承

 1 class c0():
 2 　　def f2(self):
 3 　　　　print(12)
 4 
 5 class c1(c0):
 6 　　def f0(self):
 7 　　　　print(123)
 8 
 9 class c2():
10 　　def f2(self):
11 　　　　print("c2")
12 
13 class c3(c1,c2): #继承关系左边的优先级高
14 　　def f3(self):
15 　　　　print(67)
16 
17 obj = c3()
18 obj.f2()

 

posted @ 2016-08-05 17:38  韩凯1202  阅读(399)  评论(0)  编辑  收藏  举报