Python 面向对象（一）

1 类的定义和使用

部分代码：

 1 """
 2 Description:
 3 Author:Nod
 4 Date:
 5 Record:
 6 #---------------------------------v1-----------------------------------#
 7 """
 8 
 9 class student:
10     school='oldboyedu'
11     def learn(self):
12         print('is learning')
13 
14     def choose_course(self):
15         print('%sis choose course'%self)
16 
17     #print('===========runing')    #执行类的时候会执行该代码
18 
19 print(student.__dict__)  #查看名称空间
20 
21 
22 #查
23 print(student.school)  #类的数据属性  也就是特征
24 print(student.learn)   #类的函数属性  也就是技能
25 
26 
27 #修改
28 student.school="Oldboyedu"
29 print(student.school)
30 
31 #增加
32 student.address='beijing'
33 print(student.address)
34 
35 
36 #删除
37 del student.address
38 #print(student.address)#因为删除了 所以会报错
39 
40 
41 #调用函数
42 
43 student.choose_course('xxx') #因为有位置参数   所以必须传值

View Code

2　　对象的定义和使用

说明：在程序中一定要先定义类再产生对象
1 调用类的过程称之为实例化
2 得到1个返回值，即对象
类不是真正存在而对象是真正存在的

对象应该有相同的功能也应该有部分不同的功能属性部分
如何定制对象独有的特征？

之前我们定义类是这样的：

为了定制独有的特征：

----------------------------------------------------add in 18-05-06 begin----------------------------------------

为对象定制独有属性，Python有内置方法__init__

def __init__(self,name,age,sex) 此处表示需要4个位置参数

__init__调用类实例化就触发执行

调用类的功能称之为类的实例化，实例化分为2步骤

stu1=Student（'nod','25','F'）

1 得到1个返回值，即对象，该对象是1个空对象stu1

2 student.__init__(stu1,'nod','25','F') 进行传递

关于此处__init__的传递一定要好好理解

----------------------------------------------------add in 18-05-06 end----------------------------------------

部分代码如下

 1 """
 2 Description:
 3 Author:Nod
 4 Date:
 5 Record:
 6 #---------------------------------v1-----------------------------------#
 7 """
 8 #之前的定义方式
 9 # class student:
10 #     school='oldboy'
11 #     def learn(self):
12 #         print(' is learning')
13 #     def choose_course(self):
14 #         print(' is choose course')
15 # #调用类的时候称之为实例化    会产生一个返回值  就是对象
16 #
17 # std1=student()
18 # std2=student()
19 # std3=student()
20 
21 
22 #为了定制独有特征，改进的方式
23 
24 class student:
25     school='oldboyedu'
26     def __init__(self,name,age,sex):
27         """
28         init  会在调用类  也就是实例化的时候就会实行
29         注意此处将Age与age区分大小写是为了区分
30          age表示位置参数，而Age才是类当中的一个特征
31         """
32         self.Name=name
33         self.Age=age
34         self.Sex=sex
35         """
36         python会自动把stu1传进去
37         stu1,'nod','25','M'
38         self.Age=age 变成 stu1.Age=25
39         self.Name=name变成stu1.Name=nod
40         self.Sex=sex 变成stu1.Sex=M
41         
42         """
43     def learn(self):
44         print('is learn')
45 
46     def choose_course(self):
47         print('is choose course')
48 
49 
50 #   调用1个类称之为类的实例化 stu1=student('nod','25','M')
51 #  1 得到1个返回值  就是对象 但是是一个空对象 stu1
52 #   stu1.__init__(stu1,'nod','25','M')
53 stu1=student('nod','25','FM')
54 print(stu1.__dict__)   #stu1也有自己的名称空间 {'Name': 'nod', 'Age': '25', 'Sex': 'M'}
55 
56 stu2=student('luna','26','M')
57 print(stu2.__dict__)
58 
59 #得到独有属性
60 print(stu1.Name)
61 print(stu2.Age)

View Code

上面代码错误部分修改

3　　属性查找和绑定方法

对象本身只有数据属性
{'Name': 'luna', 'Age': '26', 'Sex': 'M'}
属性查找是针对类跟对象而言如果对象类当中都没有在外部有的话对象去查找也是找不到的

