Python之字符串详解1

Posted 2020-06-17

1. 查看类型

name = ‘allen‘
print(type(name))     #查看类型
<class ‘str‘>         #类型为str

age = 19
print(type(name))     #查看类型
<class ‘int‘>         #类型为int

 2. center

描述：居中显示

语法：

    def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
        """
        B.center(width[, fillchar]) -> copy of B
        
        Return B centered in a string of length width.  Padding is
        done using the specified fill character (default is a space).
        """
        pass

样例：

name = ‘allen‘
result=name.center(20,‘*‘)   #居中对齐，显示20个字符，默认以*号代替
print(result)

*******allen********  #显示结果

center

3. ljust

描述：左对齐显示

语法：

    def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
        """
        S.ljust(width[, fillchar]) -> str
        
        Return S left-justified in a Unicode string of length width. Padding is
        done using the specified fill character (default is a space).
        """
        return ""

 样例：

name = ‘allen‘
result=name.ljust(20,‘*‘)    #左对齐，显示20个字符，默认以*号代替
print(result)


allen***************    #显示结果

ljust

 4. rjust

描述：右对齐显示

语法：

    def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
        """
        S.rjust(width[, fillchar]) -> str
        
        Return S right-justified in a string of length width. Padding is
        done using the specified fill character (default is a space).
        """
        return ""

样例：

name = ‘allen‘
result=name.rjust(20,‘*‘)    #居右对齐，显示20个字符，默认以*号代替
print(result)

***************allen    #显示结果

rjust

5. capitalize/title

描述：首字母大写

语法：

   def capitalize(self): # real signature unknown; restored from __doc__
        """
        S.capitalize() -> str
        
        Return a capitalized version of S, i.e. make the first character
        have upper case and the rest lower case.
        """
        return ""

样例：

name = ‘allen‘
result=name.capitalize()    #首字母转换为大写，其他小写
print(result)

Allen    #结果显示


name = ‘allen‘
result=name.title()    #首字母转换为大写，其他小写
print(result)

Allen    #结果显示

capitalize

6. lower

描写：所有字符转换为小写

语法：

  def lower(self): # real signature unknown; restored from __doc__
        """
        S.lower() -> str
        
        Return a copy of the string S converted to lowercase.
        """
        return ""

样例：

name = ‘ALLEN‘
result=name.lower()    #所有字符转换为小写
print(result)

allen    #结果显示

lower

7. upper

描写：所有字符转换为大写

语法：

 def upper(self): # real signature unknown; restored from __doc__
        """
        S.upper() -> str
        
        Return a copy of S converted to uppercase.
        """
        return ""

样例：

name = ‘allen‘
result=name.upper()    #所有字符转换为大写
print(result)

ALLEN    #结果显示

upper

8. encode

描写：编码转换

语法：

 def encode(self, encoding=‘utf-8‘, errors=‘strict‘): # real signature unknown; restored from __doc__
        """
        S.encode(encoding=‘utf-8‘, errors=‘strict‘) -> bytes
        
        Encode S using the codec registered for encoding. Default encoding
        is ‘utf-8‘. errors may be given to set a different error
        handling scheme. Default is ‘strict‘ meaning that encoding errors raise
        a UnicodeEncodeError. Other possible values are ‘ignore‘, ‘replace‘ and
        ‘xmlcharrefreplace‘ as well as any other name registered with
        codecs.register_error that can handle UnicodeEncodeErrors.
        """
        return b""

样例：

name = ‘你好‘
print(name)
a = name.encode(‘gbk‘)  #编码转换utf8->uncode->gbk
print (a)

你好        #utf-8编码显示结果
b‘\xc4\xe3\xba\xc3‘    #gbk编码显示结果

encode

9. startswith

描写：判断以什么字符开头，结果范围True or False

