1 def capitalize(self): # real signature unknown; restored from __doc__
  2     """
  3     B.capitalize() -> copy of B
  4     把字符串的第一个字符大写
  5     Return a copy of B with only its first character capitalized (ASCII)
  6     and the rest lower-cased.
  7     """
  8     pass
  9
 10 def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
 11     """
 12     B.center(width[, fillchar]) -> copy of B
 13     返回一个原字符串居中，并使用空格填充至长度width的新字符
 14     Return B centered in a string of length width.  Padding is
 15     done using the specified fill character (default is a space).
 16     """
 17     pass
 18
 19 def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
 20     """
 21     B.count(sub[, start[, end]]) -> int
 22     返回str在string里面出现的次数，如果start或者end指定则返回指定范围内str出现的次数
 23     Return the number of non-overlapping occurrences of subsection sub in
 24     bytes B[start:end].  Optional arguments start and end are interpreted
 25     as in slice notation.
 26     """
 27     return 0
 28
 29 def encode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__
 30     """
 31     S.encode(encoding='utf-8', errors='strict') -> bytes
 32     以encoding 指定的编码格式解码string，如果出错默认报一个ValueError的异常，除非errors指定的是‘ignore’或者replace
 33     Encode S using the codec registered for encoding. Default encoding
 34     is 'utf-8'. errors may be given to set a different error
 35     handling scheme. Default is 'strict' meaning that encoding errors raise
 36     a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
 37     'xmlcharrefreplace' as well as any other name registered with
 38     codecs.register_error that can handle UnicodeEncodeErrors.
 39     """
 40     pass
 41
 42 def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
 43     """
 44     B.endswith(suffix[, start[, end]]) -> bool
 45     检查字符串是否以suffix结束，如果start或者end指定则检查指定的范围内是否以suffix结束，如果是返回True，否则返回False
 46     Return True if B ends with the specified suffix, False otherwise.
 47     With optional start, test B beginning at that position.
 48     With optional end, stop comparing B at that position.
 49     suffix can also be a tuple of bytes to try.
 50     """
 51     return False
 52
 53 def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
 54     """
 55     B.expandtabs(tabsize=8) -> copy of B
 56     把字符串string中的tab符号\t转换为空格，默认的空格数tabsize是8
 57     Return a copy of B where all tab characters are expanded using spaces.
 58     If tabsize is not given, a tab size of 8 characters is assumed.
 59     """
 60     pass
 61
 62 def insert(self, *args, **kwargs): # real signature unknown
 63     """
 64     Insert a single item into the bytearray before the given index.
 65
 66       index
 67         The index where the value is to be inserted.
 68       item
 69         The item to be inserted.
 70     """
 71     pass
 72
 73 def isalnum(self): # real signature unknown; restored from __doc__
 74     """
 75     B.isalnum() -> bool
 76     如果string至少有一个字符并且所有字符都是字母或数字则返回True,否则返回False
 77     Return True if all characters in B are alphanumeric
 78     and there is at least one character in B, False otherwise.
 79     """
 80     return False
 81
 82 def isalpha(self): # real signature unknown; restored from __doc__
 83     """
 84     B.isalpha() -> bool
 85     如果string至少有一个字符并且所有字符都是字母则返回True，否则返回False
 86     Return True if all characters in B are alphabetic
 87     and there is at least one character in B, False otherwise.
 88     """
 89     return False
 90
 91 def isdigit(self): # real signature unknown; restored from __doc__
 92     """
 93     B.isdigit() -> bool
 94     如果string只包含十进制数字则返回True，否则返回False
 95     Return True if all characters in B are digits
 96     and there is at least one character in B, False otherwise.
 97     """
 98     return False
 99
