类中定义的函数分为两大类:绑定方法和非绑定方法
其中绑定方法又分为绑定到对象的对象方法和绑定到类的类方法。
在类中正常定义的函数默认是绑定到对象的,而为某个函数加上装饰器@classmethod后,该函数就绑定到了类。
绑定方法
定义完类之后,可以在类里面写一些方法,在类的外部直接调用类内部的方法不能调用
那么,类中得方法到底是使用类调用还是使用对象来调用?
类中得方法类能来调用,对象也能来调用,就看该方法绑定给谁了,绑定给谁就有谁来调用
"""1. 绑定给对象的方法"""
class Student():
school = 'SH'
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
"""绑定给对象来调用的,"""
def tell_info(self, username, password):
print("name:%s age:%s gender:%s %s %s" % (self.name, self.age, self.gender, username, password))
"""默认情况下,在类内部写方法是绑定给对象的,就有对象来调用,就会自动来传递参数"""
stu = Student('ly', 20, 'male')
## 如何调用方法
"""绑定给对象的方法有什么特殊之处:对象来调用方法,会把对象自己当成第一个参数传递给方法的第一个形参"""
# 谁来调用方法就是谁,对象自己
# stu.tell_info('kevin', password=123) # stu.tell_info(stu) # name:ly age:20 gender:male
## 问题是:绑定给对象的方法,类能不能来调用? 能来调用,只不过是方法中需要几个参数就要传递几个参数,包括self形参也需要自己传递
Student.tell_info(stu, 'kevin', 123)
**********************************绑定给类的方法*****************************************
## MySQL类: IP+PORT
# 127.0.0.1:3306
class Oracle():
def __init__(self, ip, port):
self.ip = ip
self.port = port
"""
此时该方法就是绑定给类的,那么就有类来调用,有什么特殊之处:就是会把类自动当成第一个参数传递给方法的第一个形参cls
条件:
1. 加一个装饰器@classmethod
2. 把方法的第一个形参改为cls
3. 外部调用该方法的时候使用类来调用即可
4. 绑定给类的方法中没有self这个参数了
5. 绑定给对象的方法中,就没有cls这个参数了
"""
@classmethod
def from_func(cls):
# cls:就是类
return cls('127.0.0.1', 3306)
obj = Oracle('127.0.0.1', 3306)
# print(obj.ip)
# print(obj.port)
# mysql_obj=obj.from_func()
# print(mysql_obj.ip)
obj1=Oracle.from_func()
print(obj1)
print(obj1.ip)
非绑定方法
非绑定方法之静态对象static
class Student():
def __init__(self, name, age, gender):
self.name = name
self.age = age
self.gender = gender
self.id = self.create_id()
@staticmethod
def create_id():
"""当你在函数中不需要对象,也不需要类的时候,就把函数设置为静态方法,类能来调用,对象也能来调用,而且不用传递任何的参数"""
import uuid
return uuid.uuid4()
def func(self):
"""如果你在方法中即需要对象,也需要类,就把方法绑定给对象"""
# self.__class__ # 返回该对象的类
# self.__class__.__name__ # Student # 类名字的字符串形式的
# return self.__class__() # Student()
stu = Student('ly', 20, 'female')
print(stu.id)
print(stu.create_id())
"""只要生成的随机数长度固定,理论上就一定会出现重复的可能!!!"""
import uuid
print(uuid.uuid4()) # 191fd3ed-cdf0-40ad-8eb7-25cbdd82938a b49fbd62-f02f-4acd-a8e4-78cf196fd124
隐藏属性
1. 隐藏属性在类的定义阶段发生了变形:_类名__属性名
2. 隐藏属性在类的外部能不能取到? 理论上是取不到了,但是非要取,也能取到,在类的外部取隐藏之后的属性不是目的
3. 类属性、类方法、对象属性都可以被隐藏
4. 隐藏属性对外不对内
5. 为什么要隐藏?
就是可以对修改类内部的属性的时候,可以在类的内部做更好的限制,然后在类的内部开放一个公共的接口,对外返回内部隐藏的值
class Student():
__school = 'SH' # _Student__school
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 get_school(self):
return self.__school
def set_school(self, v):
"""隐藏属性对外不对内"""
if type(v) is str:
Student.__school = v # Student._Student__school = 'BJ'
else:
print('修改的数据必须是字符串')
stu = Student('ly', 20, 'male')
# print(stu._Student__school) # SH
# print(Student.__dict__)
# stu._Student__func()
# print(stu.__dict__) # {'_Student__name': 'ly', 'age': 20, 'gender': 'male'}
# print(stu._Student__name)
# Student.school = 123
# print(stu.school)
stu.set_school('BEIJING')
# print(Student._Student__school)
res=stu.get_school()
print(res)
property装饰器
它是一个内置的装饰器,它是把方法伪装成属性来使用
class Student():
__school = 'SH' # _Student__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')
@property
def school(self):
return self.__school
@school.setter
def school(self, v):
print('from school')
"""隐藏属性对外不对内"""
if type(v) is str:
Student.__school = v # Student._Student__school = 'BJ'
else:
print('修改的数据必须是字符串')
@school.deleter
def school(self):
print('delete school')
del Student.__school
@property
def country(self):
return self.__country
@country.setter
def country(self, v):
print('from school')
"""隐藏属性对外不对内"""
if type(v) is str:
Student.__country = v # Student._Student__school = 'BJ'
else:
print('修改的数据必须是字符串')
@country.deleter
def country(self):
print('delete school')
del Student.__country
def get_country1(self):
return self.__country
def set_country(self, v):
print('from country')
"""隐藏属性对外不对内"""
if type(v) is str:
Student.__school = v # Student._Student__school = 'BJ'
else:
print('修改的数据必须是字符串')
def del_country(self):
print('delete country')
del Student.__country
"""有顺序要求"""
xxx = property(get_country1, set_country, del_country) # 了解
stu = Student('ly', 20, 'male')
# print(stu.get_school())
# print(stu.school) # SH 把方法伪装成属性来使用
stu.school = 'BJ'
print(stu.school)
del stu.school
练习:
计算人的bmi值
class People():
def __init__(self, height, weight):
self.height = height
self.weight = weight
@property
def bmi(self):
return self.weight / (self.height ** 2)
stu = People(1.8, 75)
print(stu.bmi)
封装
引入
面向对象编程有三大特性:封装、继承、多态,其中最重要的一个特性就是封装。封装指的就是把数据与功能都整合到一起,听起来是不是很熟悉,没错,我们之前所说的”整合“二字其实就是封装的通俗说法。除此之外,针对封装到对象或者类中的属性,我们还可以严格控制对它们的访问,分两步实现:隐藏与开放接口
什么是封装
在程序设计中,封装(Encapsulation)是对具体对象的一种抽象,即将某些部分隐藏起来,在程序外部看不到,其含义是其他程序无法调用。
要了解封装,离不开“私有化”,就是将类或者是函数中的某些属性限制在某个区域之内,外部无法调用。
为什么要封装
封装数据的主要原因是:保护隐私(把不想别人知道的东西封装起来)