Python之路【第6天】

目录

1. 深入面向对象
2. 类的成员
   2.1字段
   2.1方法
   2.3属性
3. 类成员的修饰符
   3.1公有成员
   3.2私有成员
4. 类的特殊成员
5. 异常处理
6. 反射

---

深入面向对象

• 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
• 类 是一个模板，模板中包装了多个“函数”供使用（可以讲多函数中公用的变量封装到对象中）
• 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
• 面向对象三大特性：封装、继承和多态

类的成员

类的成员可以分为三大类：字段、方法和属性

一、字段

字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，
•普通字段属于对象
•静态字段属于类

class Province:
    country="中国" #静态字段
    def __init__(self,name):
        self.name=name   #普通字段
obj=Province("河北省")
print(obj.name)  # 直接访问普通字段
print(Province.country)  # 直接访问静态字段

• 静态字段在内存中只保存一份
• 普通字段在每个对象中都要保存一份

应用场景： 通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段

二、方法

方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。
•普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
•类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
•静态方法：由类调用；无默认参数；

class Foo:
    def __init__(self,name):
        self.name=name
    def ord_func(self):
        #定义普通方法，至少一个self参数
        print("普通方法")
    @classmethod
    def class_fun(cls):
        #定义类方法，至少有一个cls参数
        print("类方法")
    @staticmethod
    def static_func():
        #定义静态方法，无默认参数
        print("静态方法")
#调用普通方法
f=Foo("aa")  #先实例化一个对象
f.ord_func()
#调用类方法
Foo.class_fun()
#调用静态方法
Foo.static_func()

相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。

不同点：方法调用者不同、调用方法时自动传入的参数不同。

三、属性

如果你已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。

对于属性，有以下三个知识点：
•属性的基本使用
•属性的两种定义方式

1、属性的基本使用

class Foo:
    def func(self):
        print("调用了方法")
        pass
    @property  #定义属性
    def prop(self):
        print("prop方法")
        pass
obj=Foo() #实例化
obj.func()  #调用func方法
obj.prop  #调用属性，无需加括号

由属性的定义和调用要注意一下几点：
•定义时，在普通方法的基础上添加 @property 装饰器；
•定义时，属性仅有一个self参数
•调用时，无需括号
方法：obj.func()
属性：obj.prop

注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象

2、属性的两种定义方式

属性的定义有两种方式：
•装饰器 即：在方法上应用装饰器
•静态字段 即：在类中定义值为property对象的静态字段

装饰器方式：在类的普通方法上应用@property装饰器

我们知道Python中的类有经典类和新式类，新式类的属性比经典类的属性丰富。（ 如果类继object，那么该类是新式类 ）
经典类，具有一种@property装饰器

class Goods:
    @property   #定义属性
    def price(self):
        return "1000"
obj=Goods()  #实例化
print(obj.price)  #调用属性

新式类，具有三种@property装饰器

class Goods(object):
    @property   #定义属性
    def price(self):
        print("@property")
    @price.setter   #可以设置属性赋值
    def price(self,value):
        self.value=value
        print("@price.setter[%s]"%self.value)
    @price.deleter   #可以执行删除操作
    def price(self):
        print("@price.deleter ")
obj=Goods()
obj.price   #调用price方法
obj.price=123  #调用price方法，将 123赋值给方法的参数
del obj.price
#结果为：
@property
@price.setter[123]
@price.deleter 

注：经典类中的属性只有一种访问方式，其对应被 @property 修饰的方法
新式类中的属性有三种访问方式，并分别对应了三个被@property、@方法名.setter、@方法名.deleter修饰的方法

由于新式类中具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除

由于静态字段方式创建属性具有三种访问方式，我们可以根据他们几个属性的访问特点，分别将三个方法定义为对同一个属性：获取、修改、删除

