Python基础2
分类:
IT文章
•
2024-05-06 17:43:07
入门知识拾遗
一、作用域
对于变量的作用域，执行声明并在内存中存在，该变量就可以在下面的代码中使用。
1 if 1==1:
2 name = 'yuxiaozheng'
3 print name
外层变量，可以被内层变量使用
内层变量，无法被外层变量使用
二、三元运算
1 result = value1 if 条件 else value2
如果条件为真：result = 值1
如果条件为假：result = 值2
三、进制
- 二进制，01
- 八进制，01234567
- 十进制，0123456789
- 十六进制，0123456789ABCDEF
对于Python，一切事物都是对象，对象基于类创建
一、整数
如： 18、73、84
每一个整数都具备如下功能：
![]()
1 class int(object):
2 """
3 int(x=0) -> integer
4 int(x, base=10) -> integer
5
6 Convert a number or string to an integer, or return 0 if no arguments
7 are given. If x is a number, return x.__int__(). For floating point
8 numbers, this truncates towards zero.
9
10 If x is not a number or if base is given, then x must be a string,
11 bytes, or bytearray instance representing an integer literal in the
12 given base. The literal can be preceded by '+' or '-' and be surrounded
13 by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
14 Base 0 means to interpret the base from the string as an integer literal.
15 >>> int('0b100', base=0)
16 4
17 """
18 def bit_length(self): # real signature unknown; restored from __doc__
19 """
20 int.bit_length() -> int
21
22 Number of bits necessary to represent self in binary.
23 >>> bin(37)
24 '0b100101'
25 >>> (37).bit_length()
26 6
27 """
28 return 0
29
30 def conjugate(self, *args, **kwargs): # real signature unknown
31 """ Returns self, the complex conjugate of any int. """
32 pass
33
34 @classmethod # known case
35 def from_bytes(cls, bytes, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
36 """
37 int.from_bytes(bytes, byteorder, *, signed=False) -> int
38
39 Return the integer represented by the given array of bytes.
40
41 The bytes argument must be a bytes-like object (e.g. bytes or bytearray).
42
43 The byteorder argument determines the byte order used to represent the
44 integer. If byteorder is 'big', the most significant byte is at the
45 beginning of the byte array. If byteorder is 'little', the most
46 significant byte is at the end of the byte array. To request the native
47 byte order of the host system, use `sys.byteorder' as the byte order value.
48
49 The signed keyword-only argument indicates whether two's complement is
50 used to represent the integer.
51 """
52 pass
53
54 def to_bytes(self, length, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
55 """
56 int.to_bytes(length, byteorder, *, signed=False) -> bytes
57
58 Return an array of bytes representing an integer.
59
60 The integer is represented using length bytes. An OverflowError is
61 raised if the integer is not representable with the given number of
62 bytes.
63
64 The byteorder argument determines the byte order used to represent the
65 integer. If byteorder is 'big', the most significant byte is at the
66 beginning of the byte array. If byteorder is 'little', the most
67 significant byte is at the end of the byte array. To request the native
68 byte order of the host system, use `sys.byteorder' as the byte order value.
69
70 The signed keyword-only argument determines whether two's complement is
71 used to represent the integer. If signed is False and a negative integer
72 is given, an OverflowError is raised.
73 """
74 pass
75
76 def __abs__(self, *args, **kwargs): # real signature unknown
77 """ abs(self) """
78 pass
79
80 def __add__(self, *args, **kwargs): # real signature unknown
81 """ Return self+value. """
82 pass
83
84 def __and__(self, *args, **kwargs): # real signature unknown
85 """ Return self&value. """
86 pass
87
88 def __bool__(self, *args, **kwargs): # real signature unknown
89 """ self != 0 """
90 pass
91
92 def __ceil__(self, *args, **kwargs): # real signature unknown
93 """ Ceiling of an Integral returns itself. """
94 pass
95
96 def __divmod__(self, *args, **kwargs): # real signature unknown
97 """ Return divmod(self, value). """
98 pass
99
100 def __eq__(self, *args, **kwargs): # real signature unknown
101 """ Return self==value. """
102 pass
103
104 def __float__(self, *args, **kwargs): # real signature unknown
105 """ float(self) """
106 pass
107
108 def __floordiv__(self, *args, **kwargs): # real signature unknown
109 """ Return self//value. """
110 pass
111
112 def __floor__(self, *args, **kwargs): # real signature unknown
113 """ Flooring an Integral returns itself. """
114 pass
115
116 def __format__(self, *args, **kwargs): # real signature unknown
117 pass
118
119 def __getattribute__(self, *args, **kwargs): # real signature unknown
120 """ Return getattr(self, name). """
121 pass
122
123 def __getnewargs__(self, *args, **kwargs): # real signature unknown
124 pass
125
126 def __ge__(self, *args, **kwargs): # real signature unknown
127 """ Return self>=value. """
128 pass
129
130 def __gt__(self, *args, **kwargs): # real signature unknown
131 """ Return self>value. """
132 pass
133
134 def __hash__(self, *args, **kwargs): # real signature unknown
135 """ Return hash(self). """
136 pass
137
138 def __index__(self, *args, **kwargs): # real signature unknown
139 """ Return self converted to an integer, if self is suitable for use as an index into a list. """
140 pass
141
142 def __init__(self, x, base=10): # known special case of int.__init__
143 """
144 int(x=0) -> integer
145 int(x, base=10) -> integer
146
147 Convert a number or string to an integer, or return 0 if no arguments
148 are given. If x is a number, return x.__int__(). For floating point
149 numbers, this truncates towards zero.
150
151 If x is not a number or if base is given, then x must be a string,
152 bytes, or bytearray instance representing an integer literal in the
153 given base. The literal can be preceded by '+' or '-' and be surrounded
154 by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
155 Base 0 means to interpret the base from the string as an integer literal.
156 >>> int('0b100', base=0)
157 4
158 # (copied from class doc)
159 """
160 pass
161
162 def __int__(self, *args, **kwargs): # real signature unknown
163 """ int(self) """
164 pass
165
166 def __invert__(self, *args, **kwargs): # real signature unknown
167 """ ~self """
168 pass
169
170 def __le__(self, *args, **kwargs): # real signature unknown
171 """ Return self<=value. """
172 pass
173
174 def __lshift__(self, *args, **kwargs): # real signature unknown
175 """ Return self<<value. """
176 pass
177
178 def __lt__(self, *args, **kwargs): # real signature unknown
179 """ Return self<value. """
180 pass
181
182 def __mod__(self, *args, **kwargs): # real signature unknown
183 """ Return self%value. """
184 pass
185
186 def __mul__(self, *args, **kwargs): # real signature unknown
187 """ Return self*value. """
188 pass
189
190 def __neg__(self, *args, **kwargs): # real signature unknown
191 """ -self """
192 pass
193
194 @staticmethod # known case of __new__
195 def __new__(*args, **kwargs): # real signature unknown
196 """ Create and return a new object. See help(type) for accurate signature. """
197 pass
198
199 def __ne__(self, *args, **kwargs): # real signature unknown
200 """ Return self!=value. """
201 pass
202
203 def __or__(self, *args, **kwargs): # real signature unknown
204 """ Return self|value. """
205 pass
206
207 def __pos__(self, *args, **kwargs): # real signature unknown
208 """ +self """
209 pass
210
211 def __pow__(self, *args, **kwargs): # real signature unknown
212 """ Return pow(self, value, mod). """
213 pass
214
215 def __radd__(self, *args, **kwargs): # real signature unknown
216 """ Return value+self. """
217 pass
218
219 def __rand__(self, *args, **kwargs): # real signature unknown
220 """ Return value&self. """
221 pass
222
223 def __rdivmod__(self, *args, **kwargs): # real signature unknown
224 """ Return divmod(value, self). """
225 pass
226
227 def __repr__(self, *args, **kwargs): # real signature unknown
228 """ Return repr(self). """
229 pass
230
231 def __rfloordiv__(self, *args, **kwargs): # real signature unknown
232 """ Return value//self. """
233 pass
234
235 def __rlshift__(self, *args, **kwargs): # real signature unknown
236 """ Return value<<self. """
237 pass
238
239 def __rmod__(self, *args, **kwargs): # real signature unknown
240 """ Return value%self. """
241 pass
242
243 def __rmul__(self, *args, **kwargs): # real signature unknown
244 """ Return value*self. """
245 pass
246
247 def __ror__(self, *args, **kwargs): # real signature unknown
248 """ Return value|self. """
249 pass
250
251 def __round__(self, *args, **kwargs): # real signature unknown
252 """
253 Rounding an Integral returns itself.
254 Rounding with an ndigits argument also returns an integer.
255 """
256 pass
257
258 def __rpow__(self, *args, **kwargs): # real signature unknown
259 """ Return pow(value, self, mod). """
260 pass
261
262 def __rrshift__(self, *args, **kwargs): # real signature unknown
263 """ Return value>>self. """
264 pass
265
266 def __rshift__(self, *args, **kwargs): # real signature unknown
267 """ Return self>>value. """
268 pass
269
270 def __rsub__(self, *args, **kwargs): # real signature unknown
271 """ Return value-self. """
272 pass
273
274 def __rtruediv__(self, *args, **kwargs): # real signature unknown
275 """ Return value/self. """
276 pass
277
278 def __rxor__(self, *args, **kwargs): # real signature unknown
279 """ Return value^self. """
280 pass
281
282 def __sizeof__(self, *args, **kwargs): # real signature unknown
283 """ Returns size in memory, in bytes """
284 pass
285
286 def __str__(self, *args, **kwargs): # real signature unknown
287 """ Return str(self). """
288 pass
289
290 def __sub__(self, *args, **kwargs): # real signature unknown
291 """ Return self-value. """
292 pass
293
294 def __truediv__(self, *args, **kwargs): # real signature unknown
295 """ Return self/value. """
296 pass
297
298 def __trunc__(self, *args, **kwargs): # real signature unknown
299 """ Truncating an Integral returns itself. """
300 pass
301
302 def __xor__(self, *args, **kwargs): # real signature unknown
303 """ Return self^value. """
304 pass
305
306 denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
307 """the denominator of a rational number in lowest terms"""
308
309 imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
310 """the imaginary part of a complex number"""
311
312 numerator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
313 """the numerator of a rational number in lowest terms"""
314
315 real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
316 """the real part of a complex number"""
View Code
二、长整型
可能如：2147483649、9223372036854775807
每个长整型都具备如下功能：
![]()
1 class long(object):
2 """
3 long(x=0) -> long
4 long(x, base=10) -> long
5
6 Convert a number or string to a long integer, or return 0L if no arguments
7 are given. If x is floating point, the conversion truncates towards zero.
8
9 If x is not a number or if base is given, then x must be a string or
10 Unicode object representing an integer literal in the given base. The
11 literal can be preceded by '+' or '-' and be surrounded by whitespace.
12 The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to
13 interpret the base from the string as an integer literal.
14 >>> int('0b100', base=0)
15 4L
16 """
17 def bit_length(self): # real signature unknown; restored from __doc__
18 """
19 long.bit_length() -> int or long
20
21 Number of bits necessary to represent self in binary.
22 >>> bin(37L)
23 '0b100101'
24 >>> (37L).bit_length()
25 """
26 return 0
27
28 def conjugate(self, *args, **kwargs): # real signature unknown
29 """ Returns self, the complex conjugate of any long. """
30 pass
31
32 def __abs__(self): # real signature unknown; restored from __doc__
33 """ x.__abs__() <==> abs(x) """
34 pass
35
36 def __add__(self, y): # real signature unknown; restored from __doc__
37 """ x.__add__(y) <==> x+y """
38 pass
39
40 def __and__(self, y): # real signature unknown; restored from __doc__
41 """ x.__and__(y) <==> x&y """
42 pass
43
44 def __cmp__(self, y): # real signature unknown; restored from __doc__
45 """ x.__cmp__(y) <==> cmp(x,y) """
46 pass
47
48 def __coerce__(self, y): # real signature unknown; restored from __doc__
49 """ x.__coerce__(y) <==> coerce(x, y) """
50 pass
51
52 def __divmod__(self, y): # real signature unknown; restored from __doc__
53 """ x.__divmod__(y) <==> divmod(x, y) """
54 pass
55
56 def __div__(self, y): # real signature unknown; restored from __doc__
57 """ x.__div__(y) <==> x/y """
58 pass
59
60 def __float__(self): # real signature unknown; restored from __doc__
61 """ x.__float__() <==> float(x) """
62 pass
63
64 def __floordiv__(self, y): # real signature unknown; restored from __doc__
65 """ x.__floordiv__(y) <==> x//y """
66 pass
67
68 def __format__(self, *args, **kwargs): # real signature unknown
69 pass
70
71 def __getattribute__(self, name): # real signature unknown; restored from __doc__
72 """ x.__getattribute__('name') <==> x.name """
73 pass
74
75 def __getnewargs__(self, *args, **kwargs): # real signature unknown
76 pass
77
78 def __hash__(self): # real signature unknown; restored from __doc__
79 """ x.__hash__() <==> hash(x) """
80 pass
81
82 def __hex__(self): # real signature unknown; restored from __doc__
83 """ x.__hex__() <==> hex(x) """
84 pass
85
86 def __index__(self): # real signature unknown; restored from __doc__
87 """ x[y:z] <==> x[y.__index__():z.__index__()] """
88 pass
89
90 def __init__(self, x=0): # real signature unknown; restored from __doc__
91 pass
92
93 def __int__(self): # real signature unknown; restored from __doc__
94 """ x.__int__() <==> int(x) """
95 pass
96
97 def __invert__(self): # real signature unknown; restored from __doc__
98 """ x.__invert__() <==> ~x """
99 pass
100
101 def __long__(self): # real signature unknown; restored from __doc__
102 """ x.__long__() <==> long(x) """
103 pass
104
105 def __lshift__(self, y): # real signature unknown; restored from __doc__
106 """ x.__lshift__(y) <==> x<<y """
107 pass
108
109 def __mod__(self, y): # real signature unknown; restored from __doc__
110 """ x.__mod__(y) <==> x%y """
111 pass
112
113 def __mul__(self, y): # real signature unknown; restored from __doc__
114 """ x.__mul__(y) <==> x*y """
115 pass
116
117 def __neg__(self): # real signature unknown; restored from __doc__
118 """ x.__neg__() <==> -x """
119 pass
120
121 @staticmethod # known case of __new__
122 def __new__(S, *more): # real signature unknown; restored from __doc__
123 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
124 pass
125
126 def __nonzero__(self): # real signature unknown; restored from __doc__
127 """ x.__nonzero__() <==> x != 0 """
128 pass
129
130 def __oct__(self): # real signature unknown; restored from __doc__
131 """ x.__oct__() <==> oct(x) """
132 pass
133
134 def __or__(self, y): # real signature unknown; restored from __doc__
135 """ x.__or__(y) <==> x|y """
136 pass
137
138 def __pos__(self): # real signature unknown; restored from __doc__
139 """ x.__pos__() <==> +x """
140 pass
141
142 def __pow__(self, y, z=None): # real signature unknown; restored from __doc__
143 """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """
144 pass
145
146 def __radd__(self, y): # real signature unknown; restored from __doc__
147 """ x.__radd__(y) <==> y+x """
148 pass
149
150 def __rand__(self, y): # real signature unknown; restored from __doc__
151 """ x.__rand__(y) <==> y&x """
152 pass
153
154 def __rdivmod__(self, y): # real signature unknown; restored from __doc__
155 """ x.__rdivmod__(y) <==> divmod(y, x) """
156 pass
157
158 def __rdiv__(self, y): # real signature unknown; restored from __doc__
159 """ x.__rdiv__(y) <==> y/x """
160 pass
161
162 def __repr__(self): # real signature unknown; restored from __doc__
163 """ x.__repr__() <==> repr(x) """
164 pass
165
166 def __rfloordiv__(self, y): # real signature unknown; restored from __doc__
167 """ x.__rfloordiv__(y) <==> y//x """
168 pass
169
170 def __rlshift__(self, y): # real signature unknown; restored from __doc__
171 """ x.__rlshift__(y) <==> y<<x """
172 pass
173
174 def __rmod__(self, y): # real signature unknown; restored from __doc__
175 """ x.__rmod__(y) <==> y%x """
176 pass
177
178 def __rmul__(self, y): # real signature unknown; restored from __doc__
179 """ x.__rmul__(y) <==> y*x """
180 pass
181
182 def __ror__(self, y): # real signature unknown; restored from __doc__
183 """ x.__ror__(y) <==> y|x """
184 pass
185
186 def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__
187 """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
188 pass
189
190 def __rrshift__(self, y): # real signature unknown; restored from __doc__
191 """ x.__rrshift__(y) <==> y>>x """
192 pass
193
194 def __rshift__(self, y): # real signature unknown; restored from __doc__
195 """ x.__rshift__(y) <==> x>>y """
196 pass
197
198 def __rsub__(self, y): # real signature unknown; restored from __doc__
199 """ x.__rsub__(y) <==> y-x """
200 pass
201
202 def __rtruediv__(self, y): # real signature unknown; restored from __doc__
203 """ x.__rtruediv__(y) <==> y/x """
204 pass
205
206 def __rxor__(self, y): # real signature unknown; restored from __doc__
207 """ x.__rxor__(y) <==> y^x """
208 pass
209
210 def __sizeof__(self, *args, **kwargs): # real signature unknown
211 """ Returns size in memory, in bytes """
212 pass
213
214 def __str__(self): # real signature unknown; restored from __doc__
215 """ x.__str__() <==> str(x) """
216 pass
217
218 def __sub__(self, y): # real signature unknown; restored from __doc__
219 """ x.__sub__(y) <==> x-y """
220 pass
221
222 def __truediv__(self, y): # real signature unknown; restored from __doc__
223 """ x.__truediv__(y) <==> x/y """
224 pass
225
226 def __trunc__(self, *args, **kwargs): # real signature unknown
227 """ Truncating an Integral returns itself. """
228 pass
229
230 def __xor__(self, y): # real signature unknown; restored from __doc__
231 """ x.__xor__(y) <==> x^y """
232 pass
233
234 denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
235 """the denominator of a rational number in lowest terms"""
236
237 imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
238 """the imaginary part of a complex number"""
239
240 numerator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
241 """the numerator of a rational number in lowest terms"""
242
243 real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
244 """the real part of a complex number"""
245
246 long
View Code
三、浮点型
如：3.14、2.88
每个浮点型都具备如下功能：
![]()
1 class float(object):
2 """
3 float(x) -> floating point number
4
5 Convert a string or number to a floating point number, if possible.
6 """
7 def as_integer_ratio(self):
8 """ 获取改值的最简比 """
9 """
10 float.as_integer_ratio() -> (int, int)
11
12 Return a pair of integers, whose ratio is exactly equal to the original
13 float and with a positive denominator.
14 Raise OverflowError on infinities and a ValueError on NaNs.
15
16 >>> (10.0).as_integer_ratio()
17 (10, 1)
18 >>> (0.0).as_integer_ratio()
19 (0, 1)
20 >>> (-.25).as_integer_ratio()
21 (-1, 4)
22 """
23 pass
24
25 def conjugate(self, *args, **kwargs): # real signature unknown
26 """ Return self, the complex conjugate of any float. """
27 pass
28
29 def fromhex(self, string):
30 """ 将十六进制字符串转换成浮点型 """
31 """
32 float.fromhex(string) -> float
33
34 Create a floating-point number from a hexadecimal string.
35 >>> float.fromhex('0x1.ffffp10')
36 2047.984375
37 >>> float.fromhex('-0x1p-1074')
38 -4.9406564584124654e-324
39 """
40 return 0.0
41
42 def hex(self):
43 """ 返回当前值的 16 进制表示 """
44 """
45 float.hex() -> string
46
47 Return a hexadecimal representation of a floating-point number.
48 >>> (-0.1).hex()
49 '-0x1.999999999999ap-4'
50 >>> 3.14159.hex()
51 '0x1.921f9f01b866ep+1'
52 """
53 return ""
54
55 def is_integer(self, *args, **kwargs): # real signature unknown
56 """ Return True if the float is an integer. """
57 pass
58
59 def __abs__(self):
60 """ x.__abs__() <==> abs(x) """
61 pass
62
63 def __add__(self, y):
64 """ x.__add__(y) <==> x+y """
65 pass
66
67 def __coerce__(self, y):
68 """ x.__coerce__(y) <==> coerce(x, y) """
69 pass
70
71 def __divmod__(self, y):
72 """ x.__divmod__(y) <==> divmod(x, y) """
73 pass
74
75 def __div__(self, y):
76 """ x.__div__(y) <==> x/y """
77 pass
78
79 def __eq__(self, y):
80 """ x.__eq__(y) <==> x==y """
81 pass
82
83 def __float__(self):
84 """ x.__float__() <==> float(x) """
85 pass
86
87 def __floordiv__(self, y):
88 """ x.__floordiv__(y) <==> x//y """
89 pass
90
91 def __format__(self, format_spec):
92 """
93 float.__format__(format_spec) -> string
94
95 Formats the float according to format_spec.
96 """
97 return ""
98
99 def __getattribute__(self, name):
100 """ x.__getattribute__('name') <==> x.name """
101 pass
102
103 def __getformat__(self, typestr):
104 """
105 float.__getformat__(typestr) -> string
106
107 You probably don't want to use this function. It exists mainly to be
108 used in Python's test suite.
109
110 typestr must be 'double' or 'float'. This function returns whichever of
111 'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
112 format of floating point numbers used by the C type named by typestr.
113 """
114 return ""
115
116 def __getnewargs__(self, *args, **kwargs): # real signature unknown
117 pass
118
119 def __ge__(self, y):
120 """ x.__ge__(y) <==> x>=y """
121 pass
122
123 def __gt__(self, y):
124 """ x.__gt__(y) <==> x>y """
125 pass
126
127 def __hash__(self):
128 """ x.__hash__() <==> hash(x) """
129 pass
130
131 def __init__(self, x):
132 pass
133
134 def __int__(self):
135 """ x.__int__() <==> int(x) """
136 pass
137
138 def __le__(self, y):
139 """ x.__le__(y) <==> x<=y """
140 pass
141
142 def __long__(self):
143 """ x.__long__() <==> long(x) """
144 pass
145
146 def __lt__(self, y):
147 """ x.__lt__(y) <==> x<y """
148 pass
149
150 def __mod__(self, y):
151 """ x.__mod__(y) <==> x%y """
152 pass
153
154 def __mul__(self, y):
155 """ x.__mul__(y) <==> x*y """
156 pass
157
158 def __neg__(self):
159 """ x.__neg__() <==> -x """
160 pass
161
162 @staticmethod # known case of __new__
163 def __new__(S, *more):
164 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
165 pass
166
167 def __ne__(self, y):
168 """ x.__ne__(y) <==> x!=y """
169 pass
170
171 def __nonzero__(self):
172 """ x.__nonzero__() <==> x != 0 """
173 pass
174
175 def __pos__(self):
176 """ x.__pos__() <==> +x """
177 pass
178
179 def __pow__(self, y, z=None):
180 """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """
181 pass
182
183 def __radd__(self, y):
184 """ x.__radd__(y) <==> y+x """
185 pass
186
187 def __rdivmod__(self, y):
188 """ x.__rdivmod__(y) <==> divmod(y, x) """
189 pass
190
191 def __rdiv__(self, y):
192 """ x.__rdiv__(y) <==> y/x """
193 pass
194
195 def __repr__(self):
196 """ x.__repr__() <==> repr(x) """
197 pass
198
199 def __rfloordiv__(self, y):
200 """ x.__rfloordiv__(y) <==> y//x """
201 pass
202
203 def __rmod__(self, y):
204 """ x.__rmod__(y) <==> y%x """
205 pass
206
207 def __rmul__(self, y):
208 """ x.__rmul__(y) <==> y*x """
209 pass
210
211 def __rpow__(self, x, z=None):
212 """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
213 pass
214
215 def __rsub__(self, y):
216 """ x.__rsub__(y) <==> y-x """
217 pass
218
219 def __rtruediv__(self, y):
220 """ x.__rtruediv__(y) <==> y/x """
221 pass
222
223 def __setformat__(self, typestr, fmt):
224 """
225 float.__setformat__(typestr, fmt) -> None
226
227 You probably don't want to use this function. It exists mainly to be
228 used in Python's test suite.
229
230 typestr must be 'double' or 'float'. fmt must be one of 'unknown',
231 'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
232 one of the latter two if it appears to match the underlying C reality.
233
234 Override the automatic determination of C-level floating point type.
235 This affects how floats are converted to and from binary strings.
236 """
237 pass
238
239 def __str__(self):
240 """ x.__str__() <==> str(x) """
241 pass
242
243 def __sub__(self, y):
244 """ x.__sub__(y) <==> x-y """
245 pass
246
247 def __truediv__(self, y):
248 """ x.__truediv__(y) <==> x/y """
249 pass
250
251 def __trunc__(self, *args, **kwargs): # real signature unknown
252 """ Return the Integral closest to x between 0 and x. """
253 pass
254
255 imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
256 """the imaginary part of a complex number"""
257
258 real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
259 """the real part of a complex number"""
260
261 float
View Code
四、字符串
如：'shawn'、'yuxiaozheng'
每个字符串都具备如下功能：
![]()
1 class str(basestring):
2 """
3 str(object='') -> string
4
5 Return a nice string representation of the object.
6 If the argument is a string, the return value is the same object.
7 """
8 def capitalize(self):
9 """ 首字母变大写 """
10 """
11 S.capitalize() -> string
12
13 Return a copy of the string S with only its first character
14 capitalized.
15 """
16 return ""
17
18 def center(self, width, fillchar=None):
19 """ 内容居中，width：总长度；fillchar：空白处填充内容，默认无 """
20 """
21 S.center(width[, fillchar]) -> string
22
23 Return S centered in a string of length width. Padding is
24 done using the specified fill character (default is a space)
25 """
26 return ""
27
28 def count(self, sub, start=None, end=None):
29 """ 子序列个数 """
30 """
31 S.count(sub[, start[, end]]) -> int
32
33 Return the number of non-overlapping occurrences of substring sub in
34 string S[start:end]. Optional arguments start and end are interpreted
35 as in slice notation.
36 """
37 return 0
38
39 def decode(self, encoding=None, errors=None):
40 """ 解码 """
41 """
42 S.decode([encoding[,errors]]) -> object
43
44 Decodes S using the codec registered for encoding. encoding defaults
45 to the default encoding. errors may be given to set a different error
46 handling scheme. Default is 'strict' meaning that encoding errors raise
47 a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
48 as well as any other name registered with codecs.register_error that is
49 able to handle UnicodeDecodeErrors.
50 """
51 return object()
52
53 def encode(self, encoding=None, errors=None):
54 """ 编码，针对unicode """
55 """
56 S.encode([encoding[,errors]]) -> object
57
58 Encodes S using the codec registered for encoding. encoding defaults
59 to the default encoding. errors may be given to set a different error
60 handling scheme. Default is 'strict' meaning that encoding errors raise
61 a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
62 'xmlcharrefreplace' as well as any other name registered with
63 codecs.register_error that is able to handle UnicodeEncodeErrors.
64 """
65 return object()
66
67 def endswith(self, suffix, start=None, end=None):
68 """ 是否以 xxx 结束 """
69 """
70 S.endswith(suffix[, start[, end]]) -> bool
71
72 Return True if S ends with the specified suffix, False otherwise.
73 With optional start, test S beginning at that position.
74 With optional end, stop comparing S at that position.
75 suffix can also be a tuple of strings to try.
76 """
77 return False
78
79 def expandtabs(self, tabsize=None):
80 """ 将tab转换成空格，默认一个tab转换成8个空格 """
81 """
82 S.expandtabs([tabsize]) -> string
83
84 Return a copy of S where all tab characters are expanded using spaces.
85 If tabsize is not given, a tab size of 8 characters is assumed.
86 """
87 return ""
88
89 def find(self, sub, start=None, end=None):
90 """ 寻找子序列位置，如果没找到，返回 -1 """
91 """
92 S.find(sub [,start [,end]]) -> int
93
94 Return the lowest index in S where substring sub is found,
95 such that sub is contained within S[start:end]. Optional
96 arguments start and end are interpreted as in slice notation.
97
98 Return -1 on failure.
99 """
100 return 0
101
102 def format(*args, **kwargs): # known special case of str.format
103 """ 字符串格式化，动态参数，将函数式编程时细说 """
104 """
105 S.format(*args, **kwargs) -> string
106
107 Return a formatted version of S, using substitutions from args and kwargs.
108 The substitutions are identified by braces ('{' and '}').
109 """
110 pass
111
112 def index(self, sub, start=None, end=None):
113 """ 子序列位置，如果没找到，报错 """
114 S.index(sub [,start [,end]]) -> int
115
116 Like S.find() but raise ValueError when the substring is not found.
117 """
118 return 0
119
120 def isalnum(self):
121 """ 是否是字母和数字 """
122 """
123 S.isalnum() -> bool
124
125 Return True if all characters in S are alphanumeric
126 and there is at least one character in S, False otherwise.
127 """
128 return False
129
130 def isalpha(self):
131 """ 是否是字母 """
132 """
133 S.isalpha() -> bool
134
135 Return True if all characters in S are alphabetic
136 and there is at least one character in S, False otherwise.
137 """
138 return False
139
140 def isdigit(self):
141 """ 是否是数字 """
142 """
143 S.isdigit() -> bool
144
145 Return True if all characters in S are digits
146 and there is at least one character in S, False otherwise.
147 """
148 return False
149
150 def islower(self):
151 """ 是否小写 """
152 """
153 S.islower() -> bool
154
155 Return True if all cased characters in S are lowercase and there is
156 at least one cased character in S, False otherwise.
157 """
158 return False
159
160 def isspace(self):
161 """
162 S.isspace() -> bool
163
164 Return True if all characters in S are whitespace
165 and there is at least one character in S, False otherwise.
166 """
167 return False
168
169 def istitle(self):
170 """
171 S.istitle() -> bool
172
173 Return True if S is a titlecased string and there is at least one
174 character in S, i.e. uppercase characters may only follow uncased
175 characters and lowercase characters only cased ones. Return False
176 otherwise.
177 """
178 return False
179
180 def isupper(self):
181 """
182 S.isupper() -> bool
183
184 Return True if all cased characters in S are uppercase and there is
185 at least one cased character in S, False otherwise.
186 """
187 return False
188
189 def join(self, iterable):
190 """ 连接 """
191 """
192 S.join(iterable) -> string
193
194 Return a string which is the concatenation of the strings in the
195 iterable. The separator between elements is S.
196 """
197 return ""
198
199 def ljust(self, width, fillchar=None):
200 """ 内容左对齐，右侧填充 """
201 """
202 S.ljust(width[, fillchar]) -> string
203
204 Return S left-justified in a string of length width. Padding is
205 done using the specified fill character (default is a space).
206 """
207 return ""
208
209 def lower(self):
210 """ 变小写 """
211 """
212 S.lower() -> string
213
214 Return a copy of the string S converted to lowercase.
215 """
216 return ""
217
218 def lstrip(self, chars=None):
219 """ 移除左侧空白 """
220 """
221 S.lstrip([chars]) -> string or unicode
222
223 Return a copy of the string S with leading whitespace removed.
224 If chars is given and not None, remove characters in chars instead.
225 If chars is unicode, S will be converted to unicode before stripping
226 """
227 return ""
228
229 def partition(self, sep):
230 """ 分割，前，中，后三部分 """
231 """
232 S.partition(sep) -> (head, sep, tail)
233
234 Search for the separator sep in S, and return the part before it,
235 the separator itself, and the part after it. If the separator is not
236 found, return S and two empty strings.
237 """
238 pass
239
240 def replace(self, old, new, count=None):
241 """ 替换 """
242 """
243 S.replace(old, new[, count]) -> string
244
245 Return a copy of string S with all occurrences of substring
246 old replaced by new. If the optional argument count is
247 given, only the first count occurrences are replaced.
248 """
249 return ""
250
251 def rfind(self, sub, start=None, end=None):
252 """
253 S.rfind(sub [,start [,end]]) -> int
254
255 Return the highest index in S where substring sub is found,
256 such that sub is contained within S[start:end]. Optional
257 arguments start and end are interpreted as in slice notation.
258
259 Return -1 on failure.
260 """
261 return 0
262
263 def rindex(self, sub, start=None, end=None):
264 """
265 S.rindex(sub [,start [,end]]) -> int
266
267 Like S.rfind() but raise ValueError when the substring is not found.
268 """
269 return 0
270
271 def rjust(self, width, fillchar=None):
272 """
273 S.rjust(width[, fillchar]) -> string
274
275 Return S right-justified in a string of length width. Padding is
276 done using the specified fill character (default is a space)
277 """
278 return ""
279
280 def rpartition(self, sep):
281 """
282 S.rpartition(sep) -> (head, sep, tail)
283
284 Search for the separator sep in S, starting at the end of S, and return
285 the part before it, the separator itself, and the part after it. If the
286 separator is not found, return two empty strings and S.
287 """
288 pass
289
290 def rsplit(self, sep=None, maxsplit=None):
291 """
292 S.rsplit([sep [,maxsplit]]) -> list of strings
293
294 Return a list of the words in the string S, using sep as the
295 delimiter string, starting at the end of the string and working
296 to the front. If maxsplit is given, at most maxsplit splits are
297 done. If sep is not specified or is None, any whitespace string
298 is a separator.
299 """
300 return []
301
302 def rstrip(self, chars=None):
303 """
304 S.rstrip([chars]) -> string or unicode
305
306 Return a copy of the string S with trailing whitespace removed.
307 If chars is given and not None, remove characters in chars instead.
308 If chars is unicode, S will be converted to unicode before stripping
309 """
310 return ""
311
312 def split(self, sep=None, maxsplit=None):
313 """ 分割， maxsplit最多分割几次 """
314 """
315 S.split([sep [,maxsplit]]) -> list of strings
316
317 Return a list of the words in the string S, using sep as the
318 delimiter string. If maxsplit is given, at most maxsplit
319 splits are done. If sep is not specified or is None, any
320 whitespace string is a separator and empty strings are removed
321 from the result.
322 """
323 return []
324
325 def splitlines(self, keepends=False):
326 """ 根据换行分割 """
327 """
328 S.splitlines(keepends=False) -> list of strings
329
330 Return a list of the lines in S, breaking at line boundaries.
331 Line breaks are not included in the resulting list unless keepends
332 is given and true.
333 """
334 return []
335
336 def startswith(self, prefix, start=None, end=None):
337 """ 是否起始 """
338 """
339 S.startswith(prefix[, start[, end]]) -> bool
340
341 Return True if S starts with the specified prefix, False otherwise.
342 With optional start, test S beginning at that position.
343 With optional end, stop comparing S at that position.
344 prefix can also be a tuple of strings to try.
345 """
346 return False
347
348 def strip(self, chars=None):
349 """ 移除两段空白 """
350 """
351 S.strip([chars]) -> string or unicode
352
353 Return a copy of the string S with leading and trailing
354 whitespace removed.
355 If chars is given and not None, remove characters in chars instead.
356 If chars is unicode, S will be converted to unicode before stripping
357 """
358 return ""
359
360 def swapcase(self):
361 """ 大写变小写，小写变大写 """
362 """
363 S.swapcase() -> string
364
365 Return a copy of the string S with uppercase characters
366 converted to lowercase and vice versa.
367 """
368 return ""
369
370 def title(self):
371 """
372 S.title() -> string
373
374 Return a titlecased version of S, i.e. words start with uppercase
375 characters, all remaining cased characters have lowercase.
376 """
377 return ""
378
379 def translate(self, table, deletechars=None):
380 """
381 转换，需要先做一个对应表，最后一个表示删除字符集合
382 intab = "aeiou"
383 outtab = "12345"
384 trantab = maketrans(intab, outtab)
385 str = "this is string example....wow!!!"
386 print str.translate(trantab, 'xm')
387 """
388
389 """
390 S.translate(table [,deletechars]) -> string
391
392 Return a copy of the string S, where all characters occurring
393 in the optional argument deletechars are removed, and the
394 remaining characters have been mapped through the given
395 translation table, which must be a string of length 256 or None.
396 If the table argument is None, no translation is applied and
397 the operation simply removes the characters in deletechars.
398 """
399 return ""
400
401 def upper(self):
402 """
403 S.upper() -> string
404
405 Return a copy of the string S converted to uppercase.
406 """
407 return ""
408
409 def zfill(self, width):
410 """方法返回指定长度的字符串，原字符串右对齐，前面填充0。"""
411 """
412 S.zfill(width) -> string
413
414 Pad a numeric string S with zeros on the left, to fill a field
415 of the specified width. The string S is never truncated.
416 """
417 return ""
418
419 def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown
420 pass
421
422 def _formatter_parser(self, *args, **kwargs): # real signature unknown
423 pass
424
425 def __add__(self, y):
426 """ x.__add__(y) <==> x+y """
427 pass
428
429 def __contains__(self, y):
430 """ x.__contains__(y) <==> y in x """
431 pass
432
433 def __eq__(self, y):
434 """ x.__eq__(y) <==> x==y """
435 pass
436
437 def __format__(self, format_spec):
438 """
439 S.__format__(format_spec) -> string
440
441 Return a formatted version of S as described by format_spec.
442 """
443 return ""
444
445 def __getattribute__(self, name):
446 """ x.__getattribute__('name') <==> x.name """
447 pass
448
449 def __getitem__(self, y):
450 """ x.__getitem__(y) <==> x[y] """
451 pass
452
453 def __getnewargs__(self, *args, **kwargs): # real signature unknown
454 pass
455
456 def __getslice__(self, i, j):
457 """
458 x.__getslice__(i, j) <==> x[i:j]
459
460 Use of negative indices is not supported.
461 """
462 pass
463
464 def __ge__(self, y):
465 """ x.__ge__(y) <==> x>=y """
466 pass
467
468 def __gt__(self, y):
469 """ x.__gt__(y) <==> x>y """
470 pass
471
472 def __hash__(self):
473 """ x.__hash__() <==> hash(x) """
474 pass
475
476 def __init__(self, string=''): # known special case of str.__init__
477 """
478 str(object='') -> string
479
480 Return a nice string representation of the object.
481 If the argument is a string, the return value is the same object.
482 # (copied from class doc)
483 """
484 pass
485
486 def __len__(self):
487 """ x.__len__() <==> len(x) """
488 pass
489
490 def __le__(self, y):
491 """ x.__le__(y) <==> x<=y """
492 pass
493
494 def __lt__(self, y):
495 """ x.__lt__(y) <==> x<y """
496 pass
497
498 def __mod__(self, y):
499 """ x.__mod__(y) <==> x%y """
500 pass
501
502 def __mul__(self, n):
503 """ x.__mul__(n) <==> x*n """
504 pass
505
506 @staticmethod # known case of __new__
507 def __new__(S, *more):
508 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
509 pass
510
511 def __ne__(self, y):
512 """ x.__ne__(y) <==> x!=y """
513 pass
514
515 def __repr__(self):
516 """ x.__repr__() <==> repr(x) """
517 pass
518
519 def __rmod__(self, y):
520 """ x.__rmod__(y) <==> y%x """
521 pass
522
523 def __rmul__(self, n):
524 """ x.__rmul__(n) <==> n*x """
525 pass
526
527 def __sizeof__(self):
528 """ S.__sizeof__() -> size of S in memory, in bytes """
529 pass
530
531 def __str__(self):
532 """ x.__str__() <==> str(x) """
533 pass
534
535 str
536
537 str
View Code
注：编码；字符串的乘法；字符串和格式化
五、列表
如：[11,22,33]、['shawn', 'alex']
每个列表都具备如下功能：
![]()
1 class list(object):
2 """
3 list() -> new empty list
4 list(iterable) -> new list initialized from iterable's items
5 """
6 def append(self, p_object): # real signature unknown; restored from __doc__
7 """ L.append(object) -- append object to end """
8 pass
9
10 def count(self, value): # real signature unknown; restored from __doc__
11 """ L.count(value) -> integer -- return number of occurrences of value """
12 return 0
13
14 def extend(self, iterable): # real signature unknown; restored from __doc__
15 """ L.extend(iterable) -- extend list by appending elements from the iterable """
16 pass
17
18 def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
19 """
20 L.index(value, [start, [stop]]) -> integer -- return first index of value.
21 Raises ValueError if the value is not present.
22 """
23 return 0
24
25 def insert(self, index, p_object): # real signature unknown; restored from __doc__
26 """ L.insert(index, object) -- insert object before index """
27 pass
28
29 def pop(self, index=None): # real signature unknown; restored from __doc__
30 """
31 L.pop([index]) -> item -- remove and return item at index (default last).
32 Raises IndexError if list is empty or index is out of range.
33 """
34 pass
35
36 def remove(self, value): # real signature unknown; restored from __doc__
37 """
38 L.remove(value) -- remove first occurrence of value.
39 Raises ValueError if the value is not present.
40 """
41 pass
42
43 def reverse(self): # real signature unknown; restored from __doc__
44 """ L.reverse() -- reverse *IN PLACE* """
45 pass
46
47 def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__
48 """
49 L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
50 cmp(x, y) -> -1, 0, 1
51 """
52 pass
53
54 def __add__(self, y): # real signature unknown; restored from __doc__
55 """ x.__add__(y) <==> x+y """
56 pass
57
58 def __contains__(self, y): # real signature unknown; restored from __doc__
59 """ x.__contains__(y) <==> y in x """
60 pass
61
62 def __delitem__(self, y): # real signature unknown; restored from __doc__
63 """ x.__delitem__(y) <==> del x[y] """
64 pass
65
66 def __delslice__(self, i, j): # real signature unknown; restored from __doc__
67 """
68 x.__delslice__(i, j) <==> del x[i:j]
69
70 Use of negative indices is not supported.
71 """
72 pass
73
74 def __eq__(self, y): # real signature unknown; restored from __doc__
75 """ x.__eq__(y) <==> x==y """
76 pass
77
78 def __getattribute__(self, name): # real signature unknown; restored from __doc__
79 """ x.__getattribute__('name') <==> x.name """
80 pass
81
82 def __getitem__(self, y): # real signature unknown; restored from __doc__
83 """ x.__getitem__(y) <==> x[y] """
84 pass
85
86 def __getslice__(self, i, j): # real signature unknown; restored from __doc__
87 """
88 x.__getslice__(i, j) <==> x[i:j]
89
90 Use of negative indices is not supported.
91 """
92 pass
93
94 def __ge__(self, y): # real signature unknown; restored from __doc__
95 """ x.__ge__(y) <==> x>=y """
96 pass
97
98 def __gt__(self, y): # real signature unknown; restored from __doc__
99 """ x.__gt__(y) <==> x>y """
100 pass
101
102 def __iadd__(self, y): # real signature unknown; restored from __doc__
103 """ x.__iadd__(y) <==> x+=y """
104 pass
105
106 def __imul__(self, y): # real signature unknown; restored from __doc__
107 """ x.__imul__(y) <==> x*=y """
108 pass
109
110 def __init__(self, seq=()): # known special case of list.__init__
111 """
112 list() -> new empty list
113 list(iterable) -> new list initialized from iterable's items
114 # (copied from class doc)
115 """
116 pass
117
118 def __iter__(self): # real signature unknown; restored from __doc__
119 """ x.__iter__() <==> iter(x) """
120 pass
121
122 def __len__(self): # real signature unknown; restored from __doc__
123 """ x.__len__() <==> len(x) """
124 pass
125
126 def __le__(self, y): # real signature unknown; restored from __doc__
127 """ x.__le__(y) <==> x<=y """
128 pass
129
130 def __lt__(self, y): # real signature unknown; restored from __doc__
131 """ x.__lt__(y) <==> x<y """
132 pass
133
134 def __mul__(self, n): # real signature unknown; restored from __doc__
135 """ x.__mul__(n) <==> x*n """
136 pass
137
138 @staticmethod # known case of __new__
139 def __new__(S, *more): # real signature unknown; restored from __doc__
140 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
141 pass
142
143 def __ne__(self, y): # real signature unknown; restored from __doc__
144 """ x.__ne__(y) <==> x!=y """
145 pass
146
147 def __repr__(self): # real signature unknown; restored from __doc__
148 """ x.__repr__() <==> repr(x) """
149 pass
150
151 def __reversed__(self): # real signature unknown; restored from __doc__
152 """ L.__reversed__() -- return a reverse iterator over the list """
153 pass
154
155 def __rmul__(self, n): # real signature unknown; restored from __doc__
156 """ x.__rmul__(n) <==> n*x """
157 pass
158
159 def __setitem__(self, i, y): # real signature unknown; restored from __doc__
160 """ x.__setitem__(i, y) <==> x[i]=y """
161 pass
162
163 def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__
164 """
165 x.__setslice__(i, j, y) <==> x[i:j]=y
166
167 Use of negative indices is not supported.
168 """
169 pass
170
171 def __sizeof__(self): # real signature unknown; restored from __doc__
172 """ L.__sizeof__() -- size of L in memory, in bytes """
173 pass
174
175 __hash__ = None
176
177 list
View Code
六、元组
如：(11,22,33)、('shawn', 'alex')
每个元组都具备如下功能：
![]()
1 class tuple(object):
2 """
3 tuple() -> empty tuple
4 tuple(iterable) -> tuple initialized from iterable's items
5
6 If the argument is a tuple, the return value is the same object.
7 """
8 def count(self, value): # real signature unknown; restored from __doc__
9 """ T.count(value) -> integer -- return number of occurrences of value """
10 return 0
11
12 def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
13 """
14 T.index(value, [start, [stop]]) -> integer -- return first index of value.
15 Raises ValueError if the value is not present.
16 """
17 return 0
18
19 def __add__(self, y): # real signature unknown; restored from __doc__
20 """ x.__add__(y) <==> x+y """
21 pass
22
23 def __contains__(self, y): # real signature unknown; restored from __doc__
24 """ x.__contains__(y) <==> y in x """
25 pass
26
27 def __eq__(self, y): # real signature unknown; restored from __doc__
28 """ x.__eq__(y) <==> x==y """
29 pass
30
31 def __getattribute__(self, name): # real signature unknown; restored from __doc__
32 """ x.__getattribute__('name') <==> x.name """
33 pass
34
35 def __getitem__(self, y): # real signature unknown; restored from __doc__
36 """ x.__getitem__(y) <==> x[y] """
37 pass
38
39 def __getnewargs__(self, *args, **kwargs): # real signature unknown
40 pass
41
42 def __getslice__(self, i, j): # real signature unknown; restored from __doc__
43 """
44 x.__getslice__(i, j) <==> x[i:j]
45
46 Use of negative indices is not supported.
47 """
48 pass
49
50 def __ge__(self, y): # real signature unknown; restored from __doc__
51 """ x.__ge__(y) <==> x>=y """
52 pass
53
54 def __gt__(self, y): # real signature unknown; restored from __doc__
55 """ x.__gt__(y) <==> x>y """
56 pass
57
58 def __hash__(self): # real signature unknown; restored from __doc__
59 """ x.__hash__() <==> hash(x) """
60 pass
61
62 def __init__(self, seq=()): # known special case of tuple.__init__
63 """
64 tuple() -> empty tuple
65 tuple(iterable) -> tuple initialized from iterable's items
66
67 If the argument is a tuple, the return value is the same object.
68 # (copied from class doc)
69 """
70 pass
71
72 def __iter__(self): # real signature unknown; restored from __doc__
73 """ x.__iter__() <==> iter(x) """
74 pass
75
76 def __len__(self): # real signature unknown; restored from __doc__
77 """ x.__len__() <==> len(x) """
78 pass
79
80 def __le__(self, y): # real signature unknown; restored from __doc__
81 """ x.__le__(y) <==> x<=y """
82 pass
83
84 def __lt__(self, y): # real signature unknown; restored from __doc__
85 """ x.__lt__(y) <==> x<y """
86 pass
87
88 def __mul__(self, n): # real signature unknown; restored from __doc__
89 """ x.__mul__(n) <==> x*n """
90 pass
91
92 @staticmethod # known case of __new__
93 def __new__(S, *more): # real signature unknown; restored from __doc__
94 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
95 pass
96
97 def __ne__(self, y): # real signature unknown; restored from __doc__
98 """ x.__ne__(y) <==> x!=y """
99 pass
100
101 def __repr__(self): # real signature unknown; restored from __doc__
102 """ x.__repr__() <==> repr(x) """
103 pass
104
105 def __rmul__(self, n): # real signature unknown; restored from __doc__
106 """ x.__rmul__(n) <==> n*x """
107 pass
108
109 def __sizeof__(self): # real signature unknown; restored from __doc__
110 """ T.__sizeof__() -- size of T in memory, in bytes """
111 pass
112
113 tuple
View Code
七、字典
如：{'name': 'shawn', 'age': 18} 、{'host': '2.2.2.2', 'port': 80]}
ps：循环时，默认循环key
每个字典都c具备如下功能：
![]()
1 class dict(object):
2 """
3 dict() -> new empty dictionary
4 dict(mapping) -> new dictionary initialized from a mapping object's
5 (key, value) pairs
6 dict(iterable) -> new dictionary initialized as if via:
7 d = {}
8 for k, v in iterable:
9 d[k] = v
10 dict(**kwargs) -> new dictionary initialized with the name=value pairs
11 in the keyword argument list. For example: dict(one=1, two=2)
12 """
13
14 def clear(self): # real signature unknown; restored from __doc__
15 """ 清除内容 """
16 """ D.clear() -> None. Remove all items from D. """
17 pass
18
19 def copy(self): # real signature unknown; restored from __doc__
20 """ 浅拷贝 """
21 """ D.copy() -> a shallow copy of D """
22 pass
23
24 @staticmethod # known case
25 def fromkeys(S, v=None): # real signature unknown; restored from __doc__
26 """
27 dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
28 v defaults to None.
29 """
30 pass
31
32 def get(self, k, d=None): # real signature unknown; restored from __doc__
33 """ 根据key获取值，d是默认值 """
34 """ D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """
35 pass
36
37 def has_key(self, k): # real signature unknown; restored from __doc__
38 """ 是否有key """
39 """ D.has_key(k) -> True if D has a key k, else False """
40 return False
41
42 def items(self): # real signature unknown; restored from __doc__
43 """ 所有项的列表形式 """
44 """ D.items() -> list of D's (key, value) pairs, as 2-tuples """
45 return []
46
47 def iteritems(self): # real signature unknown; restored from __doc__
48 """ 项可迭代 """
49 """ D.iteritems() -> an iterator over the (key, value) items of D """
50 pass
51
52 def iterkeys(self): # real signature unknown; restored from __doc__
53 """ key可迭代 """
54 """ D.iterkeys() -> an iterator over the keys of D """
55 pass
56
57 def itervalues(self): # real signature unknown; restored from __doc__
58 """ value可迭代 """
59 """ D.itervalues() -> an iterator over the values of D """
60 pass
61
62 def keys(self): # real signature unknown; restored from __doc__
63 """ 所有的key列表 """
64 """ D.keys() -> list of D's keys """
65 return []
66
67 def pop(self, k, d=None): # real signature unknown; restored from __doc__
68 """ 获取并在字典中移除 """
69 """
70 D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
71 If key is not found, d is returned if given, otherwise KeyError is raised
72 """
73 pass
74
75 def popitem(self): # real signature unknown; restored from __doc__
76 """ 获取并在字典中移除 """
77 """
78 D.popitem() -> (k, v), remove and return some (key, value) pair as a
79 2-tuple; but raise KeyError if D is empty.
80 """
81 pass
82
83 def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
84 """ 如果key不存在，则创建，如果存在，则返回已存在的值且不修改 """
85 """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
86 pass
87
88 def update(self, E=None, **F): # known special case of dict.update
89 """ 更新
90 {'name':'alex', 'age': 18000}
91 [('name','sbsbsb'),]
92 """
93 """
94 D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
95 If E present and has a .keys() method, does: for k in E: D[k] = E[k]
96 If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v
97 In either case, this is followed by: for k in F: D[k] = F[k]
98 """
99 pass
100
101 def values(self): # real signature unknown; restored from __doc__
102 """ 所有的值 """
103 """ D.values() -> list of D's values """
104 return []
105
106 def viewitems(self): # real signature unknown; restored from __doc__
107 """ 所有项，只是将内容保存至view对象中 """
108 """ D.viewitems() -> a set-like object providing a view on D's items """
109 pass
110
111 def viewkeys(self): # real signature unknown; restored from __doc__
112 """ D.viewkeys() -> a set-like object providing a view on D's keys """
113 pass
114
115 def viewvalues(self): # real signature unknown; restored from __doc__
116 """ D.viewvalues() -> an object providing a view on D's values """
117 pass
118
119 def __cmp__(self, y): # real signature unknown; restored from __doc__
120 """ x.__cmp__(y) <==> cmp(x,y) """
121 pass
122
123 def __contains__(self, k): # real signature unknown; restored from __doc__
124 """ D.__contains__(k) -> True if D has a key k, else False """
125 return False
126
127 def __delitem__(self, y): # real signature unknown; restored from __doc__
128 """ x.__delitem__(y) <==> del x[y] """
129 pass
130
131 def __eq__(self, y): # real signature unknown; restored from __doc__
132 """ x.__eq__(y) <==> x==y """
133 pass
134
135 def __getattribute__(self, name): # real signature unknown; restored from __doc__
136 """ x.__getattribute__('name') <==> x.name """
137 pass
138
139 def __getitem__(self, y): # real signature unknown; restored from __doc__
140 """ x.__getitem__(y) <==> x[y] """
141 pass
142
143 def __ge__(self, y): # real signature unknown; restored from __doc__
144 """ x.__ge__(y) <==> x>=y """
145 pass
146
147 def __gt__(self, y): # real signature unknown; restored from __doc__
148 """ x.__gt__(y) <==> x>y """
149 pass
150
151 def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
152 """
153 dict() -> new empty dictionary
154 dict(mapping) -> new dictionary initialized from a mapping object's
155 (key, value) pairs
156 dict(iterable) -> new dictionary initialized as if via:
157 d = {}
158 for k, v in iterable:
159 d[k] = v
160 dict(**kwargs) -> new dictionary initialized with the name=value pairs
161 in the keyword argument list. For example: dict(one=1, two=2)
162 # (copied from class doc)
163 """
164 pass
165
166 def __iter__(self): # real signature unknown; restored from __doc__
167 """ x.__iter__() <==> iter(x) """
168 pass
169
170 def __len__(self): # real signature unknown; restored from __doc__
171 """ x.__len__() <==> len(x) """
172 pass
173
174 def __le__(self, y): # real signature unknown; restored from __doc__
175 """ x.__le__(y) <==> x<=y """
176 pass
177
178 def __lt__(self, y): # real signature unknown; restored from __doc__
179 """ x.__lt__(y) <==> x<y """
180 pass
181
182 @staticmethod # known case of __new__
183 def __new__(S, *more): # real signature unknown; restored from __doc__
184 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
185 pass
186
187 def __ne__(self, y): # real signature unknown; restored from __doc__
188 """ x.__ne__(y) <==> x!=y """
189 pass
190
191 def __repr__(self): # real signature unknown; restored from __doc__
192 """ x.__repr__() <==> repr(x) """
193 pass
194
195 def __setitem__(self, i, y): # real signature unknown; restored from __doc__
196 """ x.__setitem__(i, y) <==> x[i]=y """
197 pass
198
199 def __sizeof__(self): # real signature unknown; restored from __doc__
200 """ D.__sizeof__() -> size of D in memory, in bytes """
201 pass
202
203 __hash__ = None
204
205 dict
View Code
八、set集合
set是一个无序且不重复的元素集合
![]()
1 class set(object):
2 """
3 set() -> new empty set object
4 set(iterable) -> new set object
5
6 Build an unordered collection of unique elements.
7 """
8 def add(self, *args, **kwargs): # real signature unknown
9 """ 添加 """
10 """
11 Add an element to a set.
12
13 This has no effect if the element is already present.
14 """
15 pass
16
17 def clear(self, *args, **kwargs): # real signature unknown
18 """ Remove all elements from this set. """
19 pass
20
21 def copy(self, *args, **kwargs): # real signature unknown
22 """ Return a shallow copy of a set. """
23 pass
24
25 def difference(self, *args, **kwargs): # real signature unknown
26 """
27 Return the difference of two or more sets as a new set.
28
29 (i.e. all elements that are in this set but not the others.)
30 """
31 pass
32
33 def difference_update(self, *args, **kwargs): # real signature unknown
34 """ 删除当前set中的所有包含在 new set 里的元素 """
35 """ Remove all elements of another set from this set. """
36 pass
37
38 def discard(self, *args, **kwargs): # real signature unknown
39 """ 移除元素 """
40 """
41 Remove an element from a set if it is a member.
42
43 If the element is not a member, do nothing.
44 """
45 pass
46
47 def intersection(self, *args, **kwargs): # real signature unknown
48 """ 取交集，新创建一个set """
49 """
50 Return the intersection of two or more sets as a new set.
51
52 (i.e. elements that are common to all of the sets.)
53 """
54 pass
55
56 def intersection_update(self, *args, **kwargs): # real signature unknown
57 """ 取交集，修改原来set """
58 """ Update a set with the intersection of itself and another. """
59 pass
60
61 def isdisjoint(self, *args, **kwargs): # real signature unknown
62 """ 如果没有交集，返回true """
63 """ Return True if two sets have a null intersection. """
64 pass
65
66 def issubset(self, *args, **kwargs): # real signature unknown
67 """ 是否是子集 """
68 """ Report whether another set contains this set. """
69 pass
70
71 def issuperset(self, *args, **kwargs): # real signature unknown
72 """ 是否是父集 """
73 """ Report whether this set contains another set. """
74 pass
75
76 def pop(self, *args, **kwargs): # real signature unknown
77 """ 移除 """
78 """
79 Remove and return an arbitrary set element.
80 Raises KeyError if the set is empty.
81 """
82 pass
83
84 def remove(self, *args, **kwargs): # real signature unknown
85 """ 移除 """
86 """
87 Remove an element from a set; it must be a member.
88
89 If the element is not a member, raise a KeyError.
90 """
91 pass
92
93 def symmetric_difference(self, *args, **kwargs): # real signature unknown
94 """ 差集，创建新对象"""
95 """
96 Return the symmetric difference of two sets as a new set.
97
98 (i.e. all elements that are in exactly one of the sets.)
99 """
100 pass
101
102 def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
103 """ 差集，改变原来 """
104 """ Update a set with the symmetric difference of itself and another. """
105 pass
106
107 def union(self, *args, **kwargs): # real signature unknown
108 """ 并集 """
109 """
110 Return the union of sets as a new set.
111
112 (i.e. all elements that are in either set.)
113 """
114 pass
115
116 def update(self, *args, **kwargs): # real signature unknown
117 """ 更新 """
118 """ Update a set with the union of itself and others. """
119 pass
120
121 def __and__(self, y): # real signature unknown; restored from __doc__
122 """ x.__and__(y) <==> x&y """
123 pass
124
125 def __cmp__(self, y): # real signature unknown; restored from __doc__
126 """ x.__cmp__(y) <==> cmp(x,y) """
127 pass
128
129 def __contains__(self, y): # real signature unknown; restored from __doc__
130 """ x.__contains__(y) <==> y in x. """
131 pass
132
133 def __eq__(self, y): # real signature unknown; restored from __doc__
134 """ x.__eq__(y) <==> x==y """
135 pass
136
137 def __getattribute__(self, name): # real signature unknown; restored from __doc__
138 """ x.__getattribute__('name') <==> x.name """
139 pass
140
141 def __ge__(self, y): # real signature unknown; restored from __doc__
142 """ x.__ge__(y) <==> x>=y """
143 pass
144
145 def __gt__(self, y): # real signature unknown; restored from __doc__
146 """ x.__gt__(y) <==> x>y """
147 pass
148
149 def __iand__(self, y): # real signature unknown; restored from __doc__
150 """ x.__iand__(y) <==> x&=y """
151 pass
152
153 def __init__(self, seq=()): # known special case of set.__init__
154 """
155 set() -> new empty set object
156 set(iterable) -> new set object
157
158 Build an unordered collection of unique elements.
159 # (copied from class doc)
160 """
161 pass
162
163 def __ior__(self, y): # real signature unknown; restored from __doc__
164 """ x.__ior__(y) <==> x|=y """
165 pass
166
167 def __isub__(self, y): # real signature unknown; restored from __doc__
168 """ x.__isub__(y) <==> x-=y """
169 pass
170
171 def __iter__(self): # real signature unknown; restored from __doc__
172 """ x.__iter__() <==> iter(x) """
173 pass
174
175 def __ixor__(self, y): # real signature unknown; restored from __doc__
176 """ x.__ixor__(y) <==> x^=y """
177 pass
178
179 def __len__(self): # real signature unknown; restored from __doc__
180 """ x.__len__() <==> len(x) """
181 pass
182
183 def __le__(self, y): # real signature unknown; restored from __doc__
184 """ x.__le__(y) <==> x<=y """
185 pass
186
187 def __lt__(self, y): # real signature unknown; restored from __doc__
188 """ x.__lt__(y) <==> x<y """
189 pass
190
191 @staticmethod # known case of __new__
192 def __new__(S, *more): # real signature unknown; restored from __doc__
193 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
194 pass
195
196 def __ne__(self, y): # real signature unknown; restored from __doc__
197 """ x.__ne__(y) <==> x!=y """
198 pass
199
200 def __or__(self, y): # real signature unknown; restored from __doc__
201 """ x.__or__(y) <==> x|y """
202 pass
203
204 def __rand__(self, y): # real signature unknown; restored from __doc__
205 """ x.__rand__(y) <==> y&x """
206 pass
207
208 def __reduce__(self, *args, **kwargs): # real signature unknown
209 """ Return state information for pickling. """
210 pass
211
212 def __repr__(self): # real signature unknown; restored from __doc__
213 """ x.__repr__() <==> repr(x) """
214 pass
215
216 def __ror__(self, y): # real signature unknown; restored from __doc__
217 """ x.__ror__(y) <==> y|x """
218 pass
219
220 def __rsub__(self, y): # real signature unknown; restored from __doc__
221 """ x.__rsub__(y) <==> y-x """
222 pass
223
224 def __rxor__(self, y): # real signature unknown; restored from __doc__
225 """ x.__rxor__(y) <==> y^x """
226 pass
227
228 def __sizeof__(self): # real signature unknown; restored from __doc__
229 """ S.__sizeof__() -> size of S in memory, in bytes """
230 pass
231
232 def __sub__(self, y): # real signature unknown; restored from __doc__
233 """ x.__sub__(y) <==> x-y """
234 pass
235
236 def __xor__(self, y): # real signature unknown; restored from __doc__
237 """ x.__xor__(y) <==> x^y """
238 pass
239
240 __hash__ = None
241
242 set
View Code
九、collection系列
1、计数器（counter）
Counter是对字典类型的补充，用于追踪值的出现次数。
ps：具备字典的所有功能 + 自己的功能
1 from collections import Counter
2 c = Counter('fsfafewfasdfsadasas')
2print(c)
3 输出：Counter({'s': 5, 'f': 5, 'a': 5, 'd': 2, 'e': 1, 'w': 1})
![]()
1 ########################################################################
2 ### Counter
3 ########################################################################
4
5 class Counter(dict):
6 '''Dict subclass for counting hashable items. Sometimes called a bag
7 or multiset. Elements are stored as dictionary keys and their counts
8 are stored as dictionary values.
9
10 >>> c = Counter('abcdeabcdabcaba') # count elements from a string
11
12 >>> c.most_common(3) # three most common elements
13 [('a', 5), ('b', 4), ('c', 3)]
14 >>> sorted(c) # list all unique elements
15 ['a', 'b', 'c', 'd', 'e']
16 >>> ''.join(sorted(c.elements())) # list elements with repetitions
17 'aaaaabbbbcccdde'
18 >>> sum(c.values()) # total of all counts
19
20 >>> c['a'] # count of letter 'a'
21 >>> for elem in 'shazam': # update counts from an iterable
22 ... c[elem] += 1 # by adding 1 to each element's count
23 >>> c['a'] # now there are seven 'a'
24 >>> del c['b'] # remove all 'b'
25 >>> c['b'] # now there are zero 'b'
26
27 >>> d = Counter('simsalabim') # make another counter
28 >>> c.update(d) # add in the second counter
29 >>> c['a'] # now there are nine 'a'
30
31 >>> c.clear() # empty the counter
32 >>> c
33 Counter()
34
35 Note: If a count is set to zero or reduced to zero, it will remain
36 in the counter until the entry is deleted or the counter is cleared:
37
38 >>> c = Counter('aaabbc')
39 >>> c['b'] -= 2 # reduce the count of 'b' by two
40 >>> c.most_common() # 'b' is still in, but its count is zero
41 [('a', 3), ('c', 1), ('b', 0)]
42
43 '''
44 # References:
45 # http://en.wikipedia.org/wiki/Multiset
46 # http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html
47 # http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm
48 # http://code.activestate.com/recipes/259174/
49 # Knuth, TAOCP Vol. II section 4.6.3
50
51 def __init__(self, iterable=None, **kwds):
52 '''Create a new, empty Counter object. And if given, count elements
53 from an input iterable. Or, initialize the count from another mapping
54 of elements to their counts.
55
56 >>> c = Counter() # a new, empty counter
57 >>> c = Counter('gallahad') # a new counter from an iterable
58 >>> c = Counter({'a': 4, 'b': 2}) # a new counter from a mapping
59 >>> c = Counter(a=4, b=2) # a new counter from keyword args
60
61 '''
62 super(Counter, self).__init__()
63 self.update(iterable, **kwds)
64
65 def __missing__(self, key):
66 """ 对于不存在的元素，返回计数器为0 """
67 'The count of elements not in the Counter is zero.'
68 # Needed so that self[missing_item] does not raise KeyError
69 return 0
70
71 def most_common(self, n=None):
72 """ 数量大于等n的所有元素和计数器 """
73 '''List the n most common elements and their counts from the most
74 common to the least. If n is None, then list all element counts.
75
76 >>> Counter('abcdeabcdabcaba').most_common(3)
77 [('a', 5), ('b', 4), ('c', 3)]
78
79 '''
80 # Emulate Bag.sortedByCount from Smalltalk
81 if n is None:
82 return sorted(self.iteritems(), key=_itemgetter(1), reverse=True)
83 return _heapq.nlargest(n, self.iteritems(), key=_itemgetter(1))
84
85 def elements(self):
86 """ 计数器中的所有元素，注：此处非所有元素集合，而是包含所有元素集合的迭代器 """
87 '''Iterator over elements repeating each as many times as its count.
88
89 >>> c = Counter('ABCABC')
90 >>> sorted(c.elements())
91 ['A', 'A', 'B', 'B', 'C', 'C']
92
93 # Knuth's example for prime factors of 1836: 2**2 * 3**3 * 17**1
94 >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
95 >>> product = 1
96 >>> for factor in prime_factors.elements(): # loop over factors
97 ... product *= factor # and multiply them
98 >>> product
99
100 Note, if an element's count has been set to zero or is a negative
101 number, elements() will ignore it.
102
103 '''
104 # Emulate Bag.do from Smalltalk and Multiset.begin from C++.
105 return _chain.from_iterable(_starmap(_repeat, self.iteritems()))
106
107 # Override dict methods where necessary
108
109 @classmethod
110 def fromkeys(cls, iterable, v=None):
111 # There is no equivalent method for counters because setting v=1
112 # means that no element can have a count greater than one.
113 raise NotImplementedError(
114 'Counter.fromkeys() is undefined. Use Counter(iterable) instead.')
115
116 def update(self, iterable=None, **kwds):
117 """ 更新计数器，其实就是增加；如果原来没有，则新建，如果有则加一 """
118 '''Like dict.update() but add counts instead of replacing them.
119
120 Source can be an iterable, a dictionary, or another Counter instance.
121
122 >>> c = Counter('which')
123 >>> c.update('witch') # add elements from another iterable
124 >>> d = Counter('watch')
125 >>> c.update(d) # add elements from another counter
126 >>> c['h'] # four 'h' in which, witch, and watch
127
128 '''
129 # The regular dict.update() operation makes no sense here because the
130 # replace behavior results in the some of original untouched counts
131 # being mixed-in with all of the other counts for a mismash that
132 # doesn't have a straight-forward interpretation in most counting
133 # contexts. Instead, we implement straight-addition. Both the inputs
134 # and outputs are allowed to contain zero and negative counts.
135
136 if iterable is not None:
137 if isinstance(iterable, Mapping):
138 if self:
139 self_get = self.get
140 for elem, count in iterable.iteritems():
141 self[elem] = self_get(elem, 0) + count
142 else:
143 super(Counter, self).update(iterable) # fast path when counter is empty
144 else:
145 self_get = self.get
146 for elem in iterable:
147 self[elem] = self_get(elem, 0) + 1
148 if kwds:
149 self.update(kwds)
150
151 def subtract(self, iterable=None, **kwds):
152 """ 相减，原来的计数器中的每一个元素的数量减去后添加的元素的数量 """
153 '''Like dict.update() but subtracts counts instead of replacing them.
154 Counts can be reduced below zero. Both the inputs and outputs are
155 allowed to contain zero and negative counts.
156
157 Source can be an iterable, a dictionary, or another Counter instance.
158
159 >>> c = Counter('which')
160 >>> c.subtract('witch') # subtract elements from another iterable
161 >>> c.subtract(Counter('watch')) # subtract elements from another counter
162 >>> c['h'] # 2 in which, minus 1 in witch, minus 1 in watch
163 >>> c['w'] # 1 in which, minus 1 in witch, minus 1 in watch
164 -1
165
166 '''
167 if iterable is not None:
168 self_get = self.get
169 if isinstance(iterable, Mapping):
170 for elem, count in iterable.items():
171 self[elem] = self_get(elem, 0) - count
172 else:
173 for elem in iterable:
174 self[elem] = self_get(elem, 0) - 1
175 if kwds:
176 self.subtract(kwds)
177
178 def copy(self):
179 """ 拷贝 """
180 'Return a shallow copy.'
181 return self.__class__(self)
182
183 def __reduce__(self):
184 """ 返回一个元组（类型，元组） """
185 return self.__class__, (dict(self),)
186
187 def __delitem__(self, elem):
188 """ 删除元素 """
189 'Like dict.__delitem__() but does not raise KeyError for missing values.'
190 if elem in self:
191 super(Counter, self).__delitem__(elem)
192
193 def __repr__(self):
194 if not self:
195 return '%s()' % self.__class__.__name__
196 items = ', '.join(map('%r: %r'.__mod__, self.most_common()))
197 return '%s({%s})' % (self.__class__.__name__, items)
198
199 # Multiset-style mathematical operations discussed in:
200 # Knuth TAOCP Volume II section 4.6.3 exercise 19
201 # and at http://en.wikipedia.org/wiki/Multiset
202 #
203 # Outputs guaranteed to only include positive counts.
204 #
205 # To strip negative and zero counts, add-in an empty counter:
206 # c += Counter()
207
208 def __add__(self, other):
209 '''Add counts from two counters.
210
211 >>> Counter('abbb') + Counter('bcc')
212 Counter({'b': 4, 'c': 2, 'a': 1})
213
214 '''
215 if not isinstance(other, Counter):
216 return NotImplemented
217 result = Counter()
218 for elem, count in self.items():
219 newcount = count + other[elem]
220 if newcount > 0:
221 result[elem] = newcount
222 for elem, count in other.items():
223 if elem not in self and count > 0:
224 result[elem] = count
225 return result
226
227 def __sub__(self, other):
228 ''' Subtract count, but keep only results with positive counts.
229
230 >>> Counter('abbbc') - Counter('bccd')
231 Counter({'b': 2, 'a': 1})
232
233 '''
234 if not isinstance(other, Counter):
235 return NotImplemented
236 result = Counter()
237 for elem, count in self.items():
238 newcount = count - other[elem]
239 if newcount > 0:
240 result[elem] = newcount
241 for elem, count in other.items():
242 if elem not in self and count < 0:
243 result[elem] = 0 - count
244 return result
245
246 def __or__(self, other):
247 '''Union is the maximum of value in either of the input counters.
248
249 >>> Counter('abbb') | Counter('bcc')
250 Counter({'b': 3, 'c': 2, 'a': 1})
251
252 '''
253 if not isinstance(other, Counter):
254 return NotImplemented
255 result = Counter()
256 for elem, count in self.items():
257 other_count = other[elem]
258 newcount = other_count if count < other_count else count
259 if newcount > 0:
260 result[elem] = newcount
261 for elem, count in other.items():
262 if elem not in self and count > 0:
263 result[elem] = count
264 return result
265
266 def __and__(self, other):
267 ''' Intersection is the minimum of corresponding counts.
268
269 >>> Counter('abbb') & Counter('bcc')
270 Counter({'b': 1})
271
272 '''
273 if not isinstance(other, Counter):
274 return NotImplemented
275 result = Counter()
276 for elem, count in self.items():
277 other_count = other[elem]
278 newcount = count if count < other_count else other_count
279 if newcount > 0:
280 result[elem] = newcount
281 return result
282
283 Counter
284
285 Counter
View Code
2、有序字典(orderedDict )
orderdDict是对字典类型的补充，他记住了字典元素添加的顺序
![]()
1 class OrderedDict(dict):
2 'Dictionary that remembers insertion order'
3 # An inherited dict maps keys to values.
4 # The inherited dict provides __getitem__, __len__, __contains__, and get.
5 # The remaining methods are order-aware.
6 # Big-O running times for all methods are the same as regular dictionaries.
7
8 # The internal self.__map dict maps keys to links in a doubly linked list.
9 # The circular doubly linked list starts and ends with a sentinel element.
10 # The sentinel element never gets deleted (this simplifies the algorithm).
11 # Each link is stored as a list of length three: [PREV, NEXT, KEY].
12
13 def __init__(self, *args, **kwds):
14 '''Initialize an ordered dictionary. The signature is the same as
15 regular dictionaries, but keyword arguments are not recommended because
16 their insertion order is arbitrary.
17
18 '''
19 if len(args) > 1:
20 raise TypeError('expected at most 1 arguments, got %d' % len(args))
21 try:
22 self.__root
23 except AttributeError:
24 self.__root = root = [] # sentinel node
25 root[:] = [root, root, None]
26 self.__map = {}
27 self.__update(*args, **kwds)
28
29 def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
30 'od.__setitem__(i, y) <==> od[i]=y'
31 # Setting a new item creates a new link at the end of the linked list,
32 # and the inherited dictionary is updated with the new key/value pair.
33 if key not in self:
34 root = self.__root
35 last = root[0]
36 last[1] = root[0] = self.__map[key] = [last, root, key]
37 return dict_setitem(self, key, value)
38
39 def __delitem__(self, key, dict_delitem=dict.__delitem__):
40 'od.__delitem__(y) <==> del od[y]'
41 # Deleting an existing item uses self.__map to find the link which gets
42 # removed by updating the links in the predecessor and successor nodes.
43 dict_delitem(self, key)
44 link_prev, link_next, _ = self.__map.pop(key)
45 link_prev[1] = link_next # update link_prev[NEXT]
46 link_next[0] = link_prev # update link_next[PREV]
47
48 def __iter__(self):
49 'od.__iter__() <==> iter(od)'
50 # Traverse the linked list in order.
51 root = self.__root
52 curr = root[1] # start at the first node
53 while curr is not root:
54 yield curr[2] # yield the curr[KEY]
55 curr = curr[1] # move to next node
56
57 def __reversed__(self):
58 'od.__reversed__() <==> reversed(od)'
59 # Traverse the linked list in reverse order.
60 root = self.__root
61 curr = root[0] # start at the last node
62 while curr is not root:
63 yield curr[2] # yield the curr[KEY]
64 curr = curr[0] # move to previous node
65
66 def clear(self):
67 'od.clear() -> None. Remove all items from od.'
68 root = self.__root
69 root[:] = [root, root, None]
70 self.__map.clear()
71 dict.clear(self)
72
73 # -- the following methods do not depend on the internal structure --
74
75 def keys(self):
76 'od.keys() -> list of keys in od'
77 return list(self)
78
79 def values(self):
80 'od.values() -> list of values in od'
81 return [self[key] for key in self]
82
83 def items(self):
84 'od.items() -> list of (key, value) pairs in od'
85 return [(key, self[key]) for key in self]
86
87 def iterkeys(self):
88 'od.iterkeys() -> an iterator over the keys in od'
89 return iter(self)
90
91 def itervalues(self):
92 'od.itervalues -> an iterator over the values in od'
93 for k in self:
94 yield self[k]
95
96 def iteritems(self):
97 'od.iteritems -> an iterator over the (key, value) pairs in od'
98 for k in self:
99 yield (k, self[k])
100
101 update = MutableMapping.update
102
103 __update = update # let subclasses override update without breaking __init__
104
105 __marker = object()
106
107 def pop(self, key, default=__marker):
108 '''od.pop(k[,d]) -> v, remove specified key and return the corresponding
109 value. If key is not found, d is returned if given, otherwise KeyError
110 is raised.
111
112 '''
113 if key in self:
114 result = self[key]
115 del self[key]
116 return result
117 if default is self.__marker:
118 raise KeyError(key)
119 return default
120
121 def setdefault(self, key, default=None):
122 'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
123 if key in self:
124 return self[key]
125 self[key] = default
126 return default
127
128 def popitem(self, last=True):
129 '''od.popitem() -> (k, v), return and remove a (key, value) pair.
130 Pairs are returned in LIFO order if last is true or FIFO order if false.
131
132 '''
133 if not self:
134 raise KeyError('dictionary is empty')
135 key = next(reversed(self) if last else iter(self))
136 value = self.pop(key)
137 return key, value
138
139 def __repr__(self, _repr_running={}):
140 'od.__repr__() <==> repr(od)'
141 call_key = id(self), _get_ident()
142 if call_key in _repr_running:
143 return '...'
144 _repr_running[call_key] = 1
145 try:
146 if not self:
147 return '%s()' % (self.__class__.__name__,)
148 return '%s(%r)' % (self.__class__.__name__, self.items())
149 finally:
150 del _repr_running[call_key]
151
152 def __reduce__(self):
153 'Return state information for pickling'
154 items = [[k, self[k]] for k in self]
155 inst_dict = vars(self).copy()
156 for k in vars(OrderedDict()):
157 inst_dict.pop(k, None)
158 if inst_dict:
159 return (self.__class__, (items,), inst_dict)
160 return self.__class__, (items,)
161
162 def copy(self):
163 'od.copy() -> a shallow copy of od'
164 return self.__class__(self)
165
166 @classmethod
167 def fromkeys(cls, iterable, value=None):
168 '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
169 If not specified, the value defaults to None.
170
171 '''
172 self = cls()
173 for key in iterable:
174 self[key] = value
175 return self
176
177 def __eq__(self, other):
178 '''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive
179 while comparison to a regular mapping is order-insensitive.
180
181 '''
182 if isinstance(other, OrderedDict):
183 return dict.__eq__(self, other) and all(_imap(_eq, self, other))
184 return dict.__eq__(self, other)
185
186 def __ne__(self, other):
187 'od.__ne__(y) <==> od!=y'
188 return not self == other
189
190 # -- the following methods support python 3.x style dictionary views --
191
192 def viewkeys(self):
193 "od.viewkeys() -> a set-like object providing a view on od's keys"
194 return KeysView(self)
195
196 def viewvalues(self):
197 "od.viewvalues() -> an object providing a view on od's values"
198 return ValuesView(self)
199
200 def viewitems(self):
201 "od.viewitems() -> a set-like object providing a view on od's items"
202 return ItemsView(self)
203
204 OrderedDict
View Code
3、默认字典(defaultdict)
学前需求：
1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
2 即： {'k1': 大于66 , 'k2': 小于66}
![]()
1 values = [11, 22, 33,44,55,66,77,88,99,90]
2
3 my_dict = {}
4
5 for value in values:
6 if value>66:
7 if my_dict.has_key('k1'):
8 my_dict['k1'].append(value)
9 else:
10 my_dict['k1'] = [value]
11 else:
12 if my_dict.has_key('k2'):
13 my_dict['k2'].append(value)
14 else:
15 my_dict['k2'] = [value]
16
17 原生字典解决方法
View Code
![]()
1 from collections import defaultdict
2
3 values = [11, 22, 33,44,55,66,77,88,99,90]
4
5 my_dict = defaultdict(list)
6
7 for value in values:
8 if value>66:
9 my_dict['k1'].append(value)
10 else:
11 my_dict['k2'].append(value)
12
13 defaultdict字典解决方法
View Code
defaultdict是对字典的类型的补充，他默认给字典的值设置了一个类型。
![]()
1 class defaultdict(dict):
2 """
3 defaultdict(default_factory[, ...]) --> dict with default factory
4
5 The default factory is called without arguments to produce
6 a new value when a key is not present, in __getitem__ only.
7 A defaultdict compares equal to a dict with the same items.
8 All remaining arguments are treated the same as if they were
9 passed to the dict constructor, including keyword arguments.
10 """
11 def copy(self): # real signature unknown; restored from __doc__
12 """ D.copy() -> a shallow copy of D. """
13 pass
14
15 def __copy__(self, *args, **kwargs): # real signature unknown
16 """ D.copy() -> a shallow copy of D. """
17 pass
18
19 def __getattribute__(self, name): # real signature unknown; restored from __doc__
20 """ x.__getattribute__('name') <==> x.name """
21 pass
22
23 def __init__(self, default_factory=None, **kwargs): # known case of _collections.defaultdict.__init__
24 """
25 defaultdict(default_factory[, ...]) --> dict with default factory
26
27 The default factory is called without arguments to produce
28 a new value when a key is not present, in __getitem__ only.
29 A defaultdict compares equal to a dict with the same items.
30 All remaining arguments are treated the same as if they were
31 passed to the dict constructor, including keyword arguments.
32
33 # (copied from class doc)
34 """
35 pass
36
37 def __missing__(self, key): # real signature unknown; restored from __doc__
38 """
39 __missing__(key) # Called by __getitem__ for missing key; pseudo-code:
40 if self.default_factory is None: raise KeyError((key,))
41 self[key] = value = self.default_factory()
42 return value
43 """
44 pass
45
46 def __reduce__(self, *args, **kwargs): # real signature unknown
47 """ Return state information for pickling. """
48 pass
49
50 def __repr__(self): # real signature unknown; restored from __doc__
51 """ x.__repr__() <==> repr(x) """
52 pass
53
54 default_factory = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
55 """Factory for default value called by __missing__()."""
56
57 defaultdict
View Code
4、可命名元组(namedtuple)
根据nametuple可以创建一个包含tuple所有功能以及其他功能的类型。
1 import collections
2
3 Mytuple = collections.namedtuple('Mytuple',['x', 'y', 'z'])
![]()
1 class Mytuple(__builtin__.tuple)
2 | Mytuple(x, y)
3 |
4 | Method resolution order:
5 | Mytuple
6 | __builtin__.tuple
7 | __builtin__.object
8 |
9 | Methods defined here:
10 |
11 | __getnewargs__(self)
12 | Return self as a plain tuple. Used by copy and pickle.
13 |
14 | __getstate__(self)
15 | Exclude the OrderedDict from pickling
16 |
17 | __repr__(self)
18 | Return a nicely formatted representation string
19 |
20 | _asdict(self)
21 | Return a new OrderedDict which maps field names to their values
22 |
23 | _replace(_self, **kwds)
24 | Return a new Mytuple object replacing specified fields with new values
25 |
26 | ----------------------------------------------------------------------
27 | Class methods defined here:
28 |
29 | _make(cls, iterable, new=<built-in method __new__ of type object>, len=<built-in function len>) from __builtin__.type
30 | Make a new Mytuple object from a sequence or iterable
31 |
32 | ----------------------------------------------------------------------
33 | Static methods defined here:
34 |
35 | __new__(_cls, x, y)
36 | Create new instance of Mytuple(x, y)
37 |
38 | ----------------------------------------------------------------------
39 | Data descriptors defined here:
40 |
41 | __dict__
42 | Return a new OrderedDict which maps field names to their values
43 |
44 | x
45 | Alias for field number 0
46 |
47 | y
48 | Alias for field number 1
49 |
50 | ----------------------------------------------------------------------
51 | Data and other attributes defined here:
52 |
53 | _fields = ('x', 'y')
54 |
55 | ----------------------------------------------------------------------
56 | Methods inherited from __builtin__.tuple:
57 |
58 | __add__(...)
59 | x.__add__(y) <==> x+y
60 |
61 | __contains__(...)
62 | x.__contains__(y) <==> y in x
63 |
64 | __eq__(...)
65 | x.__eq__(y) <==> x==y
66 |
67 | __ge__(...)
68 | x.__ge__(y) <==> x>=y
69 |
70 | __getattribute__(...)
71 | x.__getattribute__('name') <==> x.name
72 |
73 | __getitem__(...)
74 | x.__getitem__(y) <==> x[y]
75 |
76 | __getslice__(...)
77 | x.__getslice__(i, j) <==> x[i:j]
78 |
79 | Use of negative indices is not supported.
80 |
81 | __gt__(...)
82 | x.__gt__(y) <==> x>y
83 |
84 | __hash__(...)
85 | x.__hash__() <==> hash(x)
86 |
87 | __iter__(...)
88 | x.__iter__() <==> iter(x)
89 |
90 | __le__(...)
91 | x.__le__(y) <==> x<=y
92 |
93 | __len__(...)
94 | x.__len__() <==> len(x)
95 |
96 | __lt__(...)
97 | x.__lt__(y) <==> x<y
98 |
99 | __mul__(...)
100 | x.__mul__(n) <==> x*n
101 |
102 | __ne__(...)
103 | x.__ne__(y) <==> x!=y
104 |
105 | __rmul__(...)
106 | x.__rmul__(n) <==> n*x
107 |
108 | __sizeof__(...)
109 | T.__sizeof__() -- size of T in memory, in bytes
110 |
111 | count(...)
112 | T.count(value) -> integer -- return number of occurrences of value
113 |
114 | index(...)
115 | T.index(value, [start, [stop]]) -> integer -- return first index of value.
116 | Raises ValueError if the value is not present.
117
118 Mytuple
119
120 Mytuple
View Code
5、双向队列(deque)
一个线程安全的双向队列
![]()
1 class deque(object):
2 """
3 deque([iterable[, maxlen]]) --> deque object
4
5 Build an ordered collection with optimized access from its endpoints.
6 """
7 def append(self, *args, **kwargs): # real signature unknown
8 """ Add an element to the right side of the deque. """
9 pass
10
11 def appendleft(self, *args, **kwargs): # real signature unknown
12 """ Add an element to the left side of the deque. """
13 pass
14
15 def clear(self, *args, **kwargs): # real signature unknown
16 """ Remove all elements from the deque. """
17 pass
18
19 def count(self, value): # real signature unknown; restored from __doc__
20 """ D.count(value) -> integer -- return number of occurrences of value """
21 return 0
22
23 def extend(self, *args, **kwargs): # real signature unknown
24 """ Extend the right side of the deque with elements from the iterable """
25 pass
26
27 def extendleft(self, *args, **kwargs): # real signature unknown
28 """ Extend the left side of the deque with elements from the iterable """
29 pass
30
31 def pop(self, *args, **kwargs): # real signature unknown
32 """ Remove and return the rightmost element. """
33 pass
34
35 def popleft(self, *args, **kwargs): # real signature unknown
36 """ Remove and return the leftmost element. """
37 pass
38
39 def remove(self, value): # real signature unknown; restored from __doc__
40 """ D.remove(value) -- remove first occurrence of value. """
41 pass
42
43 def reverse(self): # real signature unknown; restored from __doc__
44 """ D.reverse() -- reverse *IN PLACE* """
45 pass
46
47 def rotate(self, *args, **kwargs): # real signature unknown
48 """ Rotate the deque n steps to the right (default n=1). If n is negative, rotates left. """
49 pass
50
51 def __copy__(self, *args, **kwargs): # real signature unknown
52 """ Return a shallow copy of a deque. """
53 pass
54
55 def __delitem__(self, y): # real signature unknown; restored from __doc__
56 """ x.__delitem__(y) <==> del x[y] """
57 pass
58
59 def __eq__(self, y): # real signature unknown; restored from __doc__
60 """ x.__eq__(y) <==> x==y """
61 pass
62
63 def __getattribute__(self, name): # real signature unknown; restored from __doc__
64 """ x.__getattribute__('name') <==> x.name """
65 pass
66
67 def __getitem__(self, y): # real signature unknown; restored from __doc__
68 """ x.__getitem__(y) <==> x[y] """
69 pass
70
71 def __ge__(self, y): # real signature unknown; restored from __doc__
72 """ x.__ge__(y) <==> x>=y """
73 pass
74
75 def __gt__(self, y): # real signature unknown; restored from __doc__
76 """ x.__gt__(y) <==> x>y """
77 pass
78
79 def __iadd__(self, y): # real signature unknown; restored from __doc__
80 """ x.__iadd__(y) <==> x+=y """
81 pass
82
83 def __init__(self, iterable=(), maxlen=None): # known case of _collections.deque.__init__
84 """
85 deque([iterable[, maxlen]]) --> deque object
86
87 Build an ordered collection with optimized access from its endpoints.
88 # (copied from class doc)
89 """
90 pass
91
92 def __iter__(self): # real signature unknown; restored from __doc__
93 """ x.__iter__() <==> iter(x) """
94 pass
95
96 def __len__(self): # real signature unknown; restored from __doc__
97 """ x.__len__() <==> len(x) """
98 pass
99
100 def __le__(self, y): # real signature unknown; restored from __doc__
101 """ x.__le__(y) <==> x<=y """
102 pass
103
104 def __lt__(self, y): # real signature unknown; restored from __doc__
105 """ x.__lt__(y) <==> x<y """
106 pass
107
108 @staticmethod # known case of __new__
109 def __new__(S, *more): # real signature unknown; restored from __doc__
110 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
111 pass
112
113 def __ne__(self, y): # real signature unknown; restored from __doc__
114 """ x.__ne__(y) <==> x!=y """
115 pass
116
117 def __reduce__(self, *args, **kwargs): # real signature unknown
118 """ Return state information for pickling. """
119 pass
120
121 def __repr__(self): # real signature unknown; restored from __doc__
122 """ x.__repr__() <==> repr(x) """
123 pass
124
125 def __reversed__(self): # real signature unknown; restored from __doc__
126 """ D.__reversed__() -- return a reverse iterator over the deque """
127 pass
128
129 def __setitem__(self, i, y): # real signature unknown; restored from __doc__
130 """ x.__setitem__(i, y) <==> x[i]=y """
131 pass
132
133 def __sizeof__(self): # real signature unknown; restored from __doc__
134 """ D.__sizeof__() -- size of D in memory, in bytes """
135 pass
136
137 maxlen = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
138 """maximum size of a deque or None if unbounded"""
139
140
141 __hash__ = None
142
143 deque
View Code
注：既然有双向队列，也有单项队列（先进先出 FIFO ）
![]()
1 class Queue:
2 """Create a queue object with a given maximum size.
3
4 If maxsize is <= 0, the queue size is infinite.
5 """
6 def __init__(self, maxsize=0):
7 self.maxsize = maxsize
8 self._init(maxsize)
9 # mutex must be held whenever the queue is mutating. All methods
10 # that acquire mutex must release it before returning. mutex
11 # is shared between the three conditions, so acquiring and
12 # releasing the conditions also acquires and releases mutex.
13 self.mutex = _threading.Lock()
14 # Notify not_empty whenever an item is added to the queue; a
15 # thread waiting to get is notified then.
16 self.not_empty = _threading.Condition(self.mutex)
17 # Notify not_full whenever an item is removed from the queue;
18 # a thread waiting to put is notified then.
19 self.not_full = _threading.Condition(self.mutex)
20 # Notify all_tasks_done whenever the number of unfinished tasks
21 # drops to zero; thread waiting to join() is notified to resume
22 self.all_tasks_done = _threading.Condition(self.mutex)
23 self.unfinished_tasks = 0
24
25 def task_done(self):
26 """Indicate that a formerly enqueued task is complete.
27
28 Used by Queue consumer threads. For each get() used to fetch a task,
29 a subsequent call to task_done() tells the queue that the processing
30 on the task is complete.
31
32 If a join() is currently blocking, it will resume when all items
33 have been processed (meaning that a task_done() call was received
34 for every item that had been put() into the queue).
35
36 Raises a ValueError if called more times than there were items
37 placed in the queue.
38 """
39 self.all_tasks_done.acquire()
40 try:
41 unfinished = self.unfinished_tasks - 1
42 if unfinished <= 0:
43 if unfinished < 0:
44 raise ValueError('task_done() called too many times')
45 self.all_tasks_done.notify_all()
46 self.unfinished_tasks = unfinished
47 finally:
48 self.all_tasks_done.release()
49
50 def join(self):
51 """Blocks until all items in the Queue have been gotten and processed.
52
53 The count of unfinished tasks goes up whenever an item is added to the
54 queue. The count goes down whenever a consumer thread calls task_done()
55 to indicate the item was retrieved and all work on it is complete.
56
57 When the count of unfinished tasks drops to zero, join() unblocks.
58 """
59 self.all_tasks_done.acquire()
60 try:
61 while self.unfinished_tasks:
62 self.all_tasks_done.wait()
63 finally:
64 self.all_tasks_done.release()
65
66 def qsize(self):
67 """Return the approximate size of the queue (not reliable!)."""
68 self.mutex.acquire()
69 n = self._qsize()
70 self.mutex.release()
71 return n
72
73 def empty(self):
74 """Return True if the queue is empty, False otherwise (not reliable!)."""
75 self.mutex.acquire()
76 n = not self._qsize()
77 self.mutex.release()
78 return n
79
80 def full(self):
81 """Return True if the queue is full, False otherwise (not reliable!)."""
82 self.mutex.acquire()
83 n = 0 < self.maxsize == self._qsize()
84 self.mutex.release()
85 return n
86
87 def put(self, item, block=True, timeout=None):
88 """Put an item into the queue.
89
90 If optional args 'block' is true and 'timeout' is None (the default),
91 block if necessary until a free slot is available. If 'timeout' is
92 a non-negative number, it blocks at most 'timeout' seconds and raises
93 the Full exception if no free slot was available within that time.
94 Otherwise ('block' is false), put an item on the queue if a free slot
95 is immediately available, else raise the Full exception ('timeout'
96 is ignored in that case).
97 """
98 self.not_full.acquire()
99 try:
100 if self.maxsize > 0:
101 if not block:
102 if self._qsize() == self.maxsize:
103 raise Full
104 elif timeout is None:
105 while self._qsize() == self.maxsize:
106 self.not_full.wait()
107 elif timeout < 0:
108 raise ValueError("'timeout' must be a non-negative number")
109 else:
110 endtime = _time() + timeout
111 while self._qsize() == self.maxsize:
112 remaining = endtime - _time()
113 if remaining <= 0.0:
114 raise Full
115 self.not_full.wait(remaining)
116 self._put(item)
117 self.unfinished_tasks += 1
118 self.not_empty.notify()
119 finally:
120 self.not_full.release()
121
122 def put_nowait(self, item):
123 """Put an item into the queue without blocking.
124
125 Only enqueue the item if a free slot is immediately available.
126 Otherwise raise the Full exception.
127 """
128 return self.put(item, False)
129
130 def get(self, block=True, timeout=None):
131 """Remove and return an item from the queue.
132
133 If optional args 'block' is true and 'timeout' is None (the default),
134 block if necessary until an item is available. If 'timeout' is
135 a non-negative number, it blocks at most 'timeout' seconds and raises
136 the Empty exception if no item was available within that time.
137 Otherwise ('block' is false), return an item if one is immediately
138 available, else raise the Empty exception ('timeout' is ignored
139 in that case).
140 """
141 self.not_empty.acquire()
142 try:
143 if not block:
144 if not self._qsize():
145 raise Empty
146 elif timeout is None:
147 while not self._qsize():
148 self.not_empty.wait()
149 elif timeout < 0:
150 raise ValueError("'timeout' must be a non-negative number")
151 else:
152 endtime = _time() + timeout
153 while not self._qsize():
154 remaining = endtime - _time()
155 if remaining <= 0.0:
156 raise Empty
157 self.not_empty.wait(remaining)
158 item = self._get()
159 self.not_full.notify()
160 return item
161 finally:
162 self.not_empty.release()
163
164 def get_nowait(self):
165 """Remove and return an item from the queue without blocking.
166
167 Only get an item if one is immediately available. Otherwise
168 raise the Empty exception.
169 """
170 return self.get(False)
171
172 # Override these methods to implement other queue organizations
173 # (e.g. stack or priority queue).
174 # These will only be called with appropriate locks held
175
176 # Initialize the queue representation
177 def _init(self, maxsize):
178 self.queue = deque()
179
180 def _qsize(self, len=len):
181 return len(self.queue)
182
183 # Put a new item in the queue
184 def _put(self, item):
185 self.queue.append(item)
186
187 # Get an item from the queue
188 def _get(self):
189 return self.queue.popleft()
190
191 Queue.Queue
View Code
迭代器和生成器
一、迭代器
对于Python 列表的 for 循环，他的内部原理：查看下一个元素是否存在，如果存在，则取出，如果不存在，则报异常 StopIteration。（python内部对异常已处理）
![]()
1 class listiterator(object)
2 | Methods defined here:
3 |
4 | __getattribute__(...)
5 | x.__getattribute__('name') <==> x.name
6 |
7 | __iter__(...)
8 | x.__iter__() <==> iter(x)
9 |
10 | __length_hint__(...)
11 | Private method returning an estimate of len(list(it)).
12 |
13 | next(...)
14 | x.next() -> the next value, or raise StopIteration
15
16 listiterator
View Code
二、生成器
range不是生成器 和 xrange 是生成器
readlines不是生成器 和 xreadlines 是生成器
1 >>> print range(10)
2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
3 >>> print xrange(10)
4 xrange(10)
生成器内部基于yield创建，即：对于生成器只有使用时才创建，从而不避免内存浪费
1 练习：<br>有如下列表：
2 [13, 22, 6, 99, 11]
3
4 请按照一下规则计算：
5 13 和 22 比较，将大的值放在右侧，即：[13, 22, 6, 99, 11]
6 22 和 6 比较，将大的值放在右侧，即：[13, 6, 22, 99, 11]
7 22 和 99 比较，将大的值放在右侧，即：[13, 6, 22, 99, 11]
8 99 和 42 比较，将大的值放在右侧，即：[13, 6, 22, 11, 99,]
9
10 13 和 6 比较，将大的值放在右侧，即：[6, 13, 22, 11, 99,]
11 ...
![]()
1 li = [13, 22, 6, 99, 11]
2
3 for m in range(len(li)-1):
4
5 for n in range(m+1, len(li)):
6 if li[m]> li[n]:
7 temp = li[n]
8 li[n] = li[m]
9 li[m] = temp
10
11 print li
12
13 Demo
View Code
深浅拷贝
为什么要拷贝？
1 当进行修改时，想要保留原来的数据和修改后的数据
数字字符串 和 集合 在修改时的差异？ （深浅拷贝不同的终极原因）
1 在修改数据时：
2 数字字符串：在内存中新建一份数据
3 集合：修改内存中的同一份数据
对于集合，如何保留其修改前和修改后的数据？
对于集合，如何拷贝其n层元素同时拷贝？
![]()
1 class Queue: """Create a queue object with a given maximum size.
2 If maxsize is <= 0, the queue size is infinite. """ def __init__(self, maxsize=0): self.maxsize = maxsize self._init(maxsize) # mutex must be held whenever the queue is mutating. All methods # that acquire mutex must release it before returning. mutex # is shared between the three conditions, so acquiring and # releasing the conditions also acquires and releases mutex. self.mutex = _threading.Lock() # Notify not_empty whenever an item is added to the queue; a # thread waiting to get is notified then. self.not_empty = _threading.Condition(self.mutex) # Notify not_full whenever an item is removed from the queue; # a thread waiting to put is notified then. self.not_full = _threading.Condition(self.mutex) # Notify all_tasks_done whenever the number of unfinished tasks # drops to zero; thread waiting to join() is notified to resume self.all_tasks_done = _threading.Condition(self.mutex) self.unfinished_tasks = 0
3 def task_done(self): """Indicate that a formerly enqueued task is complete.
4 Used by Queue consumer threads. For each get() used to fetch a task, a subsequent call to task_done() tells the queue that the processing on the task is complete.
5 If a join() is currently blocking, it will resume when all items have been processed (meaning that a task_done() call was received for every item that had been put() into the queue).
6 Raises a ValueError if called more times than there were items placed in the queue. """ self.all_tasks_done.acquire() try: unfinished = self.unfinished_tasks - 1 if unfinished <= 0: if unfinished < 0: raise ValueError('task_done() called too many times') self.all_tasks_done.notify_all() self.unfinished_tasks = unfinished finally: self.all_tasks_done.release()
7 def join(self): """Blocks until all items in the Queue have been gotten and processed.
8 The count of unfinished tasks goes up whenever an item is added to the queue. The count goes down whenever a consumer thread calls task_done() to indicate the item was retrieved and all work on it is complete.
9 When the count of unfinished tasks drops to zero, join() unblocks. """ self.all_tasks_done.acquire() try: while self.unfinished_tasks: self.all_tasks_done.wait() finally: self.all_tasks_done.release()
10 def qsize(self): """Return the approximate size of the queue (not reliable!).""" self.mutex.acquire() n = self._qsize() self.mutex.release() return n
11 def empty(self): """Return True if the queue is empty, False otherwise (not reliable!).""" self.mutex.acquire() n = not self._qsize() self.mutex.release() return n
12 def full(self): """Return True if the queue is full, False otherwise (not reliable!).""" self.mutex.acquire() n = 0 < self.maxsize == self._qsize() self.mutex.release() return n
13 def put(self, item, block=True, timeout=None): """Put an item into the queue.
14 If optional args 'block' is true and 'timeout' is None (the default), block if necessary until a free slot is available. If 'timeout' is a non-negative number, it blocks at most 'timeout' seconds and raises the Full exception if no free slot was available within that time. Otherwise ('block' is false), put an item on the queue if a free slot is immediately available, else raise the Full exception ('timeout' is ignored in that case). """ self.not_full.acquire() try: if self.maxsize > 0: if not block: if self._qsize() == self.maxsize: raise Full elif timeout is None: while self._qsize() == self.maxsize: self.not_full.wait() elif timeout < 0: raise ValueError("'timeout' must be a non-negative number") else: endtime = _time() + timeout while self._qsize() == self.maxsize: remaining = endtime - _time() if remaining <= 0.0: raise Full self.not_full.wait(remaining) self._put(item) self.unfinished_tasks += 1 self.not_empty.notify() finally: self.not_full.release()
15 def put_nowait(self, item): """Put an item into the queue without blocking.
16 Only enqueue the item if a free slot is immediately available. Otherwise raise the Full exception. """ return self.put(item, False)
17 def get(self, block=True, timeout=None): """Remove and return an item from the queue.
18 If optional args 'block' is true and 'timeout' is None (the default), block if necessary until an item is available. If 'timeout' is a non-negative number, it blocks at most 'timeout' seconds and raises the Empty exception if no item was available within that time. Otherwise ('block' is false), return an item if one is immediately available, else raise the Empty exception ('timeout' is ignored in that case). """ self.not_empty.acquire() try: if not block: if not self._qsize(): raise Empty elif timeout is None: while not self._qsize(): self.not_empty.wait() elif timeout < 0: raise ValueError("'timeout' must be a non-negative number") else: endtime = _time() + timeout while not self._qsize(): remaining = endtime - _time() if remaining <= 0.0: raise Empty self.not_empty.wait(remaining) item = self._get() self.not_full.notify() return item finally: self.not_empty.release()
19 def get_nowait(self): """Remove and return an item from the queue without blocking.
20 Only get an item if one is immediately available. Otherwise raise the Empty exception. """ return self.get(False)
21 # Override these methods to implement other queue organizations # (e.g. stack or priority queue). # These will only be called with appropriate locks held
22 # Initialize the queue representation def _init(self, maxsize): self.queue = deque()
23 def _qsize(self, len=len): return len(self.queue)
24 # Put a new item in the queue def _put(self, item): self.queue.append(item)
25 # Get an item from the queue def _get(self): return self.queue.popleft()
26 Queue.Queue
View Code
