Python 面向对象进阶(二)

1. 垃圾回收

小整数对象池
- Python对小整数的定义是 [-5, 257),这些整数对象是提前建立好的;
- 在一个Python程序中,所有位于这个范围内的整数,使用的都是同一个对象;
- 单个字符共用对象,常驻内存;
大整数对象池
- 每一个大整数,均创建一个新的对象;
intern机制
- 单个单词,不可修改,默认开启intern机制,共用对象,当引用计数为0时,则销毁;
- 字符串(含有空格),不可修改,没有开启intern机制,不共用对象;

# 示例:

a1 = "Helloworld"

a2 = "HelloWorld"

a3 = "HelloWorld"

a4 = "HelloWorld"

a5 = "HelloWorld"

a6 = "HelloWorld"

# 说明：

＃　intern 机制,内存中只有一个"HelloWorld"所占的空间,靠引用计数去维护何时释放。

1.1 GC 垃圾回收

Python 采用的是引用计数机制为主,以分代收集机制为辅的策略;
gc 模块常用函数:
- gc.get_threshold(): 获取gc模块中自动执行垃圾回收的频率;
- gc.set_threshold(threshold[, threshold1[, threshold2]])设置自动执行垃圾回收的频率;
- gc.get_count(): 获取当前自动执行垃圾回收的计数器,返回一个长度为3的列表;
- gc.collect(): 显示执行垃圾回收;

# 示例:

# 引用计数缺点:循环引用

class ClassA():

    def __init__(self):

        print("object born,id:%s" % str(hex(id(self))))

def f2():

    while True():

        c1 = ClassA()

        c2 = ClassA()

        c1.t = c2

        c2.t = c1

        del c1

        del c2

f2()

2. 内建属性和内建函数

2.1 内建属性

常用属性
- __init__: 构造初始化函数;
- __new__: 生成实例所需属性;
- __class__: 实例所在的类, 实例.__class__
- __str__: print(类实例)自动调用对象的__str__方法;
- __int__: int(对象)自动执行对象的__int__方法,并将返回值赋给int对象;
- __repr__: 实例字符串表示,准确性; 类实例回车时触发
- __del__: del 实例时,触发;
- __dict__: 将对象中封装的所有内容通过字典的形式返回;
- __doc__: 类文档,子类不继承; help(类或实例)
- __getattribute__: 属性访问拦截器;
- __bases__: 类的所有父类构成元素, 类名.__bases__

# 示例: 属性拦截器

class Test(object):

    def __init__(self, subject1):

        self.subject1 = subject1

        self.subject2 = 'cpp'

    # 属性访问拦截器,打印日志信息

    def __getattribute__(self, obj):

        print("===1>%s" % obj)

        if obj == 'subject1':

            print('log subject1')

            return 'redicrect python'

        else:

            temp = object.__getattribute__(self, obj)

            print("===2>%s" % str(temp))

            return temp

    def show(self):

        print("this is a Test")

s = Test("python")

print(s.subject1)

print(s.subject2)

s.show()

# 调用方法步骤:

# 1. 先使用属性访问拦截器,获取show属性对应的方法;

# 2. 方法()

# 示例二: 属性拦截器注意事项

class Person(object):

    def __getattribute__(self, obj):

        print("=== test ===")

        if obj.startswith("a"):

            return "haha"

        else:

            return self.test

    def test(self):

        print("heihei")

t = Person()

t.a     # 返回 haha

t.b     # 会让程序挂掉

# 原因: 当 t.b 执行时,会调用Person类中定义的 __getattribute__ 方法, if 条件不满足,所以程序

# 执行 else 里面的代码, 即 return self.test; 因为 return 需要 self.test 的值返回,那么首先

# 要先获取 self.test 的值, 因为 self 此时就是对象 t, 所以,self.test = t.test, t.test 此时

# 要获取t这个对象的 test 属性,那么,就会跳转到 __getattribute__ 方法去执行,即此时产生了递归调用;

# 示例三:  __getitem__

class Foo:

    def __init__(self, name, age):

          self.name = name

           self.age = age

    def __getitem__(self, item):

            return item + 10

    def __setitem__(self, key, value):

            print(key, value)

    def __delitem__(self, key):

            print(key)

li = Foo('zhangsan', 18)

a = li[8]        # 此处,会自动执行li对象的的 __getitem__ 方法,  8 会当作参数传递给 item

print(a)

li[100] = 'master'        # 会调用 __setitem__ 方法

del li[666]                # 会调用 __delitem__ 方法

# 示例四:   __iter__

class Foo:

    def __init__(self, name, age):

            self.name = name

            self.age = age

    def __iter__(self):

            return iter([11, 22, 33])

li = Foo('alex', 19)

for i in li:

     # 1. 执行li对象对应的类 Foo 中的 __iter__ 方法, 并获取其返回值

     # 2. 循环上一步返回的对象

    print(i)

# 备注:

#       1. 如果类中有 __iter__ 方法, 那么,该类生成的对象为可迭代对象;