class Goods(object):
    def __init__(self):
        self.original_price=100
        self.discount=0.8
    def get_price(self):
        new_price=self.original_price*self.discount
        return new_price
    def set_price(self,value):
        self.original_price=value
    def del_price(self,value):
        del self.original_price
    #分别将三个方法定义为对同一个属性：获取、修改、删除
    price=property(get_price,set_price,del_price,"价格属性描述")
obj=Goods()
print(obj.price)    # 获取商品价格
obj.price=200    # 修改商品原价
print(obj.price)
#del obj.price    # 删除商品原价

类成员的修饰符

每一个类的成员而言都有两种形式：

• 公有成员，在任何地方都能访问
• 私有成员，只有在类的内部才能方法

私有成员和公有成员的定义不同：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：init、call、dict等）

class C:
    def __init__(self):
        self.name="public"
        self.__foo="private"

私有成员和公有成员的访问限制不同：
静态字段

公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
私有静态字段：仅类内部可以访问；

class C:
    name="公有静态字段"
    def func(self):
        print(C.name)
class D(C):
    def show(self):
        print(C.name)
C.name  #类访问
obj=C()  #实例化
obj.func()  #类内部可以访问
sub_obj=D()  #实例化
sub_obj.show() #派生类中可以访问
#结果为：
公有静态字段
公有静态字段

私有静态字段

class C:
    __name="公有静态字段"
    def func(self):
        print(C.__name)
class D(C):
    def show(self):
        print(C.__name)
#C.__name  #类访问  ==>提示没有个属性，访问不了
obj=C()  #实例化
obj.func()   #内部访问  ==>正常访问
sub_obj=D()  #实例化
sub_obj.show()  #派生类访问  ==>提示没有个属性，访问不了

普通字段

公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
私有普通字段：仅类内部可以访问；

class C:
    def __init__(self):
        self.foo="公有字段（属性）"
    def func(self):
        print(self.foo)  #类内部访问
class D(C):
    def show(self):
        print(self.foo)  #派生内中访问
obj=C()  #实例化
obj.foo  #通过对象访问   ==> 可以访问
#print(obj.foo)
obj.func()  #类内部访问  ==>可以访问
obj_sub=D()  #实例化
obj_sub.show()  #派生类可以访问  ==>可以访问

私有字段（属性）

class C:
    def __init__(self):
        self.__foo="私有字段"
    def func(self):
        print(self.__foo)  #类内部访问
class D(C):
    def show(self):
        print(self.__foo)  #派生类访问

obj=C() #实例化
#obj.__foo   #通过对象访问   ==>提示无法访问
obj.func()  #类内部访问  ==>可以访问
obj_sub=D()  #实例化
obj_sub.show()  #派生类访问  ==>提示无法访问

方法、属性的访问于上述方式相似，即：私有成员只能在类内部使用

类的特殊成员

Python的类成员以及成员修饰符，从而了解到类中有字段、方法和属性三大类成员，并且成员名前如果有两个下划线，则表示该成员是私有成员，私有成员只能由类内部调用。无论人或事物往往都有不按套路出牌的情况，Python的类成员也是如此，存在着一些具有特殊含义的成员，详情如下：

1. doc
   表示类的描述信息

class Foo:
    """描述类信息，这里会被显示"""
    def func(self):
        pass
print (Foo.__doc__)
#结果为：
描述类信息，这里会被显示

1. module 和 class

module 表示当前操作的对象在那个模块
class 表示当前操作的对象的类是什么

__main__
<class '__main__.C'>

#结果为：
__main__
<class '__main__.C'>

3 call

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

4 dict
获取类的成员，即：静态字段、方法、

5 str
如果一个类中定义了str方法，那么在打印 对象 时，默认输出该方法的返回值。

class Foo:
    def __str__(self):
        return "aa"

