写得真的很牛B, 大佬,大佬,。
我按照它的原文摘出一些知识点
字符串可以比较
>>> "pear" == "pickle"
False
>>> "pear" != "pickle"
True
>>> "pear" < "pickle"
True
>>> "pear" > "pickle"
False
元组也可以比较
>>> target = (3, 6, 2)
>>> installed = (3, 7, 0)
>>> target == installed
False
>>> target <= installed
True
>>> target > installed
False
我的一点注释:
关于ascii表, 大概顺序是 数字 --> 大写字母 --> 小写字母 asc码逐渐增大
关于上面的元组和字符串比较,其实比较的的asc码的大小,从左往右比较asc码的大小,相同,则比较下一位。
还有长短不一致,但前缀相同的情况
>>> ("a", "b", "c") > ("a", "b")
True
>>> "ahc" > "ab"
True
就是前面都相同,长的较大
ord("") 返回asc码
关于列表
列表也可以比较,2019/8/31 紧急添加
>>> a = [1, 2, 3]
>>> b = [2, 3, 1]
>>> a == b
False
>>> a = [1, 2]
>>> b = [2, 2]
>>> a < b
True
关于集合
>>> a = {1, 2}
>>> b = {2, 1}
>>> a< b
False
>>> a == b
True
集合只能比较是否相等, 不能比较大小
关于字典
字典不能比较大小, 但是可以用 == , 看是否相等
说实话, 我没用到过 字典1 == 字典2 这样的操作
>>> a = {"a":"b", "c":"d"}
>>> b = {"c":"d", "a":"b"}
>>> a == b
True
>>> c = {"a":"b", "a":"b"}
>>> c
{'a': 'b'}
>>> d = {"a":"b", "a":"c"}
>>> d
{'a': 'c'}
>>> e = {"a":"b", "a":"c", "a": "d"}
>>> e
{'a': 'd'}
另外:实测,字典的顺序, 不影响它们是否相等, 而且,但字典里键和值都相等时,python自动忽视,看成一个。
当键相等,值不同时,也会看成一个,而且值时最后一个也是最新的一个值。
有几个小技巧
if self.x == other.x and self.y == other.y and self.z == other.z:
可以如下这样比较,更简洁
(self.x, self.y, self.z) == (other.x, other.y, other.z)
下一个例子
是说self.last 和self.first 小于other.last, other.first 才返回True, 剩下的等于什么的情况返回False
下面的last优先于first,
def __lt__(self, other):
if self.last_name < other.last_name:
return True
elif other.last_name < self.last_name:
return False
elif self.first_name < other.first_name:
return True
else:
return False
可以优化成(注意and的优先级大于or)
其实我不太理解
def __lt__(self, other):
return (
self.last_name < other.last_name or
self.last_name == other.last_name and self.first_name < other.first_name
)
这个就很好理解了
def __lt__(self, other):
return (self.last_name, self.first_name) < (other.last_name, other.first_name)
When you have code that compares two objects based on subparts in a particular order:
d1 = (1999, 12, 31)
d2 = (1999, 12, 1)
if d1[0] > d2[0]:
greater = d1
elif d1[0] < d2[0]:
greater = d2
elif d1[1] > d2[1]:
greater = d1
elif d1[1] < d2[1]:
greater = d2
elif d1[2] > d2[2]:
greater = d1
else:
greater = d2
You could probably rely on tuple ordering instead:
d1 = (1999, 12, 31)
d2 = (1999, 12, 1)
if d1 < d2:
greater = d1
else:
greater = d2
or
>>> d1 = (1999, 12, 31)
>>> d2 = (1999, 12, 1)
>>> d1[0] == d2[0] and d1[1] == d2[1] and d1[2] == d2[2]
False
>>> d1 = (1999, 12, 31)
>>> d2 = (1999, 12, 1)
>>> d1 == d2
False
Deep ordering(不知道为什么叫这个)
>>> fruits = ['kumquat', 'Cherimoya', 'Loquat', 'longan', 'jujube']
>>> def length_and_word(word): return (len(word), word.casefold())
...
>>> sorted(fruits, key=length_and_word)
['jujube', 'longan', 'Loquat', 'kumquat', 'Cherimoya']
批注:
Python casefold() 方法是Python3.3版本之后引入的,其效果和 lower() 方法非常相似,都可以转换字符串中所有大写字符为小写。
两者的区别是:lower() 方法只对ASCII编码,也就是‘A-Z’有效,对于其他语言(非汉语或英文)中把大写转换为小写的情况只能用 casefold() 方法。
sorted的key参数,是指定按什么排序,这里的key返回了两个数, 一个是长度,一个是小写字母。就是优先按长度升序排列,然后按asc升序排列。
下面只按asc排序
>>> sorted(fruits, key=len)
['Loquat', 'longan', 'jujube', 'kumquat', 'Cherimoya']
其实任何(maybe)有key参数的函数,都可这样排序。
>>> min(fruits, key=str.casefold)
'Cherimoya'
>>> max(fruits, key=str.casefold)
'Loquat'
Deep hashability (and unhashability)
主要说的是元组
元组是可以作为字典的键的,因为元组是可哈希的,集合里也是可以可以加元组的。
这个真的没细想过,元组作为字典的键。
>>> current_portals = {(1, 2): [(2, 1)], (2, 1): [(1, 2), (3, 4)]}
>>> points = {(1, 2), (2, 1), (3, 4)}
但是啊,可变元组就不能作为字典的键,比如元组里面套列表,元组里面每个对象都必须是可哈希的,列表是不可哈希的。
>>> things = {(["dress", "truck"], "yellow"), (["ball", "plane"], "purple")}
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
虽然包含列表的元组是不哈希的,但是元组包含元组是可哈希的(感觉是废话)
>>> things = {(("dress", "truck"), "yellow"), (("ball", "plane"), "purple")}
>>> things
{(('dress', 'truck'), 'yellow'), (('ball', 'plane'), 'purple')}
元组通过分派给它们包含的项的哈希值来计算自身的哈希值:
>>> x = (1, 2)
>>> y = (1, 2)
>>> hash(x)
3713081631934410656
>>> hash(x) == hash(y)
True
Python支持深度哈希,这就是我们可以使用元组作为字典键的原因,也是我们可以在集合中使用元组的原因。
以上です