100 def islower(self): # real signature unknown; restored from __doc__
101     """
102     B.islower() -> bool
103     如果string中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是小写，则返回True，否则返回False
104     Return True if all cased characters in B are lowercase and there is
105     at least one cased character in B, False otherwise.
106     """
107     return False
108
109 def isspace(self): # real signature unknown; restored from __doc__
110     """
111     B.isspace() -> bool
112     如果string中只包含空格，则返回Ture，否则返回False
113     Return True if all characters in B are whitespace
114     and there is at least one character in B, False otherwise.
115     """
116     return False
117
118 def istitle(self): # real signature unknown; restored from __doc__
119     """
120     B.istitle() -> bool
121     如果string是标题化的（就是首字母大写）则返回True，否则返回False
122     Return True if B is a titlecased string and there is at least one
123     character in B, i.e. uppercase characters may only follow uncased
124     characters and lowercase characters only cased ones. Return False
125     otherwise.
126     """
127     return False
128
129 def isupper(self): # real signature unknown; restored from __doc__
130     """
131     B.isupper() -> bool
132     如果string中包含至少一个区分大小写的字符，并且所有这些（区分大小写的）字符都是大写，则返回True，否则返回False
133     Return True if all cased characters in B are uppercase and there is
134     at least one cased character in B, False otherwise.
135     """
136     return False
137
138 def join(self, *args, **kwargs): # real signature unknown
139     """
140     Concatenate any number of bytes/bytearray objects.
141     以string 作为分隔符，将序列中所有的元素(的字符串表示)合并为一个新的字符串
142     The bytearray whose method is called is inserted in between each pair.
143
144     The result is returned as a new bytearray object.
145     """
146     pass
147
148 def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
149     """
150     B.ljust(width[, fillchar]) -> copy of B
151     返回一个原字符左对齐，并使用空格填充至长度width的新字符串
152     Return B left justified in a string of length width. Padding is
153     done using the specified fill character (default is a space).
154     """
155     pass
156
157 def lower(self): # real signature unknown; restored from __doc__
158     """
159     B.lower() -> copy of B
160     转换sting中所有大写字符为小写
161     Return a copy of B with all ASCII characters converted to lowercase.
162     """
163     pass
164
165 def maketrans(*args, **kwargs): # real signature unknown
166     """
167     Return a translation table useable for the bytes or bytearray translate method.
168
169     The returned table will be one where each byte in frm is mapped to the byte at
170     the same position in to.
171
172     The bytes objects frm and to must be of the same length.
173     """
174     pass
175
176 def partition(self, sep): # real signature unknown; restored from __doc__
177     """
178     S.partition(sep) -> (head, sep, tail)
179     有点像find()和split()的结合体，从str出现的第一个位置起，把字符串string分成一个三字符的元组(string_pre_str,str,
180     string_post_str)，如果string中不包含str则string_pre_str == string.
181     Search for the separator sep in S, and return the part before it,
182     the separator itself, and the part after it.  If the separator is not
183     found, return S and two empty strings.
184     """
185     pass
186
187 def pop(self, *args, **kwargs): # real signature unknown
188     """
189     Remove and return a single item from B.
190
191       index
192         The index from where to remove the item.
193         -1 (the default value) means remove the last item.
194
195     If no index argument is given, will pop the last item.
196     """
197     pass
198
199 def remove(self, *args, **kwargs): # real signature unknown
200     """
201     Remove the first occurrence of a value in the bytearray.
202
203       value
204         The value to remove.
205     """
206     pass
207
208 def replace(self, old, new, count=None):  # real signature unknown; restored from __doc__
209     """
210     S.replace(old, new[, count]) -> str
211     把string中的old替换成new，如果count指定，则替换不超过count次
212     Return a copy of S with all occurrences of substring
213     old replaced by new.  If the optional argument count is
214     given, only the first count occurrences are replaced.
215     """
216     return ""
217 def reverse(self, *args, **kwargs): # real signature unknown
218     """ Reverse the order of the values in B in place. """
219     pass
220
221 def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
222     """
223     B.find(sub[, start[, end]]) -> int
224     检测str是否包含在string中，如果start和end指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
225     Return the lowest index in B where subsection sub is found,
226     such that sub is contained within B[start,end].  Optional
227     arguments start and end are interpreted as in slice notation.
228
229     Return -1 on failure.
230     """
231     return 0
232
233 def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
234     """
235     B.rfind(sub[, start[, end]]) -> int
236     类似于find()函数，不过是从右边开始查找
237     Return the highest index in B where subsection sub is found,
238     such that sub is contained within B[start,end].  Optional
239     arguments start and end are interpreted as in slice notation.
240
241     Return -1 on failure.
242     """
243     return 0
244
245 def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
246     """
247     B.index(sub[, start[, end]]) -> int
248     跟find()方法一样，只不过如果str不在string中会报一个异常
249     Like B.find() but raise ValueError when the subsection is not found.
250     """
251     return 0
252
253 def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
254     """
255     B.rindex(sub[, start[, end]]) -> int
256     类似于index(),不过是从右边开始
257     Like B.rfind() but raise ValueError when the subsection is not found.
258     """
259     return 0
260
261 def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
262     """
263     B.rjust(width[, fillchar]) -> copy of B
264     返回一个原字符串右对齐，并使用空格填充至长度width的新字符串
265     Return B right justified in a string of length width. Padding is
266     done using the specified fill character (default is a space)
267     """
268     pass
269
270 def rpartition(self, sep): # real signature unknown; restored from __doc__
271     """
272     S.rpartition(sep) -> (head, sep, tail)
273     类似于partition()函数,不过是从右边开始查找
274     Search for the separator sep in S, starting at the end of S, and return
275     the part before it, the separator itself, and the part after it.  If the
276     separator is not found, return two empty strings and S.
277     """
278     pass
279
280 def strip(self, chars=None):  # real signature unknown; restored from __doc__
281     """
282     S.strip([chars]) -> str
283     删除string字符串左右两边的空格、\n回车
284     Return a copy of the string S with leading and trailing
285     whitespace removed.
286     If chars is given and not None, remove characters in chars instead.
287     """
288     return ""
289
290 def rstrip(self, *args, **kwargs): # real signature unknown
291     """
292     Strip trailing bytes contained in the argument.
293     删除string字符串末尾的空格
294     If the argument is omitted or None, strip trailing ASCII whitespace.
295     """
296     pass
297
298 def lstrip(self, chars=None):  # real signature unknown; restored from __doc__
299     """
300     S.lstrip([chars]) -> str
301     截掉string左边的空格
302     Return a copy of the string S with leading whitespace removed.
303     If chars is given and not None, remove characters in chars instead.
304     """
305     return ""
306
307 def split(self, sep=None, maxsplit=-1):  # real signature unknown; restored from __doc__
308     """
309     S.split(sep=None, maxsplit=-1) -> list of strings
310     以seq为分隔符切片string，与partition的区别结果不包含seq，如果maxsplit有指定值，仅分割maxsplit个字符串
311     Return a list of the words in S, using sep as the
312     delimiter string.  If maxsplit is given, at most maxsplit
313     splits are done. If sep is not specified or is None, any
314     whitespace string is a separator and empty strings are
315     removed from the result.
316     """
317     return []
318
319 def rsplit(self, sep=None, maxsplit=-1):  # real signature unknown; restored from __doc__
320     """
321     S.rsplit(sep=None, maxsplit=-1) -> list of strings
322
323     Return a list of the words in S, using sep as the
324     delimiter string, starting at the end of the string and
325     working to the front.  If maxsplit is given, at most maxsplit
326     splits are done. If sep is not specified, any whitespace string
327     is a separator.
328     """
329     return []
330
331 def splitlines(self, keepends=None):  # real signature unknown; restored from __doc__
332     """
333     S.splitlines([keepends]) -> list of strings
334     按照行分隔，返回一个包含各行作为元素的列表
335     Return a list of the lines in S, breaking at line boundaries.
336     Line breaks are not included in the resulting list unless keepends
337     is given and true.
338     """
339     return []
340
341 def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
342     """
343     B.startswith(prefix[, start[, end]]) -> bool
344     检查字符串是否是以prefix开头，是则返回True，否则返回False。如果start和end指定值，则在指定范围内检查
345     Return True if B starts with the specified prefix, False otherwise.
346     With optional start, test B beginning at that position.
347     With optional end, stop comparing B at that position.
348     prefix can also be a tuple of bytes to try.
349     """
350     return False
351
352 def swapcase(self): # real signature unknown; restored from __doc__
353     """
354     B.swapcase() -> copy of B
355     翻转string中大小写
356     Return a copy of B with uppercase ASCII characters converted
357     to lowercase ASCII and vice versa.
358     """
359     pass
360
361 def title(self):  # real signature unknown; restored from __doc__
362     """
363     S.title() -> str
364     返回“标题化”的string，就是说所有单词都是以大写开始，其余字母均为小写
365     Return a titlecased version of S, i.e. words start with title case
366     characters, all remaining cased characters have lower case.
367     """
368     return ""
369
370 def translate(self, table, deletechars=None): # real signature unknown; restored from __doc__
371     """
372     translate(table, [deletechars])
373     根据table的表（包含256个字符）转换string的字符，要过滤掉的字符放到deletechars参数中
374     Return a copy with each character mapped by the given translation table.
375
376       table
377         Translation table, which must be a bytes object of length 256.
378
379     All characters occurring in the optional argument deletechars are removed.
380     The remaining characters are mapped through the given translation table.
381     """
382     pass
383
384 def upper(self): # real signature unknown; restored from __doc__
385     """
386     B.upper() -> copy of B
387     转换string中的小写字母为大写
388     Return a copy of B with all ASCII characters converted to uppercase.
389     """
390     pass
391
392 def zfill(self, width): # real signature unknown; restored from __doc__
393     """
394     B.zfill(width) -> copy of B
395     返回长度为width的字符串，原字符串string右对齐，前面填充0
396     Pad a numeric string B with zeros on the left, to fill a field
397     of the specified width.  B is never truncated.
398     """
399     pass
400
401 def format(self, *args, **kwargs):  # known special case of str.format
402     """
403     S.format(*args, **kwargs) -> str
404
405     Return a formatted version of S, using substitutions from args and kwargs.
406     The substitutions are identified by braces ('{' and '}').
407     """
408     pass
409
410 def format_map(self, mapping):  # real signature unknown; restored from __doc__
411     """
412     S.format_map(mapping) -> str
413
414     Return a formatted version of S, using substitutions from mapping.
415     The substitutions are identified by braces ('{' and '}').
416     """
417     return ""
418
419 def isidentifier(self):  # real signature unknown; restored from __doc__
420     """
421     S.isidentifier() -> bool
422
423     Return True if S is a valid identifier according
424     to the language definition.
425
426     Use keyword.iskeyword() to test for reserved identifiers
427     such as "def" and "class".
428     """
429     return False