Python 面向对象（一）

1      类的定义和使用

 

部分代码：

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

class student:
    school='oldboyedu'
    def learn(self):
        print('is learning')

    def choose_course(self):
        print('%sis choose course'%self)

    #print('===========runing')    #执行类的时候会执行该代码

print(student.__dict__)  #查看名称空间


#查
print(student.school)  #类的数据属性  也就是特征
print(student.learn)   #类的函数属性  也就是技能


#修改
student.school="Oldboyedu"
print(student.school)

#增加
student.address='beijing'
print(student.address)


#删除
del student.address
#print(student.address)#因为删除了 所以会报错


#调用函数

student.choose_course('xxx') #因为有位置参数   所以必须传值

 

 

 

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----------------------------------------

部分代码如下

"""
Description:
Author:Nod
Date:
Record:
#---------------------------------v1-----------------------------------#
"""
#之前的定义方式
# class student:
#     school='oldboy'
#     def learn(self):
#         print(' is learning')
#     def choose_course(self):
#         print(' is choose course')
# #调用类的时候称之为实例化    会产生一个返回值  就是对象
#
# std1=student()
# std2=student()
# std3=student()


#为了定制独有特征，改进的方式

class student:
    school='oldboyedu'
    def __init__(self,name,age,sex):
        """
        init  会在调用类  也就是实例化的时候就会实行
        注意此处将Age与age区分大小写是为了区分
         age表示位置参数，而Age才是类当中的一个特征
        """
        self.Name=name
        self.Age=age
        self.Sex=sex
        """
        python会自动把stu1传进去
        stu1,'nod','25','M'
        self.Age=age 变成 stu1.Age=25
        self.Name=name变成stu1.Name=nod
        self.Sex=sex 变成stu1.Sex=M
        
        """
    def learn(self):
        print('is learn')

    def choose_course(self):
        print('is choose course')


#   调用1个类称之为类的实例化 stu1=student('nod','25','M')
#  1 得到1个返回值  就是对象 但是是一个空对象 stu1
#   stu1.__init__(stu1,'nod','25','M')
stu1=student('nod','25','FM')
print(stu1.__dict__)   #stu1也有自己的名称空间 {'Name': 'nod', 'Age': '25', 'Sex': 'M'}

stu2=student('luna','26','M')
print(stu2.__dict__)

#得到独有属性
print(stu1.Name)
print(stu2.Age)

 上面代码错误部分修改

 

 

 

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('\033[31;1m你的余额是%s\033[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('\033[31;1m测试案例分割\033[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
代码如下：

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

"""
需求 ：
  1定义1个老师类   
  2定义一定的数据属性和函数方法
   3 特例：每个老师都可以看到当前老师的个数
"""
#类的创建
class Teacher:
    school='oldboyedu'
    count=0
    def __init__(self,name,age,sex,salary):
        #建议区分大小写  一个是函数的位置参数  一个是对象的属性
        self.Name=name
        self.Age=age
        self.Sex=sex
        self.Salary=salary
        Teacher.count+=1
    def teach(self):
        print('%s is teach Python'%self.Name)

    def salary(self):
        print('%s salary is %s'%(self.Name,self.Salary))

#类的实例化

tea1=Teacher('nod','25','F','4000')
tea2=Teacher('luna','26','M',5000)


tea1.teach()
tea2.salary()
tea1.salary()


print('\033[31;1m老师的个数为：%s\033[0m'%Teacher.count)
print(tea1.count)

 

 

 

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

示例代码：

"""
Description:
Author:Nod
Date:18-05-05
Record:
#---------------------------------v1-----------------------------------#
"""
#类即类型
l=[1,2,3,4]

print(type(l))


class Teacher:
    school='oldboyedu'
    count=0
    def __init__(self,name,age,sex):
        self.Name=name
        self.Age=age
        self.Sex=sex
        Teacher.count+=1

    def teach(self):
        print('%sis teach python'%self.Name)

tea1=Teacher('nod','25','F')
tea2=Teacher('luna','26','M')

print(tea1.count)
print(type(tea1))   #<class '__main__.Teacher'>

print(id(tea1))
print(id(tea2))

Teacher.teach(tea1)
l1=[1,2,3,4]
l2=[3,4,5,6]
#在python当中一切皆对象
"""
list.append(l1,'l1')的时候 实际上是list.append(self) 将l1传给self 再讲值传递进去
类似于l1.append('l1')
"""
list.append(l1,'l1')
list.append(l2,'l2')
print(l1)
print(l2)

 

 

5　　对象之间的交互

 

class Gailun:
    country = 'demaxia'

    def __init__(self, name, age, life_value, att):
        self.name = name
        self.age = age
        self.life_value = life_value
        self.att = att

    def attack(self, enemy):
        enemy.life_value -= self.att


class Riwen:
    country = 'nocxus'

    def __init__(self, name, age, life_value, att):
        self.name = name
        self.age = age
        self.life_value = life_value
        self.att = att

    def attack(self, enemy):
        enemy.life_value -= self.att


g1 = Gailun('nod', '24', 1000, 100)

r1 = Riwen('riwen', '25', 800, 200)

while True:
    if g1.life_value >= 0:
        g1.attack(r1)
        print('riven的生命值是%s' % r1.life_value)
        r1.attack(g1)
        print('galn的生命值是%s' % g1.life_value)
        if r1.life_value < 0:
            print('%s已经阵亡' % r1.name)
            break
    else:
        print('%s已经阵亡，生命值为%s' % (g1.name, g1.life_value))
        break

 

 

 

6　　从代码级别看面向对象

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

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

 

 

示例代码1：

class Mysqlhandler:
    def __init__(self,host,port,charset='utf-8'):
        self.Host=host
        self.Port=port
        self.Charset=charset
        self.conn=print(host,port,charset)
    def excute1(self,sql):
        return self.conn.excute(sql)
    def excute2(self,process_name):
        return self.conn.excute(process_name)

obj=Mysqlhandler('127.0.0.1','3306')
obj.excute1('select * from g_sn_status')
obj.excute2('process_name')

 示例代码2

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


class MysqlHandler:
    def __init__(self, host, port, db, charset='utf-8'):
        self.Host = host
        self.Port = port
        self.Db = db
        self.Charset = charset
        self.conn = print(host, port, db, charset)  # 此处print模拟数据库连接

    def excute1(self, sql):
        return self.conn.excute(sql)

    def excute2(self, process_name):
        return self.conn.excute(process_name)


obj1 = MysqlHandler('172.20.90.114', '3306', 'db1')
obj2 = MysqlHandler('10.10.19.19', '1521', 'historydb')
obj1.excute1('select * from g_sn_status')
obj2.excute2('process_copy')