Python字符串部分源码分析 - 木流
Python字符串部分源码分析
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.format2 """
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 unknown2 """
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
发表于
2016-04-21 15:45
木流
阅读(760)
评论(0)
编辑
收藏
举报
以上是 Python字符串部分源码分析 - 木流 的全部内容， 来源链接： utcz.com/z/387447.html
