Python Questions and Answers

发表于 | 分类于 | 评论数： | 阅读次数：

Python

  • 1.一行代码打印九九乘法表
1
2
3
4
5
6
7
8
9
10
# 第一种
>>> print("".join('{}*{}={}\n'.format(j, i, i*j) if j == i else '{}*{}={}\t'.format(j, i, i*j) for i in range(1, 10) for j in range(1, i+1)))
# 注：区别三元表达式与for循环的结合以及for循环与if的结合两者中if的位置
>>> print([i if i > 2 else '*' for i in range(5)])
['*', '*', '*', 3, 4]
>>> print([i for i in range(5) if i > 2])
[3, 4]

# 第二种
>>> print("\n".join("\t".join(["%s*%s=%s" % (y, x, x * y) for y in range(1, x + 1)]) for x in range(1, 10)))
  • 2.字典根据键、值排序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
>>> print(sorted(zip(dic.values(), dic.keys())))
>>> print(sorted(zip(dic.keys(), dic.values())))
[(1, 'd'), (2, 'ac'), (6, 'a'), (8, 'b')]
[('a', 6), ('ac', 2), ('b', 8), ('d', 1)]

>>> print(sorted(dic.items(), key=lambda x: x[0]))
>>> print(sorted(dic.items(), key=lambda x: x[1]))
[('a', 6), ('ac', 2), ('b', 8), ('d', 1)]
[('d', 1), ('ac', 2), ('a', 6), ('b', 8)]

>>> import operator
>>> print(sorted(dic.items(), key=operator.itemgetter(0)))
>>> print(sorted(dic.items(), key=operator.itemgetter(1)))
[('a', 6), ('ac', 2), ('b', 8), ('d', 1)]
[('d', 1), ('ac', 2), ('a', 6), ('b', 8)]


# 注：
# itemgetter
"""
Return a callable object that fetches the given item(s) from its operand.
After f = itemgetter(2), the call f(r) returns r[2].
After g = itemgetter(2, 5, 3), the call g(r) returns (r[2], r[5], r[3])
"""
# itemgetter通过定义一个函数，将该函数作用到目标对象上，取出目标对象对应维度（只将处理对象看做一维）的值

>>> list_a = [(1, 2), (3, 4), (5, 6)]
>>> get = operator.itemgetter(0)
>>> print(get(list_a))
(1, 2)
>>> print([get(i) for i in list_a])
[1, 3, 5]
  • 3.列表对应求和、求积
1
2
3
4
5
6
7
8
9
10
11
>>> a = [1, 3, 5]
>>> b = [2, 4, 6]
>>> print(list(map(sum, zip(a, b))))
[3, 7, 11]
>>> print(list(map(lambda x, y: x*y, a, b)))
[2, 12, 30]
>>> print(list(map(lambda x: x[0]*x[1], zip(a, b))))
# Python3中元祖不支持自动拆箱，即元祖不可作为参数（*args）
# Python2:
# print(list(map(lambda (x,y): x*y, zip(a, b))))
[2, 12, 30]
  • 4.两个相同长度的列表变为一个字典
1
2
3
4
5
6
>>> list_a = ['a', 'b', 'c']
>>> list_b = [4, 5, 6]
>>> print({x: y for x, y in zip(list_a, list_b)})
{'a': 4, 'b': 5, 'c': 6}
>>> print(dict(zip(list_a, list_b)))
{'a': 4, 'b': 5, 'c': 6}
  • 5.父类如何知道子类继承自己
1
2
3
4
5
6
>>> class A: pass
>>> class B(A): pass
>>> print(A.__subclasses__())
[<class '__main__.B'>]
>>> print(B.__subclasses__())
[]
  • 6.实现跑马灯效果
1
2
3
4
5
6
7
8
>>> import time
>>> def main():
>>>     content = '这是跑马灯…………'
>>>     while True:
>>>         print('\r'+content, end='')
>>>         time.sleep(0.2)
>>>         content = content[1:] + content[0]
>>> main()
  • 7.给一个列表，将列表中每位元素的位数作为字典的键，对应位数的元素作为字典的值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
lst = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 32769, 65536, 4294967296]

Output:
{
	1: [1, 2, 4, 8],
	2: [16, 32, 64],
	3: [128, 256, 512],
	4: [1024],
	5: [32769, 65536],
	10: [4294967296]
}


方法一：
>>> dic = {}
>>> for i in lst:
>>>     dic.setdefault(len(str(i)), [])
>>>     dic[len(str(i))].append(i)
>>> print(dic)

方法二：
>>> dct2 = {}
>>> [dct2.setdefault(len(str(i)), []).append(i) for i in lst]
>>> print(dct2)
  • 8.将列表按下列规则排序。正数在前负数在后，正数从小到大，负数从大到小。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
lst = [7, -8, 5, 4, 0, -2, -5]

Output:
[0, 4, 5, 7, -2, -5, -8]


