封装
封装：将一些数据，重要的信息等等放到一个地方（空间中）
class A:
country = 'China'
area = '深圳'
def __init__(self,name,age):
self.name = name
self.age = age a1 = A('小明',22)
a2 = A('小华',23)
print(a1.__dict__)
print(a2.__dict__)
多态
python默认支持多态
i = 777alex
i = ‘我是字符串’
鸭子类型：python会约定俗成制定一些行为规范，保持一致性
类的约束
对类进行一些正确的引导，约束，统一规范，满足正确的可发方式
两种约束方法：
方法一：python常用的一种，在父类写一个相同的方法pay，在此方法里面，主动抛出一个错误（raise）
class A: # 这个父类制定了一个约束，规范，子类一定要有pay方法
def pay(self,money):
raise Exception('未定义的方法') class Alipay(A):
def pay(self,money):
print('alipay') class QQpay(A):
def zhifu(self,money): # 未按规定填写pay，而用了zhifu，会报 raise Exception('未定义的方法') 错误
print('QQpay') def pay(obj,money):
obj.pay(money) q = QQpay()
# pay(q,100)
a = Alipay()
pay(a,200)
方法二：在父类引用元类的抽象方法，抛出异常
from abc import ABCMeta,abstractmethod
class A(metaclass=ABCMeta): # 这个父类制定了一个约束，规范，子类一定要有pay方法
'''
抽象类，接口类：制定一个规范，强制执行。
'''
@abstractmethod
def pay(self,money):
raise Exception('未定义的方法') class Alipay(A):
def pay(self,money):
print('alipay') class QQpay(A):
def zhifu(self,money): # 未按规定填写pay，而用了zhifu，会报 raise Exception('未定义的方法') 错误
print('QQpay') def pay(obj,money):
obj.pay(money) q = QQpay()
pay(q,100)
# a = Alipay()
# pay(a,200)
类的私有成员
class Boss:
name = 'alex' # 公有静态属性 公有静态字段
__secretary =['女1', '男2', '眼膜'] # 私有静态属性 私有静态字段，有__表示
def __init__(self,username,password):
self.username = username # 公有对象属性 公有普通字段
self.__password = password # 私有对象属性 私有普通字段
def func(self): # 用方法查看私有静态属性
print(self.__secretary)
def __func(self): # 私有方法
print('经常跟秘书加班....')
class Boss_son(Boss):
def func(self):
print(self.__secretary)
私有成员：私有静态属性，私有对象属性，私有方法
私有静态属性：
类外部不能访问，通过对象可以外部访问
私有方法：
类外部和派生类不能访问
类的类方法，静态方法
class A:
name = 'barry' def __init__(self,a,b): # 双下方法
self.a = a
self.b = b def func(self): # 普通方法，实例方法
pass @staticmethod # 静态方法
def func1():
print(666) @classmethod # 类方法
def func2(cls):
print(777) @property # 属性
def bim(self):
print(111)
类方法： @classmethod
类方法 他是通过类名直接调用的方法，类方法里面至少有一个参数，第一个参数默认cls
class A:
name = 'ehco'
@classmethod
def func(cls):
print(cls)
print(111)
def func1(self):
print(self) A.func() # 可以直接用类名调用的方法，传的参数是类名
A.func1(123) # 和上面的作对比 ，这个需要传参 # 对象可否调用类方法？
# 通过对象也可以调用类方法，cls 接受的不是对象空间而是类空间。
a = A()
a.func() # <class '__main__.A'> 类名的内存地址
类方法在哪里用？
对类中的属性方法直接操作，与对象无关，这样才会用到类方法。
# 判断有多少人注册 class ClassTest(object):
__num = 0 @classmethod
def addNum(cls):
cls.__num += 1 @classmethod
def getNum(cls):
return cls.__num # 这里我用到魔术函数__new__，主要是为了在创建实例的时候调用人数累加的函数。
def __new__(self):
ClassTest.addNum() # 实例化一个对象，就调用一次addNum
return super(ClassTest, self).__new__(self) #返回一个真正的__new__去创建空间 class Student(ClassTest):
def __init__(self):
self.name = '' a = Student()
b = Student()
print(ClassTest.getNum())
静态方法
为什么要静态方法；相似功能，保持一致性 @staticmethod
对象调用类里面的方法，不会影响方法的使用
import time class TimeTest(object):
def __init__(self, hour, minute, second):
self.hour = hour
self.minute = minute
self.second = second @staticmethod
def showTime():
return time.strftime("%H:%M:%S", time.localtime()) print(TimeTest.showTime()) # 打印当前时间
t = TimeTest(2, 10, 10) # 示例对象t
nowTime = t.showTime() # t调用静态方法，并不会改变方法的执行
print(nowTime) # 打印当前时间
类的属性： @property @xxx.setter @ xxx.deleter
@property：属性
将一个方法伪装成属性，虽然在代码逻辑上没什么提高。但是让其看起来更合理
# 调用的时候少一个括号，看着没什么用
class Bmi:
def __init__(self,name,weight,height):
self.name = name
self.weight = weight
self.height = height
@property
def bmi(self):
return self.weight / self.height **2
pang = Bmi('小胖',75,1.76)
# print(pang.bmi()) # 如果没有@property，调用的时候加()
print(pang.bmi) # 如果有@property，调用的时候不要()
@xxx.setter @ xxx.deleter 这两个和@property一起使用
class Market:
def __init__(self, name, price, discount):
self.name = name
self.__price = price # 私有属性
self.__discount = discount # 定义折扣 @property
def price(self): # 返回折后价
return self.__price * self.__discount @price.setter
def price(self, new_price): # 计算降价后的折扣价
self.__price = new_price / self.__discount @price.deleter
def price(self): # 删除价格
del self.__price
apple = Market('苹果',8,0.95)
print(apple.price)
apple.price = 7.5 # 看到改等式，就执行@price.setter。并把7.5传给 new_price
print(apple.price)
del apple.price # 看到del price，就执行@price.deleter
print(apple.price)
异常处理 : 多种 try.......except.....
python解释器检测到错误，触发异常（也允许程序员自己触发异常
程序员编写特定的代码，专门用来捕捉这个异常（这段代码与程序逻辑无关，与异常处理有关）
如果捕捉成功则进入另外一个处理分支，执行你为其定制的逻辑，使程序不会崩溃，这就是异常处理
try:
l1 = [1,2,3]
l1[100] # list index out of range
except Exception as e:
print(e)
print(111) # 程序即使有错误也不影响后面文件的执行
print(222)
print(333)
单支 try except
try:
l1 = [1,2,3]
l1[100] # IndexError # 程序发现错误，直接跳到except。然后执行后续代码
print(333)
print(5555)
except IndexError as e:
print(e)
print(777)
多支 try except
try:
l1 = [1,2,3]
# l1[100] # IndexError
print(333)
print(5555)
dic = {'key1':'v1'}
dic['key2'] # KeyError
num = int(input('请输入选项：'))
print(777)
except IndexError as e:
print(e)
except KeyError as e:
print(e)
接收所有错误：try .except EXCEPOTION
try:
l1 = [1,2,3]
# l1[100] # IndexError
print(333)
print(5555)
dic = {'key1':'v1'}
# dic['key2'] # KeyError
num = int(input('请输入选项：'))
print(777)
except Exception as e: # 接收所有错误
print(e)
# 以上这三种分情况讨论：
# 1，如果你对报错信息不关系，只是想直接跳过报错而不分流执行代码。 万能异常最好。
# 2，如果你想要捕捉具体的错误信息，根据不同的错误执行不同的分支。多分支比较好。
try expcet else
出现异常不执行else语句，没有异常就执行else语句
try:
l1 = [1, 2, 3]
l1[100] # IndexError
except IndexError:
print(666)
else:
print('出现异常不执行else语句，没有异常就执行else语句')
try except finally 有没有错误finally都会执行
用处： 关闭文件句柄，断开数据库连接
try:
l1 = [1, 2, 3]
# l1[100] # IndexError
dic = {}
dic['key1']
except IndexError:
print(666)
else:
print('出现异常不执行else语句，没有异常就执行else语句')
finally:
print('finally有没有异常都执行finally语句') finally有没有异常都执行finally语句，要他有何用？
1,关闭文件句柄，数据库链接等。
with open('log',encoding='utf-8') as f1:
try:
# f1.read() 好几千代码
finally:
f1.close()
# 函数,return 循环的break 之前执行finally操作。
def func():
try:
return 666
finally:
print(111) # 会执行
func()
while被break打断，finally也会执行
while 1:
try:
break
finally:
print(777)
raise 主动抛出错误
class MyError(BaseException): # 自定义一个错误
pass
try:
raise MyError('我的错误') # 主动跑出自定义错误
except MyError as e:
print(e)
assert 1 == 2