Python全栈开发基础二
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python全栈开发基础二相关的知识，希望对你有一定的参考价值。
| Python全栈开发【基础二】 |
本节内容：
- Python 运算符（算术运算、比较运算、赋值运算、逻辑运算、成员运算）
- 基本数据类型（数字、布尔值、字符串、列表、元组、字典）
- 编码与进制转换
| Python 运算符 |
1、算术运算：
2、比较运算：
3、赋值运算：
4、逻辑运算：
5、成员运算：
| 基本数据类型 |
1、数字
int（整型）
1 class int(object): 2 """ 3 int(x=0) -> integer 4 int(x, base=10) -> integer 5 6 Convert a number or string to an integer, or return 0 if no arguments 7 are given. If x is a number, return x.__int__(). For floating point 8 numbers, this truncates towards zero. 9 10 If x is not a number or if base is given, then x must be a string, 11 bytes, or bytearray instance representing an integer literal in the 12 given base. The literal can be preceded by ‘+‘ or ‘-‘ and be surrounded 13 by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. 14 Base 0 means to interpret the base from the string as an integer literal. 15 >>> int(‘0b100‘, base=0) 16 """ 17 def bit_length(self): # real signature unknown; restored from __doc__ 18 """ 19 int.bit_length() -> int 20 21 Number of bits necessary to represent self in binary. 22 """ 23 """ 24 表示该数字返回时占用的最少位数 25 26 >>> (951).bit_length() 27 """ 28 return 0 29 30 def conjugate(self, *args, **kwargs): # real signature unknown 31 """ Returns self, the complex conjugate of any int.""" 32 33 """ 34 返回该复数的共轭复数 35 36 #返回复数的共轭复数 37 >>> (95 + 11j).conjugate() 38 (95-11j) 39 #返回复数的实数部分 40 >>> (95 + 11j).real 41 95.0 42 #返回复数的虚数部分 43 >>> (95 + 11j).imag 44 11.0 45 """ 46 pass 47 48 @classmethod # known case 49 def from_bytes(cls, bytes, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 50 """ 51 int.from_bytes(bytes, byteorder, *, signed=False) -> int 52 53 Return the integer represented by the given array of bytes. 54 55 The bytes argument must be a bytes-like object (e.g. bytes or bytearray). 56 57 The byteorder argument determines the byte order used to represent the 58 integer. If byteorder is ‘big‘, the most significant byte is at the 59 beginning of the byte array. If byteorder is ‘little‘, the most 60 significant byte is at the end of the byte array. To request the native 61 byte order of the host system, use `sys.byteorder‘ as the byte order value. 62 63 The signed keyword-only argument indicates whether two‘s complement is 64 used to represent the integer. 65 """ 66 """ 67 这个方法是在Python3.2的时候加入的,python官方给出了下面几个例子： 68 >>> int.from_bytes(b‘\\x00\\x10‘, byteorder=‘big‘) 69 >>> int.from_bytes(b‘\\x00\\x10‘, byteorder=‘little‘) 70 >>> int.from_bytes(b‘\\xfc\\x00‘, byteorder=‘big‘, signed=True) 71 -1024 72 >>> int.from_bytes(b‘\\xfc\\x00‘, byteorder=‘big‘, signed=False) 73 >>> int.from_bytes([255, 0, 0], byteorder=‘big‘) 74 """ 75 pass 76 77 def to_bytes(self, length, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 78 """ 79 int.to_bytes(length, byteorder, *, signed=False) -> bytes 80 81 Return an array of bytes representing an integer. 82 83 The integer is represented using length bytes. An OverflowError is 84 raised if the integer is not representable with the given number of 85 bytes. 86 87 The byteorder argument determines the byte order used to represent the 88 integer. If byteorder is ‘big‘, the most significant byte is at the 89 beginning of the byte array. If byteorder is ‘little‘, the most 90 significant byte is at the end of the byte array. To request the native 91 byte order of the host system, use `sys.byteorder‘ as the byte order value. 92 93 The signed keyword-only argument determines whether two‘s complement is 94 used to represent the integer. If signed is False and a negative integer 95 is given, an OverflowError is raised. 96 """ 97 """ 98 python官方给出了下面几个例子： 99 >>> (1024).to_bytes(2, byteorder=‘big‘) 100 b‘\\x04\\x00‘ 101 >>> (1024).to_bytes(10, byteorder=‘big‘) 102 b‘\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x04\\x00‘ 103 >>> (-1024).to_bytes(10, byteorder=‘big‘, signed=True) 104 b‘\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xfc\\x00‘ 105 >>> x = 1000 106 >>> x.to_bytes((x.bit_length() // 8) + 1, byteorder=‘little‘) 107 b‘\\xe8\\x03‘ 108 """ 109 pass 110 111 def __abs__(self, *args, **kwargs): # real signature unknown 112 """ abs(self)""" 113 114 """ 115 返回一个绝对值 116 117 >>> (95).__abs__() 118 -95 119 >>> (-95).__abs__() 120 """ 121 pass 122 123 124 def __add__(self, *args, **kwargs): # real signature unknown 125 """ Return self+value.""" 126 127 """ 128 加法，也可区分数字和字符串 129 130 >>> (95).__add__(1) 131 >>> (95).__add__("1") 132 NotImplemented 133 >>> 134 """ 135 pass 136 137 def __and__(self, *args, **kwargs): # real signature unknown 138 """ Return self&value.""" 139 pass 140 141 def __bool__(self, *args, **kwargs): # real signature unknown 142 """ self != 0 """ 143 144 """ 145 判断一个整数对象是否为0，如果为0,则返回False，如果不为0，则返回True 146 147 >>> (95).__bool__() 148 True 149 >>> (0).__bool__() 150 False 151 """ 152 pass 153 154 def __ceil__(self, *args, **kwargs): # real signature unknown 155 """ Ceiling of an Integral returns itself. """ 156 pass 157 158 def __divmod__(self, *args, **kwargs): # real signature unknown 159 """ Return divmod(self, value). """ 160 """ 161 返回一个元组，第一个元素为商，第二个元素为余数 162 163 >>> (9).__divmod__(5) 164 (1, 4) 165 """ 166 pass 167 168 def __eq__(self, *args, **kwargs): # real signature unknown 169 """ Return self==value. """ 170 """ 171 判断两个值是否相等 172 173 >>> (95).__eq__(95) 174 True 175 >>> (95).__eq__(9) 176 False 177 """ 178 pass 179 180 def __float__(self, *args, **kwargs): # real signature unknown 181 """ float(self) """ 182 """ 183 将一个整数转换成浮点型 184 185 >>> (95).__float__() 186 95.0 187 """ 188 pass 189 190 def __floordiv__(self, *args, **kwargs): # real signature unknown 191 """ Return self//value. """ 192 """ 193 整除，保留结果的整数部分 194 195 >>> (95).__floordiv__(9) 196 """ 197 pass 198 199 def __floor__(self, *args, **kwargs): # real signature unknown 200 """ Flooring an Integral returns itself. """ 201 """ 202 返回本身 203 204 >>> (95).__floor__() 205 """ 206 pass 207 208 def __format__(self, *args, **kwargs): # real signature unknown 209 """ 210 转换对象的类型 211 212 >>> (95).__format__(‘f‘) 213 ‘95.000000‘ 214 >>> (95).__format__(‘b‘) 215 ‘1011111‘ 216 """ 217 pass 218 219 220 def __getattribute__(self, *args, **kwargs): # real signature unknown 221 """ Return getattr(self, name). """ 222 """ 223 判断这个类中是否包含这个属性，如果包含则打印出值，如果不包含，就报错了 224 225 >>> (95).__getattribute__(‘__abs__‘) 226 <method-wrapper ‘__abs__‘ of int object at 0x9f93c0> 227 >>> (95).__getattribute__(‘__aaa__‘) 228 Traceback (most recent call last): 229 File "<stdin>", line 1, in <module> 230 AttributeError: ‘int‘ object has no attribute ‘__aaa__‘ 231 """ 232 pass 233 234 def __getnewargs__(self, *args, **kwargs): # real signature unknown 235 pass 236 237 def __ge__(self, *args, **kwargs): # real signature unknown 238 """ Return self>=value. """ 239 """ 240 判断是否大于等于 241 242 >>> (95).__ge__(9) 243 True 244 >>> (95).__ge__(99) 245 False 246 """ 247 pass 248 249 def __gt__(self, *args, **kwargs): # real signature unknown 250 """ Return self>value. """ 251 """ 252 判断是否大于 253 254 >>> (95).__gt__(9) 255 True 256 >>> (95).__gt__(99) 257 False 258 """ 259 pass 260 261 def __hash__(self, *args, **kwargs): # real signature unknown 262 """ Return hash(self). """ 263 """ 264 计算哈希值，整数返回本身 265 266 >>> (95).__hash__() 267 >>> (95.95).__hash__() 268 """ 269 pass 270 271 def __index__(self, *args, **kwargs): # real signature unknown 272 """ Return self converted to an integer, if self is suitable for use as an index into a list. """ 273 pass 274 275 def __init__(self, x, base=10): # known special case of int.__init__ 276 """ 277 这个是一个类的初始化方法，当int类被实例化的时候，这个方法默认就会被执行 278 """ 279 """ 280 int(x=0) -> integer 281 int(x, base=10) -> integer 282 283 Convert a number or string to an integer, or return 0 if no arguments 284 are given. If x is a number, return x.__int__(). For floating point 285 numbers, this truncates towards zero. 286 287 If x is not a number or if base is given, then x must be a string, 288 bytes, or bytearray instance representing an integer literal in the 289 given base. The literal can be preceded by ‘+‘ or ‘-‘ and be surrounded 290 by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. 291 Base 0 means to interpret the base from the string as an integer literal. 292 >>> int(‘0b100‘, base=0) 293 # (copied from class doc) 294 """ 295 pass 296 297 def __int__(self, *args, **kwargs): # real signature unknown 298 """ int(self) """ 299 """ 300 转换为整型 301 302 >>> (9.5).__int__() 303 """ 304 pass 305 306 307 def __invert__(self, *args, **kwargs): # real signature unknown 308 """ ~self """ 309 310 pass 311 312 def __le__(self, *args, **kwargs): # real signature unknown 313 """ Return self<=value. """ 314 """ 315 判断是否小于等于 316 317 >>> (95).__le__(99) 318 True 319 >>> (95).__le__(9) 320 False 321 """ 322 pass 323 324 def __lshift__(self, *args, **kwargs): # real signature unknown 325 """ Return self<<value. """ 326 """ 327 用于二进制位移，这个是向左移动 328 329 >>> bin(95) 330 ‘0b1011111‘ 331 >>> a = (95).__lshift__(2) 332 >>> bin(a) 333 ‘0b101111100‘ 334 >>> 335 """ 336 pass 337 338 def __lt__(self, *args, **kwargs): # real signature unknown 339 """ Return self<value. """ 340 """ 341 判断是否小于 342 343 >>> (95).__lt__(9) 344 False 345 >>> (95).__lt__(99) 346 True 347 """ 348 pass 349 350 def __mod__(self, *args, **kwargs): # real signature unknown 351 """ Return self%value. """ 352 """ 353 取模 % 354 355 >>> (95).__mod__(9) 356 """ 357 pass 358 359 def __mul__(self, *args, **kwargs): # real signature unknown 360 """ Return self*value. """ 361 """ 362 乘法 * 363 364 >>> (95).__mul__(10) 365 """ 366 pass 367 368 def __neg__(self, *args, **kwargs): # real signature unknown 369 """ -self """ 370 """ 371 将正数变为负数，将负数变为正数 372 373 >>> (95).__neg__() 374 -95 375 >>> (-95).__neg__() 376 """ 377 pass 378 379 @staticmethod # known case of __new__ 380 def __new__(*args, **kwargs): # real signature unknown 381 """ Create and return a new object. See help(type) for accurate signature. """ 382 pass 383 384 def __ne__(self, *args, **kwargs): # real signature unknown 385 """ Return self!=value. """ 386 """ 387 不等于 388 389 >>> (95).__ne__(9) 390 True 391 >>> (95).__ne__(95) 392 False 393 """ 394 pass 395 396 def __or__(self, *args, **kwargs): # real signature unknown 397 """ Return self|value. """ 398 """ 399 二进制或的关系，只要有一个为真，就为真 400 401 >>> a = 4 402 >>> b = 0 403 >>> a.__or__(b) # a --> 00000100 b --> 00000000 404 >>> b = 1 # b --> 00000001 405 >>> a.__or__(b) 406 """ 407 pass 408 409 def __pos__(self, *args, **kwargs): # real signature unknown 410 """ +self """ 411 pass 412 413 def __pow__(self, *args, **kwargs): # real signature unknown 414 """ Return pow(self, value, mod). """ 415 """ 416 幂 417 418 >>> (2).__pow__(10) 419 """ 420 pass 421 422 def __radd__(self, *args, **kwargs): # real signatre unknown 423 """ Return value+self. """ 424 """ 425 加法，将value放在前面 426 427 >>> a.__radd__(b) # 相当于 b+a 428 """ 429 pass 430 431 def __rand__(self, *args, **kwargs): # real signature unknown 432 """ Return value&self. """ 433 """ 434 二进制与的关系，两个都为真，才为真，有一个为假，就为假 435 """ 436 pass 437 438 def __rdivmod__(self, *args, **kwargs): # real signature unknown 439 """ Return divmod(value, self). """ 440 pass 441 442 def __repr__(self, *args, **kwargs): # real signature unknown 443 """ Return repr(self). """ 444 pass 445 446 def __rfloordiv__(self, *args, **kwargs): # real signature unknown 447 """ Return value//self. """ 448 pass 449 450 def __rlshift__(self, *args, **kwargs): # real signature unknown 451 """ Return value<<self. """ 452 pass 453 454 def __rmod__(self, *args, **kwargs): # real signature unknown 455 """ Return value%self. """ 456 pass 457 458 def __rmul__(self, *args, **kwargs): # real signature unknown 459 """ Return value*self. """ 460 pass 461 462 def __ror__(self, *args, **kwargs): # real signature unknown 463 """ Return value|self. """ 464 pass 465 466 def __round__(self, *args, **kwargs): # real signature unknown 467 """ 468 Rounding an Integral returns itself. 469 Rounding with an ndigits argument also returns an integer. 470 """ 471 pass 472 473 def __rpow__(self, *args, **kwargs): # real signature unknown 474 """ Return pow(value, self, mod). """ 475 pass 476 477 def __rrshift__(self, *args, **kwargs): # real signature unknown 478 """ Return value>>self. """ 479 pass 480 481 def __rshift__(self, *args, **kwargs): # real signature unknown 482 """ Return self>>value. """ 483 pass 484 485 def __rsub__(self, *args, **kwargs): # real signature unknown 486 """ Return value-self. """ 487 pass 488 489 def __rtruediv__(self, *args, **kwargs): # real signature unknown 490 """ Return value/self. """ 491 pass 492 493 def __rxor__(self, *args, **kwargs): # real signature unknown 494 """ Return value^self. """ 495 pass 496 497 def __sizeof__(self, *args, **kwargs): # real signature unknown 498 """ Returns size in memory, in bytes """ 499 """ 500 在内存中占多少个字节 501 502 >>> a = 95 503 >>> a.__sizeof__() 504 """ 505 pass 506 507 def __str__(self, *args, **kwargs): # real signature unknown 508 """ Return str(self). """ 509 """ 510 将一个正数转为字符串 511 512 >>> a = 95 513 >>> a = a.__str__() 514 >>> print(type(a)) 515 <class ‘str‘> 516 """ 517 pass 518 519 def __sub__(self, *args, **kwargs): # real signature unknown 520 """ Return self-value. """ 521 """ 522 减法运算 523 524 >>> (95).__sub__(5) 525 """ 526 pass 527 528 def __truediv__(self, *args, **kwargs): # real signature unknown 529 """ Return self/value. """ 530 """ 531 除法运算 532 533 >>> (95).__truediv__(5) 534 19.0 535 """ 536 pass 537 538 def __trunc__(self, *args, **kwargs): # real signature unknown 539 """ Truncating an Integral returns itself. """ 540 """ 541 返回一个对象的整数部分 542 543 >>> (95.95).__trunc__() 544 """ 545 pass 546 def __xor__(self, *args, **kwargs): # real signature unknown 547 """ Return self^value. """ 548 """ 549 将对象与值进行二进制的或运算，一个为真，就为真 550 551 >>> a = 4 552 >>> b = 1 553 >>> a.__xor__(b) 554 >>> c = 0 555 >>> a.__xor__(c) 556 """ 557 558 pass 559 560 denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 561 """ 分母 = 1 """ 562 """the denominator of a rational number in lowest terms""" 563 564 imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 565 """ 虚数 """ 566 """the imaginary part of a complex number""" 567 568 numerator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 569 """ 分子 = 数字大小 """ 570 """the numerator of a rational number in lowest terms""" 571 572 real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 573 """ 实属 """ 574 """the real part of a complex number""" 575 576 int
2、布尔值
真或假
1 或 0
3、字符串
1 class str(object): 2 """ 3 str(object=‘‘) -> str 4 str(bytes_or_buffer[, encoding[, errors]]) -> str 5 6 Create a new string object from the given object. If encoding or 7 errors is specified, then the object must expose a data buffer 8 that will be decoded using the given encoding and error handler. 9 Otherwise, returns the result of object.__str__() (if defined) 10 or repr(object). 11 encoding defaults to sys.getdefaultencoding(). 12 errors defaults to ‘strict‘. 13 """ 14 def capitalize(self): # real signature unknown; restored from __doc__ 15 """ 16 首字母变大写 17 name = "ocean" 18 a = name.capitalize() 19 print(a) 20 """ 21 S.capitalize() -> str 22 23 Return a capitalized version of S, i.e. make the first character 24 have upper case and the rest lower case. 25 """ 26 return "" 27 28 def casefold(self): # real signature unknown; restored from __doc__ 29 """ 30 首字母变小写 31 name = "Ocean" 32 a =name.casefold() 33 print(a) 34 """ 35 S.casefold() -> str 36 37 Return a version of S suitable for caseless comparisons. 38 """ 39 return "" 40 41 def center(self, width, fillchar=None): # real signature unknown; restored from __doc__ 42 """ 43 内容居中，width：总长度；fillchar：空白处填充内容，默认无。 44 name = "ocean" 45 a = name.center(60,‘$‘) 46 print(a) 47 """ 48 S.center(width[, fillchar]) -> str 49 Return S centered in a string of length width. Padding is 50 done using the specified fill character (default is a space) 51 """ 52 return "" 53 54 def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 55 """ 56 子序列个数，0到12中a出现了几次。 57 name = "ocean is a good man" 58 v= name.count("a",0,12) 59 print(v) 60 """ 61 S.count(sub[, start[, end]]) -> int 62 63 Return the number of non-overlapping occurrences of substring sub in 64 string S[start:end]. Optional arguments start and end are 65 interpreted as in slice notation. 66 """ 67 return 0 68 69 def encode(self, encoding=‘utf-8‘, errors=‘strict‘): # real signature unknown; restored from __doc__ 70 """ 71 """ 72 编码，针对unicode. 73 temp = "烧饼 74 temp.encode("unicode") 75 """ 76 S.encode(encoding=‘utf-8‘, errors=‘strict‘) -> bytes 77 78 Encode S using the codec registered for encoding. Default encoding 79 is ‘utf-8‘. errors may be given to set a different error 80 handling scheme. Default is ‘strict‘ meaning that encoding errors raise 81 a UnicodeEncodeError. Other possible values are ‘ignore‘, ‘replace‘ and 82 ‘xmlcharrefreplace‘ as well as any other name registered with 83 codecs.register_error that can handle UnicodeEncodeErrors. 84 """ 85 return b"" 86 87 def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__ 88 """ 89 """ 90 是否以XX结束，0到4是否以n结尾 91 name = "ocean is a good man" 92 v = name.endswith("n",0,4) 93 print(v) 94 """ 95 S.endswith(suffix[, start[, end]]) -> bool 96 97 Return True if S ends with the specified suffix, False otherwise. 98 With optional start, test S beginning at that position. 99 With optional end, stop comparing S at that position. 100 suffix can also be a tuple of strings to try. 101 """ 102 return False 103 104 def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__ 105 """ 106 """ 107 将tab转换成空格，默认一个tab转换成8个空格 108 a = n.expandtabs() 109 b = n.expandtabs(16) 110 print(a) 111 print(b) 112 """ 113 S.expandtabs(tabsize=8) -> str 114 115 Return a copy of S where all tab characters are expanded using spaces. 116 If tabsize is not given, a tab size of 8 characters is assumed. 117 """ 118 return "" 119 120 def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 121 """ 122 """ 123 寻找子序列位置，如果没找到，返回 -1。 124 name = "ocean is a good man" 125 a = name.find("good") 126 print(a) 127 """ 128 S.find(sub[, start[, end]]) -> int 129 130 Return the lowest index in S where substring sub is found, 131 such that sub is contained within S[start:end]. Optional 132 arguments start and end are interpreted as in slice notation. 133 134 Return -1 on failure. 135 """ 136 return 0 137 138 def format(self, *args, **kwargs): # known special case of str.format 139 """ 140 """ 141 字符串格式化，动态参数 142 格式化，传入的值 {"name": ‘alex‘, "a": 19} 143 test = ‘i am {name}, age {a}‘ 144 v1 = test.format(name=‘df‘,a=10) 145 v2 = test.format_map({"name": ‘alex‘, "a": 19}) 146 """ 147 S.format(*args, **kwargs) -> str 148 149 Return a formatted version of S, using substitutions from args and kwargs. 150 The substitutions are identified by braces (‘{‘ and ‘}‘). 151 """ 152 # 格式化，传入的值 {"name": ‘alex‘, "a": 19} 153 # test = ‘i am {name}, age {a}‘ 154 # v1 = test.format(name=‘df‘,a=10) 155 # v2 = test.format_map({"name": ‘alex‘, "a": 19}) 156 """ 157 """ 158 dict = {‘Foo‘: 54.23345} 159 fmt = "Foo = {Foo:.3f}" 160 result = fmt.format_map(dict) 161 print(result) #Foo = 54.233 162 """ 163 S.format_map(mapping) -> str 164 165 Return a formatted version of S, using substitutions from mapping. 166 The substitutions are identified by braces (‘{‘ and ‘}‘). 167 """ 168 return "" 169 170 def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 171 """ 172 """ 173 #子序列位置，如果没有找到就报错 174 name = "ocean is a good man" 175 a = name.index("ocean") 176 print(a) 177 """ 178 S.index(sub[, start[, end]]) -> int 179 180 Like S.find() but raise ValueError when the substring is not found. 181 """ 182 return 0 183 184 def isalnum(self): # real signature unknown; restored from __doc__ 185 """ 186 """ 187 是否是字母和数字 188 name = "ocean is a good man" 189 a = name.isalnum() 190 print(a) 191 """ 192 S.isalnum() -> bool 193 194 Return True if all characters in S are alphanumeric 195 and there is at least one character in S, False otherwise. 196 """ 197 return False 198 199 def isalpha(self): # real signature unknown; restored from __doc__ 200 """ 201 """ 202 是否是字母 203 name = "ocean is a good man" 204 a = name.isalpha() 205 print(a) 206 """ 207 S.isalpha() -> bool 208 209 Return True if all characters in S are alphabetic 210 and there is at least one character in S, False otherwise. 211 """ 212 return False 213 214 def isdecimal(self): # real signature unknown; restored from __doc__ 215 """ 216 检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。 217 """ 218 S.isdecimal() -> bool 219 220 Return True if there are only decimal characters in S, 221 False otherwise. 222 """ 223 return False 224 225 def isdigit(self): # real signature unknown; restored from __doc__ 226 """ 227 """ 228 是否是数字 229 name = "ocean is a good man" 230 a = name.isdigit() 231 print(a) 232 """ 233 S.isdigit() -> bool 234 235 Return True if all characters in S are digits 236 and there is at least one character in S, False otherwise. 237 """ 238 return False 239 240 def isidentifier(self): # real signature unknown; restored from __doc__ 241 """ 242 """ 243 判断字符串是否可为合法的标识符 244 """ 245 S.isidentifier() -> bool 246 247 Return True if S is a valid identifier according 248 to the language definition. 249 250 Use keyword.iskeyword() to test for reserved identifiers 251 such as "def" and "class". 252 """ 253 return False 254 255 def islower(self): # real signature unknown; restored from __doc__ 256 """ 257 """ 258 是否小写 259 name = "ocean is A good man" 260 a = name.islower() 261 print(a) 262 """ 263 S.islower() -> bool 264 265 Return True if all cased characters in S are lowercase and there is 266 at least one cased character in S, False otherwise. 267 """ 268 return False 269 270 def isnumeric(self): # real signature unknown; restored from __doc__ 271 """ 272 """ 273 检查是否只有数字字符组成的字符串 274 name = "111111111111111” 275 a = name.isnumeric() 276 print(a) 277 """ 278 S.isnumeric() -> bool 279 280 Return True if there are only numeric characters in S, 281 False otherwise. 282 """ 283 return False 284 285 def isprintable(self): # real signature unknown; restored from __doc__ 286 """ 287 """ 288 判断字符串中所有字符是否都属于可见字符 289 name = "ocean is a good man" 290 a = name.isprintable() 291 print(a) 292 """ 293 S.isprintable() -> bool 294 295 Return True if all characters in S are considered 296 printable in repr() or S is empty, False otherwise. 297 """ 298 return False 299 300 def isspace(self): # real signature unknown; restored from __doc__ 301 """ 302 """ 303 字符串是否只由空格组成 304 name = " " 305 a = name.isspace() 306 print(a) 307 """ 308 S.isspace() -> bool 309 310 Return True if all characters in S are whitespace 311 and there is at least one character in S, False otherwise. 312 """ 313 return False 314 315 def istitle(self): # real signature unknown; restored from __doc__ 316 """ 317 """ 318 检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写 319 name = "Ocean Is A Good Man" 320 a = name.istitle() 321 print(a) 322 """ 323 """ 324 S.istitle() -> bool 325 326 Return True if S is a titlecased string and there is at least one 327 character in S, i.e. upper- and titlecase characters may only 328 follow uncased characters and lowercase characters only cased ones. 329 Return False otherwise. 330 """ 331 return False 332 333 def isupper(self): # real signature unknown; restored from __doc__ 334 """ 335 """ 336 检测字符串中所有的字母是否都为大写 337 name = "OCEAN" 338 a = name.isupper() 339 print(a) 340 """ 341 S.isupper() -> bool 342 343 Return True if all cased characters in S are uppercase and there is 344 at least one cased character in S, False otherwise. 345 """ 346 return False 347 348 def join(self, iterable): # real signature unknown; restored from __doc__ 349 """ 350 """ 351 连接两个字符串 352 li = ["ocean","handsome"] 353 a = "".join(li) 354 b = "_".join(li) 355 print(a) 356 print(b) 357 """ 358 S.join(iterable) -> str 359 360 Return a string which is the concatenation of the strings in the 361 iterable. The separator between elements is S. 362 """ 363 return "" 364 365 def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__ 366 """ 367 """ 368 向左对齐，右侧填充 369 name = "ocean is a good man" 370 a = name.ljust(60,$) 371 print(a) 372 """ 373 S.ljust(width[, fillchar]) -> str 374 375 Return S left-justified in a Unicode string of length width. Padding is 376 done using the specified fill character (default is a space). 377 """ 378 return "" 379 380 def lower(self): # real signature unknown; restored from __doc__ 381 """ 382 """ 383 容左对齐，右侧填充 384 name = "NiNi" 385 a = name.lower() 386 print(a) 387 """ 388 S.lower() -> str 389 390 Return a copy of the string S converted to lowercase. 391 """ 392 return "" 393 394 def lstrip(self, chars=None): # real signature unknown; restored from __doc__ 395 """ 396 """ 移除左侧空白 """ 397 S.lstrip([chars]) -> str 398 399 Return a copy of the string S with leading whitespace removed. 400 If chars is given and not None, remove characters in chars instead. 401 """ 402 return "" 403 404 def maketrans(self, *args, **kwargs): # real signature unknown 405 """ 406 """ 407 用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 408 from string import maketrans 409 intab = "aeiou" 410 outtab = "12345" 411 trantab = maketrans(intab, outtab) 412 str = "this is string example....wow!!!"; 413 print str.translate(trantab); 414 """ 415 Return a translation table usable for str.translate(). 416 417 If there is only one argument, it must be a dictionary mapping Unicode 418 ordinals (integers) or characters to Unicode ordinals, strings or None. 419 Character keys will be then converted to ordinals. 420 If there are two arguments, they must be strings of equal length, and 421 in the resulting dictionary, each character in x will be mapped to the 422 character at the same position in y. If there is a third argument, it 423 must be a string, whose characters will be mapped to None in the result. 424 """ 425 pass 426 427 def partition(self, sep): # real signature unknown; restored from __doc__ 428 """ 429 """ 430 分割，前，中，后三部分 431 name = "ocean is a good man" 432 a = name.partition("good") 433 print(a) 434 """ 435 S.partition(sep) -> (head, sep, tail) 436 437 Search for the separator sep in S, and return the part before it, 438 the separator itself, and the part after it. If the separator is not 439 found, return S and two empty strings. 440 """ 441 pass 442 443 def replace(self, old, new, count=None): # real signature unknown; restored from __doc__ 444 """ 445 """ 446 替换 447 name = "ocean is a good man" 448 a = name.replace("good","man") 449 print(a) 450 """ 451 S.replace(old, new[, count]) -> str 452 453 Return a copy of S with all occurrences of substring 454 old replaced by new. If the optional argument count is 455 given, only the first count occurrences are replaced. 456 """ 457 return "" 458 459 def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 460 """ 461 """ 462 返回字符串最后一次出现的位置，如果没有匹配项则返回-1 463 """ 464 S.rfind(sub[, start[, end]]) -> int 465 466 Return the highest index in S where substring sub is found, 467 such that sub is contained within S[start:end]. Optional 468 arguments start and end are interpreted as in slice notation. 469 470 Return -1 on failure. 471 """ 472 return 0 473 474 def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 475 """ 476 """ 477 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常 478 """ 479 S.rindex(sub[, start[, end]]) -> int 480 481 Like S.rfind() but raise ValueError when the substring is not found. 482 """ 483 return 0 484 485 def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__ 486 """ 487 """ 488 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串 489 str = "this is string example....wow!!!" 490 print(str.rjust(50, ‘$‘)) 491 """ 492 S.rjust(width[, fillchar]) -> str 493 494 Return S right-justified in a string of length width. Padding is 495 done using the specified fill character (default is a space). 496 """ 497 return "" 498 499 def rpartition(self, sep): # real signature unknown; restored from __doc__ 500 """ 501 """ 502 根据指定的分隔符将字符串进行分割 503 """ 504 S.rpartition(sep) -> (head, sep, tail) 505 506 Search for the separator sep in S, starting at the end of S, and return 507 the part before it, the separator itself, and the part after it. If the 508 separator is not found, return two empty strings and S. 509 """ 510 pass 511 512 def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__ 513 """ 514 """ 515 指定分隔符对字符串进行切片 516 name = "ocean is a good man" 517 a = name.rsplit("is") 518 print(a) 519 """ 520 S.rsplit(sep=None, maxsplit=-1) -> list of strings 521 522 Return a list of the words in S, using sep as the 523 delimiter string, starting at the end of the string and 524 working to the front. If maxsplit is given, at most maxsplit 525 splits are done. If sep is not specified, any whitespace string 526 is a separator. 527 """ 528 return [] 529 530 def rstrip(self, chars=None): # real signature unknown; restored from __doc__ 531 """ 532 """ 533 删除 string 字符串末尾的指定字符（默认为空格） 534 """ 535 S.rstrip([chars]) -> str 536 537 Return a copy of the string S with trailing whitespace removed. 538 If chars is given and not None, remove characters in chars instead. 539 """ 540 return "" 541 542 def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__ 543 """ 544 """ 545 通过指定分隔符对字符串进行切片 546 str = "Line1-abcdef \\nLine2-abc \\nLine4-abcd"; 547 print str.split( ); 548 print str.split(‘ ‘, 1 ); 549 """ 550 S.split(sep=None, maxsplit=-1) -> list of strings 551 552 Return a list of the words in S, using sep as the 553 delimiter string. If maxsplit is given, at most maxsplit 554 splits are done. If sep is not specified or is None, any 555 whitespace string is a separator and empty strings are 556 removed from the result. 557 """ 558 return [] 559 560 def splitlines(self, keepends=None): # real signature unknown; restored from __doc__ 561 """ 562 """ 563 按照行分隔，返回一个包含各行作为元素的列表 564 """ 565 S.splitlines([keepends]) -> list of strings 566 567 Return a list of the lines in S, breaking at line boundaries. 568 Line breaks are not included in the resulting list unless keepends 569 is given and true. 570 """ 571 return [] 572 573 def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__ 574 """ 575 """ 576 检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False 577 """ 578 S.startswith(prefix[, start[, end]]) -> bool 579 580 Return True if S starts with the specified prefix, False otherwise. 581 With optional start, test S beginning at that position. 582 With optional end, stop comparing S at that position. 583 prefix can also be a tuple of strings to try. 584 """ 585 return False 586 587 def strip(self, chars=None): # real signature unknown; restored from __doc__ 588 """ 589 """ 590 用于移除字符串头尾指定的字符（默认为空格）. 591 """ 592 S.strip([chars]) -> str 593 594 Return a copy of the string S with leading and trailing 595 whitespace removed. 596 If chars is given and not None, remove characters in chars instead. 597 """ 598 return "" 599 600 def swapcase(self): # real signature unknown; restored from __doc__ 601 """ 602 """ 603 用于对字符串的大小写字母进行转换 604 """ 605 S.swapcase() -> str 606 607 Return a copy of S with uppercase characters converted to lowercase 608 and vice versa. 609 """ 610 return "" 611 612 def title(self): # real signature unknown; restored from __doc__ 613 """ 614 S.title() -> str 615 616 Return a titlecased version of S, i.e. words start with title case 617 characters, all remaining cased characters have lower case. 618 """ 619 return "" 620 621 def translate(self, table): # real signature unknown; restored from __doc__ 622 """ 623 S.translate(table) -> str 624 625 Return a copy of the string S in which each character has been mapped 626 through the given translation table. The table must implement 627 lookup/indexing via __getitem__, for instance a dictionary or list, 628 mapping Unicode ordinals to Unicode ordinals, strings, or None. If 629 this operation raises LookupError, the character is left untouched. 630 Characters mapped to None are deleted. 631 """ 632 return "" 633 634 def upper(self): # real signature unknown; restored from __doc__ 635 """ 636 """ 637 将字符串中的小写字母转为大写字母 638 """ 639 S.upper() -> str 640 641 Return a copy of S converted to uppercase. 642 """ 643 return "" 644 645 def zfill(self, width): # real signature unknown; restored from __doc__ 646 """ 647 """ 648 返回指定长度的字符串，原字符串右对齐，前面填充0 649 """ 650 S.zfill(width) -> str 651 652 Pad a numeric string S with zeros on the left, to fill a field 653 of the specified width. The string S is never truncated. 654 """ 655 return "" 656 657 def __add__(self, *args, **kwargs): # real signature unknown 658 """ Return self+value. """ 659 pass 660 661 def __contains__(self, *args, **kwargs): # real signature unknown 662 """ Return key in self. """ 663 pass 664 665 def __eq__(self, *args, **kwargs): # real signature unknown 666 """ Return self==value. """ 667 pass 668 669 def __format__(self, format_spec): # real signature unknown; restored from __doc__ 670 """ 671 S.__format__(format_spec) -> str 672 673 Return a formatted version of S as described by format_spec. 674 """ 675 return "" 676 677 def __getattribute__(self, *args, **kwargs): # real signature unknown 678 """ Return getattr(self, name). """ 679 pass 680 681 def __getitem__(self, *args, **kwargs): # real signature unknown 682 """ Return self[key]. """ 683 pass 684 685 def __getnewargs__(self, *args, **kwargs): # real signature unknown 686 pass 687 688 def __ge__(self, *args, **kwargs): # real signature unknown 689 """ Return self>=value. """ 690 pass 691 692 def __gt__(self, *args, **kwargs): # real signature unknown 693 """ Return self>value. """ 694 pass 695 696 def __hash__(self, *args, **kwargs): # real signature unknown 697 """ Return hash(self). """ 698 pass 699 700 def __init__(self, value=‘‘, encoding=None, errors=‘strict‘): # known special case of str.__init__ 701 """ 702 str(object=‘‘) -> str 703 str(bytes_or_buffer[, encoding[, errors]]) -> str 704 705 Create a new string object from the given object. If encoding or 706 errors is specified, then the object must expose a data buffer 707 that will be decoded using the given encoding and error handler. 708 Otherwise, returns the result of object.__str__() (if defined) 709 or repr(object). 710 encoding defaults to sys.getdefaultencoding(). 711 errors defaults to ‘strict‘. 712 # (copied from class doc) 713 """ 714 pass 715 716 def __iter__(self, *args, **kwargs): # real signature unknown 717 """ Implement iter(self). """ 718 pass 719 720 def __len__(self, *args, **kwargs): # real signature unknown 721 """ Return len(self). """ 722 pass 723 724 def __le__(self, *args, **kwargs): # real signature unknown 725 """ Return self<=value. """ 726 pass 727 728 def __lt__(self, *args, **kwargs): # real signature unknown 729 """ Return self<value. """ 730 pass 731 732 def __mod__(self, *args, **kwargs): # real signature unknown 733 """ Return self%value. """ 734 pass 735 736 def __mul__(self, *args, **kwargs): # real signature unknown 737 """ Return self*value.n """ 738 pass 739 740 @staticmethod # known case of __new__ 741 def __new__(*args, **kwargs): # real signature unknown 742 """ Create and return a new object. See help(type) for accurate signature. """ 743 pass 744 745 def __ne__(self, *args, **kwargs): # real signature unknown 746 """ Return self!=value. """ 747 pass 748 749 def __repr__(self, *args, **kwargs): # real signature unknown 750 """ Return repr(self). """ 751 pass 752 753 def __rmod__(self, *args, **kwargs): # real signature unknown 754 """ Return value%self. """ 755 pass 756 757 def __rmul__(self, *args, **kwargs): # real signature unknown 758 """ Return self*value. """ 759 pass 760 761 def __sizeof__(self): # real signature unknown; restored from __doc__ 762 """ S.__sizeof__() -> size of S in memory, in bytes """ 763 pass 764 765 def __str__(self, *args, **kwargs): # real signature unknown 766 """ Return str(self). """ 767 pass 768 769 770 str
4、列表
5、元组（不可修改）
6、字典（无序）
1、编码与进制转换
- utf-8与gbk编码转换
以上是关于Python全栈开发基础二的主要内容，如果未能解决你的问题，请参考以下文章