一、Bug篇
1、Bug的由来和分类
2、异常报错类型及处理机制
1)类型
2)处理方式
4、PyCharm的调试模式
二、 编程对象
1、两大编程思想
2、类和对象的创建
3、类对象与类属性
4、类方法与静态方法
三、面对对象的特征
1、封装
2、继承
3、方法重写
4、objiect类
5、多态
6、特殊方法和特殊属性
注:该文章为自己所写笔记,心得;不一定对每一位程序猿有所帮助
如有错误还请帮忙告知更改
一、Bug篇
1、Bug的由来和分类
由来:Bug一词的原意是臭虫或虫子。第一代计算机是由许多庞大的真空管组成,并利用大量的电力来使真空管发光。引得一只小虫子Bug钻进了一支真空管内,导致整个计算机无法工作。研究人员费了半天时间,总算发现原因所在,把这只小虫子从真空管中取出后,计算机又恢复正常。后来,Bug这个名词就沿用下来。
Bug的产生因素可以分为:
1、粗心导致
2、知识点不熟练
还能怎么样,只能练!练!练!
3、思路不清晰
4、被动掉坑
逻辑代码没有错,只是因为用户错误操作或者例外情况导致的程序崩溃
使用try-except
2、异常报错类型及处理机制
1)类型
报错类型
'''第一种:ZeroDivisionError
print(10/0)
'''
'''第二种:IndexError
a=[1,2,3]
print(a[3])
'''
'''第三种KeyError
zidian={'a':10,'b':20}
print(zidian['c'])
'''
'''第四种:NameError
print(a)
'''
'''第五种:SyntaxError
print(zip{11})
'''
'''第六种:ValueError
a=int('hello')
'''
2)处理方式
单个报错的try...except XX 语法:
try:
n1=int(input('请输入一个整数:'))
n2=int(input('请输入另一个整数:'))
jieguo=n1/n2
print(jieguo)
except ZeroDivisionError:
print('除数不能为0')
多个报错的try...except XX...except BaseException结构:
try:
n1=int(input('请输入一个整数:'))
n2=int(input('请输入另一个整数:'))
jieguo=n1/n2
print(jieguo)
except ZeroDivisionError:
print('除数不能为0')
except ValueError:
print('无法使用字符串')
except BaseException as e:
print('报错了')
try...except...else结构:
try:
n1=int(input('请输入一个整数:'))
n2=int(input('请输入另一个整数:'))
jieguo=n1/n2
print(jieguo)
except BaseException as e:
print('报错了')
else:
print('感谢你的使用')
'''
请输入一个整数:1
请输入另一个整数:2
0.5
感谢你的使用
'''
try...except...else...finally结构:
try:
n1=int(input('请输入一个整数:'))
n2=int(input('请输入另一个整数:'))
jieguo=n1/n2
print(jieguo)
except BaseException as e:
print('抱歉,您的输入有误')
else:
print('有问题请咨询工作人员')
finally:#怎么都会执行
print('感谢您的使用')
'''
请输入一个整数:5
请输入另一个整数:0
抱歉,您的输入有误
感谢您的使用
'''
traceback模块
import traceback
try:
num=1*1/0
print('输出')
except:
traceback.print_exc()#会自行输出错误类型范围
4、PyCharm的调试模式
二、编程对象
1、两大编程思想
面向工程(线性思维):思维沿着一定的线型一步一步来
面向对象:只找这个事情的参与者
宏观用面向对象,微观用面向过程
2、类和对象的创建
类是多个类似实物组成的群体统称,能够快速让我们进行区分
class Student:#Student为类的名字,由一个或多个单词组成,首字母大写其余小写(非必要,为确保其他程序员更改更容易认知)
na_pace='吉林'#写在类的变量,称为类属性
def __init__(self,name,age):
self.name#self.name实体属性,进行一个赋值操作,将局部变量的name赋值到实体属性
self.age
#实例方法
def wan(play):
print('玩电脑')
# 静态方法
@staticmethod
def st():
print('使用了staticmethod,所以是静态方法')
#类方法
@classmethod
def cm(cls):
print('使用了classmethod,所以是静态方法')
#在类之外定义的称函数,在类之内定义的称为方法
def drink():
print('喝')
3、类对象与类属性
class Student:#Student为类的名字,由一个或多个单词组成,首字母大写其余小写(非必要,为确保其他程序员更改更容易认知)
na_pace='吉林'#写在类的变量,称为类属性
def __init__(self,name,age):
self.name=name#self.name实体属性,进行一个赋值操作,将局部变量的name赋值到实体属性
self.age=age
#实例方法
def eat(self):
print('吃')
#在类之外定义的称函数,在类之内定义的称为方法
def drink():
print('喝')
#创建Student的对象
stu1=Student('张三',20)#实例对象
stu1.eat()#对象名,方法名
print(stu1.name)
print(stu1.age)
Student.eat(stu1)#与stu1.eat()作用一样,都是调用Student类的eat方法
#类名,方法名(类对象)--》实际就是方法处的self
4、类方法与静态方法
class Student:#Student为类的名字,由一个或多个单词组成,首字母大写其余小写(非必要,为确保其他程序员更改更容易认知)
na_pace='我'#写在类的变量,称为类属性
def __init__(self,name,age):
self.name=name#self.name实体属性,进行一个赋值操作,将局部变量的name赋值到实体属性
self.age=age
#实例方法
def eat(self):
print('吃')
# 静态方法
@staticmethod
def st():
print('使用了staticmethod,所以是静态方法')
#类方法
@classmethod
def cm(cls):
print('使用了classmethod,所以是静态方法')
#在类之外定义的称函数,在类之内定义的称为方法
def drink():
print('喝')
#类方法的使用方式
stu1=Student('张三',20)
stu2=Student('李四',19)
print(stu1.na_pace)
print(stu2.na_pace)
Student.na_pace='你'
print(stu1.na_pace)
print(stu2.na_pace)
#stu1和stu2是Student的实例对象,可以共享Student的类属性na_pace
5、动态绑定属性及方法
在创建对象之后,可以动态绑定属性及方法
class Student:#创建类
def __init__(self,name,age):#init方法中self为实例化对象
self.name=name
self.age=age
def eat(self):
print(self.name+'在吃饭')
stu1=Student('A',20)#stu1对象
stu2=Student('B',30)
def tianjia():
print('定义类之外称为函数')
stu=Student('C',40)#实例对象
stu.dontaibangdin='动态绑定'
stu.tianjia=tianjia#动态绑定方法
print(stu.name,stu.age,stu.dontaibangdin,stu.tianjia)
三、面对对象的特征
1、封装
封装:提高程序的安全性,将内部的属性及方法进行包装,在内部对于属性方法进行操作,而不让用户对其了解及操作
如果不希望该属性被类对象外部范围,可以在其访问方法前加双下划线__保证其私密性
class Student:
def __init__(self,name,age):
self.name=name
self.__age=age#年龄不希望在类的外部使用
def fangfa(self):
print(self.name,self.__age)#name为普通使用 age为封装
stu=Student('A',21)
stu.fangfa()
print(stu.name)
print(stu._Student__age)#类外部通过_类名加__方法使用
2、继承
如果一个类没有继承其他类,默认继承object(可以理解为祖先)
python可以进行多继承,同一个类给多个类进行继承
class Father():#默认继承objict
def __init__(self,name,age):
self.name=name
self.age=age
def info(self):
print('姓名:{0},年龄:{1}'.format(self.name,self.age))
class Erzi(Father):#继承father类的属性
def __init__(self,name,age,score):
super().__init__(name,age)
self.score=score
stu=Erzi('父亲',42,'1231')
stu.info()
class Nver(Father):#继承father类的属性 多个继承
def __init__(self,name,age,number):
super().__init__(name,age)
self.Nver=Nver
stu=Erzi('父亲',42,'223')
stu.info()
3、方法重写
如果子类继承对父类的某个属性和方法不满意,可以进行更换重写
可以通过super().xxx()调用父类中被重写的方法
class Father():#默认继承objict
def __init__(self,name,age):
self.name=name
self.age=age
def info(self):#更改对象
print('姓名:{0},年龄:{1}'.format(self.name,self.age))
class Erzi(Father):#继承father类的属性
def __init__(self,name,age,number):
super().__init__(name,age)
self.number=number
def info(self):
super().info()#进行更改
print('号码:{0}',format(self.number))
stu=Erzi('父亲',42,'1231')
stu.info()
4、objiect类
class Father():#默认继承objict
def __init__(self,name,age):
self.name=name
self.age=age
def info(self):#更改对象
print('姓名:{0},年龄:{1}'.format(self.name,self.age))
class Erzi(Father):#继承father类的属性
def __init__(self,name,age,number):
super().__init__(name,age)
self.number=number
def info(self):
super().info()#进行更改
print('号码:{0}',format(self.number))
stu=Erzi('父亲',42,'1231')
stu.info()
#print(dir(stu))#['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'info', 'name', 'number']
print(stu)#<__main__.Erzi object at 0x00000230584E7FA0> 默认调用__str__方法
print(type(stu))#<class '__main__.Erzi'>
5、多态
class Animal(object):
def eat(self):
print('动物会吃')
class Dog(Animal):
def eat(self):
print('狗会吃骨头')
class Cat(Animal):
def eat(self):
print('猫会吃鱼')
def yunxin(Animal):
Animal.eat()
yunxin(Dog())
yunxin(Cat())
6、特殊方法和特殊属性
静态语言与动态语言关于多态的区别
静态语言三要素:继承,方法重写,父类指向子类对象
动态语言:只要是对方行为运行一样就是同个类型,不关心其他
class A:
pass
class B:
pass
class C(A,B):
def __init__(self,name):
self.name=name
shili=C('实例')
print(shili.__dict__)#{'name': '实例'} 属性内容字典
print(C)#<class '__main__.C'>
print(C.__bases__)#(<class '__main__.A'>, <class '__main__.B'>) C类所继承的父类们
print(C.__base__)#<class '__main__.A'> 输出C的其中之一的父类
print(C.__mro__)#(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>) C的层次
print(A.__subclasses__())#[<class '__main__.C'>] A的子类
class Student:
def __init__(self,name):
self.name=name
def __add__(self, other):
return self.name+other.name
A=Student('A')
B=Student('B')
C=A+B#实现对象连接,因为在Student类中,编写了__add__特殊方法进行使用
print(C)#AB
D=Student('D')
E=Student('E')
F=D.__add__(E)#DE
print(F)
liebiao=[1,2,3,45]
print(liebiao.__len__())#输出4 4个数
__new__方法后再执行__init__方法
new方法为拓展一个空间,而init则为这个空间进行初始化,只有有空间有地方,物品才能进行放入
class Konajian():
def __init__(self,name):
print('init方法被调用')
self.name='张三'
def __new__(cls, *args, **kwargs):#new 方法就是用来传递Kongjian的
print('new方法调用')
return object.__new__(cls)
if __name__=='__main__':
a=Konajian('name')
#输出:new方法调用,init方法被调用