DAY7-面向对象之绑定方法与非绑定方法

一、类中定义的函数分成两大类

一：绑定方法（绑定给谁，谁来调用就自动将它本身当作第一个参数传入）：

　　　　1. 绑定到类的方法：用classmethod装饰器装饰的方法。

为类量身定制

类.boud_method(),自动将类当作第一个参数传入

（其实对象也可调用，但仍将类当作第一个参数传入）

　　　　2. 绑定到对象的方法：没有被任何装饰器装饰的方法。

为对象量身定制

对象.boud_method(),自动将对象当作第一个参数传入

（属于类的函数，类可以调用，但是必须按照函数的规则来，没有自动传值那么一说）

二：非绑定方法：用staticmethod装饰器装饰的方法

　　      1. 不与类或对象绑定，类和对象都可以调用，但是没有自动传值那么一说。就是一个普通工具而已

　　　　注意：与绑定到对象方法区分开，在类中直接定义的函数，没有被任何装饰器装饰的，都是绑定到对象的方法，可不是普通函数，对象调用该方法会自动传值，而staticmethod装饰的方法，不管谁来调用，都没有自动传值一说

二、绑定方法

绑定给对象的方法（略）

绑定给类的方法（classmethod）

　　classmehtod是给类用的，即绑定到类，类在使用时会将类本身当做参数传给类方法的第一个参数（即便是对象来调用也会将类当作第一个参数传入），python为我们内置了函数classmethod来把类中的函数定义成类方法

HOST=‘127.0.0.1‘
PORT=3306
DB_PATH=r‘C:\Users\Administrator\PycharmProjects\test\面向对象编程\test1\db‘

settings.py

import settings
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @classmethod
    def from_conf(cls):
        print(cls)
        return cls(settings.HOST,settings.PORT)

print(MySQL.from_conf) #<bound method MySQL.from_conf of <class ‘__main__.MySQL‘>>
conn=MySQL.from_conf()

conn.from_conf() #对象也可以调用，但是默认传的第一个参数仍然是类

三、非绑定方法

在类内部用staticmethod装饰的函数即非绑定方法，就是普通函数

statimethod不与类或对象绑定，谁都可以调用，没有自动传值效果

import hashlib
import time
class MySQL:
    def __init__(self,host,port):
        self.id=self.create_id()
        self.host=host
        self.port=port
    @staticmethod
    def create_id(): #就是一个普通工具
        m=hashlib.md5(str(time.time()).encode(‘utf-8‘))
        return m.hexdigest()

print(MySQL.create_id) #<function MySQL.create_id at 0x0000000001E6B9D8> #查看结果为普通函数
conn=MySQL(‘127.0.0.1‘,3306)
print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8> #查看结果为普通函数

四、classmethod与staticmethod的区别

import settings
class MySQL:
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @staticmethod
    def from_conf():
        return MySQL(settings.HOST,settings.PORT)

    # @classmethod #哪个类来调用,就将哪个类当做第一个参数传入
    # def from_conf(cls):
    #     return cls(settings.HOST,settings.PORT)

    def __str__(self):
        return ‘就不告诉你‘

class Mariadb(MySQL):
    def __str__(self):
        return ‘<%s:%s>‘ %(self.host,self.port)

m=Mariadb.from_conf()
print(m) #我们的意图是想触发Mariadb.__str__,但是结果触发了MySQL.__str__的执行，打印就不告诉你：

mariadb是mysql

mariadb是mysql

五、练习

定义MySQL类

　　1.对象有id、host、port三个属性

　　2.定义工具create_id，在实例化时为每个对象随机生成id，保证id唯一

　　3.提供两种实例化方式，方式一：用户传入host和port 方式二：从配置文件中读取host和port进行实例化

　　4.为对象定制方法，save和get_obj_by_id，save能自动将对象序列化到文件中，文件路径为配置文件中DB_PATH,文件名为id号，保存之前验证对象是否已经存在，若存在则抛出异常，;get_obj_by_id方法用来从文件中反序列化出对象

