int又称数字类型：
int（）方法：
(1)将字符串转换为数字：
a='123'
print(type(a))#str
b=int(a)
print(type(b))#int 123
(2)进制之间的转换：
num='0011'
c=int(num,base=16) #16进制的num转换为10进制的数字
print(c) #17
bit_length()方法：
当前数字的2进制，至少用n位来表示
age=1 #2进制01
r=age.bit_length() #1
age=2 #2进制10
r=age.bit_length() #2
age=4 #2进制100
r=age.bit_length() #3
详情见：
1 class int(object): 2 """ 3 int(x=0) -> int or long 4 int(x, base=10) -> int or long 5 6 Convert a number or string to an integer, or return 0 if no arguments 7 are given. If x is floating point, the conversion truncates towards zero. 8 If x is outside the integer range, the function returns a long instead. 9 10 If x is not a number or if base is given, then x must be a string or 11 Unicode object representing an integer literal in the given base. The 12 literal can be preceded by '+' or '-' and be surrounded by whitespace. 13 The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to 14 interpret the base from the string as an integer literal. 15 >>> int('0b100', base=0) 16 """ 17 def bit_length(self): 18 """ 返回表示该数字的时占用的最少位数 """ 19 """ 20 int.bit_length() -> int 21 22 Number of bits necessary to represent self in binary. 23 >>> bin(37) 24 '0b100101' 25 >>> (37).bit_length() 26 """ 27 return 0 28 29 def conjugate(self, *args, **kwargs): # real signature unknown 30 """ 返回该复数的共轭复数 """ 31 """ Returns self, the complex conjugate of any int. """ 32 pass 33 34 def __abs__(self): 35 """ 返回绝对值 """ 36 """ x.__abs__() <==> abs(x) """ 37 pass 38 39 def __add__(self, y): 40 """ x.__add__(y) <==> x+y """ 41 pass 42 43 def __and__(self, y): 44 """ x.__and__(y) <==> x&y """ 45 pass 46 47 def __cmp__(self, y): 48 """ 比较两个数大小 """ 49 """ x.__cmp__(y) <==> cmp(x,y) """ 50 pass 51 52 def __coerce__(self, y): 53 """ 强制生成一个元组 """ 54 """ x.__coerce__(y) <==> coerce(x, y) """ 55 pass 56 57 def __divmod__(self, y): 58 """ 相除，得到商和余数组成的元组 """ 59 """ x.__divmod__(y) <==> divmod(x, y) """ 60 pass 61 62 def __div__(self, y): 63 """ x.__div__(y) <==> x/y """ 64 pass 65 66 def __float__(self): 67 """ 转换为浮点类型 """ 68 """ x.__float__() <==> float(x) """ 69 pass 70 71 def __floordiv__(self, y): 72 """ x.__floordiv__(y) <==> x//y """ 73 pass 74 75 def __format__(self, *args, **kwargs): # real signature unknown 76 pass 77 78 def __getattribute__(self, name): 79 """ x.__getattribute__('name') <==> x.name """ 80 pass 81 82 def __getnewargs__(self, *args, **kwargs): # real signature unknown 83 """ 内部调用 __new__方法或创建对象时传入参数使用 """ 84 pass 85 86 def __hash__(self): 87 """如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数。在字典查找中，哈希值用于快速比较字典的键。两个数值如果相等，则哈希值也相等。""" 88 """ x.__hash__() <==> hash(x) """ 89 pass 90 91 def __hex__(self): 92 """ 返回当前数的 十六进制 表示 """ 93 """ x.__hex__() <==> hex(x) """ 94 pass 95 96 def __index__(self): 97 """ 用于切片，数字无意义 """ 98 """ x[y:z] <==> x[y.__index__():z.__index__()] """ 99 pass 100 101 def __init__(self, x, base=10): # known special case of int.__init__ 102 """ 构造方法，执行 x = 123 或 x = int(10) 时，自动调用，暂时忽略 """ 103 """ 104 int(x=0) -> int or long 105 int(x, base=10) -> int or long 106 107 Convert a number or string to an integer, or return 0 if no arguments 108 are given. If x is floating point, the conversion truncates towards zero. 109 If x is outside the integer range, the function returns a long instead. 110 111 If x is not a number or if base is given, then x must be a string or 112 Unicode object representing an integer literal in the given base. The 113 literal can be preceded by '+' or '-' and be surrounded by whitespace. 114 The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to 115 interpret the base from the string as an integer literal. 116 >>> int('0b100', base=0) 117 # (copied from class doc) 118 """ 119 pass 120 121 def __int__(self): 122 """ 转换为整数 """ 123 """ x.__int__() <==> int(x) """ 124 pass 125 126 def __invert__(self): 127 """ x.__invert__() <==> ~x """ 128 pass 129 130 def __long__(self): 131 """ 转换为长整数 """ 132 """ x.__long__() <==> long(x) """ 133 pass 134 135 def __lshift__(self, y): 136 """ x.__lshift__(y) <==> x<<y """ 137 pass 138 139 def __mod__(self, y): 140 """ x.__mod__(y) <==> x%y """ 141 pass 142 143 def __mul__(self, y): 144 """ x.__mul__(y) <==> x*y """ 145 pass 146 147 def __neg__(self): 148 """ x.__neg__() <==> -x """ 149 pass 150 151 @staticmethod # known case of __new__ 152 def __new__(S, *more): 153 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 154 pass 155 156 def __nonzero__(self): 157 """ x.__nonzero__() <==> x != 0 """ 158 pass 159 160 def __oct__(self): 161 """ 返回改值的 八进制 表示 """ 162 """ x.__oct__() <==> oct(x) """ 163 pass 164 165 def __or__(self, y): 166 """ x.__or__(y) <==> x|y """ 167 pass 168 169 def __pos__(self): 170 """ x.__pos__() <==> +x """ 171 pass 172 173 def __pow__(self, y, z=None): 174 """ 幂，次方 """ 175 """ x.__pow__(y[, z]) <==> pow(x, y[, z]) """ 176 pass 177 178 def __radd__(self, y): 179 """ x.__radd__(y) <==> y+x """ 180 pass 181 182 def __rand__(self, y): 183 """ x.__rand__(y) <==> y&x """ 184 pass 185 186 def __rdivmod__(self, y): 187 """ x.__rdivmod__(y) <==> divmod(y, x) """ 188 pass 189 190 def __rdiv__(self, y): 191 """ x.__rdiv__(y) <==> y/x """ 192 pass 193 194 def __repr__(self): 195 """转化为解释器可读取的形式 """ 196 """ x.__repr__() <==> repr(x) """ 197 pass 198 199 def __str__(self): 200 """转换为人阅读的形式，如果没有适于人阅读的解释形式的话，则返回解释器课阅读的形式""" 201 """ x.__str__() <==> str(x) """ 202 pass 203 204 def __rfloordiv__(self, y): 205 """ x.__rfloordiv__(y) <==> y//x """ 206 pass 207 208 def __rlshift__(self, y): 209 """ x.__rlshift__(y) <==> y<<x """ 210 pass 211 212 def __rmod__(self, y): 213 """ x.__rmod__(y) <==> y%x """ 214 pass 215 216 def __rmul__(self, y): 217 """ x.__rmul__(y) <==> y*x """ 218 pass 219 220 def __ror__(self, y): 221 """ x.__ror__(y) <==> y|x """ 222 pass 223 224 def __rpow__(self, x, z=None): 225 """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """ 226 pass 227 228 def __rrshift__(self, y): 229 """ x.__rrshift__(y) <==> y>>x """ 230 pass 231 232 def __rshift__(self, y): 233 """ x.__rshift__(y) <==> x>>y """ 234 pass 235 236 def __rsub__(self, y): 237 """ x.__rsub__(y) <==> y-x """ 238 pass 239 240 def __rtruediv__(self, y): 241 """ x.__rtruediv__(y) <==> y/x """ 242 pass 243 244 def __rxor__(self, y): 245 """ x.__rxor__(y) <==> y^x """ 246 pass 247 248 def __sub__(self, y): 249 """ x.__sub__(y) <==> x-y """ 250 pass 251 252 def __truediv__(self, y): 253 """ x.__truediv__(y) <==> x/y """ 254 pass 255 256 def __trunc__(self, *args, **kwargs): 257 """ 返回数值被截取为整形的值，在整形中无意义 """ 258 pass 259 260 def __xor__(self, y): 261 """ x.__xor__(y) <==> x^y """ 262 pass 263 264 denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 265 """ 分母 = 1 """ 266 """the denominator of a rational number in lowest terms""" 267 268 imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 269 """ 虚数，无意义 """ 270 """the imaginary part of a complex number""" 271 272 numerator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 273 """ 分子 = 数字大小 """ 274 """the numerator of a rational number in lowest terms""" 275 276 real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 277 """ 实属，无意义 """ 278 """the real part of a complex number""" 279 280 int
2、字符串
不可以被修改的，而是被重新创建新元素，开辟新内存。
1 class str(basestring): 2 """ 3 str(object='') -> string 4 5 Return a nice string representation of the object. 6 If the argument is a string, the return value is the same object. 7 """ 8 def capitalize(self): 9 """ 首字母变大写 """ 10 """ 11 S.capitalize() -> string 12 13 Return a copy of the string S with only its first character 14 capitalized. 15 """ 16 return "" 17 18 def center(self, width, fillchar=None): 19 """ 内容居中，width：总长度；fillchar：空白处填充内容，默认无 """ 20 """ 21 S.center(width[, fillchar]) -> string 22 23 Return S centered in a string of length width. Padding is 24 done using the specified fill character (default is a space) 25 """ 26 return "" 27 28 def count(self, sub, start=None, end=None): 29 """ 子序列个数 """ 30 """ 31 S.count(sub[, start[, end]]) -> int 32 33 Return the number of non-overlapping occurrences of substring sub in 34 string S[start:end]. Optional arguments start and end are interpreted 35 as in slice notation. 36 """ 37 return 0 38 39 def decode(self, encoding=None, errors=None): 40 """ 解码 """ 41 """ 42 S.decode([encoding[,errors]]) -> object 43 44 Decodes S using the codec registered for encoding. encoding defaults 45 to the default encoding. errors may be given to set a different error 46 handling scheme. Default is 'strict' meaning that encoding errors raise 47 a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' 48 as well as any other name registered with codecs.register_error that is 49 able to handle UnicodeDecodeErrors. 50 """ 51 return object() 52 53 def encode(self, encoding=None, errors=None): 54 """ 编码，针对unicode """ 55 """ 56 S.encode([encoding[,errors]]) -> object 57 58 Encodes S using the codec registered for encoding. encoding defaults 59 to the default encoding. errors may be given to set a different error 60 handling scheme. Default is 'strict' meaning that encoding errors raise 61 a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and 62 'xmlcharrefreplace' as well as any other name registered with 63 codecs.register_error that is able to handle UnicodeEncodeErrors. 64 """ 65 return object() 66 67 def endswith(self, suffix, start=None, end=None): 68 """ 是否以 xxx 结束 """ 69 """ 70 S.endswith(suffix[, start[, end]]) -> bool 71 72 Return True if S ends with the specified suffix, False otherwise. 73 With optional start, test S beginning at that position. 74 With optional end, stop comparing S at that position. 75 suffix can also be a tuple of strings to try. 76 """ 77 return False 78 79 def expandtabs(self, tabsize=None): 80 """ 将tab转换成空格，默认一个tab转换成8个空格 """ 81 """ 82 S.expandtabs([tabsize]) -> string 83 84 Return a copy of S where all tab characters are expanded using spaces. 85 If tabsize is not given, a tab size of 8 characters is assumed. 86 """ 87 return "" 88 89 def find(self, sub, start=None, end=None): 90 """ 寻找子序列位置，如果没找到，返回 -1 """ 91 """ 92 S.find(sub [,start [,end]]) -> int 93 94 Return the lowest index in S where substring sub is found, 95 such that sub is contained within S[start:end]. Optional 96 arguments start and end are interpreted as in slice notation. 97 98 Return -1 on failure. 99 """ 100 return 0 101 102 def format(*args, **kwargs): # known special case of str.format 103 """ 字符串格式化，动态参数，将函数式编程时细说 """ 104 """ 105 S.format(*args, **kwargs) -> string 106 107 Return a formatted version of S, using substitutions from args and kwargs. 108 The substitutions are identified by braces ('{' and '}'). 109 """ 110 pass 111 112 def index(self, sub, start=None, end=None): 113 """ 子序列位置，如果没找到，报错 """ 114 S.index(sub [,start [,end]]) -> int 115 116 Like S.find() but raise ValueError when the substring is not found. 117 """ 118 return 0 119 120 def isalnum(self): 121 """ 是否是字母和数字 """ 122 """ 123 S.isalnum() -> bool 124 125 Return True if all characters in S are alphanumeric 126 and there is at least one character in S, False otherwise. 127 """ 128 return False 129 130 def isalpha(self): 131 """ 是否是字母 """ 132 """ 133 S.isalpha() -> bool 134 135 Return True if all characters in S are alphabetic 136 and there is at least one character in S, False otherwise. 137 """ 138 return False 139 140 def isdigit(self): 141 """ 是否是数字 """ 142 """ 143 S.isdigit() -> bool 144 145 Return True if all characters in S are digits 146 and there is at least one character in S, False otherwise. 147 """ 148 return False 149 150 def islower(self): 151 """ 是否小写 """ 152 """ 153 S.islower() -> bool 154 155 Return True if all cased characters in S are lowercase and there is 156 at least one cased character in S, False otherwise. 157 """ 158 return False 159 160 def isspace(self): 161 """ 162 S.isspace() -> bool 163 164 Return True if all characters in S are whitespace 165 and there is at least one character in S, False otherwise. 166 """ 167 return False 168 169 def istitle(self): 170 """ 171 S.istitle() -> bool 172 173 Return True if S is a titlecased string and there is at least one 174 character in S, i.e. uppercase characters may only follow uncased 175 characters and lowercase characters only cased ones. Return False 176 otherwise. 177 """ 178 return False 179 180 def isupper(self): 181 """ 182 S.isupper() -> bool 183 184 Return True if all cased characters in S are uppercase and there is 185 at least one cased character in S, False otherwise. 186 """ 187 return False 188 189 def join(self, iterable): 190 """ 连接 """ 191 """ 192 S.join(iterable) -> string 193 194 Return a string which is the concatenation of the strings in the 195 iterable. The separator between elements is S. 196 """ 197 return "" 198 199 def ljust(self, width, fillchar=None): 200 """ 内容左对齐，右侧填充 """ 201 """ 202 S.ljust(width[, fillchar]) -> string 203 204 Return S left-justified in a string of length width. Padding is 205 done using the specified fill character (default is a space). 206 """ 207 return "" 208 209 def lower(self): 210 """ 变小写 """ 211 """ 212 S.lower() -> string 213 214 Return a copy of the string S converted to lowercase. 215 """ 216 return "" 217 218 def lstrip(self, chars=None): 219 """ 移除左侧空白 """ 220 """ 221 S.lstrip([chars]) -> string or unicode 222 223 Return a copy of the string S with leading whitespace removed. 224 If chars is given and not None, remove characters in chars instead. 225 If chars is unicode, S will be converted to unicode before stripping 226 """ 227 return "" 228 229 def partition(self, sep): 230 """ 分割，前，中，后三部分 """ 231 """ 232 S.partition(sep) -> (head, sep, tail) 233 234 Search for the separator sep in S, and return the part before it, 235 the separator itself, and the part after it. If the separator is not 236 found, return S and two empty strings. 237 """ 238 pass 239 240 def replace(self, old, new, count=None): 241 """ 替换 """ 242 """ 243 S.replace(old, new[, count]) -> string 244 245 Return a copy of string S with all occurrences of substring 246 old replaced by new. If the optional argument count is 247 given, only the first count occurrences are replaced. 248 """ 249 return "" 250 251 def rfind(self, sub, start=None, end=None): 252 """ 253 S.rfind(sub [,start [,end]]) -> int 254 255 Return the highest index in S where substring sub is found, 256 such that sub is contained within S[start:end]. Optional 257 arguments start and end are interpreted as in slice notation. 258 259 Return -1 on failure. 260 """ 261 return 0 262 263 def rindex(self, sub, start=None, end=None): 264 """ 265 S.rindex(sub [,start [,end]]) -> int 266 267 Like S.rfind() but raise ValueError when the substring is not found. 268 """ 269 return 0 270 271 def rjust(self, width, fillchar=None): 272 """ 273 S.rjust(width[, fillchar]) -> string 274 275 Return S right-justified in a string of length width. Padding is 276 done using the specified fill character (default is a space) 277 """ 278 return "" 279 280 def rpartition(self, sep): 281 """ 282 S.rpartition(sep) -> (head, sep, tail) 283 284 Search for the separator sep in S, starting at the end of S, and return 285 the part before it, the separator itself, and the part after it. If the 286 separator is not found, return two empty strings and S. 287 """ 288 pass 289 290 def rsplit(self, sep=None, maxsplit=None): 291 """ 292 S.rsplit([sep [,maxsplit]]) -> list of strings 293 294 Return a list of the words in the string S, using sep as the 295 delimiter string, starting at the end of the string and working 296 to the front. If maxsplit is given, at most maxsplit splits are 297 done. If sep is not specified or is None, any whitespace string 298 is a separator. 299 """ 300 return [] 301 302 def rstrip(self, chars=None): 303 """ 304 S.rstrip([chars]) -> string or unicode 305 306 Return a copy of the string S with trailing whitespace removed. 307 If chars is given and not None, remove characters in chars instead. 308 If chars is unicode, S will be converted to unicode before stripping 309 """ 310 return "" 311 312 def split(self, sep=None, maxsplit=None): 313 """ 分割， maxsplit最多分割几次 """ 314 """ 315 S.split([sep [,maxsplit]]) -> list of strings 316 317 Return a list of the words in the string S, using sep as the 318 delimiter string. If maxsplit is given, at most maxsplit 319 splits are done. If sep is not specified or is None, any 320 whitespace string is a separator and empty strings are removed 321 from the result. 322 """ 323 return [] 324 325 def splitlines(self, keepends=False): 326 """ 根据换行分割 """ 327 """ 328 S.splitlines(keepends=False) -> list of strings 329 330 Return a list of the lines in S, breaking at line boundaries. 331 Line breaks are not included in the resulting list unless keepends 332 is given and true. 333 """ 334 return [] 335 336 def startswith(self, prefix, start=None, end=None): 337 """ 是否起始 """ 338 """ 339 S.startswith(prefix[, start[, end]]) -> bool 340 341 Return True if S starts with the specified prefix, False otherwise. 342 With optional start, test S beginning at that position. 343 With optional end, stop comparing S at that position. 344 prefix can also be a tuple of strings to try. 345 """ 346 return False 347 348 def strip(self, chars=None): 349 """ 移除两段空白 """ 350 """ 351 S.strip([chars]) -> string or unicode 352 353 Return a copy of the string S with leading and trailing 354 whitespace removed. 355 If chars is given and not None, remove characters in chars instead. 356 If chars is unicode, S will be converted to unicode before stripping 357 """ 358 return "" 359 360 def swapcase(self): 361 """ 大写变小写，小写变大写 """ 362 """ 363 S.swapcase() -> string 364 365 Return a copy of the string S with uppercase characters 366 converted to lowercase and vice versa. 367 """ 368 return "" 369 370 def title(self): 371 """ 372 S.title() -> string 373 374 Return a titlecased version of S, i.e. words start with uppercase 375 characters, all remaining cased characters have lowercase. 376 """ 377 return "" 378 379 def translate(self, table, deletechars=None): 380 """ 381 转换，需要先做一个对应表，最后一个表示删除字符集合 382 intab = "aeiou" 383 outtab = "12345" 384 trantab = maketrans(intab, outtab) 385 str = "this is string example....wow!!!" 386 print str.translate(trantab, 'xm') 387 """ 388 389 """ 390 S.translate(table [,deletechars]) -> string 391 392 Return a copy of the string S, where all characters occurring 393 in the optional argument deletechars are removed, and the 394 remaining characters have been mapped through the given 395 translation table, which must be a string of length 256 or None. 396 If the table argument is None, no translation is applied and 397 the operation simply removes the characters in deletechars. 398 """ 399 return "" 400 401 def upper(self): 402 """ 403 S.upper() -> string 404 405 Return a copy of the string S converted to uppercase. 406 """ 407 return "" 408 409 def zfill(self, width): 410 """方法返回指定长度的字符串，原字符串右对齐，前面填充0。""" 411 """ 412 S.zfill(width) -> string 413 414 Pad a numeric string S with zeros on the left, to fill a field 415 of the specified width. The string S is never truncated. 416 """ 417 return "" 418 419 def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown 420 pass 421 422 def _formatter_parser(self, *args, **kwargs): # real signature unknown 423 pass 424 425 def __add__(self, y): 426 """ x.__add__(y) <==> x+y """ 427 pass 428 429 def __contains__(self, y): 430 """ x.__contains__(y) <==> y in x """ 431 pass 432 433 def __eq__(self, y): 434 """ x.__eq__(y) <==> x==y """ 435 pass 436 437 def __format__(self, format_spec): 438 """ 439 S.__format__(format_spec) -> string 440 441 Return a formatted version of S as described by format_spec. 442 """ 443 return "" 444 445 def __getattribute__(self, name): 446 """ x.__getattribute__('name') <==> x.name """ 447 pass 448 449 def __getitem__(self, y): 450 """ x.__getitem__(y) <==> x[y] """ 451 pass 452 453 def __getnewargs__(self, *args, **kwargs): # real signature unknown 454 pass 455 456 def __getslice__(self, i, j): 457 """ 458 x.__getslice__(i, j) <==> x[i:j] 459 460 Use of negative indices is not supported. 461 """ 462 pass 463 464 def __ge__(self, y): 465 """ x.__ge__(y) <==> x>=y """ 466 pass 467 468 def __gt__(self, y): 469 """ x.__gt__(y) <==> x>y """ 470 pass 471 472 def __hash__(self): 473 """ x.__hash__() <==> hash(x) """ 474 pass 475 476 def __init__(self, string=''): # known special case of str.__init__ 477 """ 478 str(object='') -> string 479 480 Return a nice string representation of the object. 481 If the argument is a string, the return value is the same object. 482 # (copied from class doc) 483 """ 484 pass 485 486 def __len__(self): 487 """ x.__len__() <==> len(x) """ 488 pass 489 490 def __le__(self, y): 491 """ x.__le__(y) <==> x<=y """ 492 pass 493 494 def __lt__(self, y): 495 """ x.__lt__(y) <==> x<y """ 496 pass 497 498 def __mod__(self, y): 499 """ x.__mod__(y) <==> x%y """ 500 pass 501 502 def __mul__(self, n): 503 """ x.__mul__(n) <==> x*n """ 504 pass 505 506 @staticmethod # known case of __new__ 507 def __new__(S, *more): 508 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 509 pass 510 511 def __ne__(self, y): 512 """ x.__ne__(y) <==> x!=y """ 513 pass 514 515 def __repr__(self): 516 """ x.__repr__() <==> repr(x) """ 517 pass 518 519 def __rmod__(self, y): 520 """ x.__rmod__(y) <==> y%x """ 521 pass 522 523 def __rmul__(self, n): 524 """ x.__rmul__(n) <==> n*x """ 525 pass 526 527 def __sizeof__(self): 528 """ S.__sizeof__() -> size of S in memory, in bytes """ 529 pass 530 531 def __str__(self): 532 """ x.__str__() <==> str(x) """ 533 pass 534 535 str
1 # _*_ encoding:utf-8 _*_ 2 __author__ = 'listen' 3 __date__ = '2018/11/3 10:54' 4 #参数只有一个self可以默认不写参数，但若还有其他的，第二个参数必写，后面的可写可不写，写了可以按照条件去执行 5 # name='listen' 6 # a=name.capitalize() 7 # print(a) #首字母变大写 8 #----------------------------- 9 # name='alex' 10 # a=name.ljust(20,'*')#用*从左往右补全20个字符 11 # b=name.rjust(10,' ')#用空格从右向左补全10个字符 12 # print(b) 13 #$$$$$$$$$$$$$ 14 # name='listen' 15 # a=name.center(20,'*') 16 # print(a) #*******listen******* 占20个位，‘*’填补，若不写这个参数，已空格来填补 17 # a=name.zfill(10) 18 # print(a)#用0左填充补齐字符 19 #---------------------------------------- 20 # name='listensdsdd' 21 # a=name.count('s') #s的个数 22 # b=name.count('s',5) #从索引为第5个位置找 23 # c=name.count('s',5,7)#从5找到7 24 # print(c) 25 #-------------------------------------------- 26 # name='listen' 27 # a=name.startswith('a') 28 # c=name.startswith('s',2) 29 # b=name.endswith('n') 30 # d=name.endswith('e',1,5)#[1,5) 31 # print(a) #bool类型，返回false 32 # print(b)#true 33 # print(c) 34 # print(d) 35 #-------------------------------------------- 36 # information='name\tage\tsex\tgrade\nlisten\t13\tmale\tgood\nlisten\t13\tmale\tgood\nlisten\t13\tmale\tgood\n' 37 # a=information.expandtabs(10) #将10字符分为一组，遇到\t补全10字符，默认一个tab转换为8个空格，也可以根据自己需要添加空格的值，一个\n为换行符，这样可以制作左对齐表格 38 # print(a) 39 # """ 40 # name age sex grade 41 # listen 13 male good 42 # listen 13 male good 43 # listen 13 male good 44 # """ 45 #-------------------------------------------------- 46 # name='listen' 47 # a=name.find('s') 48 # b=name.find('s',3) 49 # c=name.find('e',3,5) 50 # d=name.index('s',3)#找不到会报错，不建议用这个，建议用find 51 # print(a)#找索引位置2 52 # print(b) #没找到返回-1 53 # print(c) #4 54 # print(d) 55 #--------------------------------------------- 56 #字符串的格式化 57 # troduce='I am {name},{age} years old' 58 # a=troduce.format(name='listen',age=13) 59 # print(a) 60 # troduce='I am {0},{1} years old' 61 # a=troduce.format('listen',13) #跟上面一一对应 62 # print(a) 63 #------------------------------------------------ 64 #name='asc123' 65 # a=name.isalnum()#是否是字母或者数字 66 # b=name.isalpha()#是否全部是字母 67 # c=name.isdigit()#是否全为数字（厉害）② 68 #d=name.isdecimal()#是否全为数字（十进制的小数）2 69 #e=name.isnumeric()#是否为数字（最厉害，中文的二都认识）二 70 # print(a) #True 71 # print(b) #False 72 # print(c)#False 73 #---------------------------------------------- 74 # name='listen' 75 # a=name.islower() #是否为小写 76 # print(a) 77 # name1='LiStEn' 78 # b=name1.lower() #把字符串变为小写 79 # c=name1.upper() #把字符串变为大写 80 # print(b) 81 # print(c) 82 #--------------------------------------- 83 # name='adcc\t' 84 # a=name.isprintable() 85 # print(a)#是否有不可以显示出的字符\t制表符 \n换行符 都是显示不出来 86 #------------------------------------------ 87 # name=' ' 88 # a=name.isspace() #是否全为空格，空字符串也是false 89 # print(a) 90 #--------------------------------------------- 91 # name='listen is a good student' 92 # a=name.istitle()#判断是否为标题的依据是是否句子首字母为大写 93 # b=name.title() #变为标题 94 # c=b.istitle() 95 # print(c) 96 #---------------------------------------- 97 #********很重要 98 # name='nihao' 99 # t=' ' 100 # a=t.join(name) 101 # b='*'.join(name) #用*把名字的字符拼接起来 102 # print(b) 103 #----------------------------------------- 104 # name=' listen ' 105 # al='acv\neg\t' 106 # dl='\tssafgdas' 107 # a=name.strip()#把左右空格、换行符、制表符都移除 108 # print(al.strip()) 109 # b=name.lstrip()#把左边的空格移除 110 # c=name.rstrip()#把右边的空格移除,从又第一个字母开始找，有的话移除 111 # print(dl.rstrip('a')) 112 # print(dl) 113 # v=dl.strip() 114 # print(v) 115 # print(c) 116 #---------------------------------------------------- 117 # name='alexsslefgs' 118 # a=name.partition('s') #按要求分割成三部分包含分隔符 119 # a=name.rpartition('s')#从右分割为三部分 120 # a=name.split('s') #按要求分割，有几部分分几部分，但是不包含分隔符 121 # a=name.rsplit('s')#从右分割 122 123 # print(a) 124 #------------------------------------------------------- 125 # a='asdfg\nwett\nhed\nd' 126 # v=a.splitlines() #根据换行符进行分割成list 127 # print(v) 128 #--------------------------------------------------- 129 # name='alexjennyADDkiDoHeLLo' 130 # v=name.swapcase() 131 # print(v)#小写和大写之间的相互转换（小变大，大变小） 132 #---------------------------------------------------- 133 # intab='abcdefg' 134 # outab='1234567' 135 # s='abcdefgabcdefg' 136 # a=trantab=maketrans(intab,outab) 137 # # s.translate(trantab) 138 # # print(a)#转换 139 #------------------------------------------------------
140 #s='alexjennyailalisa'
141 #v=s.replace('a','m',4)#让m替换a，替换的个数为4
142 #print(v)
7+4
1 s='123ert' 2 v=s[3]#e 3 print(v)#通过索引获取某一个字符串的某一个字符 4 v=s[1:] 5 print(v)#23ert 通过切片 6 v=len(s) 7 print(v)#6获取字符串的长度 8 v='_'.join(s)*********** 9 print(v)#1_2_3_e_r_t 这几个不仅使用str还使用其他数据类型
10个红色方法为重点（移除空白、分割、长度、索引、切片）
字符串一旦创建就不可修改，一旦修改或者拼接，就会重新生成新的字符串。
3、bool布尔值
真或假（1或0）
4、列表
列表中的元素可以为任意类型，是一个集合。
列表的元素可以被修改。
基本操作：
L=['alex','jenny','danny','liming']
索引：index()
切片：L[]
追加：append()
删除：pop()和remove() del L[2:4]
长度：len(L)
循环：for x in L:
包含：'alex' in L
1 class list(object): 2 """ 3 list() -> new empty list 4 list(iterable) -> new list initialized from iterable's items 5 """ 6 def append(self, p_object): # real signature unknown; restored from __doc__ 7 """ L.append(object) -- append object to end """ 8 pass 9 10 def count(self, value): # real signature unknown; restored from __doc__ 11 """ L.count(value) -> integer -- return number of occurrences of value """ 12 return 0 13 14 def extend(self, iterable): # real signature unknown; restored from __doc__ 15 """ L.extend(iterable) -- extend list by appending elements from the iterable """ 16 pass 17 18 def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__ 19 """ 20 L.index(value, [start, [stop]]) -> integer -- return first index of value. 21 Raises ValueError if the value is not present. 22 """ 23 return 0 24 25 def insert(self, index, p_object): # real signature unknown; restored from __doc__ 26 """ L.insert(index, object) -- insert object before index """ 27 pass 28 29 def pop(self, index=None): # real signature unknown; restored from __doc__ 30 """ 31 L.pop([index]) -> item -- remove and return item at index (default last). 32 Raises IndexError if list is empty or index is out of range. 33 """ 34 pass 35 36 def remove(self, value): # real signature unknown; restored from __doc__ 37 """ 38 L.remove(value) -- remove first occurrence of value. 39 Raises ValueError if the value is not present. 40 """ 41 pass 42 43 def reverse(self): # real signature unknown; restored from __doc__ 44 """ L.reverse() -- reverse *IN PLACE* """ 45 pass 46 47 def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__ 48 """ 49 L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*; 50 cmp(x, y) -> -1, 0, 1 51 """ 52 pass 53 54 def __add__(self, y): # real signature unknown; restored from __doc__ 55 """ x.__add__(y) <==> x+y """ 56 pass 57 58 def __contains__(self, y): # real signature unknown; restored from __doc__ 59 """ x.__contains__(y) <==> y in x """ 60 pass 61 62 def __delitem__(self, y): # real signature unknown; restored from __doc__ 63 """ x.__delitem__(y) <==> del x[y] """ 64 pass 65 66 def __delslice__(self, i, j): # real signature unknown; restored from __doc__ 67 """ 68 x.__delslice__(i, j) <==> del x[i:j] 69 70 Use of negative indices is not supported. 71 """ 72 pass 73 74 def __eq__(self, y): # real signature unknown; restored from __doc__ 75 """ x.__eq__(y) <==> x==y """ 76 pass 77 78 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 79 """ x.__getattribute__('name') <==> x.name """ 80 pass 81 82 def __getitem__(self, y): # real signature unknown; restored from __doc__ 83 """ x.__getitem__(y) <==> x[y] """ 84 pass 85 86 def __getslice__(self, i, j): # real signature unknown; restored from __doc__ 87 """ 88 x.__getslice__(i, j) <==> x[i:j] 89 90 Use of negative indices is not supported. 91 """ 92 pass 93 94 def __ge__(self, y): # real signature unknown; restored from __doc__ 95 """ x.__ge__(y) <==> x>=y """ 96 pass 97 98 def __gt__(self, y): # real signature unknown; restored from __doc__ 99 """ x.__gt__(y) <==> x>y """ 100 pass 101 102 def __iadd__(self, y): # real signature unknown; restored from __doc__ 103 """ x.__iadd__(y) <==> x+=y """ 104 pass 105 106 def __imul__(self, y): # real signature unknown; restored from __doc__ 107 """ x.__imul__(y) <==> x*=y """ 108 pass 109 110 def __init__(self, seq=()): # known special case of list.__init__ 111 """ 112 list() -> new empty list 113 list(iterable) -> new list initialized from iterable's items 114 # (copied from class doc) 115 """ 116 pass 117 118 def __iter__(self): # real signature unknown; restored from __doc__ 119 """ x.__iter__() <==> iter(x) """ 120 pass 121 122 def __len__(self): # real signature unknown; restored from __doc__ 123 """ x.__len__() <==> len(x) """ 124 pass 125 126 def __le__(self, y): # real signature unknown; restored from __doc__ 127 """ x.__le__(y) <==> x<=y """ 128 pass 129 130 def __lt__(self, y): # real signature unknown; restored from __doc__ 131 """ x.__lt__(y) <==> x<y """ 132 pass 133 134 def __mul__(self, n): # real signature unknown; restored from __doc__ 135 """ x.__mul__(n) <==> x*n """ 136 pass 137 138 @staticmethod # known case of __new__ 139 def __new__(S, *more): # real signature unknown; restored from __doc__ 140 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 141 pass 142 143 def __ne__(self, y): # real signature unknown; restored from __doc__ 144 """ x.__ne__(y) <==> x!=y """ 145 pass 146 147 def __repr__(self): # real signature unknown; restored from __doc__ 148 """ x.__repr__() <==> repr(x) """ 149 pass 150 151 def __reversed__(self): # real signature unknown; restored from __doc__ 152 """ L.__reversed__() -- return a reverse iterator over the list """ 153 pass 154 155 def __rmul__(self, n): # real signature unknown; restored from __doc__ 156 """ x.__rmul__(n) <==> n*x """ 157 pass 158 159 def __setitem__(self, i, y): # real signature unknown; restored from __doc__ 160 """ x.__setitem__(i, y) <==> x[i]=y """ 161 pass 162 163 def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__ 164 """ 165 x.__setslice__(i, j, y) <==> x[i:j]=y 166 167 Use of negative indices is not supported. 168 """ 169 pass 170 171 def __sizeof__(self): # real signature unknown; restored from __doc__ 172 """ L.__sizeof__() -- size of L in memory, in bytes """ 173 pass 174 175 __hash__ = None
练习：
1 #_*_ encoding:utf-8 _*_ 2 list=['jenny','danny','alex','steven','alex'] 3 #---------------------------------------------方法 4 # list.append('listen')#在原值后追加 list.append([1,2]) 5 # print(list) #['jenny', 'danny', 'alex', 'steven', 'alex', 'listen'] 6 # #------------------------------ 7 # b=list.count('alex') #2 计数 8 # print b 9 # #---------------------------------- 10 # list1=['nihao','hi'] 11 # print list+list1 #['jenny', 'danny', 'alex', 'steven', 'alex', 'nihao', 'hi'] 12 # list.extend(list1) #扩展必须是可迭代对象（在内部执行的for循环） 13 # print list #['jenny', 'danny', 'alex', 'steven', 'alex', 'listen', 'nihao', 'hi'] 14 # #--------------------------------------- 15 # print list.index('danny') #1 根据值获取当前值索引的位置 16 #--------------------------------------- 17 # list.insert(0,'name') #在某位置插入某个元素 18 # print list #['name', 'jenny', 'danny', 'alex', 'steven', 'alex'] 19 #-------------------------------------- 20 # list.pop(0) #返回被删除的值 21 # print list #['danny', 'alex', 'steven', 'alex'] 没有参数默认是移除最后一个元素，有参数按照参数指定位置（索引）移除元素 22 #--------------------------------------- 23 # list.remove('jenny') 24 # print list #把指定值移除 删除左边优先 25 #------------------------------------------ 26 # list.reverse() 27 # print list #把列表中的元素倒叙输出，回文 ['alex', 'steven', 'alex', 'danny', 'jenny'] 28 #------------------------------------------- 29 # list.sort() 30 # print list #对原列表进行排序，默认英文字母排序（升序）,可以设置参数reverse=True是降序 31 #--------------------------------------------- 32 # print list[2:] #切片 第三个元素到最后 33 # print list[-1] #取最后一个元素 34 # print list[1:3] #[1,3) 35 # print list[1] #取第二个元素 36 # print len(list) #list的长度 37 # a=['hi'] 38 # print a*3 #['hi', 'hi', 'hi'] 39 # print 'hi' in a #True 'hi'在列表a中吗？ 包含 40 # for x in list: 41 # print x #可迭代 42 #----------------------------------------------------函数 43 # list2=['how','are','you'] 44 # list3=['ni','hao','ya'] 45 # print cmp(list2,list3) #比较两个列表的大小asci对应的- 1（右边的） 0 （平局） 1 (左边的) 46 # print max(list) #steven 47 # print min(list) 48 # tuple1=(1,2,3,4,5) 49 # print list(tuple1) #[1, 2, 3, 4, 5] list()函数 tuple转为list
5、元组
元组基本操作：
索引---根据索引取值
切片---根据切片取值
循环---for 循环
长度---len（）
包含---in
文档：
1 lass 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
ep：
1 # _*_ encoding:utf-8 _*_ 2 __author__ = 'listen' 3 __date__ = '2018/11/5 22:19' 4 5 6 # s='awegjslfjjnjf' 7 # s1=list(s) #可迭代才可以用list()方法转换成列表（内部使用for循环）---字符串转换为列表 8 # print(s1) 9 # L=['alex','hello','hi',123,34,24] 10 #str(L)整体转换为字符串，也就是说在L外面加了一个'l' 11 12 #1列表转换为字符串--需要自己写for循环(既有数字又有字符串) 13 # s2='' 14 # for i in L: 15 # s2+=str(i) 16 # print(s2) #'alexhellohi1233424' 17 # #2如果列表中都是字符串，么有整型 18 # L1=['alex','hello','hi'] 19 # s=''.join(L1) 20 # print(s) 21 22 #1 清空列表 23 # li=[1,2,3,4,5] 24 # li.clear() 25 # print(li) #清空列表 26 #2 拷贝 浅拷贝 27 # v=li.copy() 28 # print(v) #浅浅的拷贝了一下 29 30 #3del 删除 remove pop clear 31 # del li[0:3] 32 # print(li) #L=[4, 5] 33 #列表是有序的，元素可以被修改 34 35 #1元组，元素不能被修改，不能增加、删除和修改（对列表的第二次加工 ） 36 #一般写元组的时候，推荐最好在最后一个元素加一个逗号 37 #通过索引取值 38 # tu=(1,2,3,'a','b') 39 #2、索引 40 # v=tu[0] 41 # print(v) #1 42 #3、切片 43 # v=tu[1:] 44 # print(v) #(2, 3, 'a', 'b') 45 #4、循环(遍历、迭代)为可迭代对象 46 # for item in tu: 47 # # print(i) 48 #5、转换(可迭代对象) 49 # s='abcdef' 50 # li=['a','b','c'] 51 # tu=('f','s') 52 #字符串到列表 53 # v=list(s) 54 # print(v)#['a', 'b', 'c', 'd', 'e', 'f'] 55 #列表到字符串 56 # v=''.join(li) 57 # print(v) #'abc' 58 #字符串到元组 59 # v=tuple(s) 60 # print(v) #('a', 'b', 'c', 'd', 'e', 'f') 61 #元组到字符串 62 # v='_'.join(tu) 63 # print(v) #f_s 64 #列表到元祖 65 # v=tuple(li) 66 # print(v)#('a', 'b', 'c') 67 #元组到列表 68 # v=list(tu) 69 # print(v) #['f', 's'] 70 #6、元组、有序 71 #元组的第一级元素是不可被修改的 72 # tu=(11,22,'alex',([1,2],),('a','b'),True,99,22) 73 # v=tu[3][0][1] 74 # tu[3][0][1]=8 #(11, 22, 'alex', ([1, 8],), ('a', 'b'), True, 99) 75 # print(tu) #2 76 # tu[3][0]=2 77 # # print(tu) 错误的做法 78 #建议在元组的最后一个元素加上逗号，方便确认是元组 79 80 #方法 81 #1、count()该值出现的次数 82 # v=tu.count(22) 83 # print(v) #2 84 85 #2、index()该值索引的位置 86 # v=tu.index(22) 87 # print(v) #1从左到右找
6、字典（无序）
字典是键值对组成的
字典基本操作：
索引：dic['key']
新增：update()更新,有参数的键值对，就按照参数更新，如果没有，就新增键值对 setdefault()字典中有设置的默认的参数(已存在，不设置)，返回的是字典中的参数和所对应的值，设置默认参数字典中没有的，则返回默认键所对应的值,并把设置的添加到字典中（不存在，新添设置）
删除：del dic['key1'] pop()删除指定元素 popitem()随意删除一组键值对
键、值、键值对： keys() values() items()
循环：for
长度：len()
1 class dict(object): 2 """ 3 dict() -> new empty dictionary 4 dict(mapping) -> new dictionary initialized from a mapping object's 5 (key, value) pairs 6 dict(iterable) -> new dictionary initialized as if via: 7 d = {} 8 for k, v in iterable: 9 d[k] = v 10 dict(**kwargs) -> new dictionary initialized with the name=value pairs 11 in the keyword argument list. For example: dict(one=1, two=2) 12 """ 13 14 def clear(self): # real signature unknown; restored from __doc__ 15 """ 清除内容 """ 16 """ D.clear() -> None. Remove all items from D. """ 17 pass 18 19 def copy(self): # real signature unknown; restored from __doc__ 20 """ 浅拷贝 """ 21 """ D.copy() -> a shallow copy of D """ 22 pass 23 24 @staticmethod # known case 25 def fromkeys(S, v=None): # real signature unknown; restored from __doc__ 26 """ 27 dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v. 28 v defaults to None. 29 """ 30 pass 31 32 def get(self, k, d=None): # real signature unknown; restored from __doc__ 33 """ 根据key获取值，d是默认值 """ 34 """ D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """ 35 pass 36 37 def has_key(self, k): # real signature unknown; restored from __doc__ 38 """ 是否有key """ 39 """ D.has_key(k) -> True if D has a key k, else False """ 40 return False 41 42 def items(self): # real signature unknown; restored from __doc__ 43 """ 所有项的列表形式 """ 44 """ D.items() -> list of D's (key, value) pairs, as 2-tuples """ 45 return [] 46 47 def iteritems(self): # real signature unknown; restored from __doc__ 48 """ 项可迭代 """ 49 """ D.iteritems() -> an iterator over the (key, value) items of D """ 50 pass 51 52 def iterkeys(self): # real signature unknown; restored from __doc__ 53 """ key可迭代 """ 54 """ D.iterkeys() -> an iterator over the keys of D """ 55 pass 56 57 def itervalues(self): # real signature unknown; restored from __doc__ 58 """ value可迭代 """ 59 """ D.itervalues() -> an iterator over the values of D """ 60 pass 61 62 def keys(self): # real signature unknown; restored from __doc__ 63 """ 所有的key列表 """ 64 """ D.keys() -> list of D's keys """ 65 return [] 66 67 def pop(self, k, d=None): # real signature unknown; restored from __doc__ 68 """ 获取并在字典中移除 """ 69 """ 70 D.pop(k[,d]) -> v, remove specified key and return the corresponding value. 71 If key is not found, d is returned if given, otherwise KeyError is raised 72 """ 73 pass 74 75 def popitem(self): # real signature unknown; restored from __doc__ 76 """ 获取并在字典中移除 """ 77 """ 78 D.popitem() -> (k, v), remove and return some (key, value) pair as a 79 2-tuple; but raise KeyError if D is empty. 80 """ 81 pass 82 83 def setdefault(self, k, d=None): # real signature unknown; restored from __doc__ 84 """ 如果key不存在，则创建，如果存在，则返回已存在的值且不修改 """ 85 """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """ 86 pass 87 88 def update(self, E=None, **F): # known special case of dict.update 89 """ 更新 90 {'name':'alex', 'age': 18000} 91 [('name','sbsbsb'),] 92 """ 93 """ 94 D.update([E, ]**F) -> None. Update D from dict/iterable E and F. 95 If E present and has a .keys() method, does: for k in E: D[k] = E[k] 96 If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v 97 In either case, this is followed by: for k in F: D[k] = F[k] 98 """ 99 pass 100 101 def values(self): # real signature unknown; restored from __doc__ 102 """ 所有的值 """ 103 """ D.values() -> list of D's values """ 104 return [] 105 106 def viewitems(self): # real signature unknown; restored from __doc__ 107 """ 所有项，只是将内容保存至view对象中 """ 108 """ D.viewitems() -> a set-like object providing a view on D's items """ 109 pass 110 111 def viewkeys(self): # real signature unknown; restored from __doc__ 112 """ D.viewkeys() -> a set-like object providing a view on D's keys """ 113 pass 114 115 def viewvalues(self): # real signature unknown; restored from __doc__ 116 """ D.viewvalues() -> an object providing a view on D's values """ 117 pass 118 119 def __cmp__(self, y): # real signature unknown; restored from __doc__ 120 """ x.__cmp__(y) <==> cmp(x,y) """ 121 pass 122 123 def __contains__(self, k): # real signature unknown; restored from __doc__ 124 """ D.__contains__(k) -> True if D has a key k, else False """ 125 return False 126 127 def __delitem__(self, y): # real signature unknown; restored from __doc__ 128 """ x.__delitem__(y) <==> del x[y] """ 129 pass 130 131 def __eq__(self, y): # real signature unknown; restored from __doc__ 132 """ x.__eq__(y) <==> x==y """ 133 pass 134 135 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 136 """ x.__getattribute__('name') <==> x.name """ 137 pass 138 139 def __getitem__(self, y): # real signature unknown; restored from __doc__ 140 """ x.__getitem__(y) <==> x[y] """ 141 pass 142 143 def __ge__(self, y): # real signature unknown; restored from __doc__ 144 """ x.__ge__(y) <==> x>=y """ 145 pass 146 147 def __gt__(self, y): # real signature unknown; restored from __doc__ 148 """ x.__gt__(y) <==> x>y """ 149 pass 150 151 def __init__(self, seq=None, **kwargs): # known special case of dict.__init__ 152 """ 153 dict() -> new empty dictionary 154 dict(mapping) -> new dictionary initialized from a mapping object's 155 (key, value) pairs 156 dict(iterable) -> new dictionary initialized as if via: 157 d = {} 158 for k, v in iterable: 159 d[k] = v 160 dict(**kwargs) -> new dictionary initialized with the name=value pairs 161 in the keyword argument list. For example: dict(one=1, two=2) 162 # (copied from class doc) 163 """ 164 pass 165 166 def __iter__(self): # real signature unknown; restored from __doc__ 167 """ x.__iter__() <==> iter(x) """ 168 pass 169 170 def __len__(self): # real signature unknown; restored from __doc__ 171 """ x.__len__() <==> len(x) """ 172 pass 173 174 def __le__(self, y): # real signature unknown; restored from __doc__ 175 """ x.__le__(y) <==> x<=y """ 176 pass 177 178 def __lt__(self, y): # real signature unknown; restored from __doc__ 179 """ x.__lt__(y) <==> x<y """ 180 pass 181 182 @staticmethod # known case of __new__ 183 def __new__(S, *more): # real signature unknown; restored from __doc__ 184 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 185 pass 186 187 def __ne__(self, y): # real signature unknown; restored from __doc__ 188 """ x.__ne__(y) <==> x!=y """ 189 pass 190 191 def __repr__(self): # real signature unknown; restored from __doc__ 192 """ x.__repr__() <==> repr(x) """ 193 pass 194 195 def __setitem__(self, i, y): # real signature unknown; restored from __doc__ 196 """ x.__setitem__(i, y) <==> x[i]=y """ 197 pass 198 199 def __sizeof__(self): # real signature unknown; restored from __doc__ 200 """ D.__sizeof__() -> size of D in memory, in bytes """ 201 pass 202 203 __hash__ = None 204 205 dict
ep:
1 # _*_ encoding:utf-8 _*_ 2 __author__ = 'listen' 3 __date__ = '2018/11/7 21:36' 4 #1、基本结构 5 # info={ 6 # 'k1':'v1', 7 # 'k2':'v2' 8 # } 9 #2 字典的值可以值任意类型的 10 #3 列表、字典不能作为字典的key，元组可以作为字典的key hash true :1 false :0 11 #4 字典是无序的 12 #5、通过索引方式找到元素 13 # info={ 14 # 'k1':1, 15 # 'k2':2, 16 # 'k3':3, 17 # 1:'a', 18 # (1,2,3):[1,88,9], 19 # 'k5':[ 20 # 1,2,3,{ 21 # 'kk1':'3', 22 # 'kk2':(11,12) 23 # } 24 # ] 25 # 26 # } 27 # v=info['k5'][3]['kk2'][1] 28 # print(v) #12 29 30 #6 删除字典中的元素 31 # del info['k1'] 32 # print(info) 33 #7 支持 for 循环 34 # for item in info.keys(): 35 # print(item) #取key 默认是key 36 # for item in info.values(): 37 # print(item) # 取value 38 # for k,v in info.items(): 39 # print(k,v) 40 41 #方法 1、取出字典的key，并设置默认值为none,若有第2个参数，则为key的值 42 # dic={'k1':'v1', 43 # 'k2':'v2' 44 # } 45 # v=dict.fromkeys(dic,1) 46 # print(v) 47 48 #2、通过get方法取值，若没有输入的key，则会返回none，不会报错 49 # v=dic.get('k11') 50 # print(v) #none 51 52 #3、items()返回的是一个list 53 # v=dic.items() 54 # print(v) #dict_items([('k1', 'v1'), ('k2', 'v2')]) 55 56 #4、pop 删除指定的键值对，返回被删除键的值,popitem()没有参数，会随意删除字典中一个键值对，返回被删除的键值对的元组 57 # dic={'k1':'v1', 58 # 'k2':'v2' 59 # } 60 # v=dic.pop('k1') 61 # print(dic,v) #{'k2': 'v2'} v1 62 # v=dic.popitem() 63 # print(dic,v) # {'k1': 'v1'} ('k2', 'v2') 64 65 #5、setdefault 中的参数，字典中有设置的默认的参数(已存在，不设置)，返回的是字典中的参数和所对应的值，设置默认参数字典中没有的，则返回默认键所对应的值,并把设置的添加到字典中（不存在，新添设置） 66 # dic={'k1':'v1', 67 # 'k2':'v2' 68 # } 69 # v=dic.setdefault('k1',1) 70 # v1=dic.setdefault('k111',88) 71 # print(dic,v) #{'k1': 'v1', 'k2': 'v2'} v1 72 # print(dic,v1) #{'k1': 'v1', 'k2': 'v2', 'k111': 88} 88 73 74 #6更新字典 75 # dic={'k1':'v1', 76 # 'k2':'v2' 77 # } 78 # ① dic.update({'k1':123,'k3':'hi'}) 79 # print(dic) #{'k1': 123, 'k2': 'v2', 'k3': 'hi'} 80 #② dic.update(k1=123,k3='hi') 81 # print(dic) #{'k1': 123, 'k2': 'v2', 'k3': 'hi'} 82 83 #7 keys() 8 values() items() get update 常用的
七、小结：
1 # _*_ encoding:utf-8 _*_ 2 __author__ = 'listen' 3 __date__ = '2018/11/8 21:56' 4 # 一、数字 5 #int(...) 6 7 #二、字符串 8 #replace/find/join/strip/startswith/split/upper/lower/format 9 # ep='I am {name},age:{age}' 10 # # v=ep.format(name='alex',age=17) 11 # v=ep.format(**{'name':'alex','age':17}) 12 # print(v) 13 14 #三、列表 15 #append、extend、insert 16 #索引、切片、循环 17 18 #四、元组 19 #忽略 20 #索引、切片、循环 一级元素不能被修改 21 22 #五、字典 23 #get/update/keys/values/items 24 #for,索引 25 26 #六、布尔值 27 #0 1 28 #bool(...) 29 #None '' {} [] () ====>> False 其他为真
1、可变和不可变类型：
可变类型：列表、字典
不可变类型：字符串（重新附一个值，它的id改变，说明重新开辟内存，说明它是不可变类型）、数字、元组
2、访问顺序：
直接访问:数字
顺序访问:字符串、列表、元组
映射访问:字典
3、存放元素个数：
容器类型：列表、元组、字典
原子：数字、字符串
八、作业练习 :
实现字典的嵌套增加内容、查看内容、返回上一级目录：
1 # _*_ encoding:utf-8 _*_ 2 __author__ = 'listen' 3 __date__ = '2018/11/10 9:35' 4 5 db={} 6 path=[] 7 8 while True: 9 temp=db 10 for item in path: 11 temp=temp[item] 12 print('当前节点的所有子节点：',list(temp.keys()),'\n') 13 choice=input('1:添加节点;2:查看节点 (Q退出/B返回上一级) \n >>> ') #在查看的目录下添加 14 if choice == '1': 15 k=input('请输入要添加的子节点名称: ') 16 if k in temp: 17 print('节点已存在') 18 else: 19 temp[k] = {} 20 elif choice == '2': 21 k = input('请输入要查看的子节点名称: ') 22 if k in temp: 23 path.append(k) #增加深度 24 else: 25 print('子节点名称错误') 26 elif choice.lower() == 'b': 27 if path: 28 path.pop() 29 elif choice.lower() == 'q': 30 break 31 else: 32 print('输入不合法')
九、文件操作
一、文件的基本用法;
1、打开文件，得到文件句柄并赋值给衣蛾变量。
2、通过句柄对文件进行操作。
3、关闭文件。
用法：
1 f=open('a.txt','r',encoding:'utf-8') 1、 #由应用程序向操作系统发起系统调用open(...) 2 date=f.read() #操作系统打开文件并返回一个文件句柄给应用程序 3 f.close() #应用程序将文件句柄赋值给变量
二、资源回收和字符编码
1 #强调第一点： 2 打开一个文件包含两部分资源：操作系统级打开的文件+应用程序的变量。在操作完毕一个文件时，必须把与该文件的这两部分资源一个不落地回收，回收方法为： 3 1、f.close() #回收操作系统级打开的文件 4 2、del f #回收应用程序级的变量 5 6 其中del f一定要发生在f.close()之后，否则就会导致操作系统打开的文件还没有关闭，白白占用资源， 7 而python自动的垃圾回收机制决定了我们无需考虑del f，这就要求我们，在操作完毕文件后，一定要记住f.close() 8 9 虽然我这么说，但是很多同学还是会很不要脸地忘记f.close(),对于这些不长脑子的同学，我们推荐傻瓜式操作方式：使用with关键字来帮我们管理上下文 10 with open('a.txt','w') as f: 11 pass 12 13 with open('a.txt','r') as read_f,open('b.txt','w') as write_f: 14 data=read_f.read() 15 write_f.write(data) 16 17 强调第一点：资源回收
1 #强调第二点： 2 f=open(...)是由操作系统打开文件，那么如果我们没有为open指定编码，那么打开文件的默认编码很明显是操作系统说了算了，操作系统会用自己的默认编码去打开文件，在windows下是gbk，在linux下是utf-8。 3 这就用到了上节课讲的字符编码的知识：若要保证不乱码，文件以什么方式存的，就要以什么方式打开。 4 5 f=open('a.txt','r',encoding='utf-8')
三、打开模式
文件句柄=open('文件路径'，'模式')
r :只读 (默认模式，文件必须存在，不存在报错) r+可读可写 rb （---->>二进制）
w :只写（不可读，不存在创建，存在清空内容，重新写） w+可读可写 wb
a :只追加（不存在创建，存在在最后追加内容） a+可读可写可追加 ab 注：以b方式打开时，读取的内容是字节bytes类型的，写 入也需要是字节类型的，不能指定编码。
应用：
1 # _*_ encoding:utf-8 _*_ 2 __author__ = 'listen' 3 __date__ = '2018/11/18 11:44' 4 # f=open('a','r') 5 # # # date=f.read() #读取所有内容，光标移动到文件的末尾 6 # # # date=f.readable() #f 是可读的吗 7 # # date=f.readline() #aaaaaaaaaaaaaaaaaaaaa 读出文件的第一行内容 8 # # date1=f.readlines() #读出每一行内容放到列表中 9 # # print(date1) 10 # # f.close() 11 12 # f=open('b','w') 13 # date=f.write('fffffff\nhhhhhhhhhhhhhh\n') #覆盖掉原有的数据 14 # f.close() 15 16 # f=open('b','a') #在最后追加 17 # date=f.write('bbbbbbbbbbb\nccccccccccccc') 18 # f.close() 19 20 # f=open('a','r+')#可读可写 21 # date=f.write('abc') #在最开始的位置写上，光标定位到最开头的位置 22 # f.close() 23 #一定要关闭文件，为了防止此情况的发生，还有另一种with open 24 # with open('a','r') as f: 25 # date=f.readline() #abcaaaaaaaaaaaaaaaaaa 26 # print(date) 27 # 28 29 #把读到的内容写到一个新的文件中去 30 # f=open('c','r') 31 # date_read=f.read() 32 # f.close() 33 # 34 # f=open('c','w') 35 # date_write=f.write(date_read) 36 # f.close() 37 38 # f=open('testb','w',encoding='utf-8') #不写编码 默认是系统编码 39 # print(f.closed) #文件是否关闭 40 #f.flush()#把内存的东西保存到硬盘上 终端上可以看出效果 41 42 # f=open('testb','r+',encoding='utf-8') 43 # print(f.readline()) 44 #read(3)文件打开方式为文本方式时，代表读取3个字符 文件打开方式为b模式，代表读取3个字节 45 #其余的文件光标移动都是以字节为单位 seek tell truncate 46 # print(f.tell()) #在第6个位置（字节的位置） 光标的当前位置 47 # f.seek(0)#从什么位置开始读 48 # print(f.readline()) #aaaa 从第0个位置开始读 49 # print(f.truncate(10)) #截断文件 从0-10 然后返回的是现在的位置 不能以w和w+方式打开 否则直接清空，不能截取 50 51 #读取文件的最后一行 seek 参数有3个0 1 2 默认为0 从开头位置开始读，1从相对上个位置开始读，2从最后一个位置开始读 52 #得到日志的最后一行 53 # f=open('日志','rb') 54 # date=f.readlines() 55 # print(date[-1].decode('utf-8')) #2018-11-12 22:01:00 练习python视频 56 57 # f=open('日志','rb') 58 # date=f.readlines() 59 # for i in date: 60 # print(i) #遍历出每一行日志 61 62 #经典取出最后一行 63 64 f=open('日志','rb') 65 for i in f: 66 offs=-10 67 while True: 68 f.seek(offs,2) 69 date=f.readlines() 70 if len(date)>1: 71 print('文件的最后一行是:%s'%(date[-1].decode('utf-8'))) 72 break 73 offs*=2 74 75 #文件的最后一行是:2018-11-12 22:01:00 练习python视频
四、文件修改
文件的数据是存放于硬盘上的，因而只存在覆盖、不存在修改这么一说，我们平时看到的修改文件，都是模拟出来的效果，具体的说有两种实现方式：
方式一：将硬盘存放的该文件的内容全部加载到内存，在内存中是可以修改的，修改完毕后，再由内存覆盖到硬盘（word，vim，nodpad++等编辑器）
1 import os 2 3 with open('a.txt') as read_f,open('.a.txt.swap','w') as write_f: 4 data=read_f.read() #全部读入内存,如果文件很大,会很卡 5 data=data.replace('alex','SB') #在内存中完成修改 6 7 write_f.write(data) #一次性写入新文件 8 9 os.remove('a.txt') 10 os.rename('.a.txt.swap','a.txt')
方式二：将硬盘存放的该文件的内容一行一行地读入内存，修改完毕就写入新文件，最后用新文件覆盖源文件
1 import os 2 3 with open('a.txt') as read_f,open('.a.txt.swap','w') as write_f: 4 for line in read_f: 5 line=line.replace('alex','SB') 6 write_f.write(line) 7 8 os.remove('a.txt') 9 os.rename('.a.txt.swap','a.txt')
练习题：
1. 文件a.txt内容：每一行内容分别为商品名字，价钱，个数，求出本次购物花费的总钱数
apple 10 3
tesla 100000 1
mac 3000 2
lenovo 30000 3
chicken 10 3
2. 修改文件内容，把文件中的alex都替换成listen
1 # import re 2 # f=open('a','r') 3 # date=f.readlines() 4 # sum=0 5 # for i in date: 6 # a=re.findall('\d+',i) 7 # b=int(a[0])*int(a[1]) 8 # sum+=b 9 # 10 # print(sum) 11 #f.close() 12 13 import os 14 f=open('b','r') 15 f1=open('c','w') 16 for line in f: 17 line=line.replace('alex','listen') 18 f1.write(line) 19 f.close() 20 f1.close() 21 os.remove('b') 22 os.rename('b','a')
