Python 强化训练： 第一篇

NAME, AGE, EMAIL, UNIVERSITY = range(4)
print(NAME, AGE, EMAIL, UNIVERSITY) #0 1 2 3
ONE, TWO, *THREE, FOUR = range(10)
print(ONE, TWO, THREE, FOUR)#0 1 [2, 3, 4, 5, 6, 7, 8] 9
data = ["one", "two", "three", "four", "five"]
One_one, Two_two, _, _, Five_five = data
print(One_one, Two_two, Five_five)#one two five

from random import randint
import heapq
number = [randint(-100, 10000) for _ in range(100)]
print(heapq.nlargest(3, number)) # [9906, 9901, 9773]
print(heapq.nsmallest(3, number)) # [79, 233, 251]

all_data =[ {'name': 'IBM', 'shares': 100, 'price': 91.1}, 
{'name': 'AAPL', 'shares': 50, 'price': 543.22}, 
{'name': 'FB', 'shares': 200, 'price': 21.09},
{'name': 'HPQ', 'shares': 35, 'price': 31.75}, 
{'name': 'YHOO', 'shares': 45, 'price': 16.35}, 
{'name': 'ACME', 'shares': 75, 'price': 115.65}]

cheap = heapq.nsmallest(2, all_data, key=lambda a: a["price"]+a["shares"])

expensive = heapq.nlargest(2, all_data, key=lambda a: a["price"]+a["shares"])

print(cheap, "\n", expensive)
# [{'price': 16.35, 'name': 'YHOO', 'shares': 45}, {'price': 31.75, 'name': 'HPQ', 'shares': 35}]

# [{'price': 543.22, 'name': 'AAPL', 'shares': 50}, {'price': 21.09, 'name': 'FB', 'shares': 200}]

from random import randint
score = [randint(50, 101) for _ in range(70)]
first_ten = slice(0, 10)
second_five = slice(10, 15)
last_three = slice(67, 70)
print(score)
print(score[first_ten], first_ten.start, first_ten.stop)# [54, 63, 91, 53, 95, 67, 76, 94, 58, 89] 0 10
print(score[second_five], second_five.start, second_five.stop,second_five.step)# [72, 72, 81, 86, 100] 10 15 None
print(score[last_three], last_three.start, last_three.stop, last_three.step)# [58, 90, 90] 67 70 None

from random import sample
## 过滤奇偶数
list_number = [randint(-10, 10) for _ in range(15)]
ist_even = [i for i in list_number if i % 2 == 0]
list_odd = [j for j in list_number if j % 2 == 1]
print(list_number)
print(list_even)
print(list_odd)
# [-8, 5, 4, -1, 5, -1, 6, 6, 2, 6, 2, -7, -4, -9, -10]
# [-8, 4, 6, 6, 2, 6, 2, -4, -10]
# [5, -1, 5, -1, -7, -9]
## 根据字典值过滤奇偶数
dict_number = {k: randint(-10, 10) for k in sample("abcdefghijkmnvc", 7)}
dict_even = {i: j for i, j in dict_number.items() if j % 2 == 0}
dict_odd = {i:j for i, j in dict_number.items() if j %2 ==1}
print(dict_number)
print(dict_even)
print(dict_odd)
# {'e': 5, 'g': 7, 'j': 5, 'd': 5, 'v': 10, 'k': -6, 'n': 3}
# {'v': 10, 'k': -6}
# {'e': 5, 'g': 7, 'd': 5, 'n': 3, 'j': 5}

## 过滤集合
set_data = set([randint(-10,10) for _ in range(10)])
set_even = {i for i in set_data if i % 2 == 0}
set_odd = {j for j in set_data if j % 2 == 1}
print(set_data)
print(set_even)
print(set_odd)
# {0, 8, 9, 10, -8, -6, -5}
# {0, 8, 10, -6, -8}
# {9, -5}

from collections import namedtuple
tuple_student = ("xiewei", 24, "xie_wei_sh@foxmail.com", "ShanghaiUniversity")
NAME, AGE, EMAIL, UNIVERSITY = range(4)
print(tuple_student[NAME], tuple_student[EMAIL])

student1 = namedtuple("student", ["NAME", "AGE", "EMAIL", "UNIVERSITY"])
s = student1("xiewei", 24, "xie_wei_sh@foxmail.com", "ShanghaiUniversity")

print(s.NAME, s.AGE, s.EMAIL, s.UNIVERSITY)

from random import randint
data = [randint(0, 20) for _ in range(30)]
c = dict.fromkeys(data, 0)
for i in data: c[i] += 1

from collections import Counter
d = Counter(data)
e = d.most_common(3)
print(c, "\n", d, "\n", e)

dict_data = {x: randint(60, 100) for x in 'abcdefg'}
new_dict_data = sorted(dict_data)

## zip
new_dict_data_1 = sorted(zip(dict_data.values(), dict_data.keys()))

new_dict_data_2 = sorted(dict_data.items(), key=lambda x: x[1])

print(dict_data, "\n", new_dict_data, "\n", new_dict_data_1, "\n", new_dict_data_2)

from random import randint, sample
s1 = sample("abcdef", randint(3, 5))
s2 = sample("abcdef", randint(3, 5))
s3 = sample("abcdef", randint(3, 5))
print(s1, s2, s3)
dict_1 = {x: randint(1, 4) for x in s1}
dict_2 = {x: randint(1, 4) for x in s2}
dict_3 = {x: randint(1, 4) for x in s3}
print(dict_1, dict_2, dict_3)
## 集合与操作
common_key = dict_1.keys() & dict_2.keys() & dict_3.keys()
print(common_key)
all_keys = map(dict.keys, [dict_1, dict_2, dict_3])
print(list(all_keys))
## 集合,map , reduce :python3中 from functools import reducefrom functools import reduce
common_key_2 = reduce(lambda a, b: a & b, map(dict.keys, [dict_1, dict_2, dict_3]))

print(common_key_2)

from collections import OrderedDict
new_order_dict = OrderedDict()
new_order_dict["one"] = 1
new_order_dict["two"] = 2
new_order_dict["three"] = 3
new_order_dict["four"] = 4
new_order_dict["five"] = 5
print(new_order_dict)

from collections import deque
queue = deque([], maxlen=3)
queue.append(1)
queue.append(2)
queue.append(3)
queue.append(4)
print(queue)
# 求一个固定滑动窗口大小为n的平均值
""" 
h.avg(2) = 2/1 假设n = 3 
h.avg(3) = (2+3)/2 
h.avg(4) = (2+3+4)/3 
h.avg(5) = (3+4+5)/3
"""
class h(object):    
      def __init__(self, size):        
          self.n = size        
          self.queue = deque([], maxlen=size)    
    def avg(self, number):        
          self.queue.append(number)        
          print(self.queue, len(self.queue))        
          if len(queue) < self.n:            
                  return sum(self.queue)/(len(self.queue))        
          else:            
                  return sum(self.queue)/self.n
A = h(4)
B = A.avg(2)
print(B)
C = A.avg(3)
print(C)
D = A.avg(4)
print(D)
E = A.avg(5)
print(E)
F = A.avg(6)
print(F)