实现：
>>> lst = [7, -8, 5, 4, 0, -2, -5]
>>> ret = sorted(lst, key=lambda x: (x < 0, abs(x)))
>>> print(ret)

# 默认升序（满足条件key的排在后面）
# 先按正负排序
# 再按绝对值排序
  • 9.深浅拷贝
1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> import copy
>>> a = [1, 2, 3, [4, 5], 6]
>>> b = a
>>> c = copy.copy(a)
>>> d = copy.deepcopy(a)
>>> b.append(10)
>>> c[3].append(11)
>>> d[3].append(12)
>>> print(a, b, c, d, sep='\n')

[1, 2, 3, [4, 5, 11], 6, 10]
[1, 2, 3, [4, 5, 11], 6, 10]
[1, 2, 3, [4, 5, 11], 6]
[1, 2, 3, [4, 5, 12], 6]
  • 10.列表的循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
>>> li = [2, 4, 5, 6, 7]
>>> for i in li:
>>>     if i % 2 == 0:
>>>         li.remove(i)
>>> print(li)
[4, 5, 7]


# for循环遍历列表是根据指针位置（索引）取值的！！！（不要直接循环删除列表或可变序列的值，可以把要删除的元素添加到另一个集合中然后再批量删除）
# 上述过程
# 第一步：索引index=0，此时li = [2, 4, 5, 6, 7]，取出2，判断条件成立，删除2，li = [4, 5, 6, 7]
# 第二步：索引index=1，此时li = [4, 5, 6, 7]，取出5，判断条件成立，li = [4, 5, 6, 7]
# 第三步：索引index=2，此时li = [4, 5, 6, 7]，取出6，判断条件成立，删除6，li = [4, 5, 7]
# 此时li = [4, 5, 7]，索引最大为2，结束循环，输出[4, 5, 7]


# 列表的循环添加
>>> lst = [1,2,3,4,5,6]
>>> for i in lst:
>>>     lst.append(7) # 这样写法就会一直持续添加7
>>>     print(lst)
>>> print(lst)
[1, 2, 3, 4, 5, 6, 7]
[1, 2, 3, 4, 5, 6, 7, 7]
[1, 2, 3, 4, 5, 6, 7, 7, 7]
.......


# 列表的循环删除
>>> li = [11, 22, 33, 44]
>>> for i in range(0, len(li)): # 循环len(li)次, 然后从后往前删除
>>> 	li.pop()
>>> print(li)
[]

# 或者. 用另一个列表来记录你要删除的内容. 然后循环删除
>>> li = [11, 22, 33, 44]
>>> del_li = []
>>> for e in li:
>>> 	del_li.append(e)
>>> for e in del_li:
>>> 	li.remove(e)
>>> print(li)
[]

# 同样，字典循环时也不能修改，把要删除的元素暂时先保存在一个list中, 然后循环list, 再删除。
>>> dic = {'A': 'aaa', 'B': 'bbb', 'C': 'ccc'}
>>> dic_del_list = []
>>> for k in dic:
>>>     if 'A' in k:
>>>         dic_del_list.append(k)
>>> for el in dic_del_list:
>>>     del dic[el]
>>> print(dic)
{'B': 'bbb', 'C': 'ccc'}
  • 11.字典的fromkeys
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
>>> dic = dict.fromkeys(['A', 'B', 'C'], ['Hello'])
# fromkeys里第一个参数是可迭代的对象,里边的每个元素就是字典中的健,
# 第二个参数就是每个键对应的值
>>> dic = dict.fromkeys(['A', 'B', 'C'], ['Hello'])
>>> print(id(dic['A']), id(dic['B']), id(dic['C']), sep='\n')
2414280971784
2414280971784
2414280971784
>>> dic['A'].append('World')
>>> print(dic)
{'A': ['Hello', 'World'], 'B': ['Hello', 'World'], 'C': ['Hello', 'World']}
>>> print(id(dic['A']), id(dic['B']), id(dic['C']), sep='\n')
2414280971784
2414280971784
2414280971784

# 可见新字典中每个值开始都是指向一个内存地址，当fromkeys的第二个参数为可变数据类型时，新字典中每个键对应的值是公共用的这个可变数据类型

>>> dic = dict.fromkeys(['A', 'B', 'C'], 'Hello')
>>> print(id(dic['A']), id(dic['B']), id(dic['C']), sep='\n')
2821782666408
2821782666408
2821782666408
>>> dic['A'] += 'World'
>>> print(dic)
{'A': 'HelloWorld', 'B': 'Hello', 'C': 'Hello'}
>>> print(id(dic['A']), id(dic['B']), id(dic['C']), sep='\n')
2821784420912
2821782666408
2821782666408

# 可见当fromkeys的第二个参数为不可变数据类型时，虽然新字典中每个值开始都是指向一个内存地址，但一个值的修改不会影响到另一个值

未完待续…