PoEdu_Python_Lesson010_类的特性

没有写在方法里的变量的属性

使用类名即可访问

静态属性，属于类本身的

class UserInfo(object):
    name = "Poedu"

user=UserInfo()
user.name #可以
UserInfo.name #可以

user.name = ‘lala’

ususr.name改变了，而Info.name不变，其它定义的对象的name也不变

UserInfo.name = ‘lala’

所有对象的name都变为了lla

类里面的方法一定要有self属性，也就是方法的第一个参数为self

动态绑定

空类里面可以进行后绑定

class Demo(object):
    pass

d1 = Demo()
d1.user = 'root' #绑定了一个属性user
def foo(self):
    pass
d1.foo = foo
d1.foo #可以使用foo函数 绑定到了d1对象上

Demo.foo = foo #绑定到类上 这个类的所有对象都可共享得到

可以指定可绑定的

__slots__= (‘name’,’password’)

现在就只能动态绑定name和password

杜绝Python的动态绑定带来的风险

特性

希望一些属性能够隐藏，但是又希望无痛访问

比如，使用get和set的函数，能够不调用方法，而直接通过.属性进行访问，但是又希望保留方法中检查的功能

def get_name(self)
    return self.name

@property  #读特性（只允许读）
def name(self):
    return self.name

此时就可以这样访问了: user.name,看上去name是一个方法，但其实是一个方法，但是user.name = ‘lala’会报错，因为这是“读”特性，不允许写

@name.setter  #只写特性
def name(self,name):
    self.name = name

user.name = 'lala'

直接打印对象

比如有一个对象User，使用print(User)打印出里面的内容

正常的打印是输出main ，object…

方法如下：

def __str__(self):   #这是给用户看的
    return "__str__"   
print(User) #打印__str__

def __repr__(self):  #这是给程序员看的
    return "demo self"

u = User()

print(u)  #打印demo self

def __iter__(self): return self

def __next__(self): print(”)

可以用上面这两个做一个遍历

def __iter__(self):
    return self

def __next__(self):
    ret = random.randint(1..10000)
    if ret == 10000:
        raise StopIteration()  #停止遍历
    return ret

for in user:
    print(i)

但是，它也只能做个，它连下标操作都做不了，如果需要响应，则还需要__getitem__

def __getitem(self,item):
    return item

响应切片

def __getitem__(self,item):
    if isinstance(item,int):
        return "int"
    if isinstance(item,slice):
        return "切片"

写了很多的方法，原来的系统已经搭建完成，现在需要在每一个函数之前进行一个验证，如果函数多了，如果挨个的加，工作量会很大，但是在Python可以使用call来做

def __call__(self):
    print("call")

user = UserInfo()
user()  #调用call方法

示例

class CheckFoo(object)
    def __init__(self,foo):
        self.__foo=foo

    def __call__(self):
        print("验证")
        self.__foo()

def main():
    ckfoo = CheckFoo()
    ckfoo()

构造函数与析构函数

构造

def __init__(self):

析构

def __del__(self):

枚举

导入

form enum import Enum

大写的Enum才是我们要使用的那个

使用：

color = Enum(’color‘,(‘red’,’black’,gren))

首先是名称，然后跟一个元组

@unique  #去重操作：如果有重复的，会检查出来，并且不通过编译
class Color(Enum)
    RED = 1
    YEW = 2

错误处理

语法:

try:
    ...
        raise ..
except ValueError:  #ValueError错误类型
    ...
except ....:
    ...
finally :
    ...

示例

age = -1
while age == -1:
    temp = input("age:")
    try:
        age = int(age)
    except:
        age = -1

示例2

try:
    file = open(input("name"),'w')
    age = input("age") 
    file.close()  #如果上一行出错了，那么就没close了
except ValueError:
    print("输入错误")

可以在错误提示中使用file.close()这个函数，确保文件关闭，但是，一旦错误多了，那么就需要写很多close，可以使用finally：不管怎样都会执行

示例3：

file = open(input("name"),'w')
try:
    age = input("age") 
    file.close()  #如果上一行出错了，那么就没close了
except ValueError as e:
    print("输入错误",e)
finally:
    if file:
        file .close()

示例4：

file = open(input("name"),'w')
try:
    age = input("age") 
    file.close()  #如果上一行出错了，那么就没close了
except Exception as e: #接收所有错误，从继承体系中可知，多态..
    print("输入错误",e)
finally:
    if file:
        file .close()

大致继承体系：obeject > BaseException > Exception > …(各种类型的错误)

所以不写__init__的空类也不会出问题，就算其中什么都不写，它还是有一些方法，因为他继承自object

所以写一个Excption就能接收所有错误了

示例5

def div(n1,n2):
    if n2 == 0:
        raise ValueError("除数为0")
    return n1/n2

也可以新建一个我们自己的错误类，继承自Exception

作业

写一个模拟人生…锻炼使用类的继承