语法:isinstance(object,type)
作用:来判断一个对象是否是一个已知的类型。

其第一个参数(object)为对象,第二个参数(type)为类型名(int…)或
类型名的一个列表((int,list,float)是一个列表。其返回值为布尔型(True or flase)。

若对象的类型与参数二的类型相同则返回True。若参数二为一个元组,
则若对象类型与元组中类型名之一相同即返回True。

散列类型的定义 https://docs.python.org/3/glossary.html#term-hashable
如果一个对象是可散列(可哈希)的,那么在这个对象的生命周期里,他的散列值(哈希值)
是不变的,而且这个对象需要实现 hash() 方法,另外可散列对象还要有 eq()方法,
这样才能跟其他键作比较。如果两个可散列对象是相等的,那么他们的散列值一定是一样的。
原子不可变数据类型(str, bytes 和数据类型)都是可散列类型,frozenset 也是。元组的话,
需要一个元组内所有的元素都是可散列类型,他才是可散列类型。

散列值是它们的 id() 函数的返回值

1
2
3
4
5
>>> a=5
>>> id(a)
1863412880
>>> hash(a)
5

dict 字典 https://docs.python.org/3/library/stdtypes.html#mapping-types-dict
值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。
键一般是唯一的,如果重复最后的一个键值对会替换前面的,值不需要唯一。

创建字典的多种方式

1
2
3
4
5
6
7
>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3} #one为键,1为值
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True

字典推导(dictcomp)
可以从任何以键值对作为元素的可迭代对象中构建出字典

1
2
3
4
5
6
>>> di =[('dfsgs',41),
... ('wefcwe',12)
... ]
>>> cou={co:code for code, co in di}
>>> cou
{41: 'dfsgs', 12: 'wefcwe'}

dict.setdefault(k,[default]) 若字典里有键k,则直接返回k所对应的值;若无,
则让dict[k]=default,然后返回default.

我们可以自己继承字典然后实现 missing(),这样也能使得该字典在dict[key]
(即调用 getiem()时)实现该功能
collection.defaultdict也有此功能(也是靠missing()实现的)
index = collection.defaultdict(list)
index[key] 如果key不存在index的键,则调用list()建立一个新列表,吧这个新列表作为值,
key作为键放到index中,然后返回这个列表的引用
书本P62

http://www.pingo.io/docs/

1
2
3
4
5
6
7
8
9
10
11
12
import pingo
from time import sleep

board = pingo.detect.MyBoard()
led_pin = board.pins[13]
led_pin.mode = pingo.OUT

while True:
led_pin.hi()
sleep(1)
led_pin.lo()
sleep(1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class StrKeyDict0(dict):  # <1>继承了dict

def __missing__(self, key):
if isinstance(key, str): # <2>如果找不到的键本身就是字符串,报错
raise KeyError(key)
return self[str(key)] # <3>如果找不到的键不是字符串就把他转化成字符串再查找,self[str(key)]找不到会再次进入__missing__里

def get(self, key, default=None):
try:
return self[key] # <4>get方法吧查找工作用self[key]的形式委托给__getitem__,这样在宣布查找失败之前还能通过__missing__再给这个键一次机会
except KeyError:
return default # <5>如果跑出error说明__missing__也失败了,返回default

def __contains__(self, key):
return key in self.keys() or str(key) in self.keys() # <6>如果用 key in my_dict会无限递归
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import collections


class StrKeyDict(collections.UserDict): # <1>对UserDict的扩展

def __missing__(self, key): # <2> # <2>如果找不到的键本身就是字符串,报错
if isinstance(key, str):
raise KeyError(key)
return self[str(key)] # <3>如果找不到的键不是字符串就把他转化成字符串再查找,self[str(key)]找不到会再次进入__missing__里

def __contains__(self, key):
return str(key) in self.data # <3>

def __setitem__(self, key, item):
self.data[str(key)] = item # <4>

集合推导

评论