zoukankan      html  css  js  c++  java
  • python基本数据类型——str

    一、字符串的创建

    test = str() / ""
    test = str("licheng") / "licheng"
    • 无参数,创建空字符串
    • 一个参数,创建普通字符串
    • 两个参数,int(字节,编码)

    二、字符串的常用方法

    #capitalize():字符串首字符大写
    string = 'this is a string.'
    new_str = string.capitalize()
    print(new_str)
    #输出:This is a string.
     
    
    #center(width, fillchar=None):将字符串放在中间,在指定长度下,首尾以指定字符填充
    string = 'this is a string.'
    new_str = string.center(30,'*')
    print(new_str)
    #输出:******this is a string.*******
     
    
    #count(sub, start=None, end=None):计算字符串中某字符的数量
    string = 'this is a string.'
    new_str = string.count('i')
    print(new_str)
    #输出:3
     
    
    #decode/encode(encoding=None, errors=None):解码/解码
    string = 'this is a string.'
    new_str = string.decode()
    new_str = string.encode()
    print(new_str)
     
    
    #endswith(self, suffix, start=None, end=None):判断是否以某字符结尾
    string = 'this is a string.'
    new_str = string.endswith('ing.')
    print(new_str)
    #输出:True
     
    
    #find(self, sub, start=None, end=None):在字符串中寻找指定字符的位置
    string = 'this is a string.'
    new_str = string.find('a') #找的到的情况
    print(new_str)
    #输出:8
    new_str = string.find('xx') #找不到的情况返回-1
    print(new_str)
    #输出:-1
     
    
    #index(self, sub, start=None, end=None):;类似find
    string = 'this is a string.'
    new_str = string.index('a') #找的到的情况
    print(new_str)
    #输出:8
    new_str = string.index('xx') #找不到的情况,程序报错
    print(new_str)
    #输出:程序运行报错,ValueError: substring not found
    
     
    
    #isalnum(self):判断字符串中是否都是数字和字母,如果是则返回True,否则返回False
    string = 'My name is yue,my age is 18.'
    new_str = string.isalnum()
    print(new_str)
    #输出:False
    string = 'haha18121314lala'
    new_str = string.isalnum()
    print(new_str)
    #输出:True
     
    
    #isalpha(self):判断字符串中是否都是字母,如果是则返回True,否则返回False
    string = 'abcdefg'
    new_str = string.isalpha()
    print(new_str)
    #输出:True
    string = 'my name is yue'
    new_str = string.isalpha() #字母中间带空格、特殊字符都不行
    print(new_str)
    #输出:False
     
    
    # isdigit(self):判断字符串中是否都是数字,如果是则返回True,否则返回False
    string = '1234567890'
    new_str = string.isdigit()
    print(new_str)
    #输出:True
    string = 'haha123lala'
    new_str = string.isdigit() #中间带空格、特殊字符都不行
    print(new_str)
    #输出:False
    
     
    
    # islower(self):判断字符串中的字母是否都是小写,如果是则返回True,否则返回False
    string = 'my name is yue,my age is 18.'
    new_str = string.islower()
    print(new_str)
    #输出:True
    string = 'My name is Yue,my age is 18.'
    new_str = string.islower()
    print(new_str)
    #输出:False
     
    
    # isupper(self):检测字符串中所有的字母是否都为大写。
    string = 'MY NAME IS YUE.'
    new_str = string.isupper()
    print(new_str)
    #输出:True
    string = 'My name is Yue.'
    new_str = string.isupper()
    print(new_str)
    #输出:False
    
     
    
    # join(self, iterable):将序列中的元素以指定的字符连接生成一个新的字符串。
    string = ("haha","lala","ohoh")
    str = "-"
    print(str.join(string))
    #输出:haha-lala-ohoh
     
    
    # lower(self):转换字符串中所有大写字符为小写。
    string = "My Name is YUE."
    print(string.lower())
    # 输出:my name is yue.
    
     
    
    # lstrip(self, chars=None):截掉字符串左边的空格或指定字符。
    string = " My Name is YUE."
    print(string.lstrip())
    #输出:My Name is YUE.
    string = "My Name is YUE."
    print(string.lstrip('My'))
    #输出: Name is YUE.
    
     
    
    #replace(self, old, new, count=None):把字符串中的 old(旧字符串) 替换成 new(新字符串),如果指定第三个参数max,则替换不超过 max 次。
    string = "My name is yue."
    print(string.replace("yue","ying"))
    #输出:My name is ying.
    
     
    
    # rfind(self, sub, start=None, end=None):返回字符串最后一次出现的位置,如果没有匹配项则返回-1。
    string = "My name is yue."
    print(string.rfind('is'))
    #输出:8
    string = "My name is yue."
    print(string.rfind('XXX'))
    #输出:-1
     
    
    # split(self, sep=None, maxsplit=None):通过指定分隔符对字符串进行切片。
    string = "haha lala gege"
    print(string.split(' '))
    #输出:['haha', 'lala', 'gege']
    print(string.split(' ', 1 ))
    #输出: ['haha', 'lala gege']
    
     
    
    # rsplit(self, sep=None, maxsplit=None):通过指定分隔符对字符串从右进行切片。
    string = "haha lala gege"
    print(string.rsplit(' '))
    #输出:['haha', 'lala', 'gege']
    print(string.rsplit(' ', 1 ))
    #输出: ['haha lala', 'gege']
    
     
    
    # rstrip(self, chars=None):删除 string 字符串末尾的指定字符(默认为空格).
    string = " My name is yue. "
    print(string.rstrip())
    #输出: My name is yue.
    
     
    
    # strip(self, chars=None):移除字符串头尾指定的字符(默认为空格)。
    string = " My name is yue. "
    print(string.strip())
    #输出:My name is yue.
    
     
    
    # upper(self):将字符串中的小写字母转为大写字母。
    string = "my name is yue,my age is 18."
    print(string.upper())
    #输出:MY NAME IS YUE,MY AGE IS 18.
      1 class str(basestring):
      2     """
      3     str(object='') -> string
      4     
      5     Return a nice string representation of the object.
      6     If the argument is a string, the return value is the same object.
      7     """
      8     def capitalize(self):  
      9         """ 首字母变大写 """
     10         """
     11         S.capitalize() -> string
     12         
     13         Return a copy of the string S with only its first character
     14         capitalized.
     15         """
     16         return ""
     17 
     18     def center(self, width, fillchar=None):  
     19         """ 内容居中,width:总长度;fillchar:空白处填充内容,默认无 """
     20         """
     21         S.center(width[, fillchar]) -> string
     22         
     23         Return S centered in a string of length width. Padding is
     24         done using the specified fill character (default is a space)
     25         """
     26         return ""
     27 
     28     def count(self, sub, start=None, end=None):  
     29         """ 子序列个数 """
     30         """
     31         S.count(sub[, start[, end]]) -> int
     32         
     33         Return the number of non-overlapping occurrences of substring sub in
     34         string S[start:end].  Optional arguments start and end are interpreted
     35         as in slice notation.
     36         """
     37         return 0
     38 
     39     def decode(self, encoding=None, errors=None):  
     40         """ 解码 """
     41         """
     42         S.decode([encoding[,errors]]) -> object
     43         
     44         Decodes S using the codec registered for encoding. encoding defaults
     45         to the default encoding. errors may be given to set a different error
     46         handling scheme. Default is 'strict' meaning that encoding errors raise
     47         a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
     48         as well as any other name registered with codecs.register_error that is
     49         able to handle UnicodeDecodeErrors.
     50         """
     51         return object()
     52 
     53     def encode(self, encoding=None, errors=None):  
     54         """ 编码,针对unicode """
     55         """
     56         S.encode([encoding[,errors]]) -> object
     57         
     58         Encodes S using the codec registered for encoding. encoding defaults
     59         to the default encoding. errors may be given to set a different error
     60         handling scheme. Default is 'strict' meaning that encoding errors raise
     61         a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
     62         'xmlcharrefreplace' as well as any other name registered with
     63         codecs.register_error that is able to handle UnicodeEncodeErrors.
     64         """
     65         return object()
     66 
     67     def endswith(self, suffix, start=None, end=None):  
     68         """ 是否以 xxx 结束 """
     69         """
     70         S.endswith(suffix[, start[, end]]) -> bool
     71         
     72         Return True if S ends with the specified suffix, False otherwise.
     73         With optional start, test S beginning at that position.
     74         With optional end, stop comparing S at that position.
     75         suffix can also be a tuple of strings to try.
     76         """
     77         return False
     78 
     79     def expandtabs(self, tabsize=None):  
     80         """ 将tab转换成空格,默认一个tab转换成8个空格 """
     81         """
     82         S.expandtabs([tabsize]) -> string
     83         
     84         Return a copy of S where all tab characters are expanded using spaces.
     85         If tabsize is not given, a tab size of 8 characters is assumed.
     86         """
     87         return ""
     88 
     89     def find(self, sub, start=None, end=None):  
     90         """ 寻找子序列位置,如果没找到,返回 -1 """
     91         """
     92         S.find(sub [,start [,end]]) -> int
     93         
     94         Return the lowest index in S where substring sub is found,
     95         such that sub is contained within S[start:end].  Optional
     96         arguments start and end are interpreted as in slice notation.
     97         
     98         Return -1 on failure.
     99         """
    100         return 0
    101 
    102     def format(*args, **kwargs): # known special case of str.format
    103         """ 字符串格式化,动态参数,将函数式编程时细说 """
    104         """
    105         S.format(*args, **kwargs) -> string
    106         
    107         Return a formatted version of S, using substitutions from args and kwargs.
    108         The substitutions are identified by braces ('{' and '}').
    109         """
    110         pass
    111 
    112     def index(self, sub, start=None, end=None):  
    113         """ 子序列位置,如果没找到,报错 """
    114         S.index(sub [,start [,end]]) -> int
    115         
    116         Like S.find() but raise ValueError when the substring is not found.
    117         """
    118         return 0
    119 
    120     def isalnum(self):  
    121         """ 是否是字母和数字 """
    122         """
    123         S.isalnum() -> bool
    124         
    125         Return True if all characters in S are alphanumeric
    126         and there is at least one character in S, False otherwise.
    127         """
    128         return False
    129 
    130     def isalpha(self):  
    131         """ 是否是字母 """
    132         """
    133         S.isalpha() -> bool
    134         
    135         Return True if all characters in S are alphabetic
    136         and there is at least one character in S, False otherwise.
    137         """
    138         return False
    139 
    140     def isdigit(self):  
    141         """ 是否是数字 """
    142         """
    143         S.isdigit() -> bool
    144         
    145         Return True if all characters in S are digits
    146         and there is at least one character in S, False otherwise.
    147         """
    148         return False
    149 
    150     def islower(self):  
    151         """ 是否小写 """
    152         """
    153         S.islower() -> bool
    154         
    155         Return True if all cased characters in S are lowercase and there is
    156         at least one cased character in S, False otherwise.
    157         """
    158         return False
    159 
    160     def isspace(self):  
    161         """
    162         S.isspace() -> bool
    163         
    164         Return True if all characters in S are whitespace
    165         and there is at least one character in S, False otherwise.
    166         """
    167         return False
    168 
    169     def istitle(self):  
    170         """
    171         S.istitle() -> bool
    172         
    173         Return True if S is a titlecased string and there is at least one
    174         character in S, i.e. uppercase characters may only follow uncased
    175         characters and lowercase characters only cased ones. Return False
    176         otherwise.
    177         """
    178         return False
    179 
    180     def isupper(self):  
    181         """
    182         S.isupper() -> bool
    183         
    184         Return True if all cased characters in S are uppercase and there is
    185         at least one cased character in S, False otherwise.
    186         """
    187         return False
    188 
    189     def join(self, iterable):  
    190         """ 连接 """
    191         """
    192         S.join(iterable) -> string
    193         
    194         Return a string which is the concatenation of the strings in the
    195         iterable.  The separator between elements is S.
    196         """
    197         return ""
    198 
    199     def ljust(self, width, fillchar=None):  
    200         """ 内容左对齐,右侧填充 """
    201         """
    202         S.ljust(width[, fillchar]) -> string
    203         
    204         Return S left-justified in a string of length width. Padding is
    205         done using the specified fill character (default is a space).
    206         """
    207         return ""
    208 
    209     def lower(self):  
    210         """ 变小写 """
    211         """
    212         S.lower() -> string
    213         
    214         Return a copy of the string S converted to lowercase.
    215         """
    216         return ""
    217 
    218     def lstrip(self, chars=None):  
    219         """ 移除左侧空白 """
    220         """
    221         S.lstrip([chars]) -> string or unicode
    222         
    223         Return a copy of the string S with leading whitespace removed.
    224         If chars is given and not None, remove characters in chars instead.
    225         If chars is unicode, S will be converted to unicode before stripping
    226         """
    227         return ""
    228 
    229     def partition(self, sep):  
    230         """ 分割,前,中,后三部分 """
    231         """
    232         S.partition(sep) -> (head, sep, tail)
    233         
    234         Search for the separator sep in S, and return the part before it,
    235         the separator itself, and the part after it.  If the separator is not
    236         found, return S and two empty strings.
    237         """
    238         pass
    239 
    240     def replace(self, old, new, count=None):  
    241         """ 替换 """
    242         """
    243         S.replace(old, new[, count]) -> string
    244         
    245         Return a copy of string S with all occurrences of substring
    246         old replaced by new.  If the optional argument count is
    247         given, only the first count occurrences are replaced.
    248         """
    249         return ""
    250 
    251     def rfind(self, sub, start=None, end=None):  
    252         """
    253         S.rfind(sub [,start [,end]]) -> int
    254         
    255         Return the highest index in S where substring sub is found,
    256         such that sub is contained within S[start:end].  Optional
    257         arguments start and end are interpreted as in slice notation.
    258         
    259         Return -1 on failure.
    260         """
    261         return 0
    262 
    263     def rindex(self, sub, start=None, end=None):  
    264         """
    265         S.rindex(sub [,start [,end]]) -> int
    266         
    267         Like S.rfind() but raise ValueError when the substring is not found.
    268         """
    269         return 0
    270 
    271     def rjust(self, width, fillchar=None):  
    272         """
    273         S.rjust(width[, fillchar]) -> string
    274         
    275         Return S right-justified in a string of length width. Padding is
    276         done using the specified fill character (default is a space)
    277         """
    278         return ""
    279 
    280     def rpartition(self, sep):  
    281         """
    282         S.rpartition(sep) -> (head, sep, tail)
    283         
    284         Search for the separator sep in S, starting at the end of S, and return
    285         the part before it, the separator itself, and the part after it.  If the
    286         separator is not found, return two empty strings and S.
    287         """
    288         pass
    289 
    290     def rsplit(self, sep=None, maxsplit=None):  
    291         """
    292         S.rsplit([sep [,maxsplit]]) -> list of strings
    293         
    294         Return a list of the words in the string S, using sep as the
    295         delimiter string, starting at the end of the string and working
    296         to the front.  If maxsplit is given, at most maxsplit splits are
    297         done. If sep is not specified or is None, any whitespace string
    298         is a separator.
    299         """
    300         return []
    301 
    302     def rstrip(self, chars=None):  
    303         """
    304         S.rstrip([chars]) -> string or unicode
    305         
    306         Return a copy of the string S with trailing whitespace removed.
    307         If chars is given and not None, remove characters in chars instead.
    308         If chars is unicode, S will be converted to unicode before stripping
    309         """
    310         return ""
    311 
    312     def split(self, sep=None, maxsplit=None):  
    313         """ 分割, maxsplit最多分割几次 """
    314         """
    315         S.split([sep [,maxsplit]]) -> list of strings
    316         
    317         Return a list of the words in the string S, using sep as the
    318         delimiter string.  If maxsplit is given, at most maxsplit
    319         splits are done. If sep is not specified or is None, any
    320         whitespace string is a separator and empty strings are removed
    321         from the result.
    322         """
    323         return []
    324 
    325     def splitlines(self, keepends=False):  
    326         """ 根据换行分割 """
    327         """
    328         S.splitlines(keepends=False) -> list of strings
    329         
    330         Return a list of the lines in S, breaking at line boundaries.
    331         Line breaks are not included in the resulting list unless keepends
    332         is given and true.
    333         """
    334         return []
    335 
    336     def startswith(self, prefix, start=None, end=None):  
    337         """ 是否起始 """
    338         """
    339         S.startswith(prefix[, start[, end]]) -> bool
    340         
    341         Return True if S starts with the specified prefix, False otherwise.
    342         With optional start, test S beginning at that position.
    343         With optional end, stop comparing S at that position.
    344         prefix can also be a tuple of strings to try.
    345         """
    346         return False
    347 
    348     def strip(self, chars=None):  
    349         """ 移除两段空白 """
    350         """
    351         S.strip([chars]) -> string or unicode
    352         
    353         Return a copy of the string S with leading and trailing
    354         whitespace removed.
    355         If chars is given and not None, remove characters in chars instead.
    356         If chars is unicode, S will be converted to unicode before stripping
    357         """
    358         return ""
    359 
    360     def swapcase(self):  
    361         """ 大写变小写,小写变大写 """
    362         """
    363         S.swapcase() -> string
    364         
    365         Return a copy of the string S with uppercase characters
    366         converted to lowercase and vice versa.
    367         """
    368         return ""
    369 
    370     def title(self):  
    371         """
    372         S.title() -> string
    373         
    374         Return a titlecased version of S, i.e. words start with uppercase
    375         characters, all remaining cased characters have lowercase.
    376         """
    377         return ""
    378 
    379     def translate(self, table, deletechars=None):  
    380         """
    381         转换,需要先做一个对应表,最后一个表示删除字符集合
    382         intab = "aeiou"
    383         outtab = "12345"
    384         trantab = maketrans(intab, outtab)
    385         str = "this is string example....wow!!!"
    386         print str.translate(trantab, 'xm')
    387         """
    388 
    389         """
    390         S.translate(table [,deletechars]) -> string
    391         
    392         Return a copy of the string S, where all characters occurring
    393         in the optional argument deletechars are removed, and the
    394         remaining characters have been mapped through the given
    395         translation table, which must be a string of length 256 or None.
    396         If the table argument is None, no translation is applied and
    397         the operation simply removes the characters in deletechars.
    398         """
    399         return ""
    400 
    401     def upper(self):  
    402         """
    403         S.upper() -> string
    404         
    405         Return a copy of the string S converted to uppercase.
    406         """
    407         return ""
    408 
    409     def zfill(self, width):  
    410         """方法返回指定长度的字符串,原字符串右对齐,前面填充0。"""
    411         """
    412         S.zfill(width) -> string
    413         
    414         Pad a numeric string S with zeros on the left, to fill a field
    415         of the specified width.  The string S is never truncated.
    416         """
    417         return ""
    418 
    419     def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown
    420         pass
    421 
    422     def _formatter_parser(self, *args, **kwargs): # real signature unknown
    423         pass
    424 
    425     def __add__(self, y):  
    426         """ x.__add__(y) <==> x+y """
    427         pass
    428 
    429     def __contains__(self, y):  
    430         """ x.__contains__(y) <==> y in x """
    431         pass
    432 
    433     def __eq__(self, y):  
    434         """ x.__eq__(y) <==> x==y """
    435         pass
    436 
    437     def __format__(self, format_spec):  
    438         """
    439         S.__format__(format_spec) -> string
    440         
    441         Return a formatted version of S as described by format_spec.
    442         """
    443         return ""
    444 
    445     def __getattribute__(self, name):  
    446         """ x.__getattribute__('name') <==> x.name """
    447         pass
    448 
    449     def __getitem__(self, y):  
    450         """ x.__getitem__(y) <==> x[y] """
    451         pass
    452 
    453     def __getnewargs__(self, *args, **kwargs): # real signature unknown
    454         pass
    455 
    456     def __getslice__(self, i, j):  
    457         """
    458         x.__getslice__(i, j) <==> x[i:j]
    459                    
    460                    Use of negative indices is not supported.
    461         """
    462         pass
    463 
    464     def __ge__(self, y):  
    465         """ x.__ge__(y) <==> x>=y """
    466         pass
    467 
    468     def __gt__(self, y):  
    469         """ x.__gt__(y) <==> x>y """
    470         pass
    471 
    472     def __hash__(self):  
    473         """ x.__hash__() <==> hash(x) """
    474         pass
    475 
    476     def __init__(self, string=''): # known special case of str.__init__
    477         """
    478         str(object='') -> string
    479         
    480         Return a nice string representation of the object.
    481         If the argument is a string, the return value is the same object.
    482         # (copied from class doc)
    483         """
    484         pass
    485 
    486     def __len__(self):  
    487         """ x.__len__() <==> len(x) """
    488         pass
    489 
    490     def __le__(self, y):  
    491         """ x.__le__(y) <==> x<=y """
    492         pass
    493 
    494     def __lt__(self, y):  
    495         """ x.__lt__(y) <==> x<y """
    496         pass
    497 
    498     def __mod__(self, y):  
    499         """ x.__mod__(y) <==> x%y """
    500         pass
    501 
    502     def __mul__(self, n):  
    503         """ x.__mul__(n) <==> x*n """
    504         pass
    505 
    506     @staticmethod # known case of __new__
    507     def __new__(S, *more):  
    508         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
    509         pass
    510 
    511     def __ne__(self, y):  
    512         """ x.__ne__(y) <==> x!=y """
    513         pass
    514 
    515     def __repr__(self):  
    516         """ x.__repr__() <==> repr(x) """
    517         pass
    518 
    519     def __rmod__(self, y):  
    520         """ x.__rmod__(y) <==> y%x """
    521         pass
    522 
    523     def __rmul__(self, n):  
    524         """ x.__rmul__(n) <==> n*x """
    525         pass
    526 
    527     def __sizeof__(self):  
    528         """ S.__sizeof__() -> size of S in memory, in bytes """
    529         pass
    530 
    531     def __str__(self):  
    532         """ x.__str__() <==> str(x) """
    533         pass
    534 
    535 str
    str源码

    三、字符串的公共功能

    • 索引(只能取一个元素)
    • 切片(取多个元素)
    • 长度(len)
      • python2:按字节算长度
      • python3:按字符算长度
    • for循环(同长度的版本循环单位)

    四、字符与字节的转换

    # 将gbk编码的字符转化为字节
    s = "李程"
    b = bytes(s, encoding="gbk")
    type(b)  输出为字节类型
    
    # 将字节转化为字符
    c = str(b, encoding="gbk")

    五、字符串格式化

    Python的字符串格式化有两种方式: 百分号方式、format方式

    百分号的方式相对来说比较老,而format方式则是比较先进的方式,企图替换古老的方式,目前两者并存。

    1、百分号方式

    %[(name)][flags][width].[precision]typecode
    (name)      可选,用于选择指定的key
    flags          可选,可供选择的值有:
    +       右对齐;正数前加正好,负数前加负号;
    -        左对齐;正数前无符号,负数前加负号;
    空格    右对齐;正数前加空格,负数前加负号;
    0        右对齐;正数前无符号,负数前加负号;用0填充空白处
    width         可选,占有宽度
    .precision   可选,小数点后保留的位数
    typecode    必选
    s,获取传入对象的__str__方法的返回值,并将其格式化到指定位置
    r,获取传入对象的__repr__方法的返回值,并将其格式化到指定位置
    c,整数:将数字转换成其unicode对应的值,10进制范围为 0 <= i <= 1114111(py27则只支持0-255);字符:将字符添加到指定位置
    o,将整数转换成 八  进制表示,并将其格式化到指定位置
    x,将整数转换成十六进制表示,并将其格式化到指定位置
    d,将整数、浮点数转换成 十 进制表示,并将其格式化到指定位置
    e,将整数、浮点数转换成科学计数法,并将其格式化到指定位置(小写e)
    E,将整数、浮点数转换成科学计数法,并将其格式化到指定位置(大写E)
    f, 将整数、浮点数转换成浮点数表示,并将其格式化到指定位置(默认保留小数点后6位)
    F,同上
    g,自动调整将整数、浮点数转换成 浮点型或科学计数法表示(超过6位数用科学计数法),并将其格式化到指定位置(如果是科学计数则是e;)
    G,自动调整将整数、浮点数转换成 浮点型或科学计数法表示(超过6位数用科学计数法),并将其格式化到指定位置(如果是科学计数则是E;)
    %,当字符串中存在格式化标志时,需要用 %%表示一个百分号
    注:Python中百分号格式化是不存在自动将整数转换成二进制表示的方式
    参数详解

    常用格式化:

    tpl = "i am %s" % "spark"
     
    tpl = "i am %s age %d" % ("spark", 18)
     
    tpl = "i am %(name)s age %(age)d" % {"name": "spark", "age": 18}
     
    tpl = "percent %.2f" % 99.97623
     
    tpl = "i am %(pp).2f" % {"pp": 123.425556, }
     
    tpl = "i am %.2f %%" % {"pp": 123.425556, }

    2、Format方式

    [[fill]align][sign][#][0][width][,][.precision][type]
    fill           【可选】空白处填充的字符
    align        【可选】对齐方式(需配合width使用)
    <,内容左对齐
    >,内容右对齐(默认)
    =,内容右对齐,将符号放置在填充字符的左侧,且只对数字类型有效。 即使:符号+填充物+数字
    ^,内容居中
    sign         【可选】有无符号数字
    +,正号加正,负号加负;
     -,正号不变,负号加负;
    空格 ,正号空格,负号加负;
    #            【可选】对于二进制、八进制、十六进制,如果加上#,会显示 0b/0o/0x,否则不显示
    ,            【可选】为数字添加分隔符,如:1,000,000
    width       【可选】格式化位所占宽度
    .precision 【可选】小数位保留精度
    type         【可选】格式化类型
    传入” 字符串类型 “的参数
    s,格式化字符串类型数据
    空白,未指定类型,则默认是None,同s
    传入“ 整数类型 ”的参数
    b,将10进制整数自动转换成2进制表示然后格式化
    c,将10进制整数自动转换为其对应的unicode字符
    d,十进制整数
    o,将10进制整数自动转换成8进制表示然后格式化;
    x,将10进制整数自动转换成16进制表示然后格式化(小写x)
    X,将10进制整数自动转换成16进制表示然后格式化(大写X)
    传入“ 浮点型或小数类型 ”的参数
    e, 转换为科学计数法(小写e)表示,然后格式化;
    E, 转换为科学计数法(大写E)表示,然后格式化;
    f , 转换为浮点型(默认小数点后保留6位)表示,然后格式化;
    F, 转换为浮点型(默认小数点后保留6位)表示,然后格式化;
    g, 自动在e和f中切换
    G, 自动在E和F中切换
    %,显示百分比(默认显示小数点后6位)
    参数详解

     常用格式化:

     1 tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
     2   
     3 tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
     4   
     5 tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
     6   
     7 tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
     8   
     9 tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
    10   
    11 tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
    12   
    13 tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
    14   
    15 tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
    16   
    17 tpl = "i am {:s}, age {:d}".format(*["seven", 18])
    18   
    19 tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
    20   
    21 tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
    22  
    23 tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
    24  
    25 tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
    26  
    27 tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
    28  
    29 tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)

    更多格式化操作:https://docs.python.org/3/library/string.html

  • 相关阅读:
    Linux 下安装 mysql8
    Git 上传本地项目到Github
    vue+vscode+nodejs 开发环境搭建
    window下 局域网内使用mysql,mysql 开启远程访问权限
    spring boot application 配置详情
    spring boot starter列表
    【第一篇】spring boot 快速入门
    Spring中手动增加配置文件中占位符引用的变量
    spring容器
    springmvc细节篇
  • 原文地址:https://www.cnblogs.com/LiCheng-/p/6430963.html
Copyright © 2011-2022 走看看