python基础32 面向对象绑定方法

绑定方法

绑定方法分为两种：

　　绑定给类的方法

　　绑定给给对象的方法

一、绑定给给对象的方法

class Student（）：
    school=‘清华大学’
    def ——init——（self，name，age，gender）
        self.name=name
        self.age=age
        self.gender=gender

1、绑定给对象的一个参数self就是对象自己，

2、绑定给对象的方法有对象来调用，它就会把对象子集当成第一参数传给方法的第一个值

class Student():
    school = 'SH'

    def __init__(self, name, age, gender):
        # self:对象自己
        self.name = name
        self.age = age
        self.gender = gender
    def tell_info(self):
        # self：也是对象自己
        print("name:%s, age:%s, gender:%s" % (self.name, self.age, self.gender))

stu = Student('kevin', 18, 'male')
# stu.tell_info() # stu.tell_info(stu) # name:kevin, age:18, gender:male

绑定给对象的方法目的不是想让类来调用，但是，泪液可以调用的，只不过里面有几个参数就要传几个参数

Student.tell—info（stu）

二、绑定给类的方法

class Oracle():
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    @classmethod  # 该方法已经变成了绑定给类的方法，而不是绑定给对象了
    def from_func(cls):
        # self:就是类名
        print("from func")
        # return Oracle(settings.IP, settings.PORT)
        return cls(settings.IP, settings.PORT)


obj = Oracle('127.0.0.1', 3306)
res=Oracle.from_func()

在方法的上面加装饰器@classmethod，该方法就变成绑定给类的方法，而不是绑定给对象

绑定给类的方法就由类来调用，特殊之处在于会把类名当成第一个参数传给方法的第一个形参，res=Oracle.from_func()

非绑定方法

言外之意就是不绑定给类使用，也不绑定给对象使用

静态方法：static

补充：uuid 模块

import uuid
    

print（uuid.uuid4（））

只要随机串长度一定，理论上只要次数够多，是可以出现相同随机串，但可能性很小

class Student():
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        # self.id = self.create_id()
        self.id = self.get_code(5)
     def create_id():
        import uuid
        return uuid.uuid4()
    @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)
        print(self.__class__.__name__)


stu = Student('kevin', 19, 'female')

@staticmethod # 该方法已经谁都不绑定，谁都能来调用，类和对象都可以直接来调用，其实就是个普通方法

什么时候使用静态方法：一般就是方法里面既不用对象，也不用类的时候就使用静态方法

如果说方法里面及用到了对象，又用到了类，方法绑定给谁更合适?

绑定给对象

print(self.__class__.__name__)，查看对象所在类和名称

隐藏属性

1、如何隐藏属性

　　class Student（）：

　　　　__school=‘sh’双下划线加属性名就隐藏了，隐藏的意思是在累的外部不能使用

变形为-类名--属性名

变形之后的数据目的不是想让我们在外部使用的, 但是在类的外部也能使用

由于隐藏属性是对外不对内的，所以，我们要想在类的外部使用，就需要在类的内部开放一个接口，返回隐藏属性的值，以便更好的对外做限制

class Student():
    # '_Student__school': 'SH' _类名__属性名: 'SH'
    # school = 'SH'  # 把school属性已经隐藏了，隐藏的意思是，在类外部不能使用了
    __country = 'China'
    def __init__(self, name, age, gender):
        self.__name = name  # _Student__name
        self.age = age
        self.gender = gender

    def __func(self):  # _Student__func  _类名__函数名
        print('from func')

    # def index(self):
    #     return self.__school  # self._Student__school

    def get_country(self):
        return self.__country


    def set_country(self, v):
        if type(v) is not str:
            return
        Student.__country = v

stu = Student('kevin', 19, 'male')

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

property装饰器

作用：就死把方法伪装成属性来使用

方式一

class Student():
    # '_Student__school': 'SH' _类名__属性名: 'SH'
    # school = 'SH'  # 把school属性已经隐藏了，隐藏的意思是，在类外部不能使用了
    __country = 'China'
    def __init__(self, name, age, gender):
        self.__name = name  # _Student__name
        self.age = age
        self.gender = gender

    def __func(self):  # _Student__func  _类名__函数名
        print('from func')

    # def index(self):
    #     return self.__school  # self._Student__school
　　@property
    def country(self):
        return self.__country

　　@country.setter
    def country(self, v):
        if type(v) is not str:
            return
        Student.__country = v

　　　　@country.deleter
　　　　def country(self):
　　　　print("可以删除了")
　　　　del Student.__country

stu = Student("kevin", 20, 'female')

方式二

class Student():
    __country = 'China'
    __city = 'shanghai'

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

    def get_country(self):
        return self.__country

    def set_country(self, v):
        if type(v) is not str:
            return
        Student.__country = v

    def del_country(self):
        print("可以删除了")
        del Student.__country
    """这种方式，是有顺序要求的"""
    country = property(get_country, set_country, del_country)

stu = Student("kevin", 19, 'male')
print(stu.country)
#
stu.country = 'Japan'
# print(stu.a)
#
del stu.country

课堂练习

计算人的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 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 choose_course(self):
        pass

stu = Student('kevin', '19', 'male', 'python')

# 对象属性的查找顺序：先从对象自己的名称空间查找，如果找不到，再去类中取查找，如果找不到，取继承的父类转中查找，
print(stu.school)
print(stu.name)
class Teacher(People):
    def __init__(self,name, age, gender, level):
        People.__init__(self, name, age, gender)  # 有什么特殊之处，
        self.level = level

    def score(self):
        pass


tea = Teacher("ly", 20, 'female', 10)
print(tea.school)