python学习第二天笔记
基本数据类型
一切事物都是对象,对象基于类创建
注:查看对象相关成员 var,type,dir
一、整数
如: 18、20、60
每一个整数都具备如下功能:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
class int(object): """ int([x]) -> integer int(x, base=10) -> integer Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero. If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal. >>> int('0b100', base=0) 4 """ def as_integer_ratio(self): # real signature unknown; restored from __doc__ """ Return integer ratio. Return a pair of integers, whose ratio is exactly equal to the original int and with a positive denominator. >>> (10).as_integer_ratio() (10, 1) >>> (-10).as_integer_ratio() (-10, 1) >>> (0).as_integer_ratio() (0, 1) """ pass def bit_length(self): # real signature unknown; restored from __doc__ """ 返回表示该数字的时占用的最少位数 """ """ Number of bits necessary to represent self in binary. >>> bin(37) '0b100101' >>> (37).bit_length() 6 """ pass def __abs__(self): # real signature unknown; restored from __doc__ """ 返回表示该数字的绝对值 """ """ abs(self) """ """ x.__abs__() <==> abs(x) """ """ >>> age = 18 >>> age.__abs__() 18 >>> b = abs(age) >>> print(b) 18 >>> age = -18 >>> age -18 >>> age.__abs__() 18 >>> b = abs(age) >>> print(b) 18 """ pass def __divmod__(self, y): # real signature unknown; restored from __doc__ """ Return divmod(self, value). """ """ 相除,得到商和余数组成的元组 """ """ x.__divmod__(y) <==> divmod(x, y) """ """ >>> all_item = 95 >>> pager = 10 >>> result = all_item.__divmod__(10) >>> print(result) (9, 5) >>> print(divmod(95,10)) (9, 5) """ pass def __float__(self): # real signature unknown; restored from __doc__ """ float(self) """ """ 转换为浮点类型 """ """ x.__float__() <==> float(x) """ """ >>> age = 18 >>> print(type(age)) <type 'int'> >>> result = age.__float__() >>> print(type(result)) <type 'float'> """ pass def __add__(self, y): """ x.__add__(y) <==> x+y """ """ >>> age = 18 >>> result = age.__add__(7) >>> print(result) 25 >>> b = 18 + 7 >>> print(b) 25 """ pass def __floordiv__(self, y): # real signature unknown; restored from __doc__ """ x.__floordiv__(y) <==> x//y """ """ >>> age = 18 >>> result = age.__floordiv__(5) >>> print(result) 3 >>> b = 18//5 >>> print(b) 3 """ pass
二、长整型
可能如:2147483649、9223372036854775807
每个长整型都具备如下功能:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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
三、浮点型
如:3.14、2.88
每个浮点型都具备如下功能:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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
四、字符串
如:'dengli、'alex'
每个字符串都具备如下功能:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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 """ 17 >>> name = 'eric' 18 >>> result = name.capitalize() 19 >>> print(result) 20 Eric 21 """ 22 return "" 23 24 def center(self, width, fillchar=None): 25 """ 内容居中,width:总长度;fillchar:空白处填充内容,默认无 """ 26 """ 27 S.center(width[, fillchar]) -> string 28 29 Return S centered in a string of length width. Padding is 30 done using the specified fill character (default is a space) 31 """ 32 """ 33 >>> name = 'eric' 34 >>> result = name.center(20) 35 >>> print(result) 36 eric 37 >>> name = 'eric' 38 >>> result = name.center(20,'*') 39 >>> print(result) 40 ********eric******** 41 """ 42 return "" 43 44 def count(self, sub, start=None, end=None): 45 """ 子序列个数 """ 46 """ 47 S.count(sub[, start[, end]]) -> int 48 49 Return the number of non-overlapping occurrences of substring sub in 50 string S[start:end]. Optional arguments start and end are interpreted 51 as in slice notation. 52 """ 53 """ 54 >>> name = 'dafasfalffauroedccmsadudmc' 55 >>> result = name.count('a') 56 >>> print(result) 57 5 58 >>> name = 'dafasfalfjjfauroedccmsadudmc' 59 >>> result = name.count('fa',0,10) 60 >>> print(result) 61 2 62 """ 63 return 0 64 65 def decode(self, encoding=None, errors=None): 66 """ 解码 """ 67 """ 68 S.decode([encoding[,errors]]) -> object 69 70 Decodes S using the codec registered for encoding. encoding defaults 71 to the default encoding. errors may be given to set a different error 72 handling scheme. Default is 'strict' meaning that encoding errors raise 73 a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' 74 as well as any other name registered with codecs.register_error that is 75 able to handle UnicodeDecodeErrors. 76 """ 77 """ 78 >>> name = '李杰' 79 >>> result = name.encode('gbk') 80 >>> print(result) 81 b'\xc0\xee\xbd\xdc' 82 """ 83 return object() 84 85 def encode(self, encoding=None, errors=None): 86 """ 编码,针对unicode """ 87 """ 88 S.encode([encoding[,errors]]) -> object 89 90 Encodes S using the codec registered for encoding. encoding defaults 91 to the default encoding. errors may be given to set a different error 92 handling scheme. Default is 'strict' meaning that encoding errors raise 93 a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and 94 'xmlcharrefreplace' as well as any other name registered with 95 codecs.register_error that is able to handle UnicodeEncodeErrors. 96 """ 97 return object() 98 99 def endswith(self, suffix, start=None, end=None): 100 """ 是否以 xxx 结束 """ 101 """ 102 S.endswith(suffix[, start[, end]]) -> bool 103 104 Return True if S ends with the specified suffix, False otherwise. 105 With optional start, test S beginning at that position. 106 With optional end, stop comparing S at that position. 107 suffix can also be a tuple of strings to try. 108 """ 109 """ 110 >>> name = 'alex' 111 >>> result = name.endswith('x') 112 >>> print(result) 113 True 114 115 >>> name = 'alex' 116 >>> result = name.endswith('e',0,3) 117 >>> print(result) 118 True 119 """ 120 121 return False 122 123 def expandtabs(self, tabsize=None): 124 """ 将tab转换成空格,默认一个tab转换成8个空格 """ 125 """ 126 S.expandtabs([tabsize]) -> string 127 128 Return a copy of S where all tab characters are expanded using spaces. 129 If tabsize is not given, a tab size of 8 characters is assumed. 130 """ 131 """ 132 >>> name = 'a\tlex' 133 >>> result = name.expandtabs() 134 >>> print(result) 135 a lex 136 """ 137 return "" 138 139 def find(self, sub, start=None, end=None): 140 """ 寻找子序列位置,如果没找到,返回 -1 """ 141 """ 142 S.find(sub [,start [,end]]) -> int 143 144 Return the lowest index in S where substring sub is found, 145 such that sub is contained within S[start:end]. Optional 146 arguments start and end are interpreted as in slice notation. 147 148 Return -1 on failure. 149 """ 150 """ 151 >>> name = 'alex' 152 >>> result = name.find('x') 153 >>> print(result) 154 3 155 """ 156 157 return 0 158 159 def format(*args, **kwargs): # known special case of str.format 160 """ 字符串格式化,动态参数,将函数式编程时细说 """ 161 """ 162 S.format(*args, **kwargs) -> string 163 164 Return a formatted version of S, using substitutions from args and kwargs. 165 The substitutions are identified by braces ('{' and '}'). 166 """ 167 """ 168 >>> name = 'alex{0}' 169 >>> result = name.format(' sb') 170 >>> print(result) 171 alex sb 172 >>> name = 'alex{0} as {1}' 173 >>> result = name.format(' sb','eric') 174 >>> print(result) 175 alex sb as eric 176 >>> name = 'alex{name} as {id}' 177 >>> result = name.format(name=' sb',id='eric') 178 >>> print(result) 179 alex sb as eric 180 >>> name = 'alex' 181 >>> result = name.index('a') 182 >>> print(result) 183 0 184 """ 185 pass 186 187 def index(self, sub, start=None, end=None): 188 """ 子序列位置,如果没找到,报错 """ 189 S.index(sub [,start [,end]]) -> int 190 191 Like S.find() but raise ValueError when the substring is not found. 192 """ 193 """ 194 >>> name = 'alex' 195 >>> result = name.index('a') 196 >>> print(result) 197 0 198 """ 199 return 0 200 """find和index都是找子序列的索引,find没有找到会输出-1,index会报错""" 201 202 def isalnum(self): 203 """ 是否是字母和数字 """ 204 """ 205 S.isalnum() -> bool 206 207 Return True if all characters in S are alphanumeric 208 and there is at least one character in S, False otherwise. 209 """ 210 return False 211 212 def isalpha(self): 213 """ 是否是字母 """ 214 """ 215 S.isalpha() -> bool 216 217 Return True if all characters in S are alphabetic 218 and there is at least one character in S, False otherwise. 219 """ 220 return False 221 222 def isdigit(self): 223 """ 是否是数字 """ 224 """ 225 S.isdigit() -> bool 226 227 Return True if all characters in S are digits 228 and there is at least one character in S, False otherwise. 229 """ 230 return False 231 232 def islower(self): 233 """ 是否小写 """ 234 """ 235 S.islower() -> bool 236 237 Return True if all cased characters in S are lowercase and there is 238 at least one cased character in S, False otherwise. 239 """ 240 return False 241 242 def isspace(self): 243 """ 244 S.isspace() -> bool 245 246 Return True if all characters in S are whitespace 247 and there is at least one character in S, False otherwise. 248 """ 249 return False 250 251 def istitle(self): 252 """ 253 S.istitle() -> bool 254 255 Return True if S is a titlecased string and there is at least one 256 character in S, i.e. uppercase characters may only follow uncased 257 characters and lowercase characters only cased ones. Return False 258 otherwise. 259 """ 260 return False 261 262 def isupper(self): 263 """ 264 S.isupper() -> bool 265 266 Return True if all cased characters in S are uppercase and there is 267 at least one cased character in S, False otherwise. 268 """ 269 return False 270 271 def join(self, iterable): 272 """ 连接 """ 273 """ 274 S.join(iterable) -> string 275 276 Return a string which is the concatenation of the strings in the 277 iterable. The separator between elements is S. 278 """ 279 """ 280 >>> li = ['s','b','a','l','e','x'] 281 >>> result = "".join(li) 282 >>> print(result) 283 sbalex 284 >>> result = "-".join(li) 285 >>> print(result) 286 s-b-a-l-e-x 287 """ 288 return "" 289 290 def ljust(self, width, fillchar=None): 291 """ 内容左对齐,右侧填充 """ 292 """ 293 S.ljust(width[, fillchar]) -> string 294 295 Return S left-justified in a string of length width. Padding is 296 done using the specified fill character (default is a space). 297 """ 298 return "" 299 300 def lower(self): 301 """ 变小写 """ 302 """ 303 S.lower() -> string 304 305 Return a copy of the string S converted to lowercase. 306 """ 307 return "" 308 309 def lstrip(self, chars=None): 310 """ 移除左侧空白 """ 311 """ 312 S.lstrip([chars]) -> string or unicode 313 314 Return a copy of the string S with leading whitespace removed. 315 If chars is given and not None, remove characters in chars instead. 316 If chars is unicode, S will be converted to unicode before stripping 317 """ 318 return "" 319 320 def partition(self, sep): 321 """ 分割,前,中,后三部分 """ 322 """ 323 S.partition(sep) -> (head, sep, tail) 324 325 Search for the separator sep in S, and return the part before it, 326 the separator itself, and the part after it. If the separator is not 327 found, return S and two empty strings. 328 """ 329 """ 330 >>> name = 'alexissb' 331 >>> result = name.partition('is') 332 >>> print(result) 333 ('alex', 'is', 'sb') 334 """ 335 pass 336 337 def replace(self, old, new, count=None): 338 """ 替换 """ 339 """ 340 S.replace(old, new[, count]) -> string 341 342 Return a copy of string S with all occurrences of substring 343 old replaced by new. If the optional argument count is 344 given, only the first count occurrences are replaced. 345 """ 346 """ 347 >>> name = 'aleaxiasasb' 348 >>> result = name.replace('a','o') 349 >>> print(result) 350 oleoxiososb 351 """ 352 return "" 353 354 def rfind(self, sub, start=None, end=None): 355 """ 356 S.rfind(sub [,start [,end]]) -> int 357 358 Return the highest index in S where substring sub is found, 359 such that sub is contained within S[start:end]. Optional 360 arguments start and end are interpreted as in slice notation. 361 362 Return -1 on failure. 363 """ 364 return 0 365 366 def rindex(self, sub, start=None, end=None): 367 """ 368 S.rindex(sub [,start [,end]]) -> int 369 370 Like S.rfind() but raise ValueError when the substring is not found. 371 """ 372 return 0 373 374 def rjust(self, width, fillchar=None): 375 """ 376 S.rjust(width[, fillchar]) -> string 377 378 Return S right-justified in a string of length width. Padding is 379 done using the specified fill character (default is a space) 380 """ 381 return "" 382 383 def rpartition(self, sep): 384 """ 385 S.rpartition(sep) -> (head, sep, tail) 386 387 Search for the separator sep in S, starting at the end of S, and return 388 the part before it, the separator itself, and the part after it. If the 389 separator is not found, return two empty strings and S. 390 """ 391 pass 392 393 def rsplit(self, sep=None, maxsplit=None): 394 """ 395 S.rsplit([sep [,maxsplit]]) -> list of strings 396 397 Return a list of the words in the string S, using sep as the 398 delimiter string, starting at the end of the string and working 399 to the front. If maxsplit is given, at most maxsplit splits are 400 done. If sep is not specified or is None, any whitespace string 401 is a separator. 402 """ 403 return [] 404 405 def rstrip(self, chars=None): 406 """ 407 S.rstrip([chars]) -> string or unicode 408 409 Return a copy of the string S with trailing whitespace removed. 410 If chars is given and not None, remove characters in chars instead. 411 If chars is unicode, S will be converted to unicode before stripping 412 """ 413 return "" 414 415 def split(self, sep=None, maxsplit=None): 416 """ 分割, maxsplit最多分割几次 """ 417 """ 418 S.split([sep [,maxsplit]]) -> list of strings 419 420 Return a list of the words in the string S, using sep as the 421 delimiter string. If maxsplit is given, at most maxsplit 422 splits are done. If sep is not specified or is None, any 423 whitespace string is a separator and empty strings are removed 424 from the result. 425 """ 426 """ 427 >>> name = ''' 428 ... ak 429 ... aa 430 ... bb''' 431 >>> result = name.split('\n') 432 >>> print(result) 433 ['', 'ak', 'aa', 'bb'] 434 """ 435 return [] 436 437 def splitlines(self, keepends=False): 438 """ 根据换行分割 """ 439 """ 440 S.splitlines(keepends=False) -> list of strings 441 442 Return a list of the lines in S, breaking at line boundaries. 443 Line breaks are not included in the resulting list unless keepends 444 is given and true. 445 """ 446 """ 447 >>> name = ''' 448 ... ak 449 ... aa 450 ... bb''' 451 >>> result = name.splitlines() 452 >>> print(result) 453 ['', 'ak', 'aa', 'bb'] 454 """ 455 return [] 456 457 def startswith(self, prefix, start=None, end=None): 458 """ 是否起始 """ 459 """ 460 S.startswith(prefix[, start[, end]]) -> bool 461 462 Return True if S starts with the specified prefix, False otherwise. 463 With optional start, test S beginning at that position. 464 With optional end, stop comparing S at that position. 465 prefix can also be a tuple of strings to try. 466 """ 467 return False 468 469 def strip(self, chars=None): 470 """ 移除两段空白 """ 471 """ 472 S.strip([chars]) -> string or unicode 473 474 Return a copy of the string S with leading and trailing 475 whitespace removed. 476 If chars is given and not None, remove characters in chars instead. 477 If chars is unicode, S will be converted to unicode before stripping 478 """ 479 return "" 480 481 def swapcase(self): 482 """ 大写变小写,小写变大写 """ 483 """ 484 S.swapcase() -> string 485 486 Return a copy of the string S with uppercase characters 487 converted to lowercase and vice versa. 488 """ 489 return "" 490 491 def title(self): 492 """ 493 S.title() -> string 494 495 Return a titlecased version of S, i.e. words start with uppercase 496 characters, all remaining cased characters have lowercase. 497 """ 498 """ 499 >>> name = "this is a title" 500 >>> result = name.title() 501 >>> print(result) 502 This Is A Title 503 """ 504 return "" 505 506 def translate(self, table, deletechars=None): 507 """ 508 转换,需要先做一个对应表,最后一个表示删除字符集合 509 intab = "aeiou" 510 outtab = "12345" 511 trantab = maketrans(intab, outtab) 512 str = "this is string example....wow!!!" 513 print str.translate(trantab, 'xm') 514 """ 515 516 """ 517 S.translate(table [,deletechars]) -> string 518 519 Return a copy of the string S, where all characters occurring 520 in the optional argument deletechars are removed, and the 521 remaining characters have been mapped through the given 522 translation table, which must be a string of length 256 or None. 523 If the table argument is None, no translation is applied and 524 the operation simply removes the characters in deletechars. 525 """ 526 return "" 527 528 def upper(self): 529 """ 530 S.upper() -> string 531 532 Return a copy of the string S converted to uppercase. 533 """ 534 return "" 535 536 def zfill(self, width): 537 """方法返回指定长度的字符串,原字符串右对齐,前面填充0。""" 538 """ 539 S.zfill(width) -> string 540 541 Pad a numeric string S with zeros on the left, to fill a field 542 of the specified width. The string S is never truncated. 543 """ 544 return "" 545 546 def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown 547 pass 548 549 def _formatter_parser(self, *args, **kwargs): # real signature unknown 550 pass 551 552 def __add__(self, y): 553 """ x.__add__(y) <==> x+y """ 554 pass 555 556 def __contains__(self, y): 557 """ x.__contains__(y) <==> y in x """ 558 pass 559 560 def __eq__(self, y): 561 """ x.__eq__(y) <==> x==y """ 562 pass 563 564 def __format__(self, format_spec): 565 """ 566 S.__format__(format_spec) -> string 567 568 Return a formatted version of S as described by format_spec. 569 """ 570 return "" 571 572 def __getattribute__(self, name): 573 """ x.__getattribute__('name') <==> x.name """ 574 pass 575 576 def __getitem__(self, y): 577 """ x.__getitem__(y) <==> x[y] """ 578 pass 579 580 def __getnewargs__(self, *args, **kwargs): # real signature unknown 581 pass 582 583 def __getslice__(self, i, j): 584 """ 585 x.__getslice__(i, j) <==> x[i:j] 586 587 Use of negative indices is not supported. 588 """ 589 pass 590 591 def __ge__(self, y): 592 """ x.__ge__(y) <==> x>=y """ 593 pass 594 595 def __gt__(self, y): 596 """ x.__gt__(y) <==> x>y """ 597 pass 598 599 def __hash__(self): 600 """ x.__hash__() <==> hash(x) """ 601 pass 602 603 def __init__(self, string=''): # known special case of str.__init__ 604 """ 605 str(object='') -> string 606 607 Return a nice string representation of the object. 608 If the argument is a string, the return value is the same object. 609 # (copied from class doc) 610 """ 611 pass 612 613 def __len__(self): 614 """ x.__len__() <==> len(x) """ 615 pass 616 617 def __le__(self, y): 618 """ x.__le__(y) <==> x<=y """ 619 pass 620 621 def __lt__(self, y): 622 """ x.__lt__(y) <==> x<y """ 623 pass 624 625 def __mod__(self, y): 626 """ x.__mod__(y) <==> x%y """ 627 pass 628 629 def __mul__(self, n): 630 """ x.__mul__(n) <==> x*n """ 631 pass 632 633 @staticmethod # known case of __new__ 634 def __new__(S, *more): 635 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 636 pass 637 638 def __ne__(self, y): 639 """ x.__ne__(y) <==> x!=y """ 640 pass 641 642 def __repr__(self): 643 """ x.__repr__() <==> repr(x) """ 644 pass 645 646 def __rmod__(self, y): 647 """ x.__rmod__(y) <==> y%x """ 648 pass 649 650 def __rmul__(self, n): 651 """ x.__rmul__(n) <==> n*x """ 652 pass 653 654 def __sizeof__(self): 655 """ S.__sizeof__() -> size of S in memory, in bytes """ 656 pass 657 658 def __str__(self): 659 """ x.__str__() <==> str(x) """ 660 pass 661 662 st
注意:3.x 里translate方法变成只有一个参数,2.x里有2个参数哈。
五、列表
如:[11,22,33]、['dengli', 'alex']
每个列表都具备如下功能:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 >>> li = [1,2,3,] 2 >>> print(li) 3 [1, 2, 3] 4 >>> li = list([1,2,3,]) 5 >>> print(li) 6 [1, 2, 3] 7 8 class list(object): 9 """ 10 list() -> new empty list 11 list(iterable) -> new list initialized from iterable's items 12 """ 13 def append(self, p_object): # real signature unknown; restored from __doc__ 14 """ L.append(object) -- append object to end """ 15 """ 16 >>> li.append(2) 17 >>> print(li) 18 [1, 2, 3, 11, 22, 11, 2, 22, 3, 2] 19 """ 20 pass 21 22 def count(self, value): # real signature unknown; restored from __doc__ 23 """ L.count(value) -> integer -- return number of occurrences of value """ 24 """ 25 >>> li.extend([11,2,22,3,]) 26 >>> result = li.count(3) 27 >>> print(result) 28 2 29 """ 30 return 0 31 32 def extend(self, iterable): # real signature unknown; restored from __doc__ 33 """ L.extend(iterable) -- extend list by appending elements from the iterable """ 34 """ 35 >>> li.extend([11,22,]) 36 >>> print(li) 37 [1, 2, 3, 11, 22] 38 """ 39 pass 40 41 def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__ 42 """ 43 L.index(value, [start, [stop]]) -> integer -- return first index of value. 44 Raises ValueError if the value is not present. 45 """ 46 """查找value的索引值""" 47 """ 48 >>> print(li) 49 [1, 2, 3, 11, 22, 11, 2, 22, 3, 2] 50 >>> li.index(2) 51 1 52 >>> li.index(22) 53 4 54 """ 55 return 0 56 57 def insert(self, index, p_object): # real signature unknown; restored from __doc__ 58 """ L.insert(index, object) -- insert object before index """ 59 60 """在索引位置插入value""" 61 """ 62 >>> li.insert(2,66) 63 >>> print(li) 64 [1, 2, 66, 3, 11, 22, 11, 2, 22, 3, 2] 65 """ 66 pass 67 68 def pop(self, index=None): # real signature unknown; restored from __doc__ 69 """ 70 L.pop([index]) -> item -- remove and return item at index (default last). 71 Raises IndexError if list is empty or index is out of range. 72 """ 73 """ 74 >>> li = list([1,2,3,]) 75 >>> print(li) 76 [1, 2, 3] 77 >>> ret = li.pop() 78 >>> print(ret) 79 3 80 >>> print(li) 81 [1, 2] 82 """ 83 pass 84 85 def remove(self, value): # real signature unknown; restored from __doc__ 86 """ 87 L.remove(value) -- remove first occurrence of value. 88 Raises ValueError if the value is not present. 89 """ 90 """删除制定value的值"" 91 """ 92 >>> li = list([1,2,3,]) 93 >>> print(li) 94 [1, 2, 3] 95 >>> li.remove(2) 96 >>> print(li) 97 [1, 3] 98 """ 99 pass 100 101 def reverse(self): # real signature unknown; restored from __doc__ 102 """ L.reverse() -- reverse *IN PLACE* """ 103 pass 104 105 def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__ 106 """ 107 L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*; 108 cmp(x, y) -> -1, 0, 1 109 """ 110 """排序""" 111 """ 112 >>> li = list([1,2,3,44,22,11,9]) 113 >>> print(li) 114 [1, 2, 3, 44, 22, 11, 9] 115 >>> li.sort() 116 >>> print(li) 117 [1, 2, 3, 9, 11, 22, 44] 118 """ 119 pass 120 121 def __add__(self, y): # real signature unknown; restored from __doc__ 122 """ x.__add__(y) <==> x+y """ 123 pass 124 125 def __contains__(self, y): # real signature unknown; restored from __doc__ 126 """ x.__contains__(y) <==> y in x """ 127 """ 128 >>> li = list([1,2,3,44,22,11,9]) 129 >>> print(li) 130 [1, 2, 3, 44, 22, 11, 9] 131 >>> 44 in li 132 True 133 >>> li.__contains__(44) 134 True 135 """ 136 pass 137 138 def __delitem__(self, y): # real signature unknown; restored from __doc__ 139 """ x.__delitem__(y) <==> del x[y] """ 140 pass 141 142 def __delslice__(self, i, j): # real signature unknown; restored from __doc__ 143 """ 144 x.__delslice__(i, j) <==> del x[i:j] 145 146 Use of negative indices is not supported. 147 """ 148 pass 149 150 def __eq__(self, y): # real signature unknown; restored from __doc__ 151 """ x.__eq__(y) <==> x==y """ 152 pass 153 154 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 155 """ x.__getattribute__('name') <==> x.name """ 156 pass 157 158 def __getitem__(self, y): # real signature unknown; restored from __doc__ 159 """ x.__getitem__(y) <==> x[y] """ 160 pass 161 162 def __getslice__(self, i, j): # real signature unknown; restored from __doc__ 163 """ 164 x.__getslice__(i, j) <==> x[i:j] 165 166 Use of negative indices is not supported. 167 """ 168 pass 169 170 def __ge__(self, y): # real signature unknown; restored from __doc__ 171 """ x.__ge__(y) <==> x>=y """ 172 pass 173 174 def __gt__(self, y): # real signature unknown; restored from __doc__ 175 """ x.__gt__(y) <==> x>y """ 176 pass 177 178 def __iadd__(self, y): # real signature unknown; restored from __doc__ 179 """ x.__iadd__(y) <==> x+=y """ 180 pass 181 182 def __imul__(self, y): # real signature unknown; restored from __doc__ 183 """ x.__imul__(y) <==> x*=y """ 184 pass 185 186 def __init__(self, seq=()): # known special case of list.__init__ 187 """ 188 list() -> new empty list 189 list(iterable) -> new list initialized from iterable's items 190 # (copied from class doc) 191 """ 192 pass 193 194 def __iter__(self): # real signature unknown; restored from __doc__ 195 """ x.__iter__() <==> iter(x) """ 196 pass 197 198 def __len__(self): # real signature unknown; restored from __doc__ 199 """ x.__len__() <==> len(x) """ 200 pass 201 202 def __le__(self, y): # real signature unknown; restored from __doc__ 203 """ x.__le__(y) <==> x<=y """ 204 pass 205 206 def __lt__(self, y): # real signature unknown; restored from __doc__ 207 """ x.__lt__(y) <==> x<y """ 208 pass 209 210 def __mul__(self, n): # real signature unknown; restored from __doc__ 211 """ x.__mul__(n) <==> x*n """ 212 pass 213 214 @staticmethod # known case of __new__ 215 def __new__(S, *more): # real signature unknown; restored from __doc__ 216 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 217 pass 218 219 def __ne__(self, y): # real signature unknown; restored from __doc__ 220 """ x.__ne__(y) <==> x!=y """ 221 pass 222 223 def __repr__(self): # real signature unknown; restored from __doc__ 224 """ x.__repr__() <==> repr(x) """ 225 pass 226 227 def __reversed__(self): # real signature unknown; restored from __doc__ 228 """ L.__reversed__() -- return a reverse iterator over the list """ 229 pass 230 231 def __rmul__(self, n): # real signature unknown; restored from __doc__ 232 """ x.__rmul__(n) <==> n*x """ 233 pass 234 235 def __setitem__(self, i, y): # real signature unknown; restored from __doc__ 236 """ x.__setitem__(i, y) <==> x[i]=y """ 237 pass 238 239 def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__ 240 """ 241 x.__setslice__(i, j, y) <==> x[i:j]=y 242 243 Use of negative indices is not supported. 244 """ 245 pass 246 247 def __sizeof__(self): # real signature unknown; restored from __doc__ 248 """ L.__sizeof__() -- size of L in memory, in bytes """ 249 pass 250 251 __hash__ = None 252 253 list
六、元组
如:(11,22,33)、('wupeiqi', 'alex')
每个元组都具备如下功能:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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
七、字典
如:{'name': 'dengli', 'age': 18} 、{'host': '2.2.2.2', 'port': 80]}
ps:循环时,默认循环key
每个字典都具备如下功能:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 >>> dic = dict(k1='v1',k2='v2') 2 >>> print(dic['k1']) 3 v1 4 >>> print(dic['k2']) 5 v2 6 >>> dic = {'k1':'v1','k2':'v2'} 7 >>> print(dic['k1']) 8 v1 9 >>> print(dic['k2']) 10 v2 11 class dict(object): 12 """ 13 dict() -> new empty dictionary 14 dict(mapping) -> new dictionary initialized from a mapping object's 15 (key, value) pairs 16 dict(iterable) -> new dictionary initialized as if via: 17 d = {} 18 for k, v in iterable: 19 d[k] = v 20 dict(**kwargs) -> new dictionary initialized with the name=value pairs 21 in the keyword argument list. For example: dict(one=1, two=2) 22 """ 23 """ 24 >>> for k,v in dic.items(): 25 ... print(k,v) 26 ... 27 k1 v1 28 k2 v2 29 """ 30 31 def clear(self): # real signature unknown; restored from __doc__ 32 """ 清除内容 """ 33 """ D.clear() -> None. Remove all items from D. """ 34 pass 35 36 def copy(self): # real signature unknown; restored from __doc__ 37 """ 浅拷贝 """ 38 """ D.copy() -> a shallow copy of D """ 39 pass 40 41 @staticmethod # known case 42 def fromkeys(S, v=None): # real signature unknown; restored from __doc__ 43 """ 44 dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v. 45 v defaults to None. 46 """ 47 """ 48 >>> dic = dict(k1='v1',k2='v2') 49 >>> new_dict = dic.fromkeys(['k1','k2'],'v1') 50 >>> print(new_dict) 51 {'k1': 'v1', 'k2': 'v1'} 52 """ 53 pass 54 55 def get(self, k, d=None): # real signature unknown; restored from __doc__ 56 """ 根据key获取值,d是默认值 """ 57 """ D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """ 58 """ 59 >>> dic = dict(k1='v1',k2='v2') 60 >>> print(dic.get('k1')) 61 v1 62 >>> print(dic.get('k2')) 63 v2 64 >>> print(dic.get('k3')) 65 None 66 如果key的value不存在,则给一个默认值alex 67 >>> dic = dict(k1='v1',k2='v2') 68 >>> print(dic.get('k1')) 69 v1 70 >>> print(dic.get('k2','alex')) 71 v2 72 >>> print(dic.get('k3','alex')) 73 alex 74 """ 75 pass 76 77 def has_key(self, k): # real signature unknown; restored from __doc__ 78 """ 是否有key """ 79 """ D.has_key(k) -> True if D has a key k, else False """ 80 return False 81 82 def items(self): # real signature unknown; restored from __doc__ 83 """ 所有项的列表形式 """ 84 """ D.items() -> list of D's (key, value) pairs, as 2-tuples """ 85 return [] 86 87 def iteritems(self): # real signature unknown; restored from __doc__ 88 """ 项可迭代 """ 89 """ D.iteritems() -> an iterator over the (key, value) items of D """ 90 pass 91 92 def iterkeys(self): # real signature unknown; restored from __doc__ 93 """ key可迭代 """ 94 """ D.iterkeys() -> an iterator over the keys of D """ 95 pass 96 97 def itervalues(self): # real signature unknown; restored from __doc__ 98 """ value可迭代 """ 99 """ D.itervalues() -> an iterator over the values of D """ 100 pass 101 102 def keys(self): # real signature unknown; restored from __doc__ 103 """ 所有的key列表 """ 104 """ D.keys() -> list of D's keys """ 105 """ 106 >>> for k in dic.keys(): 107 ... print(k) 108 ... 109 k1 110 k2 111 """ 112 return [] 113 114 def pop(self, k, d=None): # real signature unknown; restored from __doc__ 115 """ 获取并在字典中移除 """ 116 """ 117 D.pop(k[,d]) -> v, remove specified key and return the corresponding value. 118 If key is not found, d is returned if given, otherwise KeyError is raised 119 """ 120 """ 121 >>> dic = dict(k1='v1',k2='v2') 122 >>> dic.pop('k1') 123 'v1' 124 >>> print(dic) 125 {'k2': 'v2'} 126 """ 127 pass 128 129 def popitem(self): # real signature unknown; restored from __doc__ 130 """ 获取并在字典中移除 """ 131 """ 132 D.popitem() -> (k, v), remove and return some (key, value) pair as a 133 2-tuple; but raise KeyError if D is empty. 134 """ 135 pass 136 137 def setdefault(self, k, d=None): # real signature unknown; restored from __doc__ 138 """ 如果key不存在,则创建,如果存在,则返回已存在的值且不修改 """ 139 """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """ 140 """ 141 >>> dic = dict(k1='v1',k2='v2') 142 >>> dic.setdefault('k4') 143 >>> print(dic) 144 {'k1': 'v1', 'k2': 'v2', 'k4': None} 145 """ 146 pass 147 148 def update(self, E=None, **F): # known special case of dict.update 149 """ 更新 150 {'name':'alex', 'age': 18000} 151 [('name','sbsbsb'),] 152 """ 153 """ 154 D.update([E, ]**F) -> None. Update D from dict/iterable E and F. 155 If E present and has a .keys() method, does: for k in E: D[k] = E[k] 156 If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v 157 In either case, this is followed by: for k in F: D[k] = F[k] 158 """ 159 """ 160 >>> dic = dict(k1='v1',k2='v2') 161 >>> dic.update({'k3':123}) 162 >>> print(dic) 163 {'k1': 'v1', 'k2': 'v2', 'k3': 123} 164 """ 165 pass 166 167 def values(self): # real signature unknown; restored from __doc__ 168 """ 所有的值 """ 169 """ D.values() -> list of D's values """ 170 """ 171 >>> for v in dic.values(): 172 ... print(v) 173 ... 174 v1 175 v2 176 """ 177 return [] 178 179 def viewitems(self): # real signature unknown; restored from __doc__ 180 """ 所有项,只是将内容保存至view对象中 """ 181 """ D.viewitems() -> a set-like object providing a view on D's items """ 182 pass 183 184 def viewkeys(self): # real signature unknown; restored from __doc__ 185 """ D.viewkeys() -> a set-like object providing a view on D's keys """ 186 pass 187 188 def viewvalues(self): # real signature unknown; restored from __doc__ 189 """ D.viewvalues() -> an object providing a view on D's values """ 190 pass 191 192 def __cmp__(self, y): # real signature unknown; restored from __doc__ 193 """ x.__cmp__(y) <==> cmp(x,y) """ 194 pass 195 196 def __contains__(self, k): # real signature unknown; restored from __doc__ 197 """ D.__contains__(k) -> True if D has a key k, else False """ 198 return False 199 200 def __delitem__(self, y): # real signature unknown; restored from __doc__ 201 """ x.__delitem__(y) <==> del x[y] """ 202 pass 203 204 def __eq__(self, y): # real signature unknown; restored from __doc__ 205 """ x.__eq__(y) <==> x==y """ 206 pass 207 208 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 209 """ x.__getattribute__('name') <==> x.name """ 210 pass 211 212 def __getitem__(self, y): # real signature unknown; restored from __doc__ 213 """ x.__getitem__(y) <==> x[y] """ 214 pass 215 216 def __ge__(self, y): # real signature unknown; restored from __doc__ 217 """ x.__ge__(y) <==> x>=y """ 218 pass 219 220 def __gt__(self, y): # real signature unknown; restored from __doc__ 221 """ x.__gt__(y) <==> x>y """ 222 pass 223 224 def __init__(self, seq=None, **kwargs): # known special case of dict.__init__ 225 """ 226 dict() -> new empty dictionary 227 dict(mapping) -> new dictionary initialized from a mapping object's 228 (key, value) pairs 229 dict(iterable) -> new dictionary initialized as if via: 230 d = {} 231 for k, v in iterable: 232 d[k] = v 233 dict(**kwargs) -> new dictionary initialized with the name=value pairs 234 in the keyword argument list. For example: dict(one=1, two=2) 235 # (copied from class doc) 236 """ 237 pass 238 239 def __iter__(self): # real signature unknown; restored from __doc__ 240 """ x.__iter__() <==> iter(x) """ 241 pass 242 243 def __len__(self): # real signature unknown; restored from __doc__ 244 """ x.__len__() <==> len(x) """ 245 pass 246 247 def __le__(self, y): # real signature unknown; restored from __doc__ 248 """ x.__le__(y) <==> x<=y """ 249 pass 250 251 def __lt__(self, y): # real signature unknown; restored from __doc__ 252 """ x.__lt__(y) <==> x<y """ 253 pass 254 255 @staticmethod # known case of __new__ 256 def __new__(S, *more): # real signature unknown; restored from __doc__ 257 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 258 pass 259 260 def __ne__(self, y): # real signature unknown; restored from __doc__ 261 """ x.__ne__(y) <==> x!=y """ 262 pass 263 264 def __repr__(self): # real signature unknown; restored from __doc__ 265 """ x.__repr__() <==> repr(x) """ 266 pass 267 268 def __setitem__(self, i, y): # real signature unknown; restored from __doc__ 269 """ x.__setitem__(i, y) <==> x[i]=y """ 270 pass 271 272 def __sizeof__(self): # real signature unknown; restored from __doc__ 273 """ D.__sizeof__() -> size of D in memory, in bytes """ 274 pass 275 276 __hash__ = None 277 278 dic
练习:
有如下值集合 [11,22,33,44,55,66,77,88,99,90...],将所有大于 66 的值保存至字典的第一个key中,将小于 66 的值保存至第二个key的值中。 即: {'k1': 大于66 , 'k2': 小于66}
法一:
dic = {} li = [11,22,33,44,55,66,77,88,99,90,] l1 = [] l2 = [] for i in (li[0:]): if i > 66: l1.append(i) else: l2.append(i) dic['k1'] = l1 dic['k2'] = l2 print(dic) {'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55, 66]}
法二:
li = [11,22,33,44,55,66,77,88,99,90,] dic = {} for i in li: if i>66: if 'k1' in dic.keys(): dic['k1'].append(i) else: dic['k1'] = [i,] else: if 'k2' in dic.keys(): dic['k2'].append(i) else: dic['k2'] = [i,] #dic = {} #dic = {'k2':[11,]} print(dic) {'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]}
程序练习作业
请闭眼写出以下程序。
程序:购物车程序
需求:
- 启动程序后,让用户输入工资,然后打印商品列表
- 允许用户根据商品编号购买商品
- 用户选择商品后,检测余额是否够,够就直接扣款,不够就提醒
- 可随时退出,退出时,打印已购买商品和余额
八、set集合
set是一个无序且不重复的元素集合
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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
s1 = set()
s1.add('alex')
print(s1)
s1.add('alex')
print(s1)
# 访问速度快
# 天生解决了重复问题
>>> s2 = set(['alex','eric','tony','alex',])
>>> print(s2)
{'eric', 'tony', 'alex'}
s2 = set(['alex','eric','tony','alex',])
print(s2)
s3 = s2.difference(['alex','eric',])
print(s2)
print(s3)
{'eric', 'tony', 'alex'}
{'eric', 'tony', 'alex'}
{'tony'}
s2 = set(['alex','eric','tony','alex',])
print(s2)
s2.difference_update(['alex','eric',])
print(s2)
{'tony', 'alex', 'eric'}
{'tony'}
s2 = set(['alex','eric','tony','alex',])
print(s2)
s2.pop()
print(s2)
s2.pop()
print(s2)
{'tony', 'alex', 'eric'}
{'alex', 'eric'}
{'eric'}
s2 = set(['alex','eric','tony','alex',])
print(s2)
ret = s2.pop()
print(s2)
print(ret)
{'tony', 'alex', 'eric'}
{'alex', 'eric'}
tony
s2 = set(['alex','eric','tony','alex',])
print(s2)
s2.remove('tony')
print(s2)
{'eric', 'tony', 'alex'}
{'eric', 'alex'}
练习:寻找差异
old_dict = { "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, "#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 } } new_dict = { "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 }, "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, "#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 } } 需要删除:? 需要新建:? 需要更新:? 注意:无需考虑内部元素是否改变,只要原来存在,新汇报也存在,就是需要更新
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 old_dict = { 2 "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, 3 "#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, 4 "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 } 5 } 6 7 new_dict = { 8 "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 }, 9 "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, 10 "#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 } 11 } 12 13 add_list = {} 14 del_list = {} 15 update_list = {} 16 for i in old_dict.keys(): 17 if i in new_dict.keys(): 18 # print(i) 19 s1 = set(old_dict[i].values()) 20 s2 = set(new_dict[i].values()) 21 if s2.issubset(s1): 22 continue 23 else: 24 # print(i) 25 s3 = (new_dict.get(i)) 26 update_list[i] = s3 27 # print(update_list.items()) 28 else: 29 # print(i) 30 s4 = (old_dict.get(i)) 31 del_list[i] = s4 32 # print(del_list.items()) 33 for j in new_dict.keys(): 34 if j not in old_dict.keys(): 35 # print(j) 36 s5 = (new_dict.get(j)) 37 add_list[j] = s5 38 # print(add_list.items()) 39 for k,v in add_list.items(): 40 print("add_list") 41 print(k,v) 42 for k,v in del_list.items(): 43 print("del_list") 44 print(k,v) 45 for k,v in update_list.items(): 46 print("update_list") 47 print(k,v)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 old_dict = { 2 "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, 3 "#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, 4 "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 } 5 } 6 7 new_dict = { 8 "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 }, 9 "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, 10 "#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 } 11 } 12 13 old = set(old_dict) 14 new = set(new_dict) 15 update_set = old.intersection(new) 16 # print(update_set) 17 18 delete_set = old.symmetric_difference(update_set) 19 # print(delete_set) 20 21 add_set = new.symmetric_difference(update_set) 22 # print(add_set) 23 print('s'.center(20,'*')) 24 for i in update_set: 25 if i in new_dict.keys(): 26 print("update_list") 27 print(i) 28 print(new_dict.get(i)) 29 print('s'.center(20,'*')) 30 for j in delete_set: 31 if j in old_dict: 32 print("del_list") 33 print(j) 34 print(old_dict.get(j)) 35 print('s'.center(20,'*')) 36 for l in add_set: 37 if l in new_dict.keys(): 38 print("add_list") 39 print(l) 40 print(new_dict.get(l)) 41 print('s'.center(20,'*'))
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 old_dict = { 2 "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, 3 "#2":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, 4 "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 } 5 } 6 7 new_dict = { 8 "#1":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 800 }, 9 "#3":{ 'hostname':'c1', 'cpu_count': 2, 'mem_capicity': 80 }, 10 "#4":{ 'hostname':'c2', 'cpu_count': 2, 'mem_capicity': 80 } 11 } 12 13 old_set = set(old_dict.keys()) 14 update_list = list(old_set.intersection(new_dict.keys())) 15 16 new_list = [] 17 del_list = [] 18 19 for i in new_dict.keys(): 20 if i not in update_list: 21 new_list.append(i) 22 23 for i in old_dict.keys(): 24 if i not in update_list: 25 del_list.append(i) 26 27 print(update_list,new_list,del_list)
collections系列
一、计数器(counter)
Counter是对字典类型的补充,用于追踪值的出现次数。
ps:具备字典的所有功能 + 自己的功能
c = Counter('abcdeabcdabcaba') print c 输出:Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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
二、有序字典(orderedDict )
orderdDict是对字典类型的补充,他记住了字典元素添加的顺序
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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
三、默认字典(defaultdict)
是对字典的类型的补充,他默认给字典的值设置了一个类型。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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
练习:
有如下值集合 [11,22,33,44,55,66,77,88,99,90...],将所有大于 66 的值保存至字典的第一个key中,将小于 66 的值保存至第二个key的值中。 即: {'k1': 大于66 , 'k2': 小于66}
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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]
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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字典解决方法 14 15 默认字典
四、可命名元组(namedtuple)
根据nametuple可以创建一个包含tuple所有功能以及其他功能的类型。
import collections #创建类 Mytuple = collections.namedtuple('Mytuple',['x', 'y', 'z'])
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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
五、双向队列(deque)
一个线程安全的双向队列
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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 144 145 deque
注:既然有双向队列,也有单项队列(先进先出 FIFO )
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
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