绑定办法
'绑定给类的办法'
'绑定给对象的办法'
# 绑定给对象
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