Python基础【第五篇】:基础数据类型(字符型)

String(字符串)

字符串的形式

在python中字符串可以用’    ‘(单引号),“    ”(双引号),和’‘’     ‘’‘(三个单引号)。

string1 = 'james'      
string2 = '''kobe'''
string3 = "jordan"
print(string1,string2,string3)

python中访问字符串的方法

Python 不支持单字符类型,单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串,可以使用方括号来截取字符串

string = 'abcdefg'
#1.string[0:n]表示,从从第一个元素到第n个元素
print("前四个元素:",string[0:4])
#2.string[a:b]表示从第a+1个元素到第b个元素
print("第二个元素到第三个元素:",string[1:3])
#3.string[:n]表示前n个元素
print("前三个元素:",string[:3])
#4.string[n:]表示从第n+1个元素到最后
print("第四个元素到最后一个元素:",string[3:])
#5.string[:]等价于字符串本身
print("所有的元素:",string[:])
#6.string[-n:]表示从后截取的n个元素组成的字符串
print("string[-2:]:",string[-2:])
#7.string[:-n]表示从后去掉n个元素后的字符串
print("string[:-2]:",string[:-2])
#8.string[a:b]若a>b,默认输出空
print("string[3:2]:",string[3:2])
#9.string[::n]表示从头到尾步长为n形成的字符串
print("string[::2]:",string[::2])
#10.string[::-n]表示从尾到头步长为n形成的字符串
print("string[::-2]:",string[::-2])

 

输出:

前四个元素: abcd
第二个元素到第三个元素: bc
前三个元素: abc
第四个元素到最后一个元素: defg
所有的元素: abcdefg
string[-2:]: fg
string[:-2]: abcde
string[3:2]: 
string[::2]: aceg
string[::-2]: geca

索引值以 0 为开始值,-1 为从末尾的开始位置。

 

操作符 ’  :‘ 代表了所以的意思。

怎么看截取的字符串?

  • 一看数字:假如是正数就从开头数,假如是负数就从结尾数。
  • 二看结构:包头不包尾。[a:b],包含下标为a的字符,但不包括下标为b的字符。
  • 三看方向:我们需要看’:‘在什么地方,如果在左边就往左边走,在右边就往右边走。

比如:

string = 'abcdefg'
print("string[:2]:",string[:2])
#一看数字,是正数2,则从开头数到下标2的位置,是字符’c‘;
#二看结构,2在尾部,所以不包含字符’c‘;
#三看方向,’:‘在左边,则往左走,所以截取的字符串为从下标为2的
#字符’c‘且不包含’c‘开始,往左所有的字符:’ab‘

再有:

string = 'abcdefg'
print("string[-2:]:",string[-2:])
#一看数字,是负数-2,则从结尾数到下标-2的位置,是字符’f‘;
#二看结构,-2在头部,所以包含字符’f‘;
#三看方向,’:‘在右边,则往右走,所以截取的字符串为从下标为-2的
#字符’f‘且包含’f‘开始,往右所有的字符:’fg‘

 

字符串的操作

 

‘+’      :拼接两个字符串

’*‘        :复制字符串         >>>a='hello'   >>>a*2    >>>’hellohello‘

[]         :通过索引获取字符串中的字符

in        :判断一个字符串是否包含在给定字符串当中

not in  :与in相反

r/R      :原始字符串 - 原始字符串: 原始字符串除在字符串的第一个引号前加上字母r(可以大小写)以外,与普通字符串有着几乎完全相同的语法。

string1 = "helloworld"
string2 = "hello"
string3 = "world"
string = string2 + string3
print("拼接后的字符串:",string)
print("string1*2:",string1*2)
print("string1[1]:",string1[1])
print("string2是否包含于string1:",string2 in string1)
print("string3是否不包含于string1:",string3 not in string1)
original1 = r"orig"
original2 = R"inal"
print("原始字符:",original1 + original2)

 

此实例输出:

拼接后的字符串: helloworld
string1*2: helloworldhelloworld
string1[1]: e
string2是否包含于string1: True
string3是否不包含于string1: False
原始字符: original

Python中字符格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式,但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

