任何語言都離不開字符，那就會涉及對字符的操作，尤其是腳本語言更是頻繁，不管是生產環境還是面試考驗都要面對字符串的操作。
python的字符串操作通過2部分的方法函數基本上就可以解決所有的字符串操作需求：
? python的字符串屬性函數
? python的string模塊
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1.字符串屬性函數?
系統版本：CentOS release 6.2 (Final)2.6.32-220.el6.x86_64
python版本：Python 2.6.6
字符串屬性方法
字符串格式輸出對齊
>>> str='stRINg lEArn'
?
>>>
?
>>> str.center(20)?? #生成20個字符長度，str排中間
?
'? stRINg lEArn? '
?
>>>?
?
>>> str.ljust(20)??? #str左對齊
?
'stRINg lEArn??? '?
?
>>>
?
>>> str.rjust(20)??? #str右對齊
?
'??? stRINg lEArn'
?
>>>?
?
>>> str.zfill(20)??? #str右對齊，左邊填充0
?
'00000000stRINg lEArn'
大小寫轉換
>>> str='stRINg lEArn'?
?
>>>?
?
>>> str.upper() #轉大寫
?
'STRING LEARN'
?
>>>?
?
>>> str.lower() #轉小寫
?
'string learn'
?
>>>?
?
>>> str.capitalize() #字符串首為大寫，其余小寫
?
'String learn'
?
>>>?
?
>>> str.swapcase() #大小寫對換
?
'STrinG LeaRN'
?
>>>?
?
>>> str.title() #以分隔符為標記，首字符為大寫，其余為小寫
?
'String Learn'
字符串條件判斷
>>> str='0123'
>>> str.isalnum() #是否全是字母和數字，并至少有一個字符
True
>>> str.isdigit() #是否全是數字，并至少有一個字符
True
>>> str='abcd'
>>> str.isalnum()
True
>>> str.isalpha() #是否全是字母，并至少有一個字符
True
>>> str.islower() #是否全是小寫，當全是小寫和數字一起時候，也判斷為True
True
>>> str='abcd0123'
>>> str.islower() #同上
True
>>> str.isalnum()
True
>>> str=' '
>>> str.isspace() #是否全是空白字符，并至少有一個字符
True
>>> str='ABC'
>>> str.isupper() #是否全是大寫，當全是大寫和數字一起時候，也判斷為True
True
>>> str='Abb Acc'
>>> str.istitle() #所有單詞字首都是大寫，標題
True
>>> str='string learn'
>>> str.startswith('str') #判斷字符串以'str'開頭
True
>>> str.endswith('arn') #判讀字符串以'arn'結尾
True
字符串搜索定位與替換
>>> str='string lEARn'
>>>
>>> str.find('a') #查找字符串，沒有則返回-1，有則返回查到到第一個匹配的索引
-1
>>> str.find('n')
4
>>> str.rfind('n') #同上，只是返回的索引是最后一次匹配的
11
>>>
>>> str.index('a') #如果沒有匹配則報錯
Traceback (most recent call last):
File "
", line 1, in
ValueError: substring not found
>>> str.index('n') #同find類似,返回第一次匹配的索引值
4
>>> str.rindex('n') #返回最后一次匹配的索引值
11
>>>
>>> str.count('a') #字符串中匹配的次數
0
>>> str.count('n') #同上
2
>>>
>>> str.replace('EAR','ear') #匹配替換
'string learn'
>>> str.replace('n','N')
'striNg lEARN'
>>> str.replace('n','N',1)
'striNg lEARn'
>>>
>>>
>>> str.strip('n') #刪除字符串首尾匹配的字符，通常用于默認刪除回車符
'string lEAR'
>>> str.lstrip('n') #左匹配
'string lEARn'
>>> str.rstrip('n') #右匹配
'string lEAR'
>>>
>>> str=' tab'
>>> str.expandtabs() #把制表符轉為空格
' tab'
>>> str.expandtabs(2) #指定空格數
' tab'
字符串編碼與解碼
>>> str='字符串學習'
>>> str
'xe5xadx97xe7xacxa6xe4xb8xb2xe5xadxa6xe4xb9xa0'
>>>
>>> str.decode('utf-8') #解碼過程，將utf-8解碼為unicode
u'u5b57u7b26u4e32u5b66u4e60'
>>> str.decode('utf-8').encode('gbk') #編碼過程，將unicode編碼為gbk
'xd7xd6xb7xfbxb4xaexd1xa7xcfxb0'
>>> str.decode('utf-8').encode('utf-8') #將unicode編碼為utf-8
'xe5xadx97xe7xacxa6xe4xb8xb2xe5xadxa6xe4xb9xa0'
字符串分割變換
>>> str='Learn string'
>>> '-'.join(str)
'L-e-a-r-n- -s-t-r-i-n-g'
>>> l1=['Learn','string']
>>> '-'.join(l1)
'Learn-string'
>>>
>>> str.split('n')
['Lear', ' stri', 'g']
>>> str.split('n',1)
['Lear', ' string']
>>> str.rsplit('n',1)
['Learn stri', 'g']
>>>
>>> str.splitlines()
['Learn string']
>>>
>>> str.partition('n')
('Lear', 'n', ' string')
>>> str.rpartition('n')
('Learn stri', 'n', 'g')
string模塊源代碼
"""A collection of string operations (most are no longer used).
?
?
Warning: most of the code you see here isn't normally used nowadays.
?
Beginning with Python 1.6, many of these functions are implemented as
?
methods on the standard string object. They used to be implemented by
?
a built-in module called strop, but strop is now obsolete itself.
?
?
Public module variables:
?
?
whitespace -- a string containing all characters considered whitespace
?
lowercase -- a string containing all characters considered lowercase letters
?
uppercase -- a string containing all characters considered uppercase letters
?
letters -- a string containing all characters considered letters
?
digits -- a string containing all characters considered decimal digits
?
hexdigits -- a string containing all characters considered hexadecimal digits
?
octdigits -- a string containing all characters considered octal digits
?
punctuation -- a string containing all characters considered punctuation
?
printable -- a string containing all characters considered printable
?
?
"""
?
?
# Some strings for ctype-style character classification
?
whitespace = ' tnrvf'
?
lowercase = 'abcdefghijklmnopqrstuvwxyz'
?
uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
?
letters = lowercase + uppercase
?
ascii_lowercase = lowercase
?
ascii_uppercase = uppercase
?
ascii_letters = ascii_lowercase + ascii_uppercase
?
digits = '0123456789'
?
hexdigits = digits + 'abcdef' + 'ABCDEF'
?
octdigits = '01234567'
?
punctuation = """!"#$%&'()*+,-./:;<=>?@[]^_`{|}~"""
?
printable = digits + letters + punctuation + whitespace
?
?
?
# Case conversion helpers
?
# Use str to convert Unicode literal in case of -U
?
l = map(chr, xrange(256))
?
_idmap = str('').join(l)
?
del l
?
?
?
# Functions which aren't available as string methods.
?
?
?
# Capitalize the words in a string, e.g. " aBc dEf " -> "Abc Def".
?
def capwords(s, sep=None):
?
? """capwords(s [,sep]) -> string
?
?
? Split the argument into words using split, capitalize each
?
? word using capitalize, and join the capitalized words using
?
? join. If the optional second argument sep is absent or None,
?
? runs of whitespace characters are replaced by a single space
?
? and leading and trailing whitespace are removed, otherwise
?
? sep is used to split and join the words.
?
?
? """
?
? return (sep or ' ').join(x.capitalize() for x in s.split(sep))
?
?
# Construct a translation string
?
_idmapL = None
?
def maketrans(fromstr, tostr):
?
? """maketrans(frm, to) -> string
?
?
? Return a translation table (a string of 256 bytes long)
?
? suitable for use in string.translate. The strings frm and to
?
? must be of the same length.
?
?
? """
?
? if len(fromstr) != len(tostr):
?
??? raise ValueError, "maketrans arguments must have same length"
?
? global _idmapL
?
? if not _idmapL:
?
??? _idmapL = list(_idmap)
?
? L = _idmapL[:]
?
? fromstr = map(ord, fromstr)
?
? for i in range(len(fromstr)):
?
??? L[fromstr[i]] = tostr[i]
?
? return ''.join(L)
?
?
?
####################################################################
?
import re as _re
?
?
class _multimap:
?
? """Helper class for combining multiple mappings.
?
?
?
? Used by .{safe_,}substitute() to combine the mapping and keyword
?
? arguments.
?
? """
?
? def __init__(self, primary, secondary):
?
??? self._primary = primary
?
??? self._secondary = secondary
?
?
?
? def __getitem__(self, key):
?
??? try:
?
????? return self._primary[key]
?
??? except KeyError:
?
????? return self._secondary[key]
?
?
?
class _TemplateMetaclass(type):
?
? pattern = r"""
?
? %(delim)s(?:
?
?? (?P
%(delim)s) | # Escape sequence of two delimiters
?
?? (?P
%(id)s) | # delimiter and a Python identifier
?
?? {(?P
%(id)s)} | # delimiter and a braced identifier
?
?? (?P
) # Other ill-formed delimiter exprs
?
? )
?
? """
?
?
? def __init__(cls, name, bases, dct):
?
??? super(_TemplateMetaclass, cls).__init__(name, bases, dct)
?
??? if 'pattern' in dct:
?
????? pattern = cls.pattern
?
??? else:
?
????? pattern = _TemplateMetaclass.pattern % {
?
??????? 'delim' : _re.escape(cls.delimiter),
?
??????? 'id' : cls.idpattern,
?
??????? }
?
??? cls.pattern = _re.compile(pattern, _re.IGNORECASE | _re.VERBOSE)
?
?
?
class Template:
?
? """A string class for supporting $-substitutions."""
?
? __metaclass__ = _TemplateMetaclass
?
?
?
? delimiter = '$'
?
? idpattern = r'[_a-z][_a-z0-9]*'
?
?
?
? def __init__(self, template):
?
??? self.template = template
?
?
?
? # Search for $$, $identifier, ${identifier}, and any bare $'s
?
?
?
? def _invalid(self, mo):
?
??? i = mo.start('invalid')
?
??? lines = self.template[:i].splitlines(True)
?
??? if not lines:
?
????? colno = 1
?
????? lineno = 1
?
??? else:
?
????? colno = i - len(''.join(lines[:-1]))
?
????? lineno = len(lines)
?
??? raise ValueError('Invalid placeholder in string: line %d, col %d' %
?
???????????? (lineno, colno))
?
?
?
? def substitute(self, *args, **kws):
?
??? if len(args) > 1:
?
????? raise TypeError('Too many positional arguments')
?
??? if not args:
?
????? mapping = kws
?
??? elif kws:
?
????? mapping = _multimap(kws, args[0])
?
??? else:
?
????? mapping = args[0]
?
??? # Helper function for .sub()
?
??? def convert(mo):
?
????? # Check the most common path first.
?
????? named = mo.group('named') or mo.group('braced')
?
????? if named is not None:
?
??????? val = mapping[named]
?
??????? # We use this idiom instead of str() because the latter will
?
??????? # fail if val is a Unicode containing non-ASCII characters.
?
??????? return '%s' % (val,)
?
????? if mo.group('escaped') is not None:
?
??????? return self.delimiter
?
????? if mo.group('invalid') is not None:
?
??????? self._invalid(mo)
?
????? raise ValueError('Unrecognized named group in pattern',
?
?????????????? self.pattern)
?
??? return self.pattern.sub(convert, self.template)
?
?
?
? def safe_substitute(self, *args, **kws):
?
??? if len(args) > 1:
?
????? raise TypeError('Too many positional arguments')
?
??? if not args:
?
????? mapping = kws
?
??? elif kws:
?
????? mapping = _multimap(kws, args[0])
?
??? else:
?
????? mapping = args[0]
?
??? # Helper function for .sub()
?
??? def convert(mo):
?
????? named = mo.group('named')
?
????? if named is not None:
?
??????? try:
?
????????? # We use this idiom instead of str() because the latter
?
????????? # will fail if val is a Unicode containing non-ASCII
?
????????? return '%s' % (mapping[named],)
?
??????? except KeyError:
?
????????? return self.delimiter + named
?
????? braced = mo.group('braced')
?
????? if braced is not None:
?
??????? try:
?
????????? return '%s' % (mapping[braced],)
?
??????? except KeyError:
?
????????? return self.delimiter + '{' + braced + '}'
?
????? if mo.group('escaped') is not None:
?
??????? return self.delimiter
?
????? if mo.group('invalid') is not None:
?
??????? return self.delimiter
?
????? raise ValueError('Unrecognized named group in pattern',
?
?????????????? self.pattern)
?
??? return self.pattern.sub(convert, self.template)
?
?
?
?
?
?
?
####################################################################
?
# NOTE: Everything below here is deprecated. Use string methods instead.
?
# This stuff will go away in Python 3.0.
?
?
?
# Backward compatible names for exceptions
?
index_error = ValueError
?
atoi_error = ValueError
?
atof_error = ValueError
?
atol_error = ValueError
?
?
?
# convert UPPER CASE letters to lower case
?
def lower(s):
?
? """lower(s) -> string
?
?
?
? Return a copy of the string s converted to lowercase.
?
?
?
? """
?
? return s.lower()
?
?
?
# Convert lower case letters to UPPER CASE
?
def upper(s):
?
? """upper(s) -> string
?
?
?
? Return a copy of the string s converted to uppercase.
?
?
?
? """
?
? return s.upper()
?
?
?
# Swap lower case letters and UPPER CASE
?
def swapcase(s):
?
? """swapcase(s) -> string
?
?
?
? Return a copy of the string s with upper case characters
?
? converted to lowercase and vice versa.
?
?
?
? """
?
? return s.swapcase()
?
?
?
# Strip leading and trailing tabs and spaces
?
def strip(s, chars=None):
?
? """strip(s [,chars]) -> string
?
?
?
? 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.
?
? If chars is unicode, S will be converted to unicode before stripping.
?
?
?
? """
?
? return s.strip(chars)
?
?
?
# Strip leading tabs and spaces
?
def lstrip(s, chars=None):
?
? """lstrip(s [,chars]) -> string
?
?
?
? Return a copy of the string s with leading whitespace removed.
?
? If chars is given and not None, remove characters in chars instead.
?
?
?
? """
?
? return s.lstrip(chars)
?
?
?
# Strip trailing tabs and spaces
?
def rstrip(s, chars=None):
?
? """rstrip(s [,chars]) -> string
?
?
?
? Return a copy of the string s with trailing whitespace removed.
?
? If chars is given and not None, remove characters in chars instead.
?
?
?
? """
?
? return s.rstrip(chars)
?
?
?
?
?
# Split a string into a list of space/tab-separated words
?
def split(s, sep=None, maxsplit=-1):
?
? """split(s [,sep [,maxsplit]]) -> list of strings
?
?
?
? Return a list of the words in the string s, using sep as the
?
? delimiter string. If maxsplit is given, splits at no more than
?
? maxsplit places (resulting in at most maxsplit+1 words). If sep
?
? is not specified or is None, any whitespace string is a separator.
?
?
?
? (split and splitfields are synonymous)
?
?
?
? """
?
? return s.split(sep, maxsplit)
?
splitfields = split
?
?
?
# Split a string into a list of space/tab-separated words
?
def rsplit(s, sep=None, maxsplit=-1):
?
? """rsplit(s [,sep [,maxsplit]]) -> list of strings
?
?
?
? Return a list of the words in the string 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 or is None, any whitespace string
?
? is a separator.
?
? """
?
? return s.rsplit(sep, maxsplit)
?
?
?
# Join fields with optional separator
?
def join(words, sep = ' '):
?
? """join(list [,sep]) -> string
?
?
?
? Return a string composed of the words in list, with
?
? intervening occurrences of sep. The default separator is a
?
? single space.
?
?
?
? (joinfields and join are synonymous)
?
?
?
? """
?
? return sep.join(words)
?
joinfields = join
?
?
?
# Find substring, raise exception if not found
?
def index(s, *args):
?
? """index(s, sub [,start [,end]]) -> int
?
?
?
? Like find but raises ValueError when the substring is not found.
?
?
?
? """
?
? return s.index(*args)
?
?
?
# Find last substring, raise exception if not found
?
def rindex(s, *args):
?
? """rindex(s, sub [,start [,end]]) -> int
?
?
?
? Like rfind but raises ValueError when the substring is not found.
?
?
?
? """
?
? return s.rindex(*args)
?
?
?
# Count non-overlapping occurrences of substring
?
def count(s, *args):
?
? """count(s, sub[, start[,end]]) -> int
?
?
?
? Return the number of occurrences of substring sub in string
?
? s[start:end]. Optional arguments start and end are
?
? interpreted as in slice notation.
?
?
?
? """
?
? return s.count(*args)
?
?
?
# Find substring, return -1 if not found
?
def find(s, *args):
?
? """find(s, sub [,start [,end]]) -> in
?
?
?
? 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 s.find(*args)
?
?
?
# Find last substring, return -1 if not found
?
def rfind(s, *args):
?
? """rfind(s, 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 s.rfind(*args)
?
?
?
# for a bit of speed
?
_float = float
?
_int = int
?
_long = long
?
?
?
# Convert string to float
?
def atof(s):
?
? """atof(s) -> float
?
?
?
? Return the floating point number represented by the string s.
?
?
?
? """
?
? return _float(s)
?
?
?
?
?
# Convert string to integer
?
def atoi(s , base=10):
?
? """atoi(s [,base]) -> int
?
?
?
? Return the integer represented by the string s in the given
?
? base, which defaults to 10. The string s must consist of one
?
? or more digits, possibly preceded by a sign. If base is 0, it
?
? is chosen from the leading characters of s, 0 for octal, 0x or
?
? 0X for hexadecimal. If base is 16, a preceding 0x or 0X is
?
? accepted.
?
?
?
? """
?
? return _int(s, base)
?
?
?
?
?
# Convert string to long integer
?
def atol(s, base=10):
?
? """atol(s [,base]) -> long
?
?
?
? Return the long integer represented by the string s in the
?
? given base, which defaults to 10. The string s must consist
?
? of one or more digits, possibly preceded by a sign. If base
?
? is 0, it is chosen from the leading characters of s, 0 for
?
? octal, 0x or 0X for hexadecimal. If base is 16, a preceding
?
? 0x or 0X is accepted. A trailing L or l is not accepted,
?
? unless base is 0.
?
?
?
? """
?
? return _long(s, base)
?
?
?
?
?
# Left-justify a string
?
def ljust(s, width, *args):
?
? """ljust(s, width[, fillchar]) -> string
?
?
?
? Return a left-justified version of s, in a field of the
?
? specified width, padded with spaces as needed. The string is
?
? never truncated. If specified the fillchar is used instead of spaces.
?
?
?
? """
?
? return s.ljust(width, *args)
?
?
?
# Right-justify a string
?
def rjust(s, width, *args):
?
? """rjust(s, width[, fillchar]) -> string
?
?
?
? Return a right-justified version of s, in a field of the
?
? specified width, padded with spaces as needed. The string is
?
? never truncated. If specified the fillchar is used instead of spaces.
?
?
?
? """
?
? return s.rjust(width, *args)
?
?
?
# Center a string
?
def center(s, width, *args):
?
? """center(s, width[, fillchar]) -> string
?
?
?
? Return a center version of s, in a field of the specified
?
? width. padded with spaces as needed. The string is never
?
? truncated. If specified the fillchar is used instead of spaces.
?
?
?
? """
?
? return s.center(width, *args)
?
?
?
# Zero-fill a number, e.g., (12, 3) --> '012' and (-3, 3) --> '-03'
?
# Decadent feature: the argument may be a string or a number
?
# (Use of this is deprecated; it should be a string as with ljust c.s.)
?
def zfill(x, width):
?
? """zfill(x, width) -> string
?
?
?
? Pad a numeric string x with zeros on the left, to fill a field
?
? of the specified width. The string x is never truncated.
?
?
?
? """
?
? if not isinstance(x, basestring):
?
??? x = repr(x)
?
? return x.zfill(width)
?
?
?
# Expand tabs in a string.
?
# Doesn't take non-printing chars into account, but does understand n.
?
def expandtabs(s, tabsize=8):
?
? """expandtabs(s [,tabsize]) -> string
?
?
?
? Return a copy of the string s with all tab characters replaced
?
? by the appropriate number of spaces, depending on the current
?
? column, and the tabsize (default 8).
?
?
?
? """
?
? return s.expandtabs(tabsize)
?
?
?
# Character translation through look-up table.
?
def translate(s, table, deletions=""):
?
? """translate(s,table [,deletions]) -> string
?
?
?
? Return a copy of the string s, where all characters occurring
?
? in the optional argument deletions are removed, and the
?
? remaining characters have been mapped through the given
?
? translation table, which must be a string of length 256. The
?
? deletions argument is not allowed for Unicode strings.
?
?
?
? """
?
? if deletions or table is None:
?
??? return s.translate(table, deletions)
?
? else:
?
??? # Add s[:0] so that if s is Unicode and table is an 8-bit string,
?
??? # table is converted to Unicode. This means that table *cannot*
?
??? # be a dictionary -- for that feature, use u.translate() directly.
?
??? return s.translate(table + s[:0])
?
?
?
# Capitalize a string, e.g. "aBc dEf" -> "Abc def".
?
def capitalize(s):
?
? """capitalize(s) -> string
?
?
?
? Return a copy of the string s with only its first character
?
? capitalized.
?
?
?
? """
?
? return s.capitalize()
?
?
?
# Substring replacement (global)
?
def replace(s, old, new, maxsplit=-1):
?
? """replace (str, old, new[, maxsplit]) -> string
?
?
?
? Return a copy of string str with all occurrences of substring
?
? old replaced by new. If the optional argument maxsplit is
?
? given, only the first maxsplit occurrences are replaced.
?
?
?
? """
?
? return s.replace(old, new, maxsplit)
?
?
?
?
?
# Try importing optional built-in module "strop" -- if it exists,
?
# it redefines some string operations that are 100-1000 times faster.
?
# It also defines values for whitespace, lowercase and uppercase
?
# that match
's definitions.
?
?
?
try:
?
? from strop import maketrans, lowercase, uppercase, whitespace
?
? letters = lowercase + uppercase
?
except ImportError:
?
? pass # Use the original versions
?
?
?
########################################################################
?
# the Formatter class
?
# see PEP 3101 for details and purpose of this class
?
?
?
# The hard parts are reused from the C implementation. They're exposed as "_"
?
# prefixed methods of str and unicode.
?
?
?
# The overall parser is implemented in str._formatter_parser.
?
# The field name parser is implemented in str._formatter_field_name_split
?
?
?
class Formatter(object):
?
? def format(self, format_string, *args, **kwargs):
?
??? return self.vformat(format_string, args, kwargs)
?
?
?
? def vformat(self, format_string, args, kwargs):
?
??? used_args = set()
?
??? result = self._vformat(format_string, args, kwargs, used_args, 2)
?
??? self.check_unused_args(used_args, args, kwargs)
?
??? return result
?
?
?
? def _vformat(self, format_string, args, kwargs, used_args, recursion_depth):
?
??? if recursion_depth < 0:
?
????? raise ValueError('Max string recursion exceeded')
?
??? result = []
?
??? for literal_text, field_name, format_spec, conversion in?
?
??????? self.parse(format_string):
?
?
?
????? # output the literal text
?
????? if literal_text:
?
??????? result.append(literal_text)
?
?
?
????? # if there's a field, output it
?
????? if field_name is not None:
?
??????? # this is some markup, find the object and do
?
??????? # the formatting
?
?
?
??????? # given the field_name, find the object it references
?
??????? # and the argument it came from
?
??????? obj, arg_used = self.get_field(field_name, args, kwargs)
?
??????? used_args.add(arg_used)
?
?
?
??????? # do any conversion on the resulting object
?
??????? obj = self.convert_field(obj, conversion)
?
?
?
??????? # expand the format spec, if needed
?
??????? format_spec = self._vformat(format_spec, args, kwargs,
?
????????????????????? used_args, recursion_depth-1)
?
?
?
??????? # format the object and append to the result
?
??????? result.append(self.format_field(obj, format_spec))
?
?
?
??? return ''.join(result)
?
?
?
?
?
? def get_value(self, key, args, kwargs):
?
??? if isinstance(key, (int, long)):
?
????? return args[key]
?
??? else:
?
????? return kwargs[key]
?
?
?
?
?
? def check_unused_args(self, used_args, args, kwargs):
?
??? pass
?
?
?
?
?
? def format_field(self, value, format_spec):
?
??? return format(value, format_spec)
?
?
?
?
?
? def convert_field(self, value, conversion):
?
??? # do any conversion on the resulting object
?
??? if conversion == 'r':
?
????? return repr(value)
?
??? elif conversion == 's':
?
????? return str(value)
?
??? elif conversion is None:
?
????? return value
?
??? raise ValueError("Unknown converion specifier {0!s}".format(conversion))
?
?
?
?
?
? # returns an iterable that contains tuples of the form:
?
? # (literal_text, field_name, format_spec, conversion)
?
? # literal_text can be zero length
?
? # field_name can be None, in which case there's no
?
? # object to format and output
?
? # if field_name is not None, it is looked up, formatted
?
? # with format_spec and conversion and then used
?
? def parse(self, format_string):
?
??? return format_string._formatter_parser()
?
?
?
?
?
? # given a field_name, find the object it references.
?
? # field_name: the field being looked up, e.g. "0.name"
?
? # or "lookup[3]"
?
? # used_args: a set of which args have been used
?
? # args, kwargs: as passed in to vformat
?
? def get_field(self, field_name, args, kwargs):
?
??? first, rest = field_name._formatter_field_name_split()
?
?
?
??? obj = self.get_value(first, args, kwargs)
?
?
?
??? # loop through the rest of the field_name, doing
?
??? # getattr or getitem as needed
?
??? for is_attr, i in rest:
?
????? if is_attr:
?
??????? obj = getattr(obj, i)
?
????? else:
?
??????? obj = obj[i]
?
?
?
??? return obj, first
以上這篇python中string模塊各屬性以及函數的用法介紹就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持腳本之家。
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