#        2. 对象.__iter__() 返回值为迭代器;

# 示例五: __call__ 方法

class Foo:

    def __init__:

        pass

    def __call__:

        pass

obj = Foo()        # 此处,会自动执行 __init__ 方法

obj()                 # 此处,会自动执行 __call__ 方法

2.2 内建函数

dir(__builtins__): 可以查看Python解释器启动后,默认加载的属性和函数;

# 示例一: range

range(stop)

range(start, stop[, step])

# 备注:

#   python2中 range 返回列表;

#   python3中 range 返回一个迭代值;如果想得到列表,可通过 list 函数

#  pyton3 创建列表的另外一种方法:

testList = [x*2 for x in range(10)]

testList

# 示例二: map 函数

# map 函数会根据提供的函数对指定序列做映射

# map(function, sequence[, sequence, ...]) -> list

#   function: 函数

#   sequence: 一个或多个序列,取决于function需要几个参数;

#   返回值是一个list

# 函数需要一个参数

map(lambda x: x*x, [1, 2, 3])   # 结果为: [1, 4, 9]

# 函数需要两个参数

map(lambda x, y: x+y, [1, 2, 3], [4, 5, 6])     # 结果为: [5, 7, 9]

# 示例三: filter 函数

# filter(function or None, sequence) -> list, tuple, or string

#   function: 接受一个参数,返回布尔值True或False

#   sequence: 序列可以是 str, tuple, list

#   filter 函数会对序列参数sequence中的每个元素调用function函数, 最后返回的结果包含调用结果为

#   True的元素

filter(lambda x: x%2, [1, 2, 3, 4])     # 结果为[1, 3]

# 示例四: reduce 函数

# reduce(function, sequence[, initial])  -> value

#   function: 该函数有两个参数

#   sequence: 序列可以是 str, tuple, list

#   initial: 固定初始值

#  reduce 函数依次从sequence中取一个元素,和上一次调用function的结果做参数再次调用function。第一次调用

#  function时,如果提供initial参数,会以sequence中的第一个元素和initial作为参数调用function, 否则会以

#  序列sequence中的前两个元素做参数调用function。注意,function 函数不能为None

reduce(lambda x, y: x+y, [1, 2, 3, 4])  # 结果为: 10

reduce(lambda x, y: x+y, ['aa', 'bb', 'cc'], 'dd')      # 结果为: ddaabbcc

# 备注: Python3, reduce函数已经从全局名字空间中移除,现在被放置在functools模块里面,

# 如果需要使用,需要先导入: from functools import reduce

# 示例五: sorted 函数

# sorted(iterable, cmp=None, key=None, reverse=Fale) -> new sorted list

sroted(['dd','yy','ee','ss','ww'], reverse=1)

3. 集合 set

集合与之前列表,元组类似,可以存储多个数据,但是这些数据是不重复的;
集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric_difference(对称差集)等数学运算;

# 示例:

a = "abcdef"

b = set(a)      # 输出: {'a', 'b', 'c', 'd', 'e', 'f'}

A = "bdfwm"

B = set(A)

b&B     # 取交集

b|B     # 取并集

b-B     # 取差集

b^B     # 对称差集(在b或B中,但不会同时出现在二者中)

4. functools

# Python3

import functools

dir(functools)      # 查看所有的工具函数

# 函数一: partial函数(偏函数)

# 把一个函数的某些参数设置默认值,返回一个新的函数,调用这个新函数会更简单

import functools

def showarg(*args, **kw):

    print(args)

    print(kw)

p1 = functools.partial(showarg, 1,2,3)

p1()    # 输出: (1, 2, 3) {}

p1(4, 5, 6)     # 输出: (1, 2, 3, 4, 5, 6)  {}

p1(a='python', b='java')    #输出: (1, 2, 3) {'b':'java', 'a':'python'}

# 函数二: wraps 函数

# 使用装饰器时,有一些细节需要被注意。例如,被装饰后的函数,其实已经是另外一个函数了(函数属性会发生改变)

def note(func):

    '''note function'''     # 说明文档

    def wrapper():

        '''wrapper function'''

        print('note something')

        return func()

    return wrapper

@note

def test():

    '''test function'''

    print('I am test')

print(help(test))

# 输出wrapper的说明文档

# wrapper()

#    wrapper function

# functools 包提供了 wraps 装饰器来消除这样的副作用

import functools

def note(func):

    '''note function'''

    @functools.wraps(func)

    def wrapper():

        '''wrapper function'''

        print('note something')

        return func()

    return wrapper

@note

def test():

    '''test function'''

    print('I am test')

print(help(test))

# 输出:

#   test()

#       test function

参考资料:

Python 核心编程

巴特西

Python 面向对象进阶(二)

1. 垃圾回收

1.1 GC 垃圾回收

2. 内建属性和内建函数

2.1 内建属性

2.2 内建函数

3. 集合 set

4. functools

最新文章

热门文章