语法：

   def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.startswith(prefix[, start[, end]]) -> bool
        
        Return True if S starts with the specified prefix, False otherwise.
        With optional start, test S beginning at that position.
        With optional end, stop comparing S at that position.
        prefix can also be a tuple of strings to try.
        """
        return False

样例：

name = ‘allen‘
a = name.startswith(‘a‘)    #判断字符串以a开头
print(a)

True    #显示结果


name = ‘allen‘
a = name.startswith(‘a‘,0,4)      #判断‘allen’是否以a开头  
print(a)

True    #显示结果

startswith

10. endswith

描写：判断以什么字符结尾，结果范围True or False，需注意取值与startswith略有不同

语法：

    def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.endswith(suffix[, start[, end]]) -> bool
        
        Return True if S ends with the specified suffix, False otherwise.
        With optional start, test S beginning at that position.
        With optional end, stop comparing S at that position.
        suffix can also be a tuple of strings to try.
        """
        return False

样例：

name = ‘allen‘
a = name.endswith(‘n‘,1,5)    #判断‘allen’是否以n结尾
print(a)

True    #结果显示

endswith

11. expandtabs

描写：将tab转换成8个空格

语法：

    def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
        """
        S.expandtabs(tabsize=8) -> str
        
        Return a copy of S where all tab characters are expanded using spaces.
        If tabsize is not given, a tab size of 8 characters is assumed.
        """
        return "

样例：

name = ‘a\tllen‘
result=name.expandtabs()  #将1个tab转换成8个空格
print(result)

a       llen    #显示结果

expandtabs

12. find

描写：查找序列，返回所在的位置下标。若没有找到，结果返回值为-1

语法：

def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.find(sub[, start[, end]]) -> int
        
        Return the lowest index in S where substring sub is found,
        such that sub is contained within S[start:end].  Optional
        arguments start and end are interpreted as in slice notation.
        
        Return -1 on failure.
        """
        return 0

样例：

name = ‘allen‘
result = name.find(‘e‘)    #查找字符是否包含e
print(result)

3    #结果显示，找到e并返回所在下标值

name = ‘allen‘
result = name.find(‘x‘)    #查找字符是否包含x
print(result)

-1   #结果显示为找到，返回值为-1

find

13. index

描写：查找序列，返回所在的位置下标。若没有找到，结果为报错

语法：

    def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.index(sub[, start[, end]]) -> int
        
        Like S.find() but raise ValueError when the substring is not found.
        """
        return 0

样例：

name = ‘allen‘
result = name.index(‘aa‘) #查找字符中是否包含aa
print(result)


NameError: name ‘name‘ is not defined    #未找到，结果显示报错信息

index

14. count

描写：搜索关键字并计数

