day26学习整理-Python面向对象

2019/08/30 学习整理

python面向对象

绑定方法和非绑定方法

类中定义的方法大致可以分为两类：绑定方法和非绑定方法。其中绑定方法又可以分为绑定到对象的方法和绑定到类的方法。

一、绑定方法

1.1对象的绑定方法

在类中没有被任何装饰器修饰的方法就是 绑定到对象的方法，这类方法专门为对象定制。

class Person:
    country = "China"

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

    def speak(self):
        print(self.name + ', ' + str(self.age))


p = Person('Kitty', 18)
print(p.__dict__)
{'name': 'Kitty', 'age': 18}
print(Person.__dict__['speak'])
<function Person.speak at 0x10f0dd268>

speak即为绑定到对象的方法，这个方法不在对象的名称空间中，而是在类的名称空间中。

通过对象调用绑定到对象的方法，会有一个自动传值的过程，即自动将当前对象传递给方法的第一个参数（self，一般都叫self，也可以写成别的名称）；若是使用类调用，则第一个参数需要手动传值。

p = Person('Kitty', 18)
p.speak()  # 通过对象调用
Kitty, 18
Person.speak(p)  # 通过类调用
Kitty, 18

1.2 类的绑定方法

class Operate_database():
    host = '192.168.0.5'
    port = '3306'
    user = 'abc'
    password = '123456'

    @classmethod
    def connect(cls):  # 约定俗成第一个参数名为cls，也可以定义为其他参数名
        print(cls)
        print(cls.host + ':' + cls.port + ' ' + cls.user + '/' + cls.password)


Operate_database.connect()
<class '__main__.Operate_database'>
192.168.0.5:3306 abc/123456

通过对象也可以调用，只是默认传递的第一个参数还是这个对象对应的类。

Operate_database().connect()  # 输出结果一致
<class '__main__.Operate_database'>
192.168.0.5:3306 abc/123456

二、非绑定方法

在类内部使用 @staticmethod 修饰的方法即为非绑定方法，这类方法和普通定义的函数没有区别，不与类或对象绑定，谁都可以调用，且没有自动传值的效果。

import hashlib


class Operate_database():
    def __init__(self, host, port, user, password):
        self.host = host
        self.port = port
        self.user = user
        self.password = password

    @staticmethod
    def get_passwrod(salt, password):
        m = hashlib.md5(salt.encode('utf-8'))  # 加盐处理
        m.update(password.encode('utf-8'))
        return m.hexdigest()


hash_password = Operate_database.get_passwrod('lala', '123456')  # 通过类来调用
print(hash_password)
f7a1cc409ed6f51058c2b4a94a7e1956
p = Operate_database('192.168.0.5', '3306', 'abc', '123456')
hash_password = p.get_passwrod(p.user, p.password)  # 也可以通过对象调用
print(hash_password)
0659c7992e268962384eb17fafe88364

简而言之，非绑定方法就是将普通方法放到了类的内部。

staticmethod

非绑定方法,定义在类内部,普通方法,谁都不绑定# 对象/类都可以调用,但是不会自动传值

class Person:    
    def __init__(self, name, age):        
        self.name = name        
        self.age = age    
        
    def object_method(self):        
        print('我是对象绑定方法,对象来调用我')    
        
    @classmethod    
    def class_method(cls):        
        print('我是类的绑定方法,类来调用我')    
#当成一个普通函数,只不过是写在类内部的    
    @staticmethod    
    def static_method():        
        print('我是静态方法,谁都不绑定')
 # 静态方法(非绑定方法)类来调用
Person.static_method()
 # 对象来调用
p=Person('nick',19)
p.static_method()

staticmethod

静态方法(非绑定方法)的作用跟类和对象都没有关系的时候,可以定义成静态方法,一般在类内部使用,类外部也可以使用就是一个普通函数,想把它拿到类中管理,就可以定义成静态方法

class Person:
    def __init__(self,name, age):
        self.id=self.get_uuid()
        self.name = name
        self.age = age

    #当成一个普通函数,只不过是写在类内部的
    @staticmethod
    def static_method():
        print('我是静态方法,谁都不绑定')
    @staticmethod
    def get_uuid():
        import uuid
        return uuid.uuid4()

import uuid
def get_uuid():
    return uuid.uuid4()
a=uuid.uuid4()
# p=Person(uuid.uuid4(),'nick',18)
# p=Person(get_uuid(),'nick',18)
p=Person('nick',19)
print(p.id)
print(p.get_uuid())
print(Person.get_uuid())

转载于:https://www.cnblogs.com/Wunsch/p/11430040.html