Python中使用双下划线+属性名称实现类似于静态语言中的private修饰来实现数据封装。

'''

遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006

寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！

'''

class User(object):

def __init__(self, number):

self.__number = number

self.__number_2 = 0

def set_number(self, number):

self.__number = number

def get_number(self):

return self.__number

def set_number_2(self, number2):

self.__number_2 = number2

# self.__number2 = number2

def get_number_2(self):

return self.__number_2

# return self.__number2

u = User(25)

print(u.get_number()) # 25

# 真的类似于java的反射机制吗？

print(u._User__number) # 25

# 下面又是啥情况。。。想不明白了T_T

u.set_number_2(18)

print(u.get_number_2()) # 18

print(u._User__number_2)

# Anaconda 3.6.3 第一次是：u._User__number_2 第二次是：18

# Anaconda 3.6.5 结果都是 0

# 代码我改成了正确答案，感谢我大哥给我指正错误，我保留了错误痕迹

# 变量名称写错了，算是个写博客突发事故，这问题我找了一天，万分感谢我大哥，我太傻B了，犯了低级错误

# 留给和我一样的童鞋参考我的错我之处吧！

# 正确结果：

# 25 25 18 18

No.12 Python的自省机制

自省（introspection）是一种自我检查行为。在计算机编程中，自省是指这种能力：检查某些事物以确定它是什么、它知道什么以及它能做什么。自省向程序员提供了极大的灵活性和控制力。

• dir([obj])：返回传递给它的任何对象的属性名称经过排序的列表（会有一些特殊的属性不包含在内）
• getattr(obj, attr)：返回任意对象的任何属性 ，调用这个方法将返回obj中名为attr值的属性的值
• ... ...

No.13 super函数

Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(type[, object-or-type]).xxx 。

super()函数用来调用MRO（类方法解析顺序表）的下一个类的方法。

No.14 Mixin继承

在设计上将Mixin类作为功能混入继承自Mixin的类。使用Mixin类实现多重继承应该注意：

• Mixin类必须表示某种功能
• 职责单一，如果要有多个功能，就要设计多个Mixin类
• 不依赖子类实现，Mixin类的存在仅仅是增加了子类的功能特性
• 即使子类没有继承这个Mixin类也可以工作

class Cat(object):

def eat(self):

print("I can eat.")

def drink(self):

print("I can drink.")

class CatFlyMixin(object):

def fly(self):

print("I can fly.")

class CatJumpMixin(object):

def jump(self):

print("I can jump.")

class TomCat(Cat, CatFlyMixin):

pass

class PersianCat(Cat, CatFlyMixin, CatJumpMixin):

pass

if __name__ == '__main__':

# 汤姆猫没有跳跃功能

tom = TomCat()

tom.fly()

tom.eat()

tom.drink()

# 波斯猫混入了跳跃功能

persian = PersianCat()

persian.drink()

persian.eat()

persian.fly()

persian.jump()

No.25 上下文管理器with语句与contextlib简化

普通的异常捕获机制：

try:

pass

except Exception as err:

pass

else:

pass

finally:

pass

with简化了异常捕获写法：

class Demo(object):

def __enter__(self):

print("enter...")

return self

def __exit__(self, exc_type, exc_val, exc_tb):

print("exit...")

def echo_hello(self):

print("Hello, Hello...")

with Demo() as d:

d.echo_hello()

# enter...

# Hello, Hello...

# exit...

import contextlib

# 使用装饰器

@contextlib.contextmanager

def file_open(file_name):

# 此处写__enter___函数中定义的代码

print("enter function code...")

yield {}

# 此处写__exit__函数中定义的代码

print("exit function code...")

with file_open("json.json") as f:

pass

# enter function code...

# exit function code...

No.26 序列类型的分类

• 容器序列：list tuple deque
• 扁平序列：str bytes bytearray array.array
• 可变序列：list deque bytearray array
• 不可变序列：str tuple bytes

No.27 +、+=、extend()之间的区别于应用场景

首先看测试用例：

'''

遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006

寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！

'''

# 创建一个序列类型的对象

my_list = [1, 2, 3]

