自學Python2.1-基本數據類型-字符串方法 下

自學Python之路

自學Python2.1-基本數據類型-字符串方法 下 

class str(object):
    """
    str(object='') -> str
    str(bytes_or_buffer[, encoding[, errors]]) -> str
    
    Create a new string object from the given object. If encoding or
    errors is specified, then the object must expose a data buffer
    that will be decoded using the given encoding and error handler.
    Otherwise, returns the result of object.__str__() (if defined)
    or repr(object).
    encoding defaults to sys.getdefaultencoding().
    errors defaults to 'strict'.
    """
    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 ""

    def casefold(self): # real signature unknown; restored from __doc__
        """
        S.casefold() -> str
        
        Return a version of S suitable for caseless comparisons.
        """
        return ""

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

    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

    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""

    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

    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 ""

    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

    def format(self, *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

    def format_map(self, mapping): # real signature unknown; restored from __doc__
        """
        S.format_map(mapping) -> str
        
        Return a formatted version of S, using substitutions from mapping.
        The substitutions are identified by braces ('{' and '}').
        """
        return ""

    def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.index(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.
        
        Raises ValueError when the substring is not found.
        """
        return 0

    def isalnum(self): # real signature unknown; restored from __doc__
        """
        S.isalnum() -> bool
        
        Return True if all characters in S are alphanumeric
        and there is at least one character in S, False otherwise.
        """
        return False

    def isalpha(self): # real signature unknown; restored from __doc__
        """
        S.isalpha() -> bool
        
        Return True if all characters in S are alphabetic
        and there is at least one character in S, False otherwise.
        """
        return False

    def isdecimal(self): # real signature unknown; restored from __doc__
        """
        S.isdecimal() -> bool
        
        Return True if there are only decimal characters in S,
        False otherwise.
        """
        return False

    def isdigit(self): # real signature unknown; restored from __doc__
        """
        S.isdigit() -> bool
        
        Return True if all characters in S are digits
        and there is at least one character in S, False otherwise.
        """
        return False

    def isidentifier(self): # real signature unknown; restored from __doc__
        """
        S.isidentifier() -> bool
        
        Return True if S is a valid identifier according
        to the language definition.
        
        Use keyword.iskeyword() to test for reserved identifiers
        such as "def" and "class".
        """
        return False

    def islower(self): # real signature unknown; restored from __doc__
        """
        S.islower() -> bool
        
        Return True if all cased characters in S are lowercase and there is
        at least one cased character in S, False otherwise.
        """
        return False

    def isnumeric(self): # real signature unknown; restored from __doc__
        """
        S.isnumeric() -> bool
        
        Return True if there are only numeric characters in S,
        False otherwise.
        """
        return False

    def isprintable(self): # real signature unknown; restored from __doc__
        """
        S.isprintable() -> bool
        
        Return True if all characters in S are considered
        printable in repr() or S is empty, False otherwise.
        """
        return False

    def isspace(self): # real signature unknown; restored from __doc__
        """
        S.isspace() -> bool
        
        Return True if all characters in S are whitespace
        and there is at least one character in S, False otherwise.
        """
        return False

    def istitle(self): # real signature unknown; restored from __doc__
        """
        S.istitle() -> bool
        
        Return True if S is a titlecased string and there is at least one
        character in S, i.e. upper- and titlecase characters may only
        follow uncased characters and lowercase characters only cased ones.
        Return False otherwise.
        """
        return False

    def isupper(self): # real signature unknown; restored from __doc__
        """
        S.isupper() -> bool
        
        Return True if all cased characters in S are uppercase and there is
        at least one cased character in S, False otherwise.
        """
        return False

    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 ""

    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 ""

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

    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 ""

    def maketrans(self, *args, **kwargs): # real signature unknown
        """
        Return a translation table usable for str.translate().
        
        If there is only one argument, it must be a dictionary mapping Unicode
        ordinals (integers) or characters to Unicode ordinals, strings or None.
        Character keys will be then converted to ordinals.
        If there are two arguments, they must be strings of equal length, and
        in the resulting dictionary, each character in x will be mapped to the
        character at the same position in y. If there is a third argument, it
        must be a string, whose characters will be mapped to None in the result.
        """
        pass

    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

    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 ""

    def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.rfind(sub[, start[, end]]) -> int
        
        Return the highest 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

    def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.rindex(sub[, start[, end]]) -> int
        
        Return the highest 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.
        
        Raises ValueError when the substring is not found.
        """
        return 0

    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 ""

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

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

    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 ""

    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 []

    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 []

    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

    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 ""

    def swapcase(self): # real signature unknown; restored from __doc__
        """
        S.swapcase() -> str
        
        Return a copy of S with uppercase characters converted to lowercase
        and vice versa.
        """
        return ""

    def title(self): # real signature unknown; restored from __doc__
        """
        S.title() -> str
        
        Return a titlecased version of S, i.e. words start with title case
        characters, all remaining cased characters have lower case.
        """
        return ""

    def translate(self, table): # real signature unknown; restored from __doc__
        """
        S.translate(table) -> str
        
        Return a copy of the string S in which each character has been mapped
        through the given translation table. The table must implement
        lookup/indexing via __getitem__, for instance a dictionary or list,
        mapping Unicode ordinals to Unicode ordinals, strings, or None. If
        this operation raises LookupError, the character is left untouched.
        Characters mapped to None are deleted.
        """
        return ""

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

    def zfill(self, width): # real signature unknown; restored from __doc__
        """
        S.zfill(width) -> str
        
        Pad a numeric string S with zeros on the left, to fill a field
        of the specified width. The string S is never truncated.
        """
        return ""

    def __add__(self, *args, **kwargs): # real signature unknown
        """ Return self+value. """
        pass

    def __contains__(self, *args, **kwargs): # real signature unknown
        """ Return key in self. """
        pass

    def __eq__(self, *args, **kwargs): # real signature unknown
        """ Return self==value. """
        pass

    def __format__(self, format_spec): # real signature unknown; restored from __doc__
        """
        S.__format__(format_spec) -> str
        
        Return a formatted version of S as described by format_spec.
        """
        return ""

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, *args, **kwargs): # real signature unknown
        """ Return self[key]. """
        pass

    def __getnewargs__(self, *args, **kwargs): # real signature unknown
        pass

    def __ge__(self, *args, **kwargs): # real signature unknown
        """ Return self>=value. """
        pass

    def __gt__(self, *args, **kwargs): # real signature unknown
        """ Return self>value. """
        pass

    def __hash__(self, *args, **kwargs): # real signature unknown
        """ Return hash(self). """
        pass

    def __init__(self, value='', encoding=None, errors='strict'): # known special case of str.__init__
        """
        str(object='') -> str
        str(bytes_or_buffer[, encoding[, errors]]) -> str
        
        Create a new string object from the given object. If encoding or
        errors is specified, then the object must expose a data buffer
        that will be decoded using the given encoding and error handler.
        Otherwise, returns the result of object.__str__() (if defined)
        or repr(object).
        encoding defaults to sys.getdefaultencoding().
        errors defaults to 'strict'.
        # (copied from class doc)
        """
        pass

    def __iter__(self, *args, **kwargs): # real signature unknown
        """ Implement iter(self). """
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    def __le__(self, *args, **kwargs): # real signature unknown
        """ Return self<=value. """
        pass

    def __lt__(self, *args, **kwargs): # real signature unknown
        """ Return self<value. """
        pass

    def __mod__(self, *args, **kwargs): # real signature unknown
        """ Return self%value. """
        pass

    def __mul__(self, *args, **kwargs): # real signature unknown
        """ Return self*value.n """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __ne__(self, *args, **kwargs): # real signature unknown
        """ Return self!=value. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __rmod__(self, *args, **kwargs): # real signature unknown
        """ Return value%self. """
        pass

    def __rmul__(self, *args, **kwargs): # real signature unknown
        """ Return self*value. """
        pass

    def __sizeof__(self): # real signature unknown; restored from __doc__
        """ S.__sizeof__() -> size of S in memory, in bytes """
        pass

    def __str__(self, *args, **kwargs): # real signature unknown
        """ Return str(self). """
        pass

str源代碼

1．返回第一個字母大寫

      capitalize(...)

      S.capitalize() -> string

1 2 3 4

>>>a =  'shaw' >>> b =  a.capitalize() >>> print  b Shaw

2．按指定長度填充特定字符

      center(...)

      S.center(width[, fillchar]) -> string

1 2 3 4 5 6 7

>>> a =  'linux' >>> print  a.center( 7 , '*' ) *linux* >>> print  a.center( 8 , '*' ) *linux** >>> print  a.center( 9 , '*' ) **linux**

3．查找某字符串出現的次數

      count(...)

      S.count(sub[, start[, end]]) -> int

1 2 3 4 5 6 7 8 9

>>> a =  "this is my dog, i love this dog and it's a good dog!" >>> print  a.count( 'dog' ) 3 >>> print  a.count( 'dog' , 15 ) 2 >>> print  a.count( 'dog' , 15 , 30 )  #從15到30字符之間dog的此時 0 >>> print  a.count( 'dog' , 15 , 32 ) 1

4.以指定的編碼格式解碼字符串。默認編碼爲字符串編碼（適合python2中處理中文）

      decode(...)

      S.decode([encoding[,errors]]) ->object

1 2 3

b = 'strid' >>> b.decode('utf-8') u'strid'

5.用於判斷字符串是否以指定後綴結尾，若是以指定後綴結尾返回True，不然返回False。可選參數"start"與"end"爲檢索字符串的開始與結束位置

    endswith(...)

    S.endswith(suffix[,start[, end]]) ->bool

1 2 3 4 5 6 7

>>> shaw =  'I am shaw,what\'s your name ?' >>> shaw.endswith( '?' ) True >>> shaw.endswith( 'w' , 7 , 9 ) True >>> shaw.endswith( 'w' , 7 , 8 ) False

6.把字符串中的 tab 符號('\t')轉爲空格，tab 符號('\t')默認的空格數是8，tabsize -- 指定轉換字符串中的 tab 符號('\t')轉爲空格的字符數。

    expandtabs(...)

    S.expandtabs([tabsize])-> string

1 2 3 4 5 6 7

>>> info =  'today is a good d\tay' >>> print  info.expandtabs() today is  a good d       ay >>> print  info.expandtabs( 4 )   # 把tab裝換成4個空格 today is  a good d   ay         >>> printinfo.expandtabs( 1 ) today is  a good d ay          # 把tab裝換成1個空格

7.檢測字符串中是否包含子字符串 str ，若是指定 beg（開始）和 end（結束）範圍，則檢查是否包含在指定範圍內，若是包含子字符串，則返回開始的索引值，不然返回-1。

    find(...)

    S.find(sub [,start [,end]])-> int

1 2 3 4 5 6 7

>>> a =  'stivenwang' >>> a.find( 'w' ) 6 >>> a.find( 'w' , 9 ) - 1 >>> a.find( 'w' , 9 , 11 ) - 1

8．格式換字符串輸出（方法與%類似，但能夠指定順序）

    format(...)

    S.format(*args, **kwargs)-> string

1 2 3 4 5 6 7 8

>>> name =  'StivenWang' >>> fruit =  'apple' >>> print  'my name is {},I like {}' . format (name,fruit) my name is  StivenWang,I like apple >>> print  'my name is {1},I like {0}' . format (fruit,name) my name is  StivenWang,I like apple >>> print  'my name is {mingzi},I like{shuiguo}' . format (shuiguo = fruit,mingzi = name) my name is  StivenWang,I like apple

9.檢測字符串string中是否包含子字符串 str ，若是存在，則返回str在string中的索引值，若是指定beg（開始）和 end（結束）範圍，則檢查是否包含在指定範圍內，該方法與 python find()方法同樣，只不過若是str不在 string中會報一個異常(ValueError: substring not found)。

   index(...)

    S.index(sub [,start [,end]])-> int

1 2 3 4 5 6 7 8

>>> str1 =  "this is string example....wow!!!" >>> str2 =  "exam" >>> print  str1.index(str2) 15 >>> print  str1.index(str2, 20 ) Traceback (most recent call last):    File  "<input>" ,line 1 , in  <module> ValueError: substringnot found報錯

10.檢測字符串是否由字母或數字組成。

    isalnum(...)

    S.isalnum() -> bool

1 2 3 4 5 6 7 8 9 10 11 12

>>> a =  '123' >>> a.isalnum() True >>> b =  'shaw' >>> b.isalnum() True >>> c =  'shaw123' >>> c.isalnum() True >>> d =  'th 123' >>> d.isalnum() False

11.檢測字符串是否只由字母組成

    isalpha(...)

    S.isalpha() -> bool

1 2 3 4 5 6 7 8 9 10 11 12

>> a =  '123' >>> a.isalpha() False >>> b =  '123shaw' >>> b.isalpha() False >>> c =  'shaw' >>> c.isalpha() True >>> d =  'sha w' >>> d.isalpha() False

12.檢測字符串是否只由數字組成。

    isdigit(...)

    S.isdigit() -> bool

1 2 3 4 5 6 7 8 9

>>> a =  '123' >>> a.isdigit() True >>> b =  'shaw' >>> b.isdigit() False >>> c =  '123shaw' >>> c.isdigit() False

13.檢測字符串是否由小寫字母組成。

    islower(...)

    S.islower() -> bool

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

>>> a =  'shaw' >>> a.islower() True >>> b =  '123' >>> a.islower() True >>> c =  '123shaw' >>> c.islower() True >>> d =  'SHAW' >>> d.islower() False >>> e =  '123SHAW' >>> e.islower() False

14.檢測字符串是否只由空格組成。

    isspace(...)

    S.isspace() -> bool

1 2 3 4 5 6 7 8 9

>>> a =  ' ' >>> a.isspace() True >>> a =  '123' >>> a.isspace() False >>> a =  'shaw' >>> a.isspace() False

15.檢測字符串中全部的單詞拼寫首字母是否爲大寫，且其餘字母爲小寫。

    istitle(...) 

    S.istitle() -> bool

1 2 3 4 5 6 7 8 9

>>> a =  'Shaw' >>> a.istitle() True >>> a =  'Shaw123' >>> a.istitle() True >>> a =  '123' >>> a.istitle() False

16.檢測字符串中全部的字母是否都爲大寫

    isupper(...)

      S.isupper() -> bool

1 2 3 4 5 6 7 8 9 10 11 12

>>> a =  '123' >>> a.isupper() False >>> a =  'Shaw' >>> a.isupper() False >>> a =  'Shaw123' >>> a.isupper() False >>> a =  'SHAW123' >>> a.isupper() True

17.用於將序列中的元素以指定的字符鏈接生成一個新的字符串。

     join(...)

    S.join(iterable) ->string

1 2 3 4

>>> a =  '-' >>> b =  'shaw' >>> print  a.join(b) s - h - a - w

18.返回一個原字符串左對齊,並使用空格填充至指定長度的新字符串。若是指定的長度小於原字符串的長度則返回原字符串。

    ljust(...)

    S.ljust(width[, fillchar])-> string

    width -- 指定字符串長度

    fillchar -- 填充字符，默認爲空格

1 2 3 4 5

>>> s =  'shaw' >>> s.ljust( 10 ) 'shaw      ' >>> s.ljust( 10 , '8' ) 'shaw888888'

19.轉換字符串中全部大寫字符爲小寫。

    Lower(...)

    S.lower() -> string

1 2 3 4 5 6

>>> s =  'PYTHON' >>> s.lower() 'python' >>> s =  'PYTHON123' >>> s.lower() 'python123'

20.用於截掉字符串左邊的空格或指定字符。

    lstrip(...)

    S.lstrip([chars]) ->string or unicode

1 2 3 4 5 6

>>> s =  '%%%shaw' >>> s.lstrip( '%' ) 'shaw' >>> s =  '   shaw' >>> s.lstrip() 'shaw'

21.根據指定的分隔符將字符串進行分割（返回一個3元的元組，第一個爲分隔符左邊的子串，第二個爲分隔符自己，第三個爲分隔符右邊的子串）

    partition(...)

    S.partition(sep) ->(head, sep, tail)

1 2 3

>>> S =  'are you know:lilin is lowser' >>> S.partition( 'lilin' ) ( 'are you know:' , 'lilin' , ' is lowser' )

22.把字符串中的 old（舊字符串）替換成 new(新字符串)，若是指定第三個參數max，則替換不超過 max 次。

    replace(...)

    S.replace(old, new[,count]) -> string

1 2 3

>>> S =  'shaw' >>> S.replace( 'sh' , 'LI' ) 'LIaw'

23.返回字符串最後一次出現的位置，若是沒有匹配項則返回-1。

    rfind(...)

    S.rfind(sub [,start[,end]]) -> int

    str -- 查找的字符串

    beg -- 開始查找的位置，默認爲0

    end -- 結束查找位置，默認爲字符串的長度。

1 2 3 4 5

>>> s =  'lilin is good li lao ban' >>> s.rfind( 'li' ) 14 >>> s.rfind( 'li' , 0 , 8 ) 2

24.返回子字符串 str 在字符串中最後出現的位置，若是沒有匹配的字符串會報異常，你能夠指定可選參數[beg:end]設置查找的區間。

    rindex(...)

    S.rindex(sub [,start[,end]]) -> int

    語法：

      str.rindex(str,beg=0 end=len(string))

1 2 3 4 5 6 7 8 9

>>> s =  'my name is shaw' >>> s.rindex( 's' ) 11 >>> s.rindex( 's' , 5 , 10 ) 9 >>> s.rindex( 's' , 2 , 8 ) Traceback (most recent call last):    File  "<input>" ,line 1 , in  <module> ValueError: substring not  found

25.返回的原/新字符串右對齊，且默認使用空格填充至指定長度（width）的新字符串。若是指定的長度（width）小於原字符串的長度則返回原字符串

    rjust(...)

    S.rjust(width[, fillchar])-> string

    語法：

      str.rjust(width[,fillchar])

       width -- 指定填充指定字符後新字符串的總長度.

       fillchar– 要填充的字符，默認爲空格。

1 2 3 4 5 6 7

>>> s =  'sch' >>> s.rjust( 20 ) '                 sch' >>> s.rjust( 20 , '0' ) '00000000000000000sch' >>> s.rjust( 20 , 'H' ) 'HHHHHHHHHHHHHHHHHsch'

26.刪除 string 字符串末尾的指定字符（默認爲空格）.

    rstrip(...)

    S.rstrip([chars]) ->string or unicode

    語法：

      str.rstrip([chars])

1 2 3

>>> s =  'shaw\n' >>> s.rstrip( '\n' ) 'shaw'

27.經過指定分隔符對字符串進行切片，若是參數num有指定值，則僅分隔 num 個子字符串

    split(...)

    S.split([sep [,maxsplit]])-> list ofstrings

    語法：

   str.split(str="",num=string.count(str)).

1 2 3 4 5

>>> s =  'shaw\nlinux\nmac' >>> s.split( '\n' ) [ 'shaw' , 'linux' , 'mac' ] >>> s.split( '\n' , 1 ) [ 'shaw' , 'linux\nmac' ]

28.按照行分隔，返回一個包含各行做爲元素的列表，若是 num 指定則僅切片 num 個行.

    splitlines(...)

    S.splitlines(keepends=False)-> list ofstrings

    語法：

      str.splitlines( num=string.count('\n'))

       num -- 分割行的次數。

1 2 3 4 5 6

>>> s =  'what\'s your name?\n my name is shaw\n how old areyou?' >>> s.splitlines() [ "what's your name?" , ' my name is  shaw ', '  how old areyou?'] >>> s.splitlines( 1 ) [ "what's your name?\n" , ' my name is  shaw\n ', '  how old areyou?'] >>> s.splitlines( 3 )

29.用於檢查字符串是不是以指定子字符串開頭，若是是則返回 True，不然返回 False。若是參數 beg 和 end指定值，則在指定範圍內檢查。

    startswith(...)

    S.startswith(prefix[,start[, end]]) ->bool

    語法：

    str.startswith(str,beg=0,end=len(string))

    str -- 檢測的字符串。

    strbeg -- 可選參數用於設置字符串檢測的起始位置。

    strend -- 可選參數用於設置字符串檢測的結束位置。

1 2 3 4 5

>>> s =  'my name is shaw' >>> s.startswith( 'my' ) True >>> s.startswith( 'my' , 10 , 15 ) False

30.用於移除字符串頭尾指定的字符（默認爲空格）。

    strip(...)

    S.strip([chars]) ->string or unicode

1 2 3

>>> s =  'my name is sam' >>> s.strip( 'm' ) 'y name is sa'

31.用於對字符串的大小寫字母進行轉換(小寫轉大寫，大寫轉小寫)

    swapcase(...)

    S.swapcase() -> string

1 2 3 4 5 6

>>> s =  'stiven' >>> s.swapcase() 'STIVEN' >>> s =  'SHAW' >>> s.swapcase() 'shaw'

32.返回"標題化"的字符串,就是說全部單詞都是以大寫開始，其他字母均爲小寫。

    title(...)

    S.title() -> string

1 2 3

>>> s =  'my name is shaw' >>> s.title() 'My Name Is Shaw'

33.根據參數table給出的表(包含 256 個字符)轉換字符串的字符, 並返回翻譯後的字符串。要過濾掉的字符放到del 參數中

    translate(...)

    S.translate(table [,deletechars])->string

    語法：

      str.translate(table[, deletechars])

       table -- 翻譯表，翻譯表是經過maketrans方法轉換而來。

      deletechars -- 字符串中要過濾的字符列表。

1 2 3 4 5 6 7 8 9

>>> from  string import  maketrans suchas =  maketrans( 'sm' , '@$' ) >>> s =  'this is sam\'s dog' >>> s "this is sam's dog" >>> s.translate(suchas) "thi@ i@ @a$'@ dog" >>> s.translate(suchas, 'dog' ) 去除d,o,g字符 "thi@ i@ @a$'@ "

34.將字符串中的小寫字母轉爲大寫字母

    upper(...)

    S.upper() -> string

1 2 3 4 5 6 7 8 9

>>> s =  'sam' >>> s.upper() 'SAM' >>> s =  '23sam' >>> s.upper() '23SAM' >>> s =  '23s am' >>> s.upper() '23S AM'