封装：
将一些数据，重要的信息等等放到一个地方（空间）。
class A: country = 'China' area = '深圳‘ def __init__(self,name,age): self.name = name self.age = age a1 = A('狗子',18) 实例化一个对象 将 a2 = A('臭屁',20) print(a1.__dict__) #{'name': '狗子', 'age': 18} print(a2.__dict__) #{'name': '臭屁', 'age': 20}
多态：
一种事物有多种形态
水：液态，固态，气态
python默认支持多态
i = 777
i = ‘abc’
鸭子类型
Python会约定俗成制定一些行为规范，保持一致性。
# class A: # def func1(self): # print('in A func1') # # def func2(self): # print('in A func2') # # # class B: # def func1(self): # print('in B func1') # # def func2(self): # print('in B func2') # str # bytes # 将 A,B里面相似的一些功能命名成相同的名字，隐约制定一个标准 # obj1 = A() # obj1.func1() # obj2 = B() # obj2.func1()
类的约束：
对类进行一些正确引导，约束，统一规范，满足正的开发方式
# class A: # 这个父类制定了一个约束，规范，子类一定要有pay方法。 # def pay(self,money): # pass # # class Alipay(A): # # def pay(self,money): # print('此次消费%s'% money) # # # class QQpay(A): # def pay(self,money): # print('此次消费%s' % money) # # class Wechatpay(A): # def pay(self,money): # print('此次消费%s' % money) # # class Unitypay(A): # def zhifu(self,money): # 太low了,正规化 # print('此次消费%s' % money) # # def pay(obj,money): # 归一化设计 # obj.pay(money) # # # # a = Alipay() # # a1 = Alipay() # # b = QQpay() # # c = Wechatpay() # # pay(a,100) # # pay(b,200) # # pay(a1,300) # # pay(c,400) # d = Unitypay() # pay(d,200)
遇到这情况就要强制加一个约束，只要不按照我的规则执行，就报错。
两种解决方式：
1，python常用的一种，在父类写一个相同的方法pay 在此方法里面，主动抛出一个错误，你应该在自己的类中定义此方法。
第一种是python经常用的解决方式。
# class A: # 这个父类制定了一个约束，规范，子类一定要有pay方法。 # def pay(self,money): # raise Exception('未定义pay方法') # class Alipay(A): # # def pay(self,money): # print('此次消费%s'% money) # # # class QQpay(A): # def pay(self,money): # print('此次消费%s' % money) # # class Wechatpay(A): # def pay(self,money): # print('此次消费%s' % money) # # class Unitypay(A): # 太low了,正规化 # def zhifu(self,money): # print('此次消费%s' % money) # # def pay(obj,money): # 归一化设计 # obj.pay(money) # # # # a = Alipay() # # a1 = Alipay() # # b = QQpay() # # c = Wechatpay() # # pay(a,100) # # pay(b,200) # # pay(a1,300) # # pay(c,400) # d = Unitypay() # pay(d,200)
2，在父类引用元素的抽象方法，抛出异常
from abc import ABCMeta,abstractmethod class A(metaclass=ABCMeta): # 这个父类制定了一个约束，规范，子类一定要有pay方法。 ''' 抽象类，接口类：制定一个规范，强制执行。 ''' @abstractmethod def pay(self,money): pass def func(self): pass class Alipay(A): def pay(self,money): print('此次消费%s'% money) class QQpay(A): def pay(self,money): print('此次消费%s' % money) class Wechatpay(A): # 太low了,正规化 def pay(self,money): print('此次消费%s' % money) class Unitypay(A): # def zhifu(self,money): # print('此次消费%s' % money) def pay(self,money): print('此次消费%s' % money) def pay(obj,money): # 归一化设计 obj.pay(money) # a = Alipay() # a1 = Alipay() # b = QQpay() # c = Wechatpay() # pay(a,100) # pay(b,200) # pay(a1,300) # pay(c,400) d = Unitypay() # pay(d,200)
类的私有成员：
“”“”“”“”“”“”“”““”“””’
类的结构：
class A：
静态属性
方法
“”“”“”“”“”“”“”“”“”“”
按照公有，私有对类进行划分
私有成员： 私有静态属性 私有对象属性 私有方法 __变量名 __就是定义为私有
# 私有静态属性
# 类外部访问，类内部访问，派生类访问
class Boss: name = 'alex' # 公有静态属性 公有静态字段 __secretary =['女1', '男2', '眼膜'] # 私有静态属性 私有静态字段 def __init__(self,username,password): self.username = username # 公有对象属性 公有普通字段 self.__password = password # 私有对象属性 私有普通字段 def func(self): # print(self.__secretary) self.__func() def __func(self): # 私有方法 print('经常跟秘书加班....') class Boss_son(Boss): def func(self): # print(self.__secretary) self.__func() a1 = Boss('alex',666) a1.__func() # 类外部不能访问 a1.func() # 类内部可以访问 b1 = Boss_son('fdsa',123) b1.func() # 类的派生类不能访问
# 私有成员当真访问不到么？ 不是，python做了一些加工。 # class Boss: # # name = 'alex' # 公有静态属性 公有静态字段 # __secretary =['女1', '男2', '眼膜'] # 私有静态属性 私有静态字段 # # def __init__(self,username,password): # self.username = username # 公有对象属性 公有普通字段 # self.__password = password # 私有对象属性 私有普通字段 # # def func(self): # # print(self.__secretary) # self.__func() # def __func(self): # 私有方法 # print('经常跟秘书加班....') # # b1 = Boss('alex',123) # print(Boss.__dict__) # python 将我的私有成员 _类名__私有成员 # print(Boss._Boss__secretary) # 私有成员虽然在类外面或者派生类可以访问到，但是不要这么做。
类的类方法
他是通过类名直接调用的方法，类方法里面至少有一个参数，第一个参数默认cls
# 对象可否调用类方法？ # 通过对象也可以调用类方法，cls 接受的不是对象空间而是类空间。 # 类方法在哪里用？ # 对类中的属性方法直接操作，与对象无关，这样才会用到类方法。 # 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() # return super(ClassTest, self).__new__(self) # # # class Student(ClassTest): # def __init__(self): # self.name = '' # # a = Student() # b = Student() # print(ClassTest.getNum())
静态方法：
# class A: # # name = 'barry' # # @staticmethod # def func(): # print(666) # obj = A() # # A.func() # obj.func() # 为什么要静态方法；相似功能，保持一致性 import time class TimeTest(object): def __init__(self, hour, minute, second): self.hour = hour self.minute = minute self.second = second # def time @staticmethod def showTime(): return time.strftime("%H:%M:%S", time.localtime()) print(TimeTest.showTime()) t = TimeTest(2, 10, 10) nowTime = t.showTime() print(nowTime)
类的属性：
# 体质指数（BMI）=体重（kg）÷身高^2（m） # 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('小胖',83,1.78) # barry = Bmi('太白',80,1.76) # # print(barry.bmi()) # print(barry.bmi) # 属性：将一个方法伪装成属性，虽然在代码逻辑上没什么提高， # 但是让其看起来更合理一些。
异常处理：异常：
在程序中只要出现了这种异常，程序会立马停掉，体验感极差，
遇到类似于这种逻辑上的异常，要先捕捉异常，根据不同异常，进行不同处理。
解决异常的方式：
1，利用if语句解决异常,只能处理简单少量的异常。
2，异常处理，try .....
python解释器检测到错误，触发异常（也允许程序员自己触发异常程序员编写特定的代码，专门用来捕捉这个异常（这段代码与程序逻辑无关，与异常处理有关）如果捕捉成功则进入另外一个处理分支，执行你为其定制的逻辑，使程序不会崩溃，这就是异常处理
try . except 单支
# try: # l1 = [1,2,3] # l1[100] # IndexError # print(333) # print(5555) # # dic = {'key1':'v1'} # # dic['key2'] # KeyError # print(777) # except IndexError as e: # print(e)
# try .except 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，如果你想要捕捉具体的错误信息，根据不同的错误执行不同的分支。多分支比较好。
# 4, 一般会采取多分支 + 万能异常的形式。
''' try: num = input('请输入你要办理的业务：').strip() num = int(num) menu_dict[num]() except ValueError: print('请输入数字') except KeyError: print('超出范围，请重新输入') except Exception : print("出现未知错误.....") '''
finally ***
# 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 1: # try: # break # finally: # print(777) # 主动抛出异常（用过）。 # try: # raise TypeError('类型错误') # except Exception as e: # print(e) # 很重要。 # # class PhoneconnectionError(BaseException): # pass # # try: # raise PhoneconnectionError('连接错误...') # except PhoneconnectionError as e: # print(e) # 条件不成立 主动报错 # assert 1 == 2