# 将现有的序列合并到my_list

extend_my_list = my_list + [4, 5]

print(extend_my_list) # [1, 2, 3, 4, 5]

# 将一个元组合并到这个序列

extend_my_list = my_list + (6, 7)

# 抛出异常 TypeError: can only concatenate list (not "tuple") to list

print(extend_my_list)

# 使用另一种方式合并

extend_my_list += (6, 7)

print(extend_my_list) # [1, 2, 3, 4, 5, 6, 7]

# 使用extend()函数进行合并

extend_my_list.extend((7, 8))

print(extend_my_list) # [1, 2, 3, 4, 5, 6, 7, 7, 8]

由源代码片段可知：

class MutableSequence(Sequence):

__slots__ = ()

"""All the operations on a read-write sequence.

Concrete subclasses must provide __new__ or __init__,

__getitem__, __setitem__, __delitem__, __len__, and insert().

"""

# extend()方法内部使用for循环来append()元素，它接收一个可迭代序列

def extend(self, values):

'S.extend(iterable) -- extend sequence by appending elements from the iterable'

for v in values:

self.append(v)

# 调用 += 运算的时候就是调用该函数，这个函数内部调用extend()方法

def __iadd__(self, values):

self.extend(values)

return self

No.28 使用bisect维护一个已排序的序列

import bisect

my_list = []

bisect.insort(my_list, 2)

bisect.insort(my_list, 9)

bisect.insort(my_list, 5)

bisect.insort(my_list, 5)

bisect.insort(my_list, 1)

# insort()函数返回接收的元素应该插入到指定序列的索引位置

print(my_list) # [1, 2, 5, 5, 9]

No.29 deque类详解

deque是Python中一个双端队列，能在队列两端以

的效率插入数据，位于collections模块中。

from collections import deque

# 定义一个双端队列，长度为3

d = deque(maxlen=3)

deque类的源码：

class deque(object):

"""

deque([iterable[, maxlen]]) --> deque object

一个类似列表的序列，用于对其端点附近的数据访问进行优化。

"""

def append(self, *args, **kwargs):

""" 在队列右端添加数据 """

pass

def appendleft(self, *args, **kwargs):

""" 在队列左端添加数据 """

pass

def clear(self, *args, **kwargs):

""" 清空所有元素 """

pass

def copy(self, *args, **kwargs):

""" 浅拷贝一个双端队列 """

pass

def count(self, value):

""" 统计指定value值的出现次数 """

return 0

def extend(self, *args, **kwargs):

""" 使用迭代的方式扩展deque的右端 """

pass

def extendleft(self, *args, **kwargs):

""" 使用迭代的方式扩展deque的左端 """

pass

def index(self, value, start=None, stop=None): __doc__

"""

返回第一个符合条件的索引的值

"""

return 0

def insert(self, index, p_object):

""" 在指定索引之前插入 """

pass

def pop(self, *args, **kwargs): # real signature unknown

""" 删除并返回右端的一个元素 """

pass

def popleft(self, *args, **kwargs): # real signature unknown

""" 删除并返回左端的一个元素 """

pass

def remove(self, value): # real signature unknown; restored from __doc__

""" 删除第一个与value相同的值 """

pass

def reverse(self): # real signature unknown; restored from __doc__

""" 翻转队列 """

pass

def rotate(self, *args, **kwargs): # real signature unknown

""" 向右旋转deque N步， 如果N是个负数，那么向左旋转N的绝对值步 """

pass

def __add__(self, *args, **kwargs): # real signature unknown

""" Return self+value. """

pass

def __bool__(self, *args, **kwargs): # real signature unknown

""" self != 0 """

pass

def __contains__(self, *args, **kwargs): # real signature unknown

""" Return key in self. """

pass

def __copy__(self, *args, **kwargs): # real signature unknown

""" Return a shallow copy of a deque. """

pass

def __delitem__(self, *args, **kwargs): # real signature unknown

""" Delete self[key]. """

pass

def __eq__(self, *args, **kwargs): # real signature unknown

""" Return self==value. """

pass

def __getattribute__(self, *args, **kwargs): # real signature unknown

