1、类常用属性
__name__ : 通过类名调用，得到类名字符串
__dict__ : 通过对象名调用，得到对象的所有属性
通过类名调用，可以得到类的所有信息
__bases__ : 得到的是所有的父类
class GirlFriend(object):
"""docstring for GirlFriend"""
def __init__(self, name, age, height, weight, face):
self.name = name
self.age = age
self.height = height
self.weight = weight
self.face = face
def __str__(self):
return '我的姓名是%s, 我的年龄是%s, 我的身高是%s, 我的体重是%s, 我的脸蛋是%s' % (self.name, self.age, self.height, self.weight, self.face)class Animal(object):
"""docstring for Animal"""
def __init__(self, name):
self.name = name
class ChongWu(object):
"""docstring for ChongWu"""
def __init__(self, age):
self.age = age
class Pig(Animal, ChongWu): # Pig类是Animal类 ChongWu类的子类 多继承
"""
对类的一些说明
"""
color = 'red' # 类属性
kouwei = '饲料'
def __init__(self, name, age, weight): # 对象方法
super().__init__(name) # 对象属性
# self.name = name
self.age = age
self.weight = weight
self.__number = 100 # 私有属性
def gong(self): # 对象方法
print('我喜欢拱白菜')
@classmethod # 类方法
def haha(cls):
print('哈哈')
bajie = Pig('惊叹蛇者', 30, 200)
# print(type(Pig.__name__)) #输出<class 'str'>
# print(Pig.__name__) #通过类名调用，得到类名字符串输出Pig
# print(bajie.__dict__) #通过对象名调用，得到对象的所有属性 {'name': '惊叹蛇者', 'age': 30, 'weight': 200, '_Pig__number': 100}
# print(Pig.__dict__) #通过类名调用，可以得到类的所有信息
# print(Pig.__bases__) #得到的是所有的父类(<class '__main__.Animal'>, <class '__main__.ChongWu'>)
2、限制属性动态添加
__slots__ = (‘name’, ‘age’, ‘weight’)
这是一个类属性，可以限制对象动态添加的属性只能是元组中规定的这些属性
class Wolf(object):
"""docstring for Wolf"""
__slots__ = ('name', 'age', 'weight')
def __init__(self):
super(Wolf, self).__init__()
self.name = 'goudan'
self.height = 'lala' #限制对象动态添加的属性只能是元组中属性 height 不在元组中会报错
def aoao(self):
print('嗷嗷嗷嗷嗷嗷')
lang = Wolf()
# lang.height = '狗蛋'
# lang.age = 100
3、析构方法
__del__ 当这个对象被销毁之前，系统会自动调用这个方法
和构造方法正好相反
在该方法中做一些清理性的工作，比如关闭文件、关闭数据库连接
#析构方法
'''
class Chicken(object):
"""docstring for Chicken"""
def __init__(self, name):
self.name = name
def jiao(self):
print('大爷，进来玩吧')
@classmethod
def eat(cls):
pass
def __del__(self): #当这个对象被销毁之前，系统会自动调用这个方法
print('这只鸡被抓了')
ji = Chicken('美丽姐')
ji.jiao()
#当ji变更对象时原来创建的对象在内存中被销毁前，系统会自动调用这个方法
ji = 'hello'
print(ji)
print('程序还没结束')
'''
#静态方法
class Chicken(object):
"""docstring for Chicken"""
def __init__(self, name):
self.name = name
def jiao(self):
print('大爷，进来玩吧')
@staticmethod #静态方法
def drink():#静态方法没有参数
print('鸡怎么喝水呢，这是一个难题')
ji = Chicken('美丽姐')
ji.drink() #通过对象名进行调用
#Chicken.drink() #通过类名进行调用 静态方法：
@staticmethod
静态方法可以通过对象名调用，也可以通过类名调用，但是一般都通过类名调用
静态方法和类方法唯一的区别就是，类方法必须有一个参数cls，静态方法没有参数
多态：
多种形态，同一个方法，给不同的对象，得到的反应是不同的
父类类型的指针可以指向子类的对象
# 案例演示多态
# 豆豆打小动物
# 多态：多种形态，同一个方法，给不同的对象，得到的反应是不同的
# 不同类的同一方法不同的对象名去调用输出的结果是不一样的
class Animal(object):
"""docstring for Animal"""
def bebeat(self):
pass
class Dog(Animal):
"""docstring for Dog"""
def bebeat(self):
print('狗会宠着你汪汪汪的叫，然后会咬你')
class Cat(Animal):
"""docstring for Cat"""
def bebeat(self):
print('猫瞪你一眼，夹着尾巴就跑了，然后回头挠你一把')
class Wolf(Animal):
"""docstring for Wolf"""
def bebeat(self):
print('狼嗷嗷拉起了同伴，将你吃了')
class Person(object):
"""docstring for Person"""
def __init__(self, name):
self.name = name
def beat_animal(self, animal): # animal是一个参数
print('我正在殴打小动物')
animal.bebeat()
c = Cat() # c,d,w是对象名
d = Dog()
w = Wolf()
doudou = Person('豆豆')
doudou.beat_animal(c) # beat_animal() 是同一个方法cdw不同的方法名输出的结果是不同的称为多态
doudou.beat_animal(d)
doudou.beat_animal(w)
'''
执行流程：
doudou.beat_animal() 对象名.方法名 调用beat_animal()方法 需要参数传递给animal
doudou.beat_animal(c)会将c传递给参数animal
animal.bebeat() 等价于c.bebeat() 就会调用cat的bebeat()方法
'''
# 案例
# 豆豆打小动物
# 多态：多种形态，同一个方法，给不同的对象，得到的反应是不同的
# 不同类的同一方法不同的对象名去调用输出的结果是不一样的
class Animal(object):
"""docstring for Animal"""
def bebeat(self):
pass
class Dog(Animal):
"""docstring for Dog"""
def bebeat(self):
print('狗会宠着你汪汪汪的叫，然后会咬你')
class Cat(Animal):
"""docstring for Cat"""
def bebeat(self):
print('猫瞪你一眼，夹着尾巴就跑了，然后回头挠你一把')
class Wolf(Animal):
"""docstring for Wolf"""
def bebeat(self):
print('狼嗷嗷拉起了同伴，将你吃了')
class Person(object):
"""docstring for Person"""
def __init__(self, name):
self.name = name
def beat_animal(self, animal): # animal是一个参数
print('我正在殴打小动物')
animal.bebeat()
c = Cat() # c,d,w是对象名
d = Dog()
w = Wolf()
doudou = Person('豆豆')
doudou.beat_animal(c) # beat_animal() 是同一个方法cdw不同的方法名输出的结果是不同的称为多态
doudou.beat_animal(d)
doudou.beat_animal(w)
'''
执行流程：
doudou.beat_animal() 对象名.方法名 调用beat_animal()方法 需要参数传递给animal
doudou.beat_animal(c)会将c传递给参数animal
animal.bebeat() 等价于c.bebeat() 就会调用cat的bebeat()方法
'''
4、@property
可以将函数作为属性进行使用，主要用来针对于私有属性，来快捷的设置set和get方法
class Hero(object):
"""docstring for Hero"""
def __init__(self, name):
self.name = name
self.__age = 10 # 私有属性只能内部访问，外部访问需要set方法和get方法
self.__weight = 100
@property #@property装饰器就是负责把一个方法变成属性调用的
def weight(self):
return self.__weight
@weight.setter
def weight(self, value):
self.__weight = value
'''
# 外部可以直接通过 对象名.age 获取私有成员属性的值
@property
def age(self):
return self.__age
# 外部可以直接通过 对象名.age = 10 设置私有属性的值
@age.setter
def age(self, value):
self.__age = value
'''
'''
#外部可以通过set方法和get方法访问私有属性
def get_age(self):
return self.__age
def set_age(self, value):
self.__age = value
'''
daji = Hero('妲己')
daji.name = '安琪拉'
print(daji.name)
daji.age = 100
print(daji.age)
5、pickle
用来做什么？
对象是在内存中，只有程序在运行的时候才有，程序运行结束，该对象就会被销毁
如果我想将这个对象保存起来（对象序列化保存），就要用到pickle
保存的是对象的属性，不是方法
import pickle
pickle.dump() : 将对象序列化之后保存到文件中
pickle.load() : 从文件中读取对象读到变量中读进来的时候，要保证当前类在你这个py文件中
import pickle
from person import GirlFriend
'''
内存 8g 6g
硬盘 512G 1T
'''
#zhaojun = GirlFriend('王昭君', 18, 160, 96, '耐看型')
#print(zhaojun)
#fp = open('jun.txt', 'wb') #以只写方式打开一个字节一个字节写入
#pickle.dump(zhaojun, fp) # 将对象序列化之后保存到文件中
#fp.close()
# fp = open('jun.txt', 'rb')#以只读方式打开读出来时二进制的串
# zhaojun = pickle.load(fp) #从文件中读取对象读到变量中
# fp.close()
# print(zhaojun.name)
# 保存一个列表
# xue = GirlFriend('赵雪', 14, 162, 90, '漂亮')
# fen = GirlFriend('柳慧芬', 20, 161, 93, '可爱')
# fang = GirlFriend('闫晓芳', 13, 165, 88, '野蛮')
# lt = [xue, fen, fang]
# print(lt)
# fp = open('list.txt', 'wb')
# pickle.dump(lt, fp) # 将对象序列化之后保存到文件中
# fp.close()
#fp = open('list.txt', 'rb')
#ltt = pickle.load(fp) #从文件中读取对象读到变量中
#fp.close()
# print(ltt)
#for girl in ltt:
# print(girl)
6、异常处理
语法错误:python规定的写法，小括号，逗号。。。
异常：
在代码的执行碰到的不是语法的错误，其它错误都可以有补救措施。这种就叫异常处理
有了异常处理可以让你的代码更加的健壮
常见官方异常
NameError\ZeroDivisionError\TypeError\FileNotFoundError
处理异常
try-except
将有可能出现异常的代码放到try中，如果出现异常，try里面异常那句开始下面的所有代码都将不在执行，直接跳到except结构中，去执行except里面的代码，执行完毕，程序接着往下走
Exception : 这哥们是官方的异常基类 ，你所看见的如上的错误都是其子类，可以写具体一些异常信息，那么就只会捕获指定异常的错误
except NameError as e 只能捕获nameerror
except (NameError, ZeroDivisionError) as e: 捕获多种异常，是元组中任何一个异常都能捕获
as e : 会将异常对象保存到变量e中，打印e可以看见该异常的错误信息
也可以直接写except: 捕获所有异常
【注】try-except是一种结构，一个try至少对应一个except
可以写多个except，但是捕获的时候只能有一个except捕获到，捕获的顺序是从上到下开始，所以需要将概念最大的异常类写到最后，比如Exception类放到最后进行捕获
else结构
如果try中有异常，那么try-except执行完毕之后不再执行else代码，如果try中没有异常，那么try执行完毕之后会接着执行else里面的代码
finally
无论有没有异常，finally里面的代码都将会执行
多数用于文件的关闭，不管有没有异常，都会关闭文件
with语句
只用关心怎么读写文件即可，文件的关闭不用管，底层封装的代码会自动关闭
raise语句
程序猿主动的抛出异常
如果没有except进行捕获，系统会处理这个异常，程序直接崩掉
try-except可以来回嵌套
自定义异常类
见代码吧
#异常
# print('王者荣耀')
# print(a)
# print(100 / 0)
# print('baby' + 100)
# fp = open('lala.txt', 'r')
try:
# 你要执行的有风险的代码
print(100)
print(1 / 0)
print(200)
except (NameError, ZeroDivisionError) as e:
# 这里就会捕获到异常信息
# print('哥们，这里出错了')
print(e)
print('哈哈哈')#多异常
try:
print(100)
print(a)
print(200)
except NameError as e:
print('NameError捕获到了')
except ZeroDivisionError as e:
print('ZeroDivisionError捕获到了')
except Exception as e:
print('Exception捕获到了')#else结构
# try:
# # print(a)
# print(100)
# except Exception as e:
# print(e)
# else:
# print('我是else')
# try:
# fp = open('jun.txt', 'rb')
# print(a)
# # 对文件的操作，或者代码的书写
# print(100)
# except Exception as e:
# print(e)
# finally:
# fp.close()
# print('我是finally')
with open('list.txt', 'rb') as fp:
lala = fp.read()
# fp.write()
print(lala)官方异常总结：
常见的异常
AttributeError 试图访问一个对象没有的属性，比如foo.x，但是foo没有属性x
IOError 输入/输出异常；基本上是无法打开文件
ImportError 无法引入模块或包；基本上是路径问题或名称错误
IndentationError 语法错误（的子类） ；代码没有正确对齐
IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 尝试访问一个没有申明的变量
SyntaxError Python代码非法，语法错误
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
ValueError 传入一个调用者不期望的值，即使值的类型是正确的
补充：
异常名称 描述
BaseException 所有异常的基类
SystemExit 解释器请求退出
KeyboardInterrupt 用户中断执行(通常是输入^C)
Exception 常规错误的基类
StopIteration 迭代器没有更多的值
GeneratorExit 生成器(generator)发生异常来通知退出
StandardError 所有的内建标准异常的基类
ArithmeticError 所有数值计算错误的基类
FloatingPointError 浮点计算错误
OverflowError 数值运算超出最大限制
ZeroDivisionError 除(或取模)零 (所有数据类型)
AssertionError 断言语句失败
AttributeError 对象没有这个属性
EOFError 没有内建输入,到达EOF 标记
EnvironmentError 操作系统错误的基类
IOError 输入/输出操作失败
OSError 操作系统错误
WindowsError 系统调用失败
ImportError 导入模块/对象失败
LookupError 无效数据查询的基类
IndexError 序列中没有此索引(index)
KeyError 映射中没有这个键
MemoryError 内存溢出错误(对于Python 解释器不是致命的)
NameError 未声明/初始化对象 (没有属性)
UnboundLocalError 访问未初始化的本地变量
ReferenceError 弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError 一般的运行时错误
NotImplementedError 尚未实现的方法
SyntaxError Python 语法错误
IndentationError 缩进错误
TabError Tab 和空格混用
SystemError 一般的解释器系统错误
TypeError 对类型无效的操作
ValueError 传入无效的参数
UnicodeError Unicode 相关的错误
UnicodeDecodeError Unicode 解码时的错误
UnicodeEncodeError Unicode 编码时错误
UnicodeTranslateError Unicode 转换时错误
Warning 警告的基类
DeprecationWarning 关于被弃用的特征的警告
FutureWarning 关于构造将来语义会有改变的警告
OverflowWarning 旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning 关于特性将会被废弃的警告
RuntimeWarning 可疑的运行时行为(runtime behavior)的警告
SyntaxWarning 可疑的语法的警告
UserWarning 用户代码生成的警告