#settings.py内容
‘‘‘
HOST=‘127.0.0.1‘
PORT=3306
DB_PATH=r‘E:\CMS\aaa\db‘
‘‘‘
import settings
import uuid
import pickle
import os
class MySQL:
    def __init__(self,host,port):
        self.id=self.create_id()
        self.host=host
        self.port=port

    def save(self):
        if not self.is_exists:
            raise PermissionError(‘对象已存在‘)
        file_path=r‘%s%s%s‘ %(settings.DB_PATH,os.sep,self.id)
        pickle.dump(self,open(file_path,‘wb‘))

    @property
    def is_exists(self):
        tag=True
        files=os.listdir(settings.DB_PATH)
        for file in files:
            file_abspath=r‘%s%s%s‘ %(settings.DB_PATH,os.sep,file)
            obj=pickle.load(open(file_abspath,‘rb‘))
            if self.host == obj.host and self.port == obj.port:
                tag=False
                break
        return tag
    @staticmethod
    def get_obj_by_id(id):
        file_abspath = r‘%s%s%s‘ % (settings.DB_PATH, os.sep, id)
        return pickle.load(open(file_abspath,‘rb‘))

    @staticmethod
    def create_id():
        return str(uuid.uuid1())

    @classmethod
    def from_conf(cls):
        print(cls)
        return cls(settings.HOST,settings.PORT)

# print(MySQL.from_conf) #<bound method MySQL.from_conf of <class ‘__main__.MySQL‘>>
conn=MySQL.from_conf()
conn.save()

conn1=MySQL(‘127.0.0.1‘,3306)
conn1.save() #抛出异常PermissionError: 对象已存在

obj=MySQL.get_obj_by_id(‘7e6c5ec0-7e9f-11e7-9acc-408d5c2f84ca‘)
print(obj.host)

创建唯一id之UUID

class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now(): #用Date.now()的形式去产生实例,该实例用的是当前时间
        t=time.localtime() #获取结构化的时间格式
        return Date(t.tm_year,t.tm_mon,t.tm_mday) #新建实例并且返回
    @staticmethod
    def tomorrow():#用Date.tomorrow()的形式去产生实例,该实例用的是明天的时间
        t=time.localtime(time.time()+86400)
        return Date(t.tm_year,t.tm_mon,t.tm_mday)

a=Date(‘1987‘,11,27) #自己定义时间
b=Date.now() #采用当前时间
c=Date.tomorrow() #采用明天的时间

print(a.year,a.month,a.day)
print(b.year,b.month,b.day)
print(c.year,c.month,c.day)

#分割线==============================
import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    @staticmethod
    def now():
        t=time.localtime()
        return Date(t.tm_year,t.tm_mon,t.tm_mday)

class EuroDate(Date):
    def __str__(self):
        return ‘year:%s month:%s day:%s‘ %(self.year,self.month,self.day)

e=EuroDate.now()
print(e) #我们的意图是想触发EuroDate.__str__,但是结果为
‘‘‘
输出结果:
<__main__.Date object at 0x1013f9d68>
‘‘‘
因为e就是用Date类产生的,所以根本不会触发EuroDate.__str__,解决方法就是用classmethod

import time
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day
    # @staticmethod
    # def now():
    #     t=time.localtime()
    #     return Date(t.tm_year,t.tm_mon,t.tm_mday)

    @classmethod #改成类方法
    def now(cls):
        t=time.localtime()
        return cls(t.tm_year,t.tm_mon,t.tm_mday) #哪个类来调用,即用哪个类cls来实例化

class EuroDate(Date):
    def __str__(self):
        return ‘year:%s month:%s day:%s‘ %(self.year,self.month,self.day)

e=EuroDate.now()
print(e) #我们的意图是想触发EuroDate.__str__,此时e就是由EuroDate产生的,所以会如我们所愿
‘‘‘
输出结果:
year:2017 month:3 day:3
‘‘‘

原文地址：https://www.cnblogs.com/guoyunlong666/p/8331219.html

时间： 2024-10-23 06:11:37

DAY7-面向对象之绑定方法与非绑定方法的相关文章

三 面向对象之绑定方法与非绑定方法

一 绑定方法 二 非绑定方法 三 classmethod和staticmethod的区别 一 绑定方法 绑定方法(绑定给谁,谁来调用就自动将它本身当作第一个参数传入): 1. 绑定到类的方法:用classmethod装饰器装饰的方法.                 为类量身定制                 类.boud_method(),自动将类当作第一个参数传入               (其实对象也可调用,但仍将类当作第一个参数传入) 2. 绑定到对象的方法:没有被任何装饰器装饰的方

面向对象：多态（多态性）、封装（隐藏属性）、绑定方法与非绑定方法

多态: 多态指的是一类事物有多种形态:比如 动物有多种形态:人.狗.猪 如下代码: import abc class Animal(metaclass=abc.ABCMeta): #同一类事物:动物 @abc.abstractmethod def talk(self): pass class People(Animal): #动物的形态之一:人 def talk(self): print('say hello') class Dog(Animal): #动物的形态之二:狗 def talk(se

