类变量,方法与封装

析构函数:
系统定义的函数
def del (self):
pass
析构函数不需要我们自己手动调用,当对象被销毁的时候会自动调用.
对象什么时候会被销毁:
1.当程序运行结束的时候
2.显式销毁对象(del 对象名)

‘’’

class Person():

def __init__(self,name):
    self.name = name
    print("构造函数被调用啦")

def say(self):
    print("say hello")

def __del__(self):
    print("析构函数被调用啦。。。")

if name == ‘main’:
if name == ‘main’:
per = Person(“bane”)
per.say()
del per

‘’’
self:代表当前类的实例[对象自己本身]
self并不是关键字,可以使用别的变量名代替,是约定俗成的写法,不建议使用别的名字
self不能省略,必须写在 参数列表中第一个位置,声明的必须要声明,传递参数的时候
不需要手动传参.

类名.变量名
注意:若使用对象来进行调用也不报错,但是一般不建议这么使用

成员变量:
定义在类的函数中,并且要绑定在self身上的变量,只作用于当前实例

类变量与成员变量的区别:
1.定义的位置不同
2.访问方式不同
类变量使用类名[使用对象访问不报错]
成员变量使用对象来访问[使用类名来访问的时候会报错]
3.在内存出现的时机不同
类变量随着类的加载而出现,成员变量实例化对象的时候创建
4.调用的优先级不同,当使用对象来调用变量与成员变量的时候,优先选择
成员变量,若成员变量不存在,则去访问类变量
5.通过对象来更改类型变量的值得时候,更改的是对象的值[只会影响当前对象],
通过类名更改变量的时候,更高类变量的初始值[会影响在类变量更改之后创建的所有对象]

正常情况下,当我们定义了一个类,我们创建类的实例之后,可以给该类的实例绑定
任意的属性以及方法,这就是动态数据类型语言的灵活性.
在Python中,我们可以使用__slots__变量来限制我们动态添加属性以及方法.
注意:slots =() 的值是一个元组,元组中使用字符串进行声明可以动态添加
的属性以及函数的函数名.只作用于当前类的实例.

‘’’
class Student():
slots =(“name”,“age”,“sex”,“stuid”,“classid”,“eat”,“sleep”,“study”)
def init(self,name,age,sex,stuid,classid):
self.name = name
self.age = age
self.sex = sex
self.stuid = stuid
self.classid = classid

student = Student(“bane”,“18”,“male”,“112”,“1904”)
print(student.name)

类中函数/方法分为三大类:
1.成员方法
一般情况下在类中定义所有的方法都成为成员方法,在成员方法中,他的第一个参数self
声明的时候必须声明在参数列表中第一个位置,使用对象来进行调用的时候,对象将
自己作为参数自动传递给self,不需要我们手动传递
成员方法是给对象准备的,调用的时候必须使用对象来进行调用
2.类方法
类方法是专门给类准备的方法,他不是绑定在对象身上,而是绑定在类身上的方法,
在声明类方法的时候,我们通常情况下使用@classmethod装饰器来进行声明.
在类方法只给你,参数列表的第一个位置的参数是cls,代表类本身,使用类名来进行调用,
若使用对象来进行调用也不报错,但是会让别人造成误解
3.静态方法
就是一类普通的方法,但是写在了类中.声明静态方法的时候使用@staticmethod
来进行声明,调用的时候建议使用类名来进行调用,若使用对象来进行调用也不报错

成员方法,类方法.静态方法使用契机:
成员方法:
当此方法中有使用到self[对象]/成员变量的时候,必须将此方法写成成员方法
类方法:
当此方法中没有使用到self/[成员变量]/成员方法,但是它使用到了类变量,
必须将此函数写成类方法.
静态方法:
此方法中没有使用到成员变量,也没有使用到类变量,就是一个普通的方法,这时候
我们可以将此函数写成静态方法.

‘’’
class Pizza:

price = 10

def __init__(self,kouwei,size):
    self.kouwei = kouwei
    self.size = size

def getprice(self):

    if self.kouwei == "榴莲":
        return self.price*self.size + 20
    else:
        return self.price*self.size

def getSize(self):
    return (self.size/2)**2*3.14

class Pizza2:
class Pizza2:
price = 10

def __init__(self, kouwei):
    self.kouwei = kouwei
    self.size = size

def getprice(self):
    if self.kouwei == "榴莲":
        return self.price + 20
    else:
        return self.price

@staticmethod
def getSize(size):
    return (size / 2) ** 2 * 3.14

if name == ‘main’:
if name == ‘main’:
pizza = Pizza(“奥尔良烤翅”,10)
print(pizza.getprice())
pizza = Pizza(“榴莲”, 10)
print(pizza.getprice())

面向对象的三大特征:
封装,继承以及多态
封装:
广义的封装:类与函数的定义就是封装的体现.
狭义的封装:类中的有些属性我们不希望外界能够直接访问,我们可以将这些属性
进行私有化只有本类持有,再给外界暴露出一个可以访问的接口
封装的本质:属性私有化的过程
封装的优点:提高数据的复用性,保证数据的安全性

对于私有化的属性我们可以对它进行过滤
语法糖:
@property功能:可以将函数转为属性来进行调用.
将@property添加给getter头上,将getter变成一个属性来进行调用,与此同时,
@property还会生成一个新的装饰器,这个装饰器的名字叫做@属性.setter的
装饰器,这个装饰器可以将setter方法变成属性赋值.
优点:方便使用者写出更加简洁的代码.

被私有化的属性不能直接访问的原因是解释器在解释我们的属性的时候讲被私有化的属性
解释为_类名__具体名,因此我们直接使用对象.__属性名是访问不到的,但是若我们使用
对象.__类名__属性名来进行访问,是可以访问的. 不建议这么做,因为不同的解释器解释出来的
变量不一样

下划线:
foo 首尾双下划线,这个定义的时候使用,自己定义变量的时候也不报错
__foo 首双下划线,私有类型,访问范围,在类本身可以访问
-foo 首单下划线,保护类型的,虽然可以直接访问,但是建议将它视为私有变量来进行访问

‘’’

class Girl():
def init(self,name,age):
self.name = name
self.__age = age
@property
def age(self):
return self.__age
@age.setter
def age(self,age):
if age < 0 or age >160:
print("…")
else:
self.__age = age

if name == “main”:
girl = Girl(“Art”,25)
print(girl.age)