语法：

  def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.count(sub[, start[, end]]) -> int
        
        Return the number of non-overlapping occurrences of substring sub in
        string S[start:end].  Optional arguments start and end are
        interpreted as in slice notation.
        """
        return 0

样例：

name = ‘aasd;asdfasdfas‘
a = name.count(‘df‘)    #搜索‘df’的个数
print(a)

2    #显示结果

name = ‘aasd;asdfasdfas‘
a = name.count(‘df‘,0,10)  #在0-10下标内，所搜‘df’的个数
print(a)

1    #显示结果

count

15. format

描写：字段拼接，类似于%s

语法：

  def format(*args, **kwargs): # known special case of str.format
        """
        S.format(*args, **kwargs) -> str
        
        Return a formatted version of S, using substitutions from args and kwargs.
        The substitutions are identified by braces (‘{‘ and ‘}‘).
        """
        pass

样例：

name = "aa {name} {id}"
result = name.format(name=‘allen‘,id=‘123‘)    #变量赋值，拼接内容
print(result)

aa allen 123    #显示结果

format

16. replace

描写：字符替换

语法：

 def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
        """
        S.replace(old, new[, count]) -> str
        
        Return a copy of S with all occurrences of substring
        old replaced by new.  If the optional argument count is
        given, only the first count occurrences are replaced.
        """
        return ""

样例：

name = ‘allen‘
result=name.replace(‘a‘,‘e‘)    #将字符a更改为e
print(result)

ellen    #显示结果



name = ‘allen‘
result=name.replace(‘l‘,‘o‘,1)    #将字符l替换成o，限第一次匹配
print(result)

aolen    #显示结果

replace

17. partition

描写：搜索关键字，以关键字为分隔符。若未匹配，则显示为空的字符串

语法：

    def partition(self, sep): # real signature unknown; restored from __doc__
        """
        S.partition(sep) -> (head, sep, tail)
        
        Search for the separator sep in S, and return the part before it,
        the separator itself, and the part after it.  If the separator is not
        found, return S and two empty strings.
        """
        pass

样例：

name = ‘allenisboy‘
result=name.partition(‘is‘)    #以is为分隔符
print(result)

(‘allen‘, ‘is‘, ‘boy‘)    #显示结果

partition

18 join

描写：以定义的字符为分隔符，进行内容拼接

语法：

    def join(self, iterable): # real signature unknown; restored from __doc__
        """
        S.join(iterable) -> str
        
        Return a string which is the concatenation of the strings in the
        iterable.  The separator between elements is S.
        """
        return ""

样例：

list = [‘a‘,‘b‘,‘c‘,‘d‘]
result="_".join(list)    #以下滑线为分隔符，进行拼接
print(result)

a_b_c_d    #结果显示

join

19. split

描写：以定义的字符为分隔符，进行字符串分割

语法：

    def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
        """
        S.split(sep=None, maxsplit=-1) -> list of strings
        
        Return a list of the words in S, using sep as the
        delimiter string.  If maxsplit is given, at most maxsplit
        splits are done. If sep is not specified or is None, any
        whitespace string is a separator and empty strings are
        removed from the result.
        """
        return []

样例：

name =‘‘‘
aaa
bbb
ccc‘‘‘

result=name.split(‘\n‘)    #以换行为分隔符，进行分割
print(result)

[‘‘, ‘aaa‘, ‘bbb‘, ‘ccc‘]    #结果以列表形式显示

split

20. splitlines

描写：以换行符为分隔符，进行字符串分割

语法：

 def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
        """
        S.splitlines([keepends]) -> list of strings
        
        Return a list of the lines in S, breaking at line boundaries.
        Line breaks are not included in the resulting list unless keepends
        is given and true.
        """
        return []

样例：

name =‘‘‘
aaa
bbb
ccc‘‘‘
result=name.splitlines()    #默认以换行符进行分割
print(result)

[‘‘, ‘aaa‘, ‘bbb‘, ‘ccc‘]    #以列表项是显示结果

splitlines

21. strip

描写：移除字符串头尾指定的字符（默认为空格）。

语法：

    def strip(self, chars=None): # real signature unknown; restored from __doc__
        """
        S.strip([chars]) -> str
        
        Return a copy of the string S with leading and trailing
        whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        """
        return ""

样例：

name = ‘123allen‘
result=name.strip(‘12‘)    #移除包含1、2的字符
print(result)

3allen    #显示结果

result=name.strip(‘21‘)    #移除包含1、2的字符
print(result)

3allen    #显示结果

strip

21. lstrip

描写：左匹配字符串，进行移除操作

语法：

    def lstrip(self, chars=None): # real signature unknown; restored from __doc__
        """
        S.lstrip([chars]) -> str
        
        Return a copy of the string S with leading whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        """
        return ""

样例：

name = ‘123allen‘
result=name.lstrip(‘213‘)    #从左开始，搜索字符1,2,3并移除
print(result)

allen    #显示结果

lstrip

22. rstrip

描写：右匹配字符串，进行移除操作

语法：

    def rstrip(self, chars=None): # real signature unknown; restored from __doc__
        """
        S.rstrip([chars]) -> str
        
        Return a copy of the string S with trailing whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        """
        return ""

样例：

name = ‘123allen‘
result=name.rstrip(‘en‘)    #从右边开始，搜索en并移除
print(result)

123all    #显示结果

rstrip