1 查找一个对象属性的顺序是先找对象自己的__dict__ 再找类的
2 类的数据属性是所有对象共享所有对象都指向同1个内存地址
3对象的技能

bound method 绑定方法
绑定方法在类当中定义函数函数绑定给对应的对象使用
类中定义的函数是绑定给对象使用
不同的对象是不同的绑定方法
绑定给谁就应该谁来调用谁来调用就会把谁当做第一个参数传给对应的函数
比如stu1.choose_course() 会把stu1传给def choose_course(self) 当中的self

部分代码如下所示：

"""
Description:
Author:Nod
Date:
Record:18-05-05
#---------------------------------v1-----------------------------------#
"""

class student:
    school='oldboyedu'
    addr='shanghai'
    def __init__(self,name,age,sex):
        self.Name=name
        self.Age=age
        self.Sex=sex

    def learn(self):
        print('%s is learn'%self.Name)

    def choose_course(self):
        print(' is choose course')
    def pay(self,balance):
        print('%s is paying....'%self.Name)
        print('33[31;1m你的余额是%s33[0m'%balance)

stu1=student('nod','25','F')
print(stu1.Name)
stu1.addr='changzhou' #对象新增数据属性
print(stu1.__dict__) #对象的名称空间
print(stu1.addr)  #如果对象当中和类当中存在相同的数据属性  会优先匹配对象当中的数据属性
print(student.addr)
print(stu1.school)  #查找属性的时候 会优先从对象的数据属性进行查找，如果没有找到再去类的数据当中找


#函数属性
print(student.choose_course)#<function student.choose_course at 0x027B5270>
print(stu1.choose_course)#<bound method student.choose_course of <__main__.student object at 0x027C0310>>
#bound method  绑定方法
#类中定义的函数是绑定给对象使用 不同的对象是不同的绑定方法 绑定给谁  就应该谁来调用
#谁来调用就会把谁当做第一个参数传给对应的函数
#比如stu1.choose_course()  会把stu1传给def choose_course(self) 当中的self
print('=================')
stu1.learn()
stu1.choose_course()


#用类的方法实现该功能stu1.learn()

student.learn(stu1)#  将stu1传给def learn(self)的时候 会将stu1的名称空间{'Name': 'nod', 'Age': '25', 'Sex': 'F', 'addr': 'changzhou'}
#传进去，然后拿到其中的self.name显示出来
print(stu1)

#测试案例
print('33[31;1m测试案例分割33[0m')
stu2=student('luna','26','M')
student.pay(stu2,'4000')
"""
还是参照以上的解释，会将stu2的对象属性（名称空间）传给self  然后将4000传给balance
"""
print(stu2.__dict__)   #对象的名称空间
print(student.__dict__)  #类的名称空间

3.1先来一段小例子：

需求 ：
  1定义1个老师类   
  2定义一定的数据属性和函数方法
   3 特例：每个人都可以看到当前老师的个数


解析 ：每次实例化的时候  都会将类当中的count值加1  只有这样每个人都可以看见  如果写在__init__当中是self.count+=1的话  只会给每个实例化对象进行修改；而不是全局
因而要写成Teacher.count+=1
代码如下：

 1 """
 2 Description:
 3 Author:Nod
 4 Date:18-05-05
 5 Record:
 6 #---------------------------------v1-----------------------------------#
 7 """
 8 
 9 """
10 需求 ：
11   1定义1个老师类   
12   2定义一定的数据属性和函数方法
13    3 特例：每个老师都可以看到当前老师的个数
14 """
15 #类的创建
16 class Teacher:
17     school='oldboyedu'
18     count=0
19     def __init__(self,name,age,sex,salary):
20         #建议区分大小写  一个是函数的位置参数  一个是对象的属性
21         self.Name=name
22         self.Age=age
23         self.Sex=sex
24         self.Salary=salary
25         Teacher.count+=1
26     def teach(self):
27         print('%s is teach Python'%self.Name)
28 
29     def salary(self):
30         print('%s salary is %s'%(self.Name,self.Salary))
31 
32 #类的实例化
33 
34 tea1=Teacher('nod','25','F','4000')
35 tea2=Teacher('luna','26','M',5000)
36 
37 
38 tea1.teach()
39 tea2.salary()
40 tea1.salary()
41 
42 
43 print('33[31;1m老师的个数为：%s33[0m'%Teacher.count)
44 print(tea1.count)