在 Python 中,字符串格式化使用与 C 中 sprintf 函数一样的语法。

    符   号描述
      %c  格式化字符及其ASCII码
      %s  格式化字符串
      %d  格式化整数
      %u  格式化无符号整型
      %o  格式化无符号八进制数
      %x  格式化无符号十六进制数
      %X  格式化无符号十六进制数(大写)
      %f  格式化浮点数字,可指定小数点后的精度
      %e  用科学计数法格式化浮点数
      %E  作用同%e,用科学计数法格式化浮点数
      %g  %f和%e的简写
      %G  %f 和 %E 的简写
      %p  用十六进制数格式化变量的地址

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

格式化操作符的辅助命令

Python2.6 开始,新增了一种格式化字符串的函数 str.format()方法,它增强了字符串格式化的功能,在本文将会讲到。

下面来演示格式化操作符的效果:

符号功能
. 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号( + )
<sp> 在正数前面显示空格
# 在八进制数前面显示零('0'),在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0 显示的数字前面填充'0'而不是默认的空格
% '%%'输出一个单一的'%'
(var) 映射变量(字典参数)
m.n. m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

 

 

 

 

 

 

 

 

 

 

 

 

name = "kobe"
age = 38
points = 33643
field_average = 24.9
highest = 81
print('''\t%s是历史上最伟大的篮球运动员之一。\n他%6.d岁从NBA退役,场均可以拿到%-10.5f分,生涯总得分为%.5e,排名历史第三。\n其中一次与猛龙的比赛中拿到了其生涯最高分%010u分,写成八进制为%o分,写成十六进制为%#x分'''%(name,age,field_average,points,highest,highest,highest))

 

 输出:

  kobe是历史上最伟大的篮球运动员之一。
他    38岁从NBA退役,场均可以拿到24.90000  分,生涯总得分为3.36430e+04,排名历史第三。
其中一次与猛龙的比赛中拿到了其生涯最高分0000000081分,
写成八进制为121分,写成十六进制为0x51分

结果解释:

  • %s格式为字符串
  • %6.d格式为整数,且总长度为6个,用空格填补
  • %-10.5f格式为浮点数,且总长度为10,小数点后长度为5,' - '代表左对齐
  • %.5e代表使用科学计数法表示,且小数点后长度为5
  • %010u格式为无符号整数,且总长度为10,数字前用0填充而不是空格
  • %o格式为八进制表示;%#o用十六进制表示,且在十六进制数前显示’ox‘

关于上例的三引号作用解释’‘’    ‘’‘

python三引号允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符。上例中之所以\n,\t可以起到作用,就是三引号的功能。三引号还可以起到注释的作用。

print("""三引号使[\n] ,以及[\t]等一些特殊字符发挥了作用""")

'''
这是三引号的多行注释
'''

输出:

三引号使[
] ,以及[    ]等一些特殊字符发挥了作用

字符串的存储

在Python2中,普通字符串是以8位ASCII码进行存储的,而Unicode字符串则存储为16位unicode字符串,这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u

在Python3中,所有的字符串都是Unicode字符串。

 


 

