解压可迭代对象赋值给多个变量

---恢复内容开始---

#任何的序列（或者可迭代对象）可以通过一个简单的赋值语句解压后同时
#赋值给N个变量，唯一前提是变量的数量必须跟序列元素的数量是一样的

 1 lis = [1,2] 2 x,y = lis 3 print(y) 
print（）#打印2

1 data = ['Alex','leiwen','无言',[1,2,3,4]]
2 name, shares, price, (year,mom, day ,you ) = data
3 print(name) #打印 Alex‘’
4 print(shares)#打印leiwen

1 record = ('Dave', 'lei','8920281727','12356')
#赋值占位 *一个变量，默认占位， 比如前八月的数据，要比1月份和2到8月份的，这个就是个很好的永达
2 name, email, *phone_numbers = record
3 print(name)#打印Dave
4 print(email)#打印lei
5 print(phone_numbers)#打印['8920281727', '12356']
#值得注意的是上面解压出的 phone_numbers 变量永远都是列表类型，不管解压的电话号码数量是多少（包括 0 个）。
# 所以，任何使用到 phone_numbers 变量的代码就不需要做多余的类型检查去确认它是否是列表类型了。

 

#扩展的迭代解压语法是专门为解压不确定个数或任意个数元素的可迭代对象而设计的

 1 records = [
 2     ('foo',1,2),
 3     ('bar', 'hell0'),
 4     ('foo',3,4)
 5 ]
 6 def do_foo(x,y):
 7     print('foo', x,y)
 8 def do_bar(s):
 9     print('bar',s)
10 for tag,*args in records:
11     #带不带*有区别，我观察到带有*代表他们是多字符串 所以打印出来的是字符
12     #不到星号把他所占位的元素当一个列表处理
13     print(tag,*args) #加星号* foo 1 2
14     print(tag,args) #foo [1, 2]
15     if tag == "foo":
16         do_foo(*args)
17     elif tag == 'bar':
18         do_bar(*args)
19 
20 
21 data = ['Alex','leiwen','无言',1,2,3,4]
22 name, *argr = data
23 print(*args)   #3 4
24 print(args)#[3, 4]

1 #星号解压语法在字符串操作的时候也会很有用，比如字符串的分割
2 line = 'nobody:*:-2:-2:Unprivileged User:/var/empty:/usr/bin/false'
3 print(line.split(':'))
4 #['nobody', '*', '-2', '-2', 'Unprivileged User', '/var/empty', '/usr/bin/false']
5 uname, *fields, homedir, sh = line.split(":")
6 print(uname) #nobody
7 print(homedir)#/var/empty
8 print(sh)#usr/bin/false
9 print(fields)#['*', '-2', '-2', 'Unprivileged User']

有时候，你想解压一些元素后丢弃它们，你不能简单就使用 * ， 但是你可以使用一个普通的废弃名称，比如 _ 或者 ign （ignore）。

1 record = ('ACME', 50, 123.45, (12, 18, 2012))
2 name, *_,(*ign,year) = record
3 print(name)
4 print(year)
5 print(_)
6 print(ign)

一个巧妙的程序思考良多

 1 lis = [1,2,3,4,5,6,7,8,9]
 2 def sum1(lis):
 3     head, *tail = lis
 4     #下面4行代码可以用一行代替
 5     # return head + sum1(tail) if tail else haed
 6     if tail:
 7        return head +sum1(tail)
 8     else:
 9         return  head
10 print(sum1(lis))

一种新的队列deque

 1 from  collections import deque
 2 q = deque(maxlen=1)
 3 q.append(1)
 4 q.append(2)
 5 q.append(3)
 6 print(q)#deque([1, 2, 3], maxlen=3)
 7 q.append(4)
 8 print(q)#deque([2, 3, 4], maxlen=3)
 9 deq = deque(maxlen=4)
10 deq.append(1)
11 deq.append(2)
12 deq.append(3)
13 deq.appendleft(4)#在左边插入 deque([4, 1, 2, 3], maxlen=4)
14 print(deq)
15 # 在队列两端插入或删除元素时间复杂度都是 O(1) ，区别于列表，在列表的开头插入或删除元素的时间复杂度为 O(N) 。

 

怎样从一个集合中获得最大或者最小的 N 个元素列表？heapq 模块有两个函数：nlargest() 和 nsmallest() 可以完美解决这个问题。

1 import heapq
2 heapq.nsmallest() #查询最大元素的个数
3 heapq.nlargest() #查询最小元素的个数
4 nums = [1,2,3,4,5,6,7,8,9]
5 print(heapq.nlargest(3, nums)) #查询最大元素的个数
6 print(heapq.nlargest(5,nums))
7 print(heapq.nsmallest(3,nums)) #查询最小元素的个数

1 from  collections import defaultdict
2 
3 d = defaultdict(list)
4 d['a'].append(1)
5 d['a'].append(2)
6 print(d)##defaultdict(<class 'list'>, {'a': [1, 2]})

prices = {
    'ACME': 45.23,
    'AAPL': 612.78,
    'IBM': 205.55,
    'HPQ': 37.20,
    'FB': 10.75
}
#zip 函数 翻转keys 和 val值 
min_price = min(zip(prices.values(), prices.keys()))
print(min_price)
max_prince = max(zip(prices.values(),prices.keys()))
print(max_prince)

 

---恢复内容结束---

转载于:https://www.cnblogs.com/leiwenxuan/p/9466246.html