obj=Foo()
print (obj)  #打印得到的返回值
print(Foo.__dict__)  # 获取类的成员
#结果为：
aa
{'__module__': '__main__', '__str__': <function Foo.__str__ at 0x00000198EAC52620>, '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>, '__doc__': None}

6 getitem、setitem、_delitem
用于索引操作，如字典。以上分别表示获取、设置、删除数据

class Foo(object):
    def __getitem__(self, key):
        print("__getitem__",key)
    def __setitem__(self,key,value):
        print("__setitem__",key,value)
    def __delitem__(self,key):
        print("__delitem__",key)
obj=Foo()
result=obj["k1"]   #自动触发执行  __getitem__
obj["k2"]="aa"  #自动触发执行   __setitem__
del obj["k1"]   #自动触发执行  __delitem__

7 getslice、setslice、delslice

该三个方法用于分片操作，如：列表

异常处理

1、异常基础

在编程过程中为了增加友好性，在程序出现bug时一般不会将错误信息显示给用户，而是现实一个提示的页面
需求：将用户输入的两个数字相加

while True:
    num1=input("num1:")
    num2=input("num2:")
    try:
        num1=int(num1)
        num2=num2  #故意不将字符串转化为数字型
        ret=num1+num2
        break
    except Exception:
        print("出现异常，信息如下：")
        break
print (ret)
#结果为：
num1:1
num2:2
出现异常，信息如下：

2、异常种类

1. python中的异常种类非常多，每个异常专门用于处理某一项异常！！！
2. AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
3. IOError 输入/输出异常；基本上是无法打开文件
4. ImportError 无法引入模块或包；基本上是路径问题或名称错误
5. IndentationError 语法错误（的子类） ；代码没有正确对齐
6. IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
7. KeyError 试图访问字典里不存在的键
8. KeyboardInterrupt Ctrl+C被按下
9. NameError 使用一个还未被赋予对象的变量
10. SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
11. TypeError 传入对象类型与要求的不符合
12. UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
13. ValueError 传入一个调用者不期望的值，即使值的类型是正确的

ArithmeticError
AssertionError
AttributeError
BaseException
BufferError
BytesWarning
DeprecationWarning
EnvironmentError
EOFError
Exception
FloatingPointError
FutureWarning
GeneratorExit
ImportError
ImportWarning
IndentationError
IndexError
IOError
KeyboardInterrupt
KeyError
LookupError
MemoryError
NameError
NotImplementedError
OSError
OverflowError
PendingDeprecationWarning
ReferenceError
RuntimeError
RuntimeWarning
StandardError
StopIteration
SyntaxError
SyntaxWarning
SystemError
SystemExit
TabError
TypeError
UnboundLocalError
UnicodeDecodeError
UnicodeEncodeError
UnicodeError
UnicodeTranslateError
UnicodeWarning
UserWarning
ValueError
Warning
ZeroDivisionError

s1="hello"
try:
    int(s1)
except KeyError:
    print("键错误")
except IndexError:
    print("索引错误")
except TypeError:
    print("类型错误")
except Exception:
    print("出现了错误")

主动触发异常

try:
    raise Exception('错误了。。。')
except Exception:
    print("出现了错误")

自定义异常

class UserException(Exception):
    def __init__(self,msg):
        self.message=msg
    def __str__(self):
        return self.message
try:
    raise UserException("自定义异常")
except UserException:
    print("出现了错误")

反射

python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：检查是否含有某成员、获取成员、设置成员、删除成员。

class Foo(object):
    def __init__(self):
        self.name="aa"
    def func(self):
        return "func"
obj=Foo()
# #### 检查是否含有成员 ####
print(hasattr(obj,"name"))
print(hasattr(obj,"func"))
# #### 获取成员 ####
getattr(obj,"name")
getattr(obj,"func")
# #### 设置成员 ####
setattr(obj,"age",18)
setattr(obj,"show",lambda num:num+1)
print(obj.age)
print(obj.show(obj.age))
# #### 删除成员 ####
delattr(obj,"name")
#delattr(obj,"func")
#结果为：
True
True
18
19

结论：反射是通过字符串的形式操作对象相关的成员。一切事物都是对象！！！