python中字符串的内建函数

  • capitalize     该方法返回一个首字母大写,且其他为小写的字符串。
    str = 'hello world'
    print(str.capitalize())
    
    #输出 Hello world
  • center(width,fillchar)     width是字符串的总宽度,fillchar是填充字符。返回一个指定的宽度 width 居中的字符串,如果 width 小于字符串宽度直接返回字符串,否则使用 fillchar 去填充。
  • ljust(width,fillchar)     与center()方法不同的就是返回一个指定宽度width居左的字符串。
  • rjust(width,fillchar)    与center()方法不同的就是返回一个指定宽度width居右的字符串。
    str = "hello world"
    print("str.ljust(20,'*'):",str.ljust(20,'*'))
    print("str.center(20,'*'):",str.center(20,'*'))
    print("str.rjust(20,'*'):",str.rjust(20,'*'))
    #fillchar只能是单字符。

      str.ljust(20,'*'): hello world*********
      str.center(20,'*'): ****hello world*****
      str.rjust(20,'*'): *********hello world

  • lstrip(chars)     截掉字符串左边的空格或指定字符串中的每个字符,返回截取后的字符串
  • rstrip(chars)     截掉字符串右边的空格或者指定字符串的每个字符,返回截取后的字符串
  • strip(chars)      同时实现lstrip()和rstrip()方法
    str = '    hello world    '
    print(str.lstrip())
    print(str.lstrip(' h'))
    print(str.lstrip(' hew'))
    print(str.rstrip())
    print(str.rstrip(' d'))
    print(str.rstrip(' dlw'))
    print(str.strip(' hd')) 
    hello world    
    ello world    
    llo world    
        hello world
        hello worl
        hello wor
    ello worl
  • count(sub,start,end)     sub是搜索的子字符串,start是开始搜索的下标,end是结束的下标,返回子字符串在字符串中出现的次数。
    str = "hello world hello world"
    sub = "hello"
    print("‘hello’在字符串中出现了%d次"%(str.count(sub)))
    print("‘hello’在下标0~16中出现了%d次"%(str.count(sub,0,16)))
    print(str[0],str[16])
    #搜索的范围包括下标为start的字符,不包括下标为end的字符
    ‘hello’在字符串中出现了2次
    ‘hello’在下标0~16中出现了1次
    h o
  • encode(encoding,errors)      encode是编码,使用指定的编码格式编码字符串。encoding是指定使用什么编码方式。errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace','xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。
    str = '大大焕'
    str_utf8 = str.encode("UTF-8",'strict')
    str_gbk = str.encode("GBK",'strict')
    print("UTF-8编码:",str_utf8)
    print("GBK编码:",str_gbk)
    UTF-8编码: b'\xe5\xa4\xa7\xe5\xa4\xa7\xe7\x84\x95'
    GBK编码: b'\xb4\xf3\xb4\xf3\xbb\xc0'

    返回值:该方法返回的并不是一个普通的字符串,而是一个bytes对象。

  • bytes.decode(encoding,errors)     参数encode是一样的,不过此方法是指定一种方法解码,而调用这个方法的是bytes对象,不是普通的字符串对象。
    str = '大大焕'
    str_utf8 = str.encode("UTF-8",'strict')
    str_gbk = str.encode("GBK",'strict')
    print("UTF-8编码:",str_utf8)
    print("GBK编码:",str_gbk)
    print("UTF-8 解码:",str_utf8.decode('UTF-8','strict'))
    print("GBK解码:",str_gbk.decode('GBK','strict'))
    #如果我们试图用不对应的编码去解码,则会出现错误
    str_utf8.decode('GBK','strict')
    UTF-8编码: b'\xe5\xa4\xa7\xe5\xa4\xa7\xe7\x84\x95'
    GBK编码: b'\xb4\xf3\xb4\xf3\xbb\xc0'
    UTF-8 解码: 大大焕
    GBK解码: 大大焕
    Traceback (most recent call last):
      File "C:/Users/dell/PycharmProjects/Python_1/day10/firstPy.py", line 9, in <module>
        str_utf8.decode('GBK','strict')
    UnicodeDecodeError: 'gbk' codec can't decode byte 0x95 in position 8: incomplete multibyte sequence
  • endswith(suffix,start,end)     用于判断在下标为start~end的字符串中是否以字符串suffix结尾。返回true或者false。
    str = 'hello wold'
    print("是否以字符‘ld’结尾:",str.endswith("ld"))
    print("在下标2-7形成的字符串%s中,是否以‘ld’结尾:"%str[2:7],
    str.endswith('ld',2,7))
    是否以字符‘ld’结尾: True
    在下标2-7形成的字符串llo w中,是否以‘ld’结尾: False 
  • startswith(suffix,start,end)      用于判断在下标为start~end的字符串中是否以字符串suffix结尾。返回true或者false。
    str = 'hello world'
    print("是否以字符‘he’开头:",str.startswith("he"))
    print("在下标2-7形成的字符串%s中,是否以‘ld’开头:"%str[2:7],
    str.startswith('ld',2,7))
    是否以字符‘he’开头: True
    在下标2-7形成的字符串llo w中,是否以‘ld’开头: False
  • expandtabs(tabsize)    将字符串中的tab符号(\t)换为空格,空格的个数为tabsize。
  • str = 'hello\tworld'
    print("原始字符串:"+str)
    #原始tabs长度默认为8个空格
    print("使用空格替换\\t符号:"+str.expandtabs())
    print("使用16个空格替换\\t符号:"+str.expandtabs(16))
    原始字符串:hello    world
    使用空格替换\t符号:hello   world
    使用16个空格替换\t符号:hello           world

     

  • find(str,start,end)     检测字符串中是否包含子字符串 str ,如果指定 start(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,如果指定范围内如果包含指定索引值,返回的是索引值在字符串中的起始位置。如果不包含索引值,返回-1。
  • rfind(str,start,end)    与find()一样,不过是从右边开始检索。
    #find()
    str = 'abcdefabcdab'
    print("字符串‘ab’在str当中开始的索引为:",str.find('ab'))
    print("字符串‘ab’在str从下标3开始的字符串%s中开始的索引为:"%(str[3:]),str.find('ab',3))
    #将会返回第一个出现的字符串开始的索引
    print("字符串‘ab’是否在str的下标1-6形成的字符串%s中:"%(str[1:6]),str.find('ab',1,6))
    #rfind()
    print("str.rfind('ab'):",str.rfind('ab'))
    print("str.rfind('ab',1,6):",str.rfind('ab',1,6))
    字符串‘ab’在str当中开始的索引为: 0
    字符串‘ab’在str从下标3开始的字符串defabcdab中开始的索引为: 6
    字符串‘ab’是否在str的下标1-6形成的字符串bcdef中: -1
    str.rfind('ab'): 10
    str.rfind('ab',1,6): -1
  • index(str,start,end)     和find()方法一样,但是如果str不在调用的字符串中,会报一个异常。
  • rindex(str,start,end)    和index方法一样,但是从后面开始检索。
  • str = 'abcdefabcdab'
    print("字符串‘ab’是否在str的下标1-6形成的字符串中:",
    str.index('ab',1,6))
    Traceback (most recent call last):
      File "C:/Users/dell/PycharmProjects/Python_1/day10/firstPy.py", line 2, in <module>
        print("字符串‘ab’是否在str的下标1-6形成的字符串中:",str.index('ab',1,6))
    ValueError: substring not found

     

  • isalnum()         检测字符串是否由字母和数字组成。如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False。
    str = '#123abc'
    print("str.isalnum():",str.isalnum())   #False
    str1 = '123'
    print("str1.isalnum():",str1.isalnum())  #True
    str2 = 'abc'
    print("str2.isalnum():",str2.isalnum())   #True

     

  • isalpha()       如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
  • isdigit()         如果字符串只包含数字则返回 True 否则返回 False
    str = '123abc'
    print("str.isdigit():",str.isdigit())    #False
    print("str.isalpha():",str.isalpha())    #False
    str1 = 'abc'
    str2 = '123'
    print("str1.isalpha():",str1.isalpha())  #True
    print("str2.isdigit():",str2.isdigit())  #True
    str.isdigit(): False
    str.isalpha(): False
    str1.isalpha(): True
    str2.isdigit(): True 
  • isnumeric()      与isidgit()的性质相差不多,不过它只针对unicode字符串。
  • isdecimal()       也是判断字符串是否全部由数字构成。
     1 '''
     2 isdigit()、isdecimal()、isnumeric()三者的区别。
     3 
     4 isdigit()
     5 True:Unicode字符串,byte数字
     6 False:罗马数字、中文数字
     7 error:无
     8 
     9 isdecimal()
    10 True:Unicode数字
    11 False:罗马数字、中文数字
    12 error:byte数字
    13 
    14 isnumeric()
    15 True:Unicode数字、罗马数字、中文汉字
    16 False:无
    17 error:byte数字
    18 '''
    isdigit()、isdecimal()、isnumeric()三者的区别。
    1 str1 = '123'     #unicode编码数字
    2 str2 = b'123'     #byte数字
    3 str3 = '一二三'  #中文数字
    4 str4 = 'ⅠⅡⅢ'  #罗马数字
    5 print("str1.isdigit():",str1.isdigit())
    6 print("str2.isdigit():",str2.isdigit())
    7 print("str3.isdigit():",str3.isdigit())
    8 print("str4.isdigit():",str4.isdigit())
    9 print('\n')
    测试isdigital()
    1 str1 = '123'     #unicode编码数字
    2 str2 = b'123'     #byte数字
    3 str3 = '一二三'  #中文数字
    4 str4 = 'ⅠⅡⅢ'  #罗马数字
    5 print('str1.isdecimal():',str1.isdecimal())
    6 print('str2.isdecimal():',str2.isdecimal())
    7 print('str3.isdecimal():',str3.isdecimal())
    8 print('str4.isdecimal():',str4.isdecimal())
    9 print('\n')
    测试isdecimal()
    1 print('str1.isnumeric():',str1.isnumeric())
    2 print('str2.isnumeric():',str2.isnumeric())
    3 print('str3.isnumeric():',str3.isnumeric())
    4 print('str4.isnumeric():',str4.isnumeric())
    测试isnumeric()

     

  • islower()      如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False。
    str = 'ABCabc'
    str1 = 'abcabc'
    print(str.islower())    #False
    print(str1.islower())   #True

     

  • isupper()    如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False。
  • lower()        将字符串的字母都转换为小写
  • upper()        将字符串的字母都转换为大写
    str = '你好,世界,hello WORLD'
    print('变为小写:',str.lower())
    print('变为大写:',str.upper())
    
    变为小写: 你好,世界,hello world
    变为大写: 你好,世界,HELLO WORLD
  • casefold()     也是将字符串的字母全变为小写,功能比lower()更强大。
    str = 'heLLo WOrlD '
    print(str.casefold())
    hello world 
  • isspace()      如果字符串中只含有空白,返回True,否则返回False。
  • title()          返回标题化的字符串,及所有单词都是首字母大写,其余小写。
  • istitle()       判断字符串是否为标题化的
    str = 'hello world'
    print('str:%-15s是否已经标题化:'%(str),str.istitle())
    str = str.title()
    print('str:%-15s是否已经标题化:'%(str),str.istitle())
    
    
    str:hello world    是否已经标题化: False
    str:Hello World    是否已经标题化: True
  • join(seq)       将序列中的元素以指定的字符连接生成一个新的字符串。返回通过指定字符连接序列中元素后生成的新字符串。
    str1 = '-'
    str2 = ''
    list1 = 'hello world'
    list2 = ['I','l','o','v','e','y','o','u']
    print(str1.join(list1))
    print(str1.join(list2))
    print(str2.join(list2))
    
    
    h-e-l-l-o- -w-o-r-l-d
    I-l-o-v-e-y-o-u
    Iloveyou

    输入的参数seq必须是字符串,不能是数字,否则会报错。

  • len(str)      返回字符串的长度
    str = 'hello world'
    print(len(str))   
    
    11
  • translate(table,deletechars)         table是翻译表通过maketrans()方法转换而来。deletechars是字符串中要过滤的字符列表。
    inchars = 'eol'      #被映射的字符串
    outchars = '123'     #映射的字符串
    trans_table = str.maketrans(inchars,outchars)  #制作映射翻译表
    str = 'hello world'
    print(str.translate(trans_table))
    #两个str意义是不一样的。第一个是表示str模块,第二个是变量名
    '''如果要加上参数deletechars,则要将字符串对象都改为bytes对象
    (在字符串前面加b)
    ''' #制作映射翻译表,将字符小写变成大写 bytes_trans_table = bytes.maketrans(b'abcdefghigklmnopqrstuvwxyz',
    b'ABCDEFGHIGKLMNOPQRSTUVWXYZ') print(b'hello world'.translate(bytes_trans_table,b'ol')) #去掉原bytes对象中的字符‘o’和‘l’之后映射的字符串
    h1332 w2r3d
    b'HE WRD'
  • maketrans(intab,outtab)      制作映射翻译表,,intab是要被替换的字符串,outtab是替换的字符串。返回一个映射的字典对象。此方法可以用bytes调用,也可以用str调用。
    inchars = 'eol'      #被映射的字符串
    outchars = '123'     #映射的字符串
    trans_table = str.maketrans(inchars,outchars)  #制作映射翻译表
    print(trans_table,type(trans_table))
  • min(str)、max(str)    返回字符串str中最小/大的字母
    str = 'efghik'
    print("str中最小的字母是%s,最大的字母是%s"%(min(str),max(str)))
    
    输出:
    
    str中最小的字母是e,最大的字母是k
  • replace(old,new,max)  把 将字符串中的 old 替换成 new,如果 max 指定,则替换不超过 max 次。
    str = 'my name is kobe'
    str1 = str.replace('kobe','james')
    print(str1)
    str = 'abcabcabcabc'
    str1 = str.replace('abc','123',3)
    print(str1)
    my name is james
    123123123abc
  • split(str,num)      通过指定分隔符(默认空格)对字符串进行切片,如果参数num 有指定值,则仅分隔 num 个子字符串。str表示以什么分隔符进行切片,num表示切几次。返回一个由切割完的字符串形成的列表。
    str = 'kobe is my favorite basketball player'
    print(type(str.split()))
    print(str.split())
    print(str.split('i'))
    print(str.split('a',3))
    <class 'list'>
    ['kobe', 'is', 'my', 'favorite', 'basketball', 'player']
    ['kobe ', 's my favor', 'te basketball player']
    ['kobe is my f', 'vorite b', 'sketb', 'll player']
  • splitlines(keepends)      在字符串中按照行(\n,\r,\r\n)分割返回一个包含各行的列表。参数keepends是判断符,默认为False,不包含换行符,若为True,则包含换行符
    str = "\nabc\nefg\rhigoror\n"
    print(str)
    print(str.splitlines())
    print(str.splitlines(True))
    abc
    higoror
    
    ['', 'abc', 'efg', 'higoror']
    ['\n', 'abc\n', 'efg\r', 'higoror\n']
  • swapcase()     将字符串中大写变小写,小写变大写。
    str = 'hello WORLD'
    print(str.swapcase())
    
    HELLO world

     


 

