您的位置:新葡亰496net > 奥门新萄京娱乐场 > 新葡亰496net自兴人工智能,python之字符串

新葡亰496net自兴人工智能,python之字符串

发布时间:2019-06-19 12:38编辑:奥门新萄京娱乐场浏览(162)

    字符串是python中最常用的数据类型,大家能够使用单引号(' ')或双引号(" ")来创立字符串。

    (自兴人工智能)python字符串,人工智能python

    字符串是python中最常用的数据类型,大家能够应用单引号(' ')或双引号(" ")来创立字符串。

    a='Hello'
    b="Hello"
    

    怀有正式种类操作如(索引,分片,成员身价,求长度,取最小值和最大值等),对字符串同样适用。

    字符串常用的格式化符号:

    (%s 格式化字符串)

    print('Hello,%s'%'world') #使用%s作为'world'的占位符
    Hello,world #结果
    
    print('还有%s天') #使用%d作为10的占位符
    还有10天 #结果
    #%s不仅可以格式化字符串,还可以格式化整数
    

    (%d 格式化整数)

    print('还有%d天') #使用%d作为10的占位符
    还有10天 #结果
    

     字符串常用的点子:

    find():用于检测字符串中是还是不是包括子字符串str,能够钦点发轫和截至的限定。

    a='hello,world'
    print(a.find('wo'))
    6 #返回了匹配值的索引
    print(a.find('kb'))
    -1 #找不到,返回-1
    
    print(a.find('wo',3)) #提供起点
    6 #结果
    print(a.find('wd',6))
    -1 #结果
    
    print(a.find('wo',3,8)) #提供起点和终点
    6 #结果
    print(a.find('wd',3,7))
    -1 #结果
    

    lower():将字符串中保有大写字符调换为题写

    a='HeLlo'
    b=a.lower()
    print(b)
    hello #结果
    

    upper():将字符串中享有小写字符调换为题写

    a='HeLlo'
    b=a.upper()
    print(b)
    HELLO #结果
    

    新葡亰496net自兴人工智能,python之字符串。swapcase():将字符串中有所小写字符调换为大写,大写字符转变为题写

    a='HeLlo'
    b=a.swapcase()
    print(b)
    hElLO #结果
    

    replace():把字符串中的旧字符串替换到新字符串

    a='hello world'
    b=a.replace('hello','HELLO')
    print(b)
    HELLO world #结果
    

    strip():移除字符串头尾钦定字符

    a='  hello world  '
    b=a.strip(' ')
    print(b)
    hello world #结果
    
    b=a.strip('  h')
    print(b)
    ello world #结果
    
    b=a.strip('  d')
    print(b)
    hello worl #结果
    

     

    字符串是python中最常用的数据类型,大家得以动用单引号(' ')或双引号(" ")来创设字符串。...

    字符串是 Python 中最常用的数据类型。大家能够利用引号('或")来创立字符串。
    如:
    str1='god'
    str2="my god"

    字符串能够看做元组来管理

    Str 字符串

    a='Hello'
    b="Hello"
    

    python三引号允许三个字符串跨多行,字符串中得以分包换行符、制表符以及别的特殊字符。
    例如:
    str3="good...............
    morning sir"

    str1 = "I LOVE YOU"

    python 字符串str是在Python编写程序进度中,最广大的一种为主数据类型。

    怀有正式连串操作如(索引,分片,成员身价,求长度,取最小值和最大值等),对字符串一样适用。

    三引号让程序员从引号和极度字符串的泥潭之中解脱出来,一如既往保持一小块字符串的格式是所谓的WYSIWYG(所见即所得)格式的。

    str1[:4]


    字符串常用的格式化符号:

    在Python3中,全部的字符串都是Unicode字符串。

    I LO

    A、成立字符串

    (%s 格式化字符串)

    1
    capitalize()
    将字符串的首先个字符转变为题写
    2
    center(width, fillchar)

    str1[4]

    a=str('字符串')

    print('Hello,%s'%'world') #使用%s作为'world'的占位符
    Hello,world #结果
    
    print('还有%s天') #使用%d作为10的占位符
    还有10天 #结果
    #%s不仅可以格式化字符串,还可以格式化整数
    

    归来三个点名的上涨的幅度 width 居中的字符串,fillchar 为填充的字符,默感觉空格。
    3
    count(str, beg= 0,end=len(string))

    V

    a='那样也是字符串'

    (%d 格式化整数)

    回去 str 在 string 里面出现的次数,借使 beg 恐怕 end 钦定则赶回钦点范围内 str 出现的次数
    4
    bytes.decode(encoding="utf-8", errors="strict")

    str2=str1[:6] ' U' str[新葡亰496net,6:]

    astr='我是字符串'  #使用单引号或是双引号来创建
    bint=123   #这是一个int类型
    bstr=str(bint)  #str()可以用来把List,dict,int,float这些类转为字符串
    
    #输入出结果及类型
    print(astr,type(astr))
    print(bint,type(bint))
    print(bstr,type(bstr))
    
    #输出
    
    print('还有%d天') #使用%d作为10的占位符
    还有10天 #结果
    

    Python3 中从不 decode 方法,但大家得以运用 bytes 对象的 decode() 方法来解码给定的 bytes 对象,那个 bytes 对象足以由 str.encode() 来编码再次回到。
    5
    encode(encoding='UTF-8',errors='strict')

    I LOVE U YOU

     作者是字符串 <class 'str'>
     123 <class 'int'>
     123 <class 'str'>

     字符串常用的情势:

    以 encoding 钦点的编码格式编码字符串,假若出错暗许报二个ValueError 的可怜,除非 errors 钦点的是'ignore'恐怕'replace'
    6
    endswith(suffix, beg=0, end=len(string))
    检查字符串是不是以 obj 结束,如若beg 也许 end 内定则检查钦定的限制内是否以 obj 结束,假使是,重回 True,不然重临 False.
    7
    expandtabs(tabsize=8)


     

    find():用于检查评定字符串中是还是不是带有子字符串str,能够钦点初叶和终结的限量。

    把字符串 string 中的 tab 符号转为空格,tab 符号私下认可的空格数是 8 。
    8
    find(str, beg=0 end=len(string))

    capitalize()    把字符串的第三个字符改为题写

    casefold()    把整个字符串的全数字符改为题写

    center(width)    将字符串居中,并行使空格填充至长度 width 的新字符串

    count(sub[, start[, end]])    再次来到 sub 在字符串里边出现的次数,start 和 end 参数表示范围,可选。

    encode(encoding='utf-8', errors='strict')    以 encoding 钦命的编码格式对字符串实行编码。

    endswith(sub[, start[, end]])    

    检查字符串是或不是以 sub 子字符串甘休,要是是再次来到 True,不然重返False。start 和 end 参数表示范围,可选。

    expandtabs([tabsize=8])    

    把字符串中的 tab 符号(t)转变为空格,如不钦命参数,私下认可的空格数是 tabsize=8。

    find(sub[, start[, end]])    

    检查测试 sub 是还是不是带有在字符串中,纵然有则重临索引值,不然重临 -1,start 和 end 参数表示范围,可选。

    index(sub[, start[, end]])    跟 find 方法同样,但是只要 sub 不在 string 中会发生贰个卓殊。

    isalnum()

    若是字符串至少有二个字符并且有着字符都以字母或数字则赶回 True,不然重临 False。

    is阿尔法()    假使字符串至少有八个字符并且有所字符都以字母则赶回 True,不然再次来到 False。

    isdecimal()    若是字符串只包蕴十进制数字则赶回 True,不然重临 False。

    isdigit()    假设字符串只包罗数字则赶回 True,不然再次回到 False。

    islower()    

    要是字符串中最少含有叁个界别轻重缓急写的字符,并且那几个字符都以小写,则赶回 True,不然重临 False。

    isnumeric()    如果字符串中只含有数字字符,则赶回 True,不然返回False。

    isspace()    借使字符串中只含有空格,则赶回 True,不然重回 False。

    istitle() 

    若果字符串是题目化(全部的单词都以以大写起始,别的字母均小写),则赶回 True,不然重回 False。

    isupper()

    设若字符串中最少含有三个界别轻重缓急写的字符,并且这么些字符都以大写,则赶回 True,不然再次来到 False。

    新葡亰496net自兴人工智能,python之字符串。join(sub)    以字符串作为分隔符,插入到 sub 中有所的字符之间。

    ljust(width)     再次回到三个左对齐的字符串,并采纳空格填充至长度为 width 的新字符串。

    lower()    转变字符串中保有大写字符为小写。

    lstrip()    去掉字符串左侧的全体空格

    partition(sub)   

    找到子字符串 sub,把字符串分成三个 3 元组 (pre_sub, sub, fol_sub),借使字符串中不包涵 sub 则赶回 ('原字符串', '', '')

    replace(old, new[, count])

    把字符串中的 old 子字符串替换到 new 子字符串,假若 count 钦命,则替换不当先 count 次。

    rfind(sub[, start[, end]])

    好像于 find() 方法,可是是从左侧起首查找。

    rindex(sub[, start[, end]])

    临近于 index() 方法,然则是从左侧早先。

    rjust(width)

    回去二个右对齐的字符串,并利用空格填充至长度为 width 的新字符串。

    rpartition(sub)

    就好像于 partition() 方法,可是是从左边伊始查找。

    rstrip()

    删去字符串末尾的空格。

    split(sep=None, maxsplit=-1)

    不带参数私下认可是以空格为分隔符切成块字符串,假诺 maxsplit 参数有设置,则仅相隔 maxsplit 个子字符串,重回切成条后的子字符串拼接的列表。

    splitlines(([keepends]))

    按照 'n' 分隔,再次回到三个暗含各行作为成分的列表,即便 keepends 参数钦命,则赶回前 keepends 行。

    startswith(prefix[, start[, end]])

    自己争论字符串是或不是以 prefix 开端,是则赶回 True,不然再次回到 False。start 和 end 参数能够钦点范围检查,可选。

    strip([chars])

    去除字符串前面和前面全体的空格,chars 参数能够定制删除的字符,可选。

    swapcase()

    翻转字符串中的大小写。

    title()

    回去标题化(全数的单词都以以大写开端,别的字母均小写)的字符串。

    translate(table)

    据悉 table 的条条框框(能够由 str.maketrans('a', 'b') 定制)转变字符串中的字符。

    upper()

    转移字符串中的全数小写字符为大写。

    zfill(width)

    回到长度为 width 的字符串,原字符串右对齐,前面用 0 填充。

     

    a='hello,world'
    print(a.find('wo'))
    6 #返回了匹配值的索引
    print(a.find('kb'))
    -1 #找不到,返回-1
    
    print(a.find('wo',3)) #提供起点
    6 #结果
    print(a.find('wd',6))
    -1 #结果
    
    print(a.find('wo',3,8)) #提供起点和终点
    6 #结果
    print(a.find('wd',3,7))
    -1 #结果
    

    检查实验 str 是还是不是包括在字符串中,倘诺钦命范围 beg 和 end ,则检查是否含有在钦定范围内,倘诺带有重返早先的索引值,不然重返-1
    9
    index(str, beg=0, end=len(string))

    格式化输出


    lower():将字符串中负有大写字符调换为题写

    跟find()方法同样,只不过假如str不在字符串中会报四个格外.
    10
    isalnum()

    "{0} love {1}{2} {3}".format('I','U',',','HusH') 

    B、三引号"""  """

    a='HeLlo'
    b=a.lower()
    print(b)
    hello #结果
    

    万一字符串至少有贰个字符并且有所字符都以字母或数字则返 回 True,不然再次来到False
    11
    isalpha()

    '{0:.1f}{1}'.format(22.222,'GB')    :冒号表示格式化开头上面疏解

    1、定义字符串

    upper():将字符串中有所小写字符调换为题写

    若是字符串至少有一个字符并且具有字符都以字母则赶回 True, 不然赶回 False
    12
    isdigit()

    字符串格式化符号含义

    2、解释表达

    a='HeLlo'
    b=a.upper()
    print(b)
    HELLO #结果
    

    若果字符串只包罗数字则赶回 True 不然重返 False..
    13
    islower()

    %c

    3、文书档案字符串,主要用在类(calss)里面,使用 __doc__

    swapcase():将字符串中装有小写字符调换为大写,大写字符转变为题写

    假若字符串中蕴藏至少两个有别于轻重缓急写的字符,并且存有那个(区分轻重缓急写的)字符都以小写,则赶回 True,不然重临 False
    14
    isnumeric()

    格式化字符及其ASCII码

    atstr="""
            我这里可以这样写
            我的排列,输出来就这样
     我怎么排,输出就怎么样
            """
    
    a='HeLlo'
    b=a.swapcase()
    print(b)
    hElLO #结果
    

    只要字符串中只包涵数字字符,则赶回 True,不然再次回到 False
    15
    isspace()

    %s

    出口结果:

    replace():把字符串中的旧字符串替换到新字符串

    固然字符串中只包蕴空白,则赶回 True,否则重回 False.
    16
    istitle()

    格式化字符串

            我这里可以这样写
            我的排列,输出来就这样
     我怎么排,输出就怎么样
    
    a='hello world'
    b=a.replace('hello','HELLO')
    print(b)
    HELLO world #结果
    

    万一字符串是题目化的(见 title())则赶回 True,否则重回 False
    17
    isupper()

    %d

     

    strip():移除字符串头尾钦定字符

    要是字符串中隐含至少贰个区分轻重缓急写的字符,并且具备那几个(区分轻重缓急写的)字符都以大写,则赶回 True,否则重回 False
    18
    join(seq)

    格式化整数


    a='  hello world  '
    b=a.strip(' ')
    print(b)
    hello world #结果
    
    b=a.strip('  h')
    print(b)
    ello world #结果
    
    b=a.strip('  d')
    print(b)
    hello worl #结果
    

    以钦定字符串作为分隔符,将 seq 中持有的成分(的字符串表示)合并为八个新的字符串
    19
    len(string)

    %o

    C、python用反斜杠()转义字符

     

    回到字符串长度
    20
    ljust(width[, fillchar])

    格式化无符号八进制数

    转义字符      描述
    (在行尾时)  续行符
    \     反斜杠符号
    '     单引号
    "     双引号
    a     响铃
    b     退格(Backspace)
    e     转义
    00       空
    n     换行
    v     纵向制表符
    t     横向制表符
    r     回车
    f     换页
    oyy       八进制数,yy代表的字符,例如:o12代表换行
    xyy       十六进制数,yy代表的字符,例如:x0a代表换行
    other     其它的字符以普通格式输出
    

    回去一个原字符串左对齐,并应用 fillchar 填充至长度 width 的新字符串,fillchar 默以为空格。
    21
    lower()

    %x

     

    退换字符串中有所大写字符为小写.
    22
    lstrip()

    格式化无符号十六进制数


    截掉字符串左边的空格或内定字符。
    23
    maketrans()

    %X

    1、原始字符串  

    创办字符映射的转变表,对于收受五个参数的最简便易行的调用方式,第贰个参数是字符串,表示要求更动的字符,第叁个参数也是字符串表示转变的靶子。
    24
    max(str)

    格式化无符号十六进制数(大写)

    行使r 表示原始字符串 如:(r'C:PythonPython36Scripts') 

    归来字符串 str 中最大的字母。
    25
    min(str)

    %f

     

    回到字符串 str 中型Mini小的的字母。
    26
    replace(old, new [, max])

    格式化定点数,可钦定小数点后的精度


    把 将字符串中的 str1 替换到 str2,若是 max 钦命,则替换不超越 max 次。
    27
    rfind(str, beg=0,end=len(string))

    %e

    D、字符串格式化。

    类似于 find()函数,然则是从左边初步查找.
    28
    rindex( str, beg=0, end=len(string))

    用正确计数法格式化定点数

    1、 % 格式化符

    恍如于 index(),然而是从右侧起初.
    29
    rjust(width,[, fillchar])

    %E

    print('我叫 %s 今年 %d 岁!' % ('小明', 10))
    
    #输出结果:
    我叫 小明 今年 10 岁!
    

    回来一个原字符串右对齐,并利用fillchar(私下认可空格)填充至长度 width 的新字符串
    30
    rstrip()

    作用同%e,用科学计数法格式化定点数

     

    除去字符串字符串末尾的空格.
    31
    split(str="", num=string.count(str))

    %g依据值的尺寸决定使用%f活%e

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

    num=string.count(str)) 以 str 为分隔符截取字符串,假若 num 有钦定值,则仅截取 num 个子字符串
    32
    splitlines([keepends])

    %G

      

    按照行('r', 'rn', n')分隔,重返叁个含有各行作为成分的列表,假诺参数 keepends 为 False,不含有换行符,借使为 True,则保留换行符。
    33
    startswith(str, beg=0,end=len(string))

    功用同%g,依据值的轻重缓急决定动用%f恐怕%E

     2、.format() 格式化 使用到 {}(大括号)

    反省字符串是还是不是是以 obj 开始,是则赶回 True,不然再次来到 False。若是beg 和 end 钦命值,则在钦命范围内检查。
    34
    strip([chars])

    格式化操作符帮助指令

    print('我叫 {} 今年 {} 岁!'.format('小明',10))
    
    #输出结果:
    我叫 小明 今年 10 岁!
    

    在字符串上推行 lstrip()和 rstrip()
    35
    swapcase()

    m.n

     

    将字符串中山大学写调换为小写,小写调换为题写
    36
    title()

    m是展现的纤维总幅度,n是小数点后的位数


    归来"标题化"的字符串,正是说全部单词都是以大写开首,别的字母均为题写(见 istitle())
    37
    translate(table, deletechars="")

    -

    E、字符串运算符 astr='Holle'  、bstr='Python'

    据他们说 str 给出的表(包蕴 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
    38
    upper()

    用于左对齐

    1、 字符串连接 astr bstr

    转移字符串中的小写字母为题写
    39
    zfill (width)

    cstr=astr bstr
    print(cstr)
    
    #输出结果:
    HollePython
    

    回去长度为 width 的字符串,原字符串右对齐,前边填充0
    40
    isdecimal()

    在正数前面呈现加号( )

    2、* 重复输出字符串 astr*3

    反省字符串是不是只含有十进制字符,倘诺是回来 true,不然重返 false。

    #

    print(astr*3)
    
    #输出结果:
    HolleHolleHolle
    

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

    在八进制数前面展现 '0o',在十六进制数前边展现 '0x'或 '0X'

    3、[] 通过索引获取字符串中字符 astr[0]

    上边说过,字符串也得以做切成片操作

    0

    print(astr[0])
    
    #输出结果:
    H
    

    显示的数字前边填充 '0'代替空格

    4、[ : ] 截取字符串中的一局地 astr[1:4],从索收 1到4,不包含4

    字符串转义字符含义

    print(astr[1:4])
    
    #输出结果:
    oll
    

    符号

    正向

    说明

     新葡亰496net 1

    '

    反向

    单引号

    新葡亰496net 2

    "

     

    双引号

    5、[::-1]反转字符串 (-1反向)

    a

    print(astr[::-1])
    
    #输出结果:
    elloH
    

    发出系统响铃声

     

    b


    退格符

    6、判断

    n

    6.1、in 成员运算符 - 如果字符串中富含给定的字符再次回到True

    换行符

    print('H'in astr)
    
    #输出结果:
    True
    

    t

    6.2、not in 成员运算符 - 假诺字符串中不带有给定的字符返回True

    横向制表符(TAB)

    print('H'not in astr)
    
    #输出结果:
    False
    #--------------------------------
    print('A'not in astr)
    
    #输出结果:
    True
    

    v

     

    纵向制表符


    r

    F、字符串内置函数

    回车符

    1、strip()用于移除字符串头尾钦定的字符(暗许为空格)其余还应该有strip('须求移除的标记')

    f

    a='   $#$#holle python     '
    c=a.strip()
    d=c.strip('$#')
    print(c)
    print(d)
    
    #输出结果:
    $#$#holle python
    
    holle python
    

    换页符

    1.1 .lstrip() 移除左边空格

    o

    a='   lstrip   '
    print(a.lstrip())
    
    #输出结果:
    lstrip   
    

    八进制数代表的字符

    1.2.rstrip()移除左边空格

    x

    a='   lstrip   '
    print(a.rstrip())
    
    #输出结果:
       lstrip
    

    十六进制数代表的字符

    2、replace(x,y,z)替换字符,传入参数3个,前八个是必传,

    率先个是要替换的原本子字符串,第二个是内需替换的新子字符串,第五个是最大的更迭次数,不填写暗中同意全体轮换

    代表多个空字符

    dstr='我是小明,小明的小明'
    
    print(dstr.replace('小明','小白'))
    
    print(dstr.replace('小明','小白',2))#传入第三个参数,最大替换2次
    
    #输出结果:
    我是小白,小白的小白
    我是小白,小白的小明
    

    \

    3、index()、find() 查找字符串中是或不是带有子字符串并赶回字符串索引地方

    反斜杠

    3.1、index()查找,找到则显得字符串所在的目录地点


    aindex='我的名字叫小明'
    
    print(aindex.index('名'))
    
    #输出结果:
    2
    

    3.2、index()如搜寻的不存在则报错

    aindex='我的名字叫小明'
    
    print(aindex.index('他'))
    
    #输出结果:
    ValueError: substring not found
    

    3.3、find()查找,找到则显得字符串所在的目录地方(暗中同意从右侧开端查找)

    aindex='我的名字叫小x'
    
    print(aindex.find('x'))
    
    #输出结果:
    6
    

    3.4、rfind()从右侧伊始查找,找到则显示字符串所在的目录地方

    aindex='我的名字叫小x'
    
    print(aindex.rfind('x'))
    
    #输出结果:
    6
    

    3.4、 find()与rfind()如搜寻不到则赶回-1

    aindex='我的名字叫小x'
    
    print(aindex.find('s'))
    
    #输出结果:
    -1
    

     


    E、字符串比较

    动用到operator需求导入 :from operator import lt ,le,gt,ge,eq

    lt 相当于: < 、le 相当于:<= 、gt 相当于:> 、ge 相当于:>= 、eq 相当于:==

    *那边例子用到字母比较,从贰16个字母a开头,最开首的a 是小小的的,越现在越大。

    ator='abc'
    btor='hij'
    
    print(lt(ator,btor))
    
    #输出结果:
    True
    
    print(le(ator,btor))
    
    #输出结果:
    True
    
    print(gt(ator,btor))
    
    #输出结果:
    False
    
    print(ge(ator,btor))
    
    #输出结果:
    False
    
    print(eq(ator,btor))
    
    #输出结果:
    False
    

     


    F、字符串字母转换

    1、字母小写转大写 upper()

    abi='abcde'
    
    print(abi.upper())#字母小写转大写
    
    #输出结果:
    ABCDE
    

    2、字母大写转小写 lower()

     

    axi='ABCDE'
    print(abi.lower())#字母大写变小写
    
    #输出结果:
    abcde
    

    3、标题化--首字母大写 title()

    axi='ABCDE'
    
    print(axi.title())#标题化,首字母大写
    
    #输出结果:
    Abcde
    

    4、大小写反转 --- 小写转大写,大写转小写 swapcase()

    abx='aBcdEfGHijKL'
    
    print(abx.swapcase())
    
    #输出结果:
    AbCDeFghIJkl
    

    5、分割字符串并放入二个list()内   ----- .split()

    asp='a b c d e'
    print(asp.split())
    
    #输出结果:
    ['a', 'b', 'c', 'd', 'e']
    

    5.1、.split(',') 分割,字符串并放入一个list()内

    aspb='a,b,c,d,e'
    print(aspb.split())
    
    #输出结果:
    ['a,b,c,d,e']
    

     6、join()拼接字符串

    ajo='abcd'
    bjo='$'.join(ajo)#使用$连接字符串
    
    print(bjo)
    
    #输出结果:
    a$b$c$d
    

    7、字符串对齐 ljust() 、rjust() 、center()

    ajust='python'
    print(ajust.ljust(50,'-'))#向右以-补对齐50
    
    #输出结果:
    python--------------------------------------------
    
    print(ajust.rjust(50,'-'))#向左以-对齐50
    
    #输出结果:
    --------------------------------------------python
    
    print(ajust.center(50,'-'))#以- 50两向中间对齐
    
    #输出结果:
    ----------------------python----------------------
    

    8、剖断字符起先与结尾字符 startswith()、endtswith()

    asta='holle python'
    
    print(asta.startswith('ho'))  #判断以ho开头
    
    #输出结果:
    True
    
    asta='holle python'
    
    print(asta.endswith('on'))  #判断以on结尾
    
    #输出结果:
    True
    

    9、总计字符串中的子字符串出现几次count()

    acou='xi in xi cc bbi dd'
    
    print(acou.count('xi'))#计算 xi 在acou中出现几次
    
    #输出结果:
    2
    

    10、zfill() 重回钦定长度的字符串,原字符串向右对齐,前边以0充。

    ajust='python'
    
    print(ajust.zfill(10)) #返回长度为10的字符串,向右对齐以0填充
    
    #输出结果:
    000000000python
    

     

     

    #其它Python 的字符串常用内建函数点击查阅》》》》》》》》》》

     

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:新葡亰496net自兴人工智能,python之字符串

    关键词:

上一篇:没有了

下一篇:没有了