抄写了两个Spider,发现对于Python基础的掌握实在是差劲的可以.
于是乎 过来补补基础
一直在Hackerrank上面做Python的题目.知识点覆盖挺全面的,推荐一波.
Basic
乱七八糟小技巧
1
2
3
| >>> n,m,*l = ['1','2']
>>> print(n,m,l)
1 2 []
|
基本数据类型
.
set
集合是一个无序的，不重复的数据组合，它的主要作用如下：
去重，把一个列表变成集合，就自动去重了
关系测试，测试两组数据之前的交集、差集、并集等关系
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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
list_1 = [1,3,4,7,3,6,7,9]
list_1 = set(list_1)
list_2 = set([2,6,0,66,22,8,4])
list_3 = set([1,3,7])
print(list_1)
print(list_2)
print(list_3)
print("---------------------------")
print(list_1.intersection(list_2))
print(list_1.union(list_2))
print(list_1.difference(list_2))
print(list_1.symmetric_difference(list_2))
print(list_3.issubset(list_1))
print(list_1.issuperset(list_3))
list_4 = set([5,6,8])
print(list_3.isdisjoint(list_4))
s = set([3,5,9,10])
t = set("Hello")
a = t | s
b = t & s
c = t – s
d = t ^ s
基本操作：
t.add('x')
s.update([10,37,42])
使用remove()可以删除一项：
t.remove('H')
t.pop()
t.discard('H')
len(s)
set 的长度
x in s
测试 x 是否是 s 的成员
x not in s
测试 x 是否不是 s 的成员
s.issubset(t)
s <= t
测试是否 s 中的每一个元素都在 t 中
s.issuperset(t)
s >= t
测试是否 t 中的每一个元素都在 s 中
s.union(t)
s | t
返回一个新的 set 包含 s 和 t 中的每一个元素
s.intersection(t)
s & t
返回一个新的 set 包含 s 和 t 中的公共元素
s.difference(t)
s - t
返回一个新的 set 包含 s 中有但是 t 中没有的元素
s.symmetric_difference(t)
s ^ t
返回一个新的 set 包含 s 和 t 中不重复的元素
s.copy()
返回 set “s”的一个浅复制
|
排序
.
对字符定义优先级
将需要排序的字符集放到一个字符串中
在这个字符串中越靠前的字符排序后越靠前
1
2
| order = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1357902468'
print(*sorted(input(), key=order.index), sep='')
|
关键字排序
1
2
3
4
5
6
7
| N, M = map(int, input().split())
rows = [input() for _ in range(N)]
K = int(input())
for row in sorted(rows, key=lambda x: int(x.split()[K])):
print(row)
|
字符串
.
26字母
1
2
| import string
alpha = string.ascii_lowercase
|
字符串反转
1
2
3
| >>> s = 'abcde'
>>> print(s[::-1])
edcba
|
字符串格式化输出
个人喜欢最新的'{}'.format()的形式,不仅写起来更方便一些,还有旧方法不能实现的操作.感觉以后可能完全取缔旧的方法.
.format的介绍(与旧方法的对比)
输出一行 ‘-’
1
| '{:-{align}{width} }'.format( '',align='>', width = 5)
|
输出
函数(function)
可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
- 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
- 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
- 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
- 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
.
eval()
eval(string) 对于一个字符串，相当与运行这个字符串所代表的python代码
1
2
3
4
| >>> x = 1
>>> eval('x+1')
>>> print(eval('x+1'))
2
|
各种库
导入库
1
2
| import 库
from 库 import 函数
|
collections
Counter
计数用的函数
defaultdict
可以简单理解为一个map,
1
2
3
| a = defaultdict([Type of value])
------
a['key'] type is [Type of value]
|
deque
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
| >>> from collections import deque
>>> d = deque()
>>> d.append(1)
>>> print d
deque([1])
>>> d.appendleft(2)
>>> print d
deque([2, 1])
>>> d.clear()
>>> print d
deque([])
>>> d.extend('1')
>>> print d
deque(['1'])
>>> d.extendleft('234')
>>> print d
deque(['4', '3', '2', '1'])
>>> d.count('1')
1
>>> d.pop()
'1'
>>> print d
deque(['4', '3', '2'])
>>> d.popleft()
'4'
>>> print d
deque(['3', '2'])
>>> d.extend('7896')
>>> print d
deque(['3', '2', '7', '8', '9', '6'])
>>> d.remove('2')
>>> print d
deque(['3', '7', '8', '9', '6'])
>>> d.reverse()
>>> print d
deque(['6', '9', '8', '7', '3'])
>>> d.rotate(3)
>>> print d
deque(['8', '7', '3', '6', '9'])
|
自省
.
.
getattr()
1
2
3
4
5
6
7
8
| '''
getattr(object, name[, default]) -> value
其中 name 可以是字符串.
这样的话 相当于 name可以用字符串代替 就不用一大堆`if elif else`了
'''
getattr(object, name[, default]) -> value
<==>
object.name(value)
|
wechat