字符串的格式化format()方法

主要是使用{}与:来代替%的另一种格式化方法。

format可接受不限个参数,如果没有位置索引,则按先后顺序。format()中的参数全部可以视为一个列表或者元组。

>>> 'i am {},{} years old '.format('kobe',38)
'i am kobe,38 years old '
>>> 'i am {},{} years old '.format('kobe',38,56)
'i am kobe,38 years old '
>>> 'i am {},{} years old '.format('kobe')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>>

{}可以比format()中的参数少,但不能多,多则会报错。

也可以使用索引来控制。

>>> 'i am {0},{1} years old '.format('kobe',38)
'i am kobe,38 years old '
>>> "i like {0},don't like {1},but my friends like {1}".format('basketball','football')
"i like basketball,don't like football,but my friends like football"
>>>

也可以设置对应参数

print('i am {name},{age} years old'.format(name = 'kobe',age = 39))
#输出
i am kobe,39 years old

也可以通过字典设置

print('i am {name},{age} years old'.format(**{'name':'kobe','age' :39}))
#输出
i am kobe,39 years old

也可以通过控制列表索引

print('i am {0},{1} years old'.format(*['kobe',39]))
#输出
i am kobe,39 years old

*与**分别控制列表和字典,相当于将列表和字典的每个元素都变为format的参数。

如果不想使用*,也可以使用如下方法

list = ['kobe',39]
print('i am {0[0]},{0[1]} years old'.format(list))
#0不可少,表示索引为0的元素
#输出
i am kobe,39 years old

也可以使用:改变格式,也是采用顺序赋值

demo = "i am {:s},age{:d}".format(*['kobe',39])
print(demo)
demo = "i am {:s},age{:d}".format('kobe',39)
print(demo)
demo = "numbers:{:b},{:o},{:d},{:x},{:X},{:%}".format(15,15,15,15,15,15.5432)
print(demo)
#o为八进制,b为二进制,x为16进制,X为16进制

输出:

i am kobe,age39
i am kobe,age39
numbers:1111,17,15,f,F,1554.320000%

 

posted @ 2018-08-13 23:02  焕熊  阅读(1987)  评论(0编辑  收藏  举报