1 def capitalize(self): # real signature unknown; restored from __doc__ 2 """ 3 S.capitalize() -> str 4 5 Return a capitalized version of S, i.e. make the first character 6 have upper case and the rest lower case. 7 """ 8 return ""
1 #练习1、首字母大写 2 li = str("sdfsdagasdf23s5435436dsfdsg") 3 print(li) 4 aa = li.capitalize() #字符串首字母变大写 5 print(aa)
6 执行结果: 7 sdfsdagasdf23s5435436dsfdsg 8 Sdfsdagasdf23s5435436dsfdsg
1 def casefold(self): # real signature unknown; restored from __doc__ 2 """ 3 S.casefold() -> str 4 5 Return a version of S suitable for caseless comparisons. 6 """ 7 return ""
1 #练习2、所有大写变小写 2 li = str("sdfsdaGaSdf23s5435436DsfDsG") 3 print(li) 4 aa = li.casefold() #把字符串里所有大写字母变小写 5 print(aa)
6 执行结果: 7 sdfsdaGaSdf23s5435436DsfDsG 8 sdfsdagasdf23s5435436dsfdsg
1 def center(self, width, fillchar=None): # real signature unknown; restored from __doc__ 2 """ 3 S.center(width[, fillchar]) -> str 4 5 Return S centered in a string of length width. Padding is 6 done using the specified fill character (default is a space) 7 """ 8 return ""
#练习3、将字符串置于长度长的空间的中间,两边填充其他 li = str("sdfGDS324D") aa = li.center(20,"*") #字符串li总长度10,把字符串li置于20个长度的中间,两边空余的地方用“*”填充 print(li) print(aa)
#执行结果: sdfGDS324D *****sdfGDS324D*****
1 def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 2 """ 3 S.count(sub[, start[, end]]) -> int 4 5 Return the number of non-overlapping occurrences of substring sub in 6 string S[start:end]. Optional arguments start and end are 7 interpreted as in slice notation. 8 """ 9 return 0
1 #练习4、计算指定位置段,指定字符出现的次数 2 li = str("sdfGDS324DsdgfeGRAfsdf232") 3 aa = li.count("s") #计算指定字符在字符串中出现的次数 4 print(aa) 5 bb = li.count("s",0,10) #计算指定位置段的字符出现次数,0<=x<10,即顾前不顾后 6 print(bb) 7 8 #执行结果: 9 3 10 1
1 def encode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__ 2 """ 3 S.encode(encoding='utf-8', errors='strict') -> bytes 4 5 Encode S using the codec registered for encoding. Default encoding 6 is 'utf-8'. errors may be given to set a different error 7 handling scheme. Default is 'strict' meaning that encoding errors raise 8 a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and 9 'xmlcharrefreplace' as well as any other name registered with 10 codecs.register_error that can handle UnicodeEncodeErrors. 11 """ 12 return b""
1 #练习5、编码转换 2 li = str("sdfGDS324DsdgfeGRAfsdf232") 3 aa = li.encode("gbk") #这里源编码是utf-8,转换为其他编码gbk 4 print(li) 5 print(aa) 6 bb = aa.decode() #其他编码转换回默认的utf-8编码 7 print(bb) 8 9 执行结果: 10 sdfGDS324DsdgfeGRAfsdf232 11 b'sdfGDS324DsdgfeGRAfsdf232' 12 sdfGDS324DsdgfeGRAfsdf232
1 def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__ 2 """ 3 S.endswith(suffix[, start[, end]]) -> bool 4 5 Return True if S ends with the specified suffix, False otherwise. 6 With optional start, test S beginning at that position. 7 With optional end, stop comparing S at that position. 8 suffix can also be a tuple of strings to try. 9 """ 10 return False
1 #练习6、字符串结尾是否正确 2 li = str("sdfGDS324DsdgfeGRAfsdf232") 3 aa = li.endswith("kkk") #当然也有验证字符串前头是否正确,startswith 4 bb = li.endswith("232") 5 print(aa) 6 print(bb) 7 8 #执行结果: 9 False 10 True
1 def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__ 2 """ 3 S.expandtabs(tabsize=8) -> str 4 5 Return a copy of S where all tab characters are expanded using spaces. 6 If tabsize is not given, a tab size of 8 characters is assumed. 7 """ 8 return ""
1 #练习7、将tab转换为8个空格 2 li = str("sdfGDS324\tDsdgfeGRAfsdf232") 3 aa = li.expandtabs() #将tab转换为8个空格 4 print(aa) 5 6 #执行结果: 7 sdfGDS324 DsdgfeGRAfsdf232
1 def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 2 """ 3 S.find(sub[, start[, end]]) -> int 4 5 Return the lowest index in S where substring sub is found, 6 such that sub is contained within S[start:end]. Optional 7 arguments start and end are interpreted as in slice notation. 8 9 Return -1 on failure. 10 """ 11 return 0
1 #练习8、寻找指定字母位置 2 li = str("sdfGDS324DsdgfeGRAfsdf232") 3 aa = li.find("G") #查找指定字母位置,从左往右找 4 bb = li.rfind("G") #查找指定字母位置,从右往左找 5 print(aa) 6 print(bb) 7 8 #执行结果: 9 3 10 15
1 def format(self, *args, **kwargs): # known special case of str.format 2 """ 3 S.format(*args, **kwargs) -> str 4 5 Return a formatted version of S, using substitutions from args and kwargs. 6 The substitutions are identified by braces ('{' and '}'). 7 """ 8 pass
1 #练习9、字符串格式化 2 li = str("sdfGDS324{0}\nDsdgfe{1}\nGRAfsdf232") 3 aa = li.format("-----","*****") #字符串格式化,可以优化输出结果 4 print(aa) 5 6 #执行结果: 7 sdfGDS324----- 8 Dsdgfe***** 9 GRAfsdf232
1 def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 2 """ 3 S.index(sub[, start[, end]]) -> int 4 5 Like S.find() but raise ValueError when the substring is not found. 6 """ 7 return 0
1 #练习10、查找字符索引 2 li = str("sdfGDS324DsdgfeGRAfsdf232") 3 aa = li.index("sd",10,20) #查找指定位置段指定字符串的索引,注意:只输出第一个 4 bb = li.index("sd") #默认寻找全部第一个 5 print(aa) 6 print(bb) 7 8 #执行结果: 9 10 10 0
1 def isalnum(self): # real signature unknown; restored from __doc__ 2 """ 3 S.isalnum() -> bool 4 5 Return True if all characters in S are alphanumeric 6 and there is at least one character in S, False otherwise. 7 """ 8 return False
1 #练习11、判断字符串是否为纯字母和数字 2 li = str("sdfGDS324DsdgfeGRAfsdf232") 3 aa = li.isalnum() #纯字母和数字则为真 4 li11 = str("!@#$%^sdgsdg235") #否则为假 5 bb = li11.isalnum() 6 print(aa) 7 print(bb) 8 9 #执行结果: 10 True 11 False
1 def isalpha(self): # real signature unknown; restored from __doc__ 2 """ 3 S.isalpha() -> bool 4 5 Return True if all characters in S are alphabetic 6 and there is at least one character in S, False otherwise. 7 """ 8 return False
1 #练习12、判断字符串是否纯为字母 2 li = str("sdfGDS324DsdgfeGRAfsdf232") 3 aa = li.isalpha() #判断字符串是否纯为字母,不是则为加 4 li11 = str("fsdgahsdfh") #否则为真 5 bb = li11.isalpha() 6 print(aa) 7 print(bb) 8 9 #执行结果: 10 False 11 True
1 def isdigit(self): # real signature unknown; restored from __doc__ 2 """ 3 S.isdigit() -> bool 4 5 Return True if all characters in S are digits 6 and there is at least one character in S, False otherwise. 7 """ 8 return False
1 #练习13、判断字符串是否纯为数字 2 li = str("sdfGDS324DsdgfeGRAfsdf232") 3 aa = li.isdigit() #判断字符串是否纯为数字,不是则为假 4 li11 = str("2142353156") #否则为真 5 bb = li11.isdigit() 6 print(aa) 7 print(bb) 8 9 #执行结果: 10 False 11 True
1 def islower(self): # real signature unknown; restored from __doc__ 2 """ 3 S.islower() -> bool 4 5 Return True if all cased characters in S are lowercase and there is 6 at least one cased character in S, False otherwise. 7 """ 8 return False
1 #练习14、判断字符串是否纯为小写字母 2 li = str("sdfGDS324DsdgfeGRAfsdf232") 3 aa = li.islower() #字符串不是纯小写字母,则为假 4 li11 = str("aaaaaaaa") #否则为真 5 bb = li11.islower() 6 print(aa) 7 print(bb) 8 9 #执行结果: 10 False 11 True
1 def join(self, iterable): # real signature unknown; restored from __doc__ 2 """ 3 S.join(iterable) -> str 4 5 Return a string which is the concatenation of the strings in the 6 iterable. The separator between elements is S. 7 """ 8 return ""
#练习15、一个字符串加入另外一个字符串 li = str("sdfGDS32") aa = "***" bb = li.join(aa) #字符串li加入到字符串aa中的每个字符中间 cc = aa.join(li) print(bb) print(cc) #执行结果: *sdfGDS32*sdfGDS32* s***d***f***G***D***S***3***2
1 def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__ 2 """ 3 S.ljust(width[, fillchar]) -> str 4 5 Return S left-justified in a Unicode string of length width. Padding is 6 done using the specified fill character (default is a space). 7 """ 8 return ""
1 #练习16、字符串左对齐 2 li = str("sdfGDS32") 3 aa = li.ljust(20,"*") #指定空间左对齐,不足的可以填充其他,可用于优化显示 4 bb = li.ljust(20) #当然也有右对齐rjust,用法一样 5 print(aa) 6 print(bb) 7 8 #执行结果 9 sdfGDS32************ 10 sdfGDS32
1 def lower(self): # real signature unknown; restored from __doc__ 2 """ 3 S.lower() -> str 4 5 Return a copy of the string S converted to lowercase. 6 """ 7 return ""
1 #练习17、把字符串的大写字母变为小写 2 li = str("sdfGDS32") 3 aa = li.lower() #将字符串所有的大写字母变为小写 4 print(li) 5 print(aa) 6 7 #执行结果: 8 sdfGDS32 9 sdfgds32
1 def lstrip(self, chars=None): # real signature unknown; restored from __doc__ 2 """ 3 S.lstrip([chars]) -> str 4 5 Return a copy of the string S with leading whitespace removed. 6 If chars is given and not None, remove characters in chars instead. 7 """ 8 return ""
1 #练习18、移除左侧空白 2 li = str(" sdfGDS32") 3 aa = li.lstrip() #移除字符串左侧空白,也有移除右侧空白rstrip,以及移除两端空白strip() 4 print(li) 5 print(aa) 6 7 #执行结果: 8 sdfGDS32 9 sdfGDS32
1 def partition(self, sep): # real signature unknown; restored from __doc__ 2 """ 3 S.partition(sep) -> (head, sep, tail) 4 5 Search for the separator sep in S, and return the part before it, 6 the separator itself, and the part after it. If the separator is not 7 found, return S and two empty strings. 8 """ 9 pass
1 #练习19、分割字符串 2 li = str("sdfGDS32") 3 aa = li.partition("G") #分割,指定字符为中间部分,前面和后面2部分 4 print(aa) 5 bb = li.partition("*") #如果指定字符不存在,在字符串后加空字符 6 print(bb) 7 8 #执行结果: 9 ('sdf', 'G', 'DS32') 10 ('sdfGDS32', '', '')
1 def replace(self, old, new, count=None): # real signature unknown; restored from __doc__ 2 """ 3 S.replace(old, new[, count]) -> str 4 5 Return a copy of S with all occurrences of substring 6 old replaced by new. If the optional argument count is 7 given, only the first count occurrences are replaced. 8 """ 9 return ""
1 #练习20、替换 2 li = str("sdfGDS32sdyyer234sddfdg") 3 aa = li.replace("sd","**",2) # 替换,默认替换所有,加数字则替换前几个 4 print(aa) 5 6 #执行结果: 7 **fGDS32**yyer234sddfdg
1 def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__ 2 """ 3 S.split(sep=None, maxsplit=-1) -> list of strings 4 5 Return a list of the words in S, using sep as the 6 delimiter string. If maxsplit is given, at most maxsplit 7 splits are done. If sep is not specified or is None, any 8 whitespace string is a separator and empty strings are 9 removed from the result. 10 """ 11 return []
1 #练习21、分割 2 li = str("sdfGDS32sdyyer234sddfdg") 3 aa = li.split("sd") # 默认以指定字符为标志分割所有 4 bb = li.split("sd",2) #指定数字(最多分割几次) 5 print(aa) 6 print(bb) 7 8 #执行结果: 9 ['', 'fGDS32', 'yyer234', 'dfdg'] 10 ['', 'fGDS32', 'yyer234sddfdg']
1 def splitlines(self, keepends=None): # real signature unknown; restored from __doc__ 2 """ 3 S.splitlines([keepends]) -> list of strings 4 5 Return a list of the lines in S, breaking at line boundaries. 6 Line breaks are not included in the resulting list unless keepends 7 is given and true. 8 """ 9 return []
1 #练习22、根据换行分割 2 li = str("sdfGDS32\nsdyyer\n234sddfdg") 3 aa = li.splitlines() #根据换行分割 4 print(aa) 5 6 #执行结果: 7 ['sdfGDS32', 'sdyyer', '234sddfdg']
1 def swapcase(self): # real signature unknown; restored from __doc__ 2 """ 3 S.swapcase() -> str 4 5 Return a copy of S with uppercase characters converted to lowercase 6 and vice versa. 7 """ 8 return ""
1 #练习23、大写转换为小写,小写转换为大写 2 li = str("sdfGDS32sdyyer234sddfdg") 3 aa = li.swapcase() #大写转换为小写,小写转换为大写 4 print(li) 5 print(aa) 6 7 #执行结果: 8 sdfGDS32sdyyer234sddfdg 9 SDFgds32SDYYER234SDDFDG
1 def translate(self, table): # real signature unknown; restored from __doc__ 2 """ 3 S.translate(table) -> str 4 5 Return a copy of the string S, where all characters have been mapped 6 through the given translation table, which must be a mapping of 7 Unicode ordinals to Unicode ordinals, strings, or None. 8 Unmapped characters are left untouched. Characters mapped to None 9 are deleted. 10 """ 11 return ""
1 def maketrans(self, *args, **kwargs): # real signature unknown 2 """ 3 Return a translation table usable for str.translate(). 4 5 If there is only one argument, it must be a dictionary mapping Unicode 6 ordinals (integers) or characters to Unicode ordinals, strings or None. 7 Character keys will be then converted to ordinals. 8 If there are two arguments, they must be strings of equal length, and 9 in the resulting dictionary, each character in x will be mapped to the 10 character at the same position in y. If there is a third argument, it 11 must be a string, whose characters will be mapped to None in the result. 12 """ 13 pass
1 #练习24、转换,先做一个对应表,然后对换 2 st = "" 3 intab = "aeiou" 4 outtab = "12345" 5 table = st.maketrans(intab,outtab) #需要结合maketrans使用,对应表 6 astr = "aeiou-777777-12345" 7 bstr = astr.translate(table) #转换 8 print(bstr) 9 10 执行结果: 11 12345-777777-12345
1 def zfill(self, width): # real signature unknown; restored from __doc__ 2 """ 3 S.zfill(width) -> str 4 5 Pad a numeric string S with zeros on the left, to fill a field 6 of the specified width. The string S is never truncated. 7 """ 8 return ""
1 #练习25、返回指定字符串长度,长度超过字符串则以“0”填充 2 li = str("213dsf3") 3 aa = li.zfill(20) 4 print(aa) 5 6 #执行结果: 7 0000000000000213dsf3