""" Return getattr(self, name). """

pass

def __getitem__(self, *args, **kwargs): # real signature unknown

""" Return self[key]. """

pass

def __ge__(self, *args, **kwargs): # real signature unknown

""" Return self>=value. """

pass

def __gt__(self, *args, **kwargs): # real signature unknown

""" Return self>value. """

pass

def __iadd__(self, *args, **kwargs): # real signature unknown

""" Implement self+=value. """

pass

def __imul__(self, *args, **kwargs): # real signature unknown

""" Implement self*=value. """

pass

def __init__(self, iterable=(), maxlen=None): # known case of _collections.deque.__init__

"""

deque([iterable[, maxlen]]) --> deque object

A list-like sequence optimized for data accesses near its endpoints.

# (copied from class doc)

"""

pass

def __iter__(self, *args, **kwargs): # real signature unknown

""" Implement iter(self). """

pass

def __len__(self, *args, **kwargs): # real signature unknown

""" Return len(self). """

pass

def __le__(self, *args, **kwargs): # real signature unknown

""" Return self<=value. """

pass

def __lt__(self, *args, **kwargs): # real signature unknown

""" Return self<value. """

pass

def __mul__(self, *args, **kwargs): # real signature unknown

""" Return self*value.n """

pass

@staticmethod # known case of __new__

def __new__(*args, **kwargs): # real signature unknown

""" Create and return a new object. See help(type) for accurate signature. """

pass

def __ne__(self, *args, **kwargs): # real signature unknown

""" Return self!=value. """

pass

def __reduce__(self, *args, **kwargs): # real signature unknown

""" Return state information for pickling. """

pass

def __repr__(self, *args, **kwargs): # real signature unknown

""" Return repr(self). """

pass

def __reversed__(self): # real signature unknown; restored from __doc__

""" D.__reversed__() -- return a reverse iterator over the deque """

pass

def __rmul__(self, *args, **kwargs): # real signature unknown

""" Return self*value. """

pass

def __setitem__(self, *args, **kwargs): # real signature unknown

""" Set self[key] to value. """

pass

def __sizeof__(self): # real signature unknown; restored from __doc__

""" D.__sizeof__() -- size of D in memory, in bytes """

pass

maxlen = property(lambda self: object(), lambda self, v: None, lambda self: None) # default

"""maximum size of a deque or None if unbounded"""

__hash__ = None

No.30 列表推导式、生成器表达式、字典推导式

• 列表推导式

列表生成式要比操作列表效率高很多，但是列表生成式的滥用会导致代码可读性降低，并且列表生成式可以替换map()和reduce()函数。

'''

遇到问题没人解答？小编创建了一个Python学习交流QQ群：857662006

寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！

'''

# 构建列表

my_list = [x for x in range(9)]

print(my_list) # [0, 1, 2, 3, 4, 5, 6, 7, 8]

# 构建0-8中为偶数的列表

my_list = [x for x in range(9) if(x%2==0)]

print(my_list) # [0, 2, 4, 6, 8]

# 构建0-8为奇数的列表，并将每个数字做平方运算

def function(number):

return number * number

my_list = [function(x) for x in range(9) if x%2!=0]

print(my_list) # [1, 9, 25, 49]

• 生成器表达式

生成器表达式就是把列表表达式的中括号变成小括号。

# 构造一个生成器

gen = (i for i in range(9))

# 生成器可以被遍历

for i in gen:

print(i)

生成器可以使用list()函数转换为列表：

# 将生成器转换为列表

li = list(gen)

print(li)

• 字典推导式

d = {

'tom': 18,

'alice': 16,

'bob': 20,

}

dict = {key: value for key, value in d.items()}

print(dict) # {'tom': 18, 'alice': 16, 'bob': 20}

• Set集合推导式

my_set = {i for i in range(9)}

print(my_set) # {0, 1, 2, 3, 4, 5, 6, 7, 8}

编程语言往往使程序员能够比使用机器语言更准确地表达他们所想表达的目的。对那些从事计算机科学的人来说，懂得程序设计语言是十分重要的，因为在当今所有的计算都需要程序设计语言才能完成。