【2020Python修炼记】面向对象编程——绑定方法与非绑定方法

[目录] 一.绑定方法与非绑定方法 二.非绑定方法 一.绑定方法与非绑定方法 ? 类中定义的函数分为两大类:绑定方法和非绑定方法 ? 其中绑定方法又分为绑定到对象的对象方法和绑定到类的类方法. ? 在类中正常定义的函数默认是绑定到对象的,而为某个函数加上装饰器@classmethod后,该函数就绑定到类了. 类方法通常用来在__init__的基础上提供额外的初始化实例的方式: # 配置文件settings.py的内容 HOST='127.0.0.1' PORT=3306 # 类方法的应用 imp

python基础之多态与多态性、绑定方法和非绑定方法

多态与多态性 多态 多态并不是一个新的知识 多态是指一类事物有多种形态,在类里就是指一个抽象类有多个子类,因而多态的概念依赖于继承 举个栗子:动物有多种形态,人.狗.猫.猪等,python的序列数据类型有字符串.列表.元组,文件的类型分为普通文件和可执行文件,人类又有多种形态,男女老少..等等例子 1 import abc 2 class Animal(metaclass=abc.ABCMeta): #模拟动物类 3 @abc.abstractmethod 4 def talk(self): 5

Python学习——02-Python基础——【8-面向对象的程序设计】——封装、绑定方法与非绑定方

十 封装 1引子 从封装本身的意思去理解,封装就好像是拿来一个麻袋,把小猫,小狗,小王八,还有alex一起装进麻袋,然后把麻袋封上口子.照这种逻辑看,封装='隐藏',这种理解是相当片面的 2先看如何隐藏 在python中用双下划线开头的方式将属性隐藏起来(设置成私有的) #其实这仅仅这是一种变形操作且仅仅只在类定义阶段发生变形 #类中所有双下划线开头的名称如__x都会在类定义时自动变形成:_类名__x的形式: class A: __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据

python_day7 绑定方法与非绑定方法

在类中定义函数如果 不加装饰器 则默认 为对象作为绑定方法 如果增加 classmethod 是 以 类 作为绑定方法 增加 classmethod 是 非绑定方法,就是不将函数 绑定 ##################### class Foo: def func(self): print(self) @classmethod def func2(cls): print(cls) @staticmethod def sta(): print('非绑定参数') JG=Foo()JG.func(

全面解析python类的绑定方法与非绑定方法

类中的方法有两类: 绑定方法 非绑定方法 一.绑定方法 1.对象的绑定方法 首先我们明确一个知识点,凡是类中的方法或函数,默认情况下都是绑定给对象使用的.下面,我们通过实例,来慢慢解析绑定方法的应用. class People: def __init__(self,name,age): self.name = name self.age = age def talk(self): pass p = People('xiaohua',18) print(p.talk) 输出结果: <bound m

property，多态，绑定方法与非绑定方法

1.property property本质就是一个python为你准备好了的--装饰器,那既然他是装饰器,也就意味着他的用法就是我们熟悉的装饰器语法糖用法@+名字,而它的作用就是将装饰的函数(类中定义的方法)伪装成一种属性(类中有两种特质,一是属性你也可以理解为不变的量,二是方法也就是多态变化的函数),那property具体是怎么做到这点呢?先来思考一个问题. 成人的BMI数值: 过轻:低于18.5 正常:18.5-23.9 过重:24-27 肥胖:28-32 非常肥胖, 高于32 体质指数(B

绑定方法和非绑定方法

一:绑定方法 绑定方法有两种,一种是与对象绑定,在类中定义的方法都是都是默认与对象绑定的,另一种是绑定到类的方法,要加上classmethod装饰器: class People: def __init__(self, name, age): self.name = name self.age = age def get_name(self): print("我的名字是:{}".format(self.name)) @classmethod def say_hello(cls): pri

面对对象-绑定方法与非绑定方法

在类内部定义的函数,分为两大类:一:绑定方法:绑定给谁,就应该由谁来调用,谁来调用就会把调用者当做第一个参数自动传入 绑定到对象的方法:在类内定义的没有被任何装饰器来修饰的 邦定到类的方法:在类内定义的被装饰器classmethod修饰的方法 二:非绑定方法:没有自动传值一说了,就是类中的普通工具 非绑定方法:不与类或者对象绑定 staticmethon class Foo: def __init__(self,name): self.name=name def tell(self): # 绑定