View Code

4 　　类即类型在python当中一切皆对象

示例代码：

 1 """
 2 Description:
 3 Author:Nod
 4 Date:18-05-05
 5 Record:
 6 #---------------------------------v1-----------------------------------#
 7 """
 8 #类即类型
 9 l=[1,2,3,4]
10 
11 print(type(l))
12 
13 
14 class Teacher:
15     school='oldboyedu'
16     count=0
17     def __init__(self,name,age,sex):
18         self.Name=name
19         self.Age=age
20         self.Sex=sex
21         Teacher.count+=1
22 
23     def teach(self):
24         print('%sis teach python'%self.Name)
25 
26 tea1=Teacher('nod','25','F')
27 tea2=Teacher('luna','26','M')
28 
29 print(tea1.count)
30 print(type(tea1))   #<class '__main__.Teacher'>
31 
32 print(id(tea1))
33 print(id(tea2))
34 
35 Teacher.teach(tea1)
36 l1=[1,2,3,4]
37 l2=[3,4,5,6]
38 #在python当中一切皆对象
39 """
40 list.append(l1,'l1')的时候 实际上是list.append(self) 将l1传给self 再讲值传递进去
41 类似于l1.append('l1')
42 """
43 list.append(l1,'l1')
44 list.append(l2,'l2')
45 print(l1)
46 print(l2)

View Code

5　　对象之间的交互

 1 class Gailun:
 2     country = 'demaxia'
 3 
 4     def __init__(self, name, age, life_value, att):
 5         self.name = name
 6         self.age = age
 7         self.life_value = life_value
 8         self.att = att
 9 
10     def attack(self, enemy):
11         enemy.life_value -= self.att
12 
13 
14 class Riwen:
15     country = 'nocxus'
16 
17     def __init__(self, name, age, life_value, att):
18         self.name = name
19         self.age = age
20         self.life_value = life_value
21         self.att = att
22 
23     def attack(self, enemy):
24         enemy.life_value -= self.att
25 
26 
27 g1 = Gailun('nod', '24', 1000, 100)
28 
29 r1 = Riwen('riwen', '25', 800, 200)
30 
31 while True:
32     if g1.life_value >= 0:
33         g1.attack(r1)
34         print('riven的生命值是%s' % r1.life_value)
35         r1.attack(g1)
36         print('galn的生命值是%s' % g1.life_value)
37         if r1.life_value < 0:
38             print('%s已经阵亡' % r1.name)
39             break
40     else:
41         print('%s已经阵亡，生命值为%s' % (g1.name, g1.life_value))
42         break

对象之间的交互示例

6　　从代码级别看面向对象

类就是将数据与数据的功能的结合体

专门的功能处理专门的数据
数据与处理数据的功能的捆绑效果

示例代码1：

 1 class Mysqlhandler:
 2     def __init__(self,host,port,charset='utf-8'):
 3         self.Host=host
 4         self.Port=port
 5         self.Charset=charset
 6         self.conn=print(host,port,charset)
 7     def excute1(self,sql):
 8         return self.conn.excute(sql)
 9     def excute2(self,process_name):
10         return self.conn.excute(process_name)
11 
12 obj=Mysqlhandler('127.0.0.1','3306')
13 obj.excute1('select * from g_sn_status')
14 obj.excute2('process_name')

View Code

示例代码2

 1 """
 2 Description:
 3 Author:Nod
 4 Date: 18-05-05
 5 Record:
 6 #---------------------------------v1-----------------------------------#
 7 """
 8 
 9 
10 class MysqlHandler:
11     def __init__(self, host, port, db, charset='utf-8'):
12         self.Host = host
13         self.Port = port
14         self.Db = db
15         self.Charset = charset
16         self.conn = print(host, port, db, charset)  # 此处print模拟数据库连接
17 
18     def excute1(self, sql):
19         return self.conn.excute(sql)
20 
21     def excute2(self, process_name):
22         return self.conn.excute(process_name)
23 
24 
25 obj1 = MysqlHandler('172.20.90.114', '3306', 'db1')
26 obj2 = MysqlHandler('10.10.19.19', '1521', 'historydb')
27 obj1.excute1('select * from g_sn_status')
28 obj2.excute2('process_copy')

示例代码2