import collectionsCard = collections.namedtuple('Card',['rank','suit'])class FrenchDeck:ranks = [str(n) for n in range(2,11)] + list('JQKA')# ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']suits = 'spades diamonds clubs hearts'.split()def __init__(self):self._cards = [Card(rank,suit) for suit in self.suits for rank in self.ranks]def __len__(self):# print("用的是我写的lenth")# 如果不写这个方法，用len(deck)时会报错：TypeError: object of type 'FrenchDeck' has no len()return len(self._cards)def __getitem__(self, position):return self._cards[position]

>>> beer_card = Card('7','hearts')
>>> beer_card
Card(rank='7', suit='hearts')
这张牌就是红心7

FrenchDeck类中的self._cards生成了一个有52张'牌'的列表
[Card(rank='2', suit='spades'), Card(rank='3', suit='spades'), ...共52个]
suits = ['spades', 'diamonds', 'clubs', 'hearts']
namedtuple的作用：
>>> beer_card = Card('7','hearts')
>>> beer_card
Card(rank='7', suit='hearts')
FrenchDeck类支持的方法：
>>> deck = FrenchDeck()
>>> len(deck)
52
>>> from random import choice
>>> choice(deck)
支持分片：只看牌面是A的牌--先抽出索引是12的那张牌，然后每隔13张拿一张
>>> deck[12::13]
[Card(rank='A', suit='spades'), Card(rank='A', suit='diamonds'),Card(rank='A', suit='clubs'), Card(rank='A', suit='hearts')]
这个我觉得作者的用法很好
仅仅用__getitem__方法，使这一摞牌变成可迭代
>>> for card in deck:
...     print(card)
反向迭代
>>> for card in reversed(deck):
...     print(card)
一个集合类型如果没有实现__contains__方法，in运算符就会按顺序做一次迭代搜索
>>> Card(rank='A', suit='spades') in deck
True

list1 = [('david', 90), ('mary',90), ('sara',80),('lily',95)]
sorted(list1, key=lambda x: x[0])  # 按照元组中第一个元素排序
sorted(list1, key=lambda x: x[1])  # 按照元组中第二个元素排序
array = [{"age":20,"name":"a"},{"age":25,"name":"b"},{"age":10,"name":"c"}]
array1 = sorted(array,key=lambda x:x["age"])  # 按照年龄排序

1.需求：将列表中的元素按照绝对值大小进行升序排列
list1 = [3,5,-4,-1,0,-2,-6]
sorted(list1, key=lambda x: abs(x))当然，也可以如下：list1 = [3,5,-4,-1,0,-2,-6]
def get_abs(x):return abs(x)
sorted(list1,key=get_abs)
只不过这种方式的代码看起来不够Pythonic
2、应用在闭包中
def get_y(a,b):return lambda x:ax+b
y1 = get_y(1,1)
y1(1) # 结果为2当然，也可以用常规函数实现闭包，如下：def get_y(a,b):def func(x):return ax+breturn func
y1 = get_y(1,1)
y1(1) # 结果为2
只不过这种方式显得有点啰嗦。
那么是不是任何情况下lambda函数都要比常规函数更清晰明了呢？
Python之禅中有这么一句话：Explicit is better than implicit（明了胜于晦涩），就是说那种方式更清晰就用哪一种方式，不要盲目的都使用lambda表达式。

suit_values = dict(spades=3, hearts=2, diamonds=1, clubs=0)
# {'clubs': 0, 'diamonds': 1, 'spades': 3, 'hearts': 2}def spades_high(card):rank_values = FrenchDeck.ranks.index(card.rank)return rank_values * len(suit_values) + suit_values[card.suit]for card in sorted(deck,key=spades_high):print(card)

一道面试题：
list1=[7, -8, 5, 4, 0, -2, -5]
要求1.正数在前负数在后 2.整数从小到大 3.负数从大到小
解题思路：先按照正负排先后，再按照大小排先后
list1=[7, -8, 5, 4, 0, -2, -5]
print(sorted(list1,key=lambda x:(x<0,abs(x))))
[7, 5, 4, 0, -8, -2, -5]
[0, 4, 5, 7, -2, -5, -8]一个经典的复杂例子
这是一个字符串排序，排序规则：小写<大写<奇数<偶数
s = ‘asdf234GDSdsf23’  #排序:小写-大写-奇数-偶数
print(“”.join(sorted(s, key=lambda x: (x.isdigit(),x.isdigit() and int(x) % 2 == 0,x.isupper(),x))))
原理：先比较元组的第一个值，FALSE