类与对象
1.定义类：
类是具有相同属性和行为的事物的统称
class Cat:
"""
函数体
"""
pass
2.创建对象：
某一个具体事物的存在 现实生活中看得见 摸得着
对象名1 = 类名（）
对象名2 = 类名（）
多个对象之间互不干扰 相互独立
3.为对象添加属性
tom = Cat()
tom.name = '汤姆'
print(tom.name)
4.在方法内获取对象的属性：
class Cat:
"""
函数体
"""
def eat(self):
print('%s在喝水' % tom.name)
tom = Cat()
tom.name = '汤姆'
tom.eat()
print(tom.name)
5.self的作用
self 代表了当前调用方法的对象
6.__init__的使用
使用： 方法在创建对象后执行 一般用来初始化对象的共有属性
__init__传参的作用： 可以在self 后面定义需要用到的参数 init需要的参数，在创建对象时传递
def __init__(self，new_name):
"""
魔法方法：在恰当的时机会自动执行的方法
"""
print('init 执行了')
self.name = new_name
class Cat:
def __init__(self, new_name):
self.name = new_name
xiaobai = Cat('伊丽莎白')
7.全局变量与属性的区别：
全局变量 在程序中只能有一个 self引用了一个对象，添加的各个属性在各个对象间独立存在
8.__str__方法的使用：
__str__方法会在打印对象时执行，一般用于返回对象的描述信息
__str__方法必须有返回值，并且返回值必须是字符串类型
def __str__(self):
# print('str 执行了')
return '我是 %s' % self.name
```
###### 9.__del__方法的使用：
__del__方法当对象被销毁时执行
__del__方法一般用于验证对象是否被销毁以及释放没有用的资源（关闭文件等）
接面向对象二10.私有属性：
属性前面加两个下划线，只有定义属性的类才能用，
如果在类之外为私有属性赋值，产生一个新的属性。
class Animal(object):
def __init__(self, ):
self.__age = 18 # 定义私有属性
11.私有方法：
只能在 类内部用的方法，方法前面加双下划线
私有权限：在属性名和方法名 前面 加上两个下划线 __ 类的私有属性 和 私有方法，都不能通过对象直接访问，但是可以在本类内部访问； 类的私有属性 和 私有方法，都不会被子类继承，子类也无法访问； 私有属性 和 私有方法 往往用来处理类的内部事情，不通过对象处理，起到安全作用。
12.父类，子类
Python3 没写父类的继承，就默认继承 object
Python2 如果没写继承 就是经典类，
写明object 是新式类
13.继承
子类可以继承父类的属性和方法
子类如果要使用父类的私有属性，只能通过共有方法
只要创建子类的对象，就默认执行了那个继承过来的__init__方法
（1）单继承
只继承了一个父类
（2）多继承
当父类有同名方法时 一般用强制调用方法指定调用哪一个父类
可以继承多个父类 也继承了父类的所有属性和方法
如果多个父类中有同名的 属性和方法，则默认使用第一个父类的属性和方法（根据类的魔法属性mro的顺序来查找）
is-a has-a 思维工具、逻辑工具
is-a 表示继承关系 is 前面是子类
has-a 表示属性关系 a 后面 是属性
当父类有同名方法时 一般用强制调用方法指定调用哪一个父类
14.重写
定义 父类不满足子类功能 子类写一个与父类同名的方法
重写后的方法，在调用时会调用自己类里面的方法， 变量 是重新赋值 不算重写方法
重写后 仍需要父类同名方法代码里的数据 内容：
1） 父类名.方法名(self,...) (多继承里用
super(子类名，子类对象“self”).父类方法()
super().父类方法（） 只能在 py3中使用
上述方法传参： 如果被重写的方法需要接受参数 在子类调用方法时传参 一般父类需要的 参数 子类也要作为形参
15.__new__方法：
创建对象时执行，能够控制一个类是否要创建对象。
cls:表示调用方法时的类对象。
必须要 return后 才能创建对象。
__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例
def __new__(cls, *args, **kwargs):
obj = object.__new__(cls)
return obj
__new__方法的传参：
用 不定长参数来接受参数 创建对象时的参数解释器会给__new__方法传来，但是__new__方法一般不会使用参数，此时可以使用不定长参数来接收
16. 类对象 与 类属性 实例对象 与 实例属性
类对象：
遇到class关键字 解释器会自动创建类对象
类属性：
当前类的所有实例对象共享一个类属性。
修改类属性：
类名.类属性 = 类属性
实例对象：
类创建出的对象，真实存在的东西
实例属性：
彼此相互独立，互补干扰。
17.实例方法 与 类方法、静态方法
实例方法：
方法的第一个参数是实例对象，叫实例方法
类方法
方法上写@classmethod 方法的第一个参数 一定是接受类对象的
静态方法：
方法上面加上 @staticmethod 方法不接受任何强制性参数
方法的调用 实例方法： 对象名.实例方法（）
类方法： 类名.类方法()
静态方法：类名.静态方法()
class Person(object):
__num = 0 # 私有类属性
def __init__(self, name):
self.name = name
Person.__num += 1
def drink(self): # 方法的第一个参数接收的是实例对象，叫做实例方法
print('%s 能喝' % self.name)
@classmethod # 装饰器
def get_num(cls): # 类方法，在方法上写一个 @classmethod ，方法的第一个参数必定是类对象
print('get_num,cls=',cls)
return cls.__num
@staticmethod
def add2num(a, b): # 静态方法，在方法上写一个 @staticmethod ，方法不需要接收任何强制性的参数
return a+b
zs = Person('张三')
# zs.drink()
# print(Person.get_num()) # 类方法调用，类名.类方法()
print(Person.add2num(11,22)) # 静态方法调用，类名.静态方法()
18.单例模式：
设计模式：
* 设计模式是由技术大牛们总结出来的一套代码模板
* 即使是技术不够强大的程序员，只要按照模板的套路来写，就可以解决比较复杂的问题
定义：一个类只允许创建一个对象 intance = None
def __new__(cls, *args, **kwargs):
# if cls.instance == None: # 当类属性引用为 None 才创建新对象
if not cls.instance: # 当类属性引用为 None 才创建新对象
cls.instance = object.__new__(cls)
return cls.instance
19.if判断
class A(object):
pass
tmp = 0 # False
tmp = 1 # True
tmp = -1 # True
tmp = 0.0 # False
tmp = 0.2 # True
tmp = True
tmp = False
tmp = '' # False
tmp = ' ' # True
tmp = [] # False
tmp = [11] # True
tmp = () # False
tmp = (11,) # True
tmp = {} # False
tmp = {'age': 18} # True
tmp = set() # False
tmp = {11} # True
tmp = A() # True
tmp = None # False
if tmp:
print('True')
else:
print('False')
20.多态：
多态定义：只要是父类能工作的地方，子类都能工作，并且不同子类的执行效果不同
多态的写法
1）定义父类 提供基本方法 2）定义子类 重写父类方法 3）把子类对象传递给调用者，会产生不同的执行效果
多态的好处：
提高调用的灵活性
面向对象三大特性
封装 , 这是定义类的 准则，单个类 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中，
继承 , 这是设计类的 技巧，父与子 主要体现是实现代码的 重用，相同的代码不需要重复的编写 子类可以在父类功能上进行重写，扩展类的功能
多态, 不同的 子类对象调用 相同的 父类方法，产生 不同的 执行结果，可以增加代码的外部 调用灵活度，
多态以 继承 和 重写 父类方法 为前提 多态是调用方法的技巧，不会影响到类的内部设计
class Dog(object):
def work(self):
pass
class ArmyDog(Dog):
def work(self):
print('追击敌人')
class DrugDog(Dog):
def work(self):
print('追查毒品')
class XiaoTianQuan(Dog):
def work1(self):
print('吃月亮')
class Person(object):
def work_with_dog(self, dog): # 多态定义：只要是父类能工作的地方，子类都能工作，并且不同子类的执行效果不同
dog.work()
# 多态的好处：提高调用的灵活性
# 多态的写法：
# 1.定义父类，提供基本方法
# 2.定义子类，重写父类方法
# 3.把子类对象传递给调用者，会产生不同的执行效果
army = ArmyDog()
drug = DrugDog()
xiaotian = XiaoTianQuan()
p = Person()
p.work_with_dog(army)
p.work_with_dog(drug)
p.work_with_dog(xiaotian)
21.异常与捕获异常：
异常：让程序崩溃的代码 捕获异常： try...except...
try:
print('try start')
print(a)
print('try end') # 即使捕捉了异常，异常之后的代码也不会执行
except: # 当出现异常的时候会执行 except
print('捕捉到异常，正在进行修复')
1）捕获多个异常和指定异常
根据工作经验和 解释器给出的异常名
多个异常捕捉 用同样方法解决 可以用元组 里写异常名
except (NameError, FileNotFoundError): # 捕捉多个指定异常，except (异常名称1, 异常名称2, ...)
print('捕捉到资源不存在异常，正在进行修复')
except ValueError:
print('类型转换发生异常，正在进行修复')
2）捕捉任意异常
查找父类：__mro__方法，能通过查找顺序来查找一个类的父类
except Exception：是py里大部分异常处理的父类 （可以设置别名） except 后面不写 ：则是就收所有的异常，（不可以使用别名）
except Exception: # Exception 是Python里大部分异常的父类，可以捕捉绝大部分的异常
print('Exception 捕捉到异常')
except: # except 后不指定异常，可以捕捉任意异常
print('捕捉到未知异常，正在修复~~')
3）异常的别名：
except 异常名 as 变量： 打印变量 时就会打印出异常信息。 except （多个异常名称）as 变量： 打印变量只会打印出一个异常信息，（因为一次只捕获一次）
except ValueError as exp: # except 异常名称 as 别名
print('类型转换发生异常，正在进行修复, exp=', exp)
except (NameError, FileNotFoundError) as exp: # except (异常1，异常2，..) as 别名
print('捕捉到资源不存在异常，正在进行修复, exp=', exp)
except Exception as exp: # Exception 可以设置别名
print('Exception 捕捉到异常, exp=', exp)
except: # except 不能设置别名
print('捕捉到未知异常，正在修复~~')
4）try ...except ... else ... finally.
else :在没有异常时会执行 finally 无论有没有异常都会执行
except ValueError as exp:
print('类型转换发生异常，正在进行修复, exp=', exp)
else:
print('else 当没有异常发生时才会执行')
finally:
print('finally 不管有没有异常都会执行')
5）异常的传递：
被调用的函数发生异常，会把异常传回调用者。
def func1():
print('func1 --- start')
x = 1 / 0 # 被调用的函数发生异常，会把异常传递给调用者
print('func1 --- end')
def func2():
print('func2 --- start')
try:
func1()
except Exception:
print('捕捉到异常')
print('func2 --- end')
func2()
print('程序结束')
6)自定义异常：
自定义异常必须继承Exception
通过raise 执行异常
李龙 21:31:49
类与对象
1.定义类：
类是具有相同属性和行为的事物的统称
class Cat:
"""
函数体
"""
pass
2.创建对象：
某一个具体事物的存在 现实生活中看得见 摸得着
对象名1 = 类名（）
对象名2 = 类名（）
多个对象之间互不干扰 相互独立
3.为对象添加属性
tom = Cat()
tom.name = '汤姆'
print(tom.name)
4.在方法内获取对象的属性：
class Cat:
"""
函数体
"""
def eat(self):
print('%s在喝水' % tom.name)
tom = Cat()
tom.name = '汤姆'
tom.eat()
print(tom.name)
5.self的作用
self 代表了当前调用方法的对象
6.__init__的使用
使用： 方法在创建对象后执行 一般用来初始化对象的共有属性
__init__传参的作用： 可以在self 后面定义需要用到的参数 init需要的参数，在创建对象时传递
def __init__(self，new_name):
"""
魔法方法：在恰当的时机会自动执行的方法
"""
print('init 执行了')
self.name = new_name
class Cat:
def __init__(self, new_name):
self.name = new_name
xiaobai = Cat('伊丽莎白')
7.全局变量与属性的区别：
全局变量 在程序中只能有一个 self引用了一个对象，添加的各个属性在各个对象间独立存在
8.__str__方法的使用：
__str__方法会在打印对象时执行，一般用于返回对象的描述信息
__str__方法必须有返回值，并且返回值必须是字符串类型
def __str__(self):
# print('str 执行了')
return '我是 %s' % self.name
```
###### 9.__del__方法的使用：
__del__方法当对象被销毁时执行
__del__方法一般用于验证对象是否被销毁以及释放没有用的资源（关闭文件等）
接面向对象二10.私有属性：
属性前面加两个下划线，只有定义属性的类才能用，
如果在类之外为私有属性赋值，产生一个新的属性。
class Animal(object):
def __init__(self, ):
self.__age = 18 # 定义私有属性
11.私有方法：
只能在 类内部用的方法，方法前面加双下划线
私有权限：在属性名和方法名 前面 加上两个下划线 __ 类的私有属性 和 私有方法，都不能通过对象直接访问，但是可以在本类内部访问； 类的私有属性 和 私有方法，都不会被子类继承，子类也无法访问； 私有属性 和 私有方法 往往用来处理类的内部事情，不通过对象处理，起到安全作用。
12.父类，子类
Python3 没写父类的继承，就默认继承 object
Python2 如果没写继承 就是经典类，
写明object 是新式类
13.继承
子类可以继承父类的属性和方法
子类如果要使用父类的私有属性，只能通过共有方法
只要创建子类的对象，就默认执行了那个继承过来的__init__方法
（1）单继承
只继承了一个父类
（2）多继承
当父类有同名方法时 一般用强制调用方法指定调用哪一个父类
可以继承多个父类 也继承了父类的所有属性和方法
如果多个父类中有同名的 属性和方法，则默认使用第一个父类的属性和方法（根据类的魔法属性mro的顺序来查找）
is-a has-a 思维工具、逻辑工具
is-a 表示继承关系 is 前面是子类
has-a 表示属性关系 a 后面 是属性
当父类有同名方法时 一般用强制调用方法指定调用哪一个父类
14.重写
定义 父类不满足子类功能 子类写一个与父类同名的方法
重写后的方法，在调用时会调用自己类里面的方法， 变量 是重新赋值 不算重写方法
重写后 仍需要父类同名方法代码里的数据 内容：
1） 父类名.方法名(self,...) (多继承里用
super(子类名，子类对象“self”).父类方法()
super().父类方法（） 只能在 py3中使用
上述方法传参： 如果被重写的方法需要接受参数 在子类调用方法时传参 一般父类需要的 参数 子类也要作为形参
15.__new__方法：
创建对象时执行，能够控制一个类是否要创建对象。
cls:表示调用方法时的类对象。
必须要 return后 才能创建对象。
__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例
def __new__(cls, *args, **kwargs):
obj = object.__new__(cls)
return obj
__new__方法的传参：
用 不定长参数来接受参数 创建对象时的参数解释器会给__new__方法传来，但是__new__方法一般不会使用参数，此时可以使用不定长参数来接收
16. 类对象 与 类属性 实例对象 与 实例属性
类对象：
遇到class关键字 解释器会自动创建类对象
类属性：
当前类的所有实例对象共享一个类属性。
修改类属性：
类名.类属性 = 类属性
实例对象：
类创建出的对象，真实存在的东西
实例属性：
彼此相互独立，互补干扰。
17.实例方法 与 类方法、静态方法
实例方法：
方法的第一个参数是实例对象，叫实例方法
类方法
方法上写@classmethod 方法的第一个参数 一定是接受类对象的
静态方法：
方法上面加上 @staticmethod 方法不接受任何强制性参数
方法的调用 实例方法： 对象名.实例方法（）
类方法： 类名.类方法()
静态方法：类名.静态方法()
class Person(object):
__num = 0 # 私有类属性
def __init__(self, name):
self.name = name
Person.__num += 1
def drink(self): # 方法的第一个参数接收的是实例对象，叫做实例方法
print('%s 能喝' % self.name)
@classmethod # 装饰器
def get_num(cls): # 类方法，在方法上写一个 @classmethod ，方法的第一个参数必定是类对象
print('get_num,cls=',cls)
return cls.__num
@staticmethod
def add2num(a, b): # 静态方法，在方法上写一个 @staticmethod ，方法不需要接收任何强制性的参数
return a+b
zs = Person('张三')
# zs.drink()
# print(Person.get_num()) # 类方法调用，类名.类方法()
print(Person.add2num(11,22)) # 静态方法调用，类名.静态方法()
18.单例模式：
设计模式：
* 设计模式是由技术大牛们总结出来的一套代码模板
* 即使是技术不够强大的程序员，只要按照模板的套路来写，就可以解决比较复杂的问题
定义：一个类只允许创建一个对象 intance = None
def __new__(cls, *args, **kwargs):
# if cls.instance == None: # 当类属性引用为 None 才创建新对象
if not cls.instance: # 当类属性引用为 None 才创建新对象
cls.instance = object.__new__(cls)
return cls.instance
19.if判断
class A(object):
pass
tmp = 0 # False
tmp = 1 # True
tmp = -1 # True
tmp = 0.0 # False
tmp = 0.2 # True
tmp = True
tmp = False
tmp = '' # False
tmp = ' ' # True
tmp = [] # False
tmp = [11] # True
tmp = () # False
tmp = (11,) # True
tmp = {} # False
tmp = {'age': 18} # True
tmp = set() # False
tmp = {11} # True
tmp = A() # True
tmp = None # False
if tmp:
print('True')
else:
print('False')
20.多态：
多态定义：只要是父类能工作的地方，子类都能工作，并且不同子类的执行效果不同
多态的写法
1）定义父类 提供基本方法 2）定义子类 重写父类方法 3）把子类对象传递给调用者，会产生不同的执行效果
多态的好处：
提高调用的灵活性
面向对象三大特性
封装 , 这是定义类的 准则，单个类 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中，
继承 , 这是设计类的 技巧，父与子 主要体现是实现代码的 重用，相同的代码不需要重复的编写 子类可以在父类功能上进行重写，扩展类的功能
多态, 不同的 子类对象调用 相同的 父类方法，产生 不同的 执行结果，可以增加代码的外部 调用灵活度，
多态以 继承 和 重写 父类方法 为前提 多态是调用方法的技巧，不会影响到类的内部设计
class Dog(object):
def work(self):
pass
class ArmyDog(Dog):
def work(self):
print('追击敌人')
class DrugDog(Dog):
def work(self):
print('追查毒品')
class XiaoTianQuan(Dog):
def work1(self):
print('吃月亮')
class Person(object):
def work_with_dog(self, dog): # 多态定义：只要是父类能工作的地方，子类都能工作，并且不同子类的执行效果不同
dog.work()
# 多态的好处：提高调用的灵活性
# 多态的写法：
# 1.定义父类，提供基本方法
# 2.定义子类，重写父类方法
# 3.把子类对象传递给调用者，会产生不同的执行效果
army = ArmyDog()
drug = DrugDog()
xiaotian = XiaoTianQuan()
p = Person()
p.work_with_dog(army)
p.work_with_dog(drug)
p.work_with_dog(xiaotian)
21.异常与捕获异常：
异常：让程序崩溃的代码 捕获异常： try...except...
try:
print('try start')
print(a)
print('try end') # 即使捕捉了异常，异常之后的代码也不会执行
except: # 当出现异常的时候会执行 except
print('捕捉到异常，正在进行修复')
1）捕获多个异常和指定异常
根据工作经验和 解释器给出的异常名
多个异常捕捉 用同样方法解决 可以用元组 里写异常名
except (NameError, FileNotFoundError): # 捕捉多个指定异常，except (异常名称1, 异常名称2, ...)
print('捕捉到资源不存在异常，正在进行修复')
except ValueError:
print('类型转换发生异常，正在进行修复')
2）捕捉任意异常
查找父类：__mro__方法，能通过查找顺序来查找一个类的父类
except Exception：是py里大部分异常处理的父类 （可以设置别名） except 后面不写 ：则是就收所有的异常，（不可以使用别名）
except Exception: # Exception 是Python里大部分异常的父类，可以捕捉绝大部分的异常
print('Exception 捕捉到异常')
except: # except 后不指定异常，可以捕捉任意异常
print('捕捉到未知异常，正在修复~~')
3）异常的别名：
except 异常名 as 变量： 打印变量 时就会打印出异常信息。 except （多个异常名称）as 变量： 打印变量只会打印出一个异常信息，（因为一次只捕获一次）
except ValueError as exp: # except 异常名称 as 别名
print('类型转换发生异常，正在进行修复, exp=', exp)
except (NameError, FileNotFoundError) as exp: # except (异常1，异常2，..) as 别名
print('捕捉到资源不存在异常，正在进行修复, exp=', exp)
except Exception as exp: # Exception 可以设置别名
print('Exception 捕捉到异常, exp=', exp)
except: # except 不能设置别名
print('捕捉到未知异常，正在修复~~')
4）try ...except ... else ... finally.
else :在没有异常时会执行 finally 无论有没有异常都会执行
except ValueError as exp:
print('类型转换发生异常，正在进行修复, exp=', exp)
else:
print('else 当没有异常发生时才会执行')
finally:
print('finally 不管有没有异常都会执行')
5）异常的传递：
被调用的函数发生异常，会把异常传回调用者。
def func1():
print('func1 --- start')
x = 1 / 0 # 被调用的函数发生异常，会把异常传递给调用者
print('func1 --- end')
def func2():
print('func2 --- start')
try:
func1()
except Exception:
print('捕捉到异常')
print('func2 --- end')
func2()
print('程序结束')
6)自定义异常：
自定义异常必须继承Exception
通过raise 执行异常
class MyError(Exception):
def __init__(self, age):
self.age = age
def __str__(self): # __str__ 方法返回的数据，就是异常的描述信息
return '年龄不能小于 0,您输入的是 %d' % self.age
try:
age = int(input('请输入您的年龄:'
class MyError(Exception):
def __init__(self, age):
self.age = age
def __str__(self): # __str__ 方法返回的数据，就是异常的描述信息
return '年龄不能小于 0,您输入的是 %d' % self.age
try:
age = int(input('请输入您的年龄:'
|
|
收藏
淘帖
踩
