Python高阶基础之绑定办法、非绑定方法、隐藏属性、装饰器

绑定办法

'绑定给类的办法'
'绑定给对象的办法'

# 绑定给对象
class Student:
    school = 'SH'

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
	# 这个就是绑定给对象的方法，有什么特殊之处?1. 函数的第一个形参self是对象自己，
    # 2. 绑定给对象的方法就有对象来调用，它会把对象自己当成第一个参数传给方法的第一个形参self
    def info(self):
        print(f"name:{self.name},age:{self.age},gender:{self.gender}")


stu = Student('kevin', 18, 'female')
# 通过对象可以直接调用
stu.info()  # name:kevin,age:18,gender:female
# 当然也可以通过类来调用，但是绑定给对象不是让类来调用的，不推荐这样调用
Student.info(stu) # name:kevin,age:18,gender:female
"""绑定给对象的方法目的不是想让类来调用的，但是，类也能调用，只不过方法里面有几个参数就要传几个参数"""

# 绑定给类

关键字：'classmethod'
class Myaql:
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    @classmethod  # 该方法已经变成了绑定给类的方法，而不是绑定给对象了
    def func(cls):
        print('from>>>>>func')
        return '192.168.101', 8080


obj = Myaql('192.168.101', 8080)
res = Myaql.func()  # from func  绑定给类的方法就有类来调用，特殊之处就是：会把类名当成第一个参数传给方法的第一个形参
print(res)
# from>>>>>func ('192.168.101', 8080)
# 可以直接通过类名来直接调用方法

非绑定方法

# 言外之意就是不绑定给类使用，也不绑定给对象使用
# 静态方法：static
# 补充：uuid
# import uuid
# """只要随机串的长度一定，理论上，只要次数足够多，就一定会出现重复的可能"""
# print(uuid.uuid4())  # 65f1ff6b-dd39-441a-8788-0dfde07d6922
关键字：
	@staticmethod
    
import uuid


class Student:
    school = 'SH'

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

    def info(self):
        print(f"name:{self.name},age:{self.age},gender:{self.gender},id:{self.id}")

    @staticmethod # 该方法已经谁都不绑定，谁都能来调用，类和对象都可以直接来调用，其实就是个普通方法
    def id():
        return uuid.uuid4()


stu = Student('kevin', 18, 'female')
# 对象调用
stu.info() # name:kevin,age:18,gender:female,id:c4e28c76-d4d4-4c80-be7e-cdf201134265
# 类调用
print(Student.id())  # 9037dcb4-ffdb-4456-8b76-7bc603757ffe

"""什么时候使用静态方法：一般就是方法里面既不用对象，也不用类的时候就使用静态方法"""
    @staticmethod
    def get_code(n):
        code = ''
        import random
        for i in range(n):
            random_int = str(random.randint(0, 9))
            random_upper = chr(random.randint(65, 90))
            random_lower = chr(random.randint(97, 122))
            temp = random.choice([random_int, random_upper, random_lower])
            code += temp
        return code
    
"""如果说方法里面及用到了对象，又用到了类，方法绑定给谁更合适?"""
	'绑定给对象最合适'
    def func(self):
        print(self) # # <__main__.Student object at 0x00000202B404F100> 	
        print(self.__class__.__name__) # # Student

隐藏属性

1. 如何隐藏？
2. 为什么隐藏?
"""
    1. 隐藏属性在类的定义阶段，发生了变形，_类名__属性名
    2. 不但可以隐藏类属性、方法、对象的属性都可以隐藏
    3. 隐藏属性对外不对内，对类的外部是隐藏的，而对类的内部是开放的
"""

class Student:
    __school = 'SH'

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

    def info(self):
        return self.__school

    def infos(self, v):
        self.__school = v


stu = Student('kevin', 18, 'female')
# print(stu.school) # SH
# 隐藏起来后就没办法从外部直接调用了
"""这时候就需要开一个接口，我们定义了一个info的接口，接收__school的值"""
stu.info()
print(stu.info())  # SH
# 这时候我们就可以拿到被隐藏得值了
"""下面我们有定义了一个Infos的函数，用来修改__school的值"""
stu.infos(1232)
print(stu.info())  # 1232
# 这时候__school的值就被修改为1232了

property装饰器

"""作用：就是把方法伪装成属性来使用!"""
class Student:
    __school = 'SH'

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

    @property
    def count(self):
        return self.__school

    @count.setter
    def count(self, v):
        self.__school = v

    @count.deleter
    def count(self):
        print('删除')


stu = Student('kevin', 18, 'female')
print(stu.count)  # SH
# 查看
stu.count = 'ABS'
print(stu.count)  # ABS
# 修改
del stu.count  # 删除
# 删除

# 方式二

class Student:
    __school = 'SH'

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

    def get_count(self):
        return self.__school

    def set_count(self, v):
        self.__school = v

    def del_count(self):
        print('删除')
        
	"""这种方式，是有顺序要求的"""
    count = property(get_count, set_count, del_count)


stu = Student('kevin', 18, 'female')
print(stu.count)  # SH
# 查看
stu.count = 'ABS'
print(stu.count)  # ABS
# 修改
del stu.count  # 删除
# 删除

# 课堂练习：计算人的bmi指数

class Bmi():
    def __init__(self, weight, height):
        self.weight = weight
        self.height = height

    @property
    def bmi(self):
        return self.weight / (self.height ** 2)

bmi = Bmi(70, 1.8)
print(bmi.bmi)

面向对象的三大特征

封装：是一种思想，把冗余代码，重复的代码封装成函数，以后每次用只需要调函数。
继承：
	1、什么是继承？
    	"""继承就是新建类的一种方式，新建出来的类被称为是子类或者派生类，被继承的类称为父类或者基类"""
        '子类可以继承父类的所有属性和方法!'
        
    2. 为什么要继承?
    	类解决什么问题：解决的是对象与对象之间的代码冗余问题
        继承解决什么问题：解决的是类与类之间的代码冗余问题
        
    3. 怎么样继承?
    	新式类：继承了object类的子子孙孙类都是新式类
        经典类：没有继承object类的子子孙孙类都是经典类
        
        """只有在python2中才区分经典类和新式类，因为在python3中都是新式类"""
        
# class Parent1(object):
#     pass
#
# class Parent2:
#     pass
#
# # 直接把类名写在括号里就是继承，括号里面写的类是父类，括号外的是子类
# class Sub1(Parent1):
#     pass
#
#
# # python中支持多继承, 括号里面可以写多个类
# class Sub2(Parent1, Parent2):
#     pass
#
# # 如何查看一个类继承了哪些父类?
# print(Sub1.__bases__)
# print(Sub2.__bases__)
# print(Parent1.__bases__)  # object


## 学生选课系统

class People:
    school = 'sh'  # 属性会严格依赖继承关系

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


class Student(People):

    def __init__(self, name, age, gender, course):
        """这个是指名道姓的调用方法，不依赖于继承"""
        People.__init__(self, name, age, gender)
        self.course = course

    def index(self):
        print(f'{self.name}选择了{self.course}')


stu = Student('kevin', 18, 'female', 'python')
stu.index()  # kevin选择了python
print(stu.school)


# 对象属性的查找顺序：先从对象自己的名称空间查找，如果找不到，再去类中取查找，
# 如果找不到，取继承的父类转中查找，

class Teacher(People):

    def __init__(self, name, age, gender, level):
        """这个是指名道姓的调用方法，不依赖于继承"""
        People.__init__(self, name, age, gender)
        self.level = level


tea = Teacher('tank', 30, 'male', 'IV')
print(tea.name)  # tank