zoukankan      html  css  js  c++  java

  • Python_Day_02 str内部方法总结

    刚开始学习Python，看了一天的字符串内部方法，现在来总结一下。

    •  capitalize(self) 将一句话的首字母变大写,其他字母都变小
    1 name = "love PyThon"
2 # capitalize(self)
3 result1 = name.capitalize() #将一句话的首字母变大写,其他字母都变小
4 print('result1:%s'%result1)

    打印结果：

    1 result1:Love python
    •  casefold(self) 官方解释比较霸道,确实是比较霸道,所有的字母都变成小写,不过好像用的不多
    1 # casefold(self)
2 name = 'HELLo Python My Name IS RookieJX'
3 result2 = name.casefold()
4 print('result2:%s'%result2)

    　　打印结果：

    1 result2:hello python my name is rookiejx
    •  center(self, width, fillchar=None) 这个是将原字符串居中,如果self长度小于width，那么多余的部分就用 fillchar 字符填充并,默认为空格，如果多余的是奇数，那么最后多余的一个就填充到左边。其中fillchar只能为单个字符。
    1 # center(self, width, fillchar=None)
2 name = 'Python'
3 result3 = name.center(9,"H") 
4 print('result3:%s'%result3)

    　　打印结果：

    1 result3:HHPythonH
    •  count(self, sub, start=None, end=None) 查询某个字符或者字符串在self中出现的次数，默认是在整个self上查询，也可以自定义位置
    1 # count(self, sub, start=None, end=None)
2 name = 'Hello Python'
3 result4 = name.count("lo",0,40)
4 print('result4:%s'%result4)

    　　打印结果：

    1 result4:1
    • encode(self, encoding='utf-8', errors='strict') 编码为utf-8格式编码,如果出错使用严格,其他还有'ignore', 'replace' 等
    1 # encode(self, encoding='utf-8', errors='strict')
2 name = 'Hello Python'
3 result5 = name.encode('utf-8','strict') 
4 print('result5:%s'%result5)

    　　打印结果：

    1 result5:b'Hello Python'
    •  endswith(self, suffix, start=None, end=None) 以什么为结束,默认是整个字符串,可以自己选择长度
    1 # endswith(self, suffix, start=None, end=None)
2 name = 'Hello Python'
3 result6 = name.endswith('o',0,3) 
4 print('result6:%s'%result6)

    　　打印结果：

    1 result6:False
    •  expandtabs(self, tabsize=8) 将字符串中所有的tab键转换成空格键,默认为8
    1 # expandtabs(self, tabsize=8)
2 result7 = 'hate	Python'
3 print('origin result7:%s'%result7)
4 result8 = result7.expandtabs() #将字符串中所有的tab键转换成空格键,默认为8
5 print('result8:%s'%result8)
6 result9 = result7.expandtabs(20) #更改默认值
7 print('result9:%s'%result9)

    　　打印结果：

    1 origin result7:hate    Python
2 result8:hate    Python
3 result9:hate                Python
    •  find(self, sub, start=None, end=None) 查找某个字符或者字符串在字符串中的下标,默认为查找全部字符串
    1 # find(self, sub, start=None, end=None)
2 name = 'Hello Python'
3 result10 = name.find('P') #查找某个字符或者字符串在字符串中的下标,默认为查找全部字符串
4 print('result10:%s'%result10)
5 result11 = name.find('P',0,4) #可以自定义查找范围,如果没有就返回 -1
6 print('result11:%s'%result11)

    　　打印结果：

    1 result10:6
2 result11:-1
    •  format(*args, **kwargs) 好像很暴力的样子,格式化字符串,有很多用法
     1 # format(*args, **kwargs)
 2 # 好像很暴力的样子,格式化字符串,有很多用法
 3 # 1.可以使用 {} 用作占位符 这里分割的时候需要使用 . 不是用 , 这点需要注意
 4 print('I am {},I {} '.format('rookieJX','Love Python'))
 5 # 2.也可以使用 {0} {1}等样式的占位符
 6 print('I am {1},I {0}'.format('Love Python','rookieJX'))
 7 # 3.还可以使用变量形式的占位符
 8 print('My job is {job}'.format(job = 'IT'))
 9 # 4.还可以混合使用
10 print('I am {1},My job is {job}'.format('haha','rookieJX',job = 'IT'))

    　　打印结果：

    1 I am rookieJX,I Love Python 
2 I am rookieJX,I Love Python
3 My job is IT
4 I am rookieJX,My job is IT
    •  format_map(self, mapping) 暂时了解的还不多
    •  index(self, sub, start=None, end=None) 类似于find方法,但是当要查找的字符串不在查找的字符串中的话会报错
    1 # index(self, sub, start=None, end=None)
2 name = 'Hello Python'
3 result12 = name.index('P') # 类似于find方法,但是当要查找的字符串不在查找的字符串中的话会报错
4 print('result12:%s'%result12)
5 result13 = name.index('P',0,10) # 还可以自定义限制查找的范围
6 print('result13:%s'%result13)

    　　打印结果：

    1 result12:6
2 result13:6
    •  isalnum(self) 字符串中至少有一个字符,并且所有的字符都是字母或者数字返回为True 否则返回为 False (空格也返回False)
    1 # isalnum(self)
2 name = 'Hello Python'
3 result14 = name.isalnum() # 字符串中至少有一个字符,并且所有的字符都是字母或者数字返回为True 否则返回为 False (空格也返回False)
4 print('result14:%s'%result14)

    　　打印结果：

    1 result14:False
    •  isalpha(self) 字符串中至少有一个是字符,并且所有的字符都是字母返回为 True 否则返回为 False (空格也返回False)
    1 # isalpha(self)
2 name = 'Hello Python'
3 result15 = name.isalpha()
4 print('result15:%s'%result15) # 字符串中至少有一个是字符,并且所有的字符都是字母返回为 True 否则返回为 False (空格也返回False)

    　　打印结果：

    1 result15:False
    •  isdecimal(self) 判断字符串是否是十进制整数,如果不是返回为 False ,如果不是字符串就会报错
    1 # isdecimal(self)
2 namedeclimal = "324.2" # 判断字符串是否是十进制整数,如果不是返回为 False ,如果不是字符串就会报错
3 result16 = namedeclimal.isdecimal()
4 print('result16:%s'%result16)

    　　打印结果：

    1 result16:False
    •  isdigit(self) 判断字符串中是否只包含数字
    1 # isdigit(self)
2 namedeclimal = "324.2"
3 result17 = namedeclimal.isdigit() # 判断字符串中是否只包含数字
4 print('result17:%s'%result17)

    　　打印结果：

    1 result17:False
    •  isidentifier(self) 判断字符串是否是关键字
    1 # isidentifier(self)
2 result18 = 'str'.isidentifier() # 判断字符串是否是关键字
3 print('result18:%s'%result18)

    　　打印结果：

    1 result18:True
    •  islower(self) 字符串中至少有一个字符,字符全部为小写就返回 True
    1 # islower(self)
2 name = 'Hello Python'
3 result19 = name.islower() # 字符串中至少有一个字符,字符全部为小写就返回 True
4 print('result19:%s'%result19)

    　　打印结果：

    1 result19:False
    •  isnumeric(self) 字符串中如果全部都是数字字符返回 True 貌似跟 isdecimal 差不多,暂时还没有发现有什么不同的用法
    1 # isnumeric(self)
2 result20 = '4232'.isnumeric() # 字符串中如果全部都是数字字符返回 True 貌似跟 isdecimal 差不多,暂时还没有发现有什么不同的用法
3 print('result20:%s'%result20)

    　　打印结果：

    1 result20:True
    •  isprintable(self) 判断字符串中所有字符是否是可见状态
    1 # isprintable(self)
2 result21 = 'IaPython'.isprintable() # 判断字符串中所有字符是否是可见状态
3 print('result20:%s'%result21)

    　　打印结果：

    1 result20:False
    •  isspace(self) 字符串中如果只至少有一个字符,并且全部为空格时 返回为True
    1 # isspace(self)
2 result22 = '   '.isspace() # 字符串中如果只至少有一个字符,并且全部为空格时 返回为True
3 print('result22:%s'%result22)

    　　打印结果：

    1 result22:True
    •  istitle(self) 字符串是否为标题格式 就是每个单词首字母都是大写
    1 # istitle(self)
2 result23 = 'This Is Python'.istitle() # 字符串是否为标题格式 就是每个单词首字母都是大写
3 print('result23:%s'%result23)

    　　打印结果：

    1 result23:True
    •  isupper(self) 字符串至少有一个字符 判断字符是否是大写 如果是大写就返回 True (只会判断其中的英文字符,特殊符号,数字不会判断)
    1 # isupper(self)
2 result24 = 'NAME.803'.isupper() # 字符串至少有一个字符 判断字符是否是大写 如果是大写就返回 True (只会判断其中的英文字符,特殊符号,数字不会判断)
3 print('result24:%s'%result24)

    　　打印结果：

    1 result24:True
    •  join(self, iterable) 将self字符串用iterable打散,每个两个字符串之间插入 iterable 字符串
    1 # join(self, iterable)
2 name = 'Hello Python'
3 result25 = name.join('Hello World') # 将iterable字符串打散,每个两个字符串之间插入 string 字符串
4 print('result25:%s'%result25)

    　　打印结果：

    1 result25:HHello PythoneHello PythonlHello PythonlHello PythonoHello Python Hello PythonWHello PythonoHello PythonrHello PythonlHello Pythond
    •  ljust(self, width, fillchar=None) 原字符串左对齐,总字符串长度为自定义长度,右边填充字符 默认为空格 如果定义长度小于元字符串长度,则不会进行操作
    1 # ljust(self, width, fillchar=None)
2 name = 'Hello Python'
3 result26 = name.ljust(23,'H') # 原字符串左对齐,总字符串长度为自定义长度,右边填充字符 默认为空格 如果定义长度小于元字符串长度,则不会进行操作
4 print('result26:%s'%result26)

    　　打印结果：

    1 result26:Hello PythonHHHHHHHHHHH
    •  lower(self) 拷贝一份原有的字符串,并将之变为小写 貌似跟casefold效果一样的
    1 # lower(self)
2 name = 'Hello Python'
3 result27 = name.lower() # 拷贝一份原有的字符串,并将之变为小写 貌似跟casefold效果一样的
4 print('result27:%s'%result27)

    　　打印结果：

    1 result27:hello python
    •  lstrip(self, chars=None) 默认截掉字符串左边的空格,如果自定义字符,那么字符必须是从字符串的开始才能截取成功
    1 # lstrip(self, chars=None)
2 result28 = '   Hello'.lstrip() # 默认截掉字符串左边的空格,如果自定义字符,那么字符必须是从字符串的开始才能截取成功
3 print('result28:%s'%result28)
4 
5 result29 = 'Hello'.lstrip('H') # 默认截掉字符串左边的空格,如果自定义字符,那么字符必须是从字符串的开始才能截取成功
6 print('result29:%s'%result29)

    　　打印结果：

    1 result28:Hello
2 result29:ello
    •  maketrans(self, *args, **kwargs) 构建替换映射表,首先构建映射对应表格,映射前为intab,映射后为outtab.然后构建对应表格maketrans,最后开始转换
    1 # maketrans(self, *args, **kwargs)
2 intab = "aeiou"
3 outtab = "12398"
4 intro = "hello python in my heart"
5 result29 = str.maketrans(intab,outtab)
6 result30 = intro.translate(result29) # 构建替换映射表,首先构建映射对应表格,映射前为intab,映射后为outtab.然后构建对应表格maketrans,最后开始转换
7 print('intro:%s'%result30)

    　　打印结果：

    1 intro:h2ll9 pyth9n 3n my h21rt
    •  partition(self, sep) 根据指定字符串来分割原字符串,如果原字符串存在指定字符串,结果为 分割左边原字符串,指定字符串,分割后右字符串...如果不存在指定字符串则返回原字符串,只会分割出现的第一个位置
    1 # partition(self, sep)
2 test = 'Hello Python , Hello Python ,Hello World'
3 result31 = test.partition('P') # 根据指定字符串来分割原字符串,如果原字符串存在指定字符串,结果为 分割左边原字符串,指定字符串,分割后右字符串...如果不存在指定字符串则返回原字符串,只会分割出现的第一个位置
4 print('result31:',result31)

    　　打印结果：

    1 result31: ('Hello ', 'P', 'ython , Hello Python ,Hello World')
    •  replace(self, old, new, count=None) 替换字符串.最大不超过多少次
    1 # replace(self, old, new, count=None)
2 result32 = 'love python love python love python love python love python '.replace('love','hate',3) # 替换字符串.最大不超过多少次
3 print('result32:%s'%result32)

    　　打印结果：

    1 result32:hate python hate python hate python love python love python
    •  rfind(self, sub, start=None, end=None) 查找指定字符串在原字符串中最右边的位置,默认为整个字符串
    1 # rfind(self, sub, start=None, end=None)
2 result33 = 'love python love '.rfind('lo') # 查找指定字符串在原字符串中最右边的位置,默认为整个字符串
3 print('result33:%s'%result33)

    　　打印结果：

    1 result33:12
    •  rindex(self, sub, start=None, end=None) 查找指定字符串在原字符串中最右边的位置,默认为整个字符串,跟rfind效果差不多,但是如果找不到就会报错
    1 # rindex(self, sub, start=None, end=None)
2 result34 = 'love python love '.rindex('lo') # 查找指定字符串在原字符串中最右边的位置,默认为整个字符串,跟rfind效果差不多,但是如果找不到就会报错
3 print('result34:%s'%result34)

    　　打印结果：

    1 result34:12
    •  rjust(self, width, fillchar=None) 返回一个右边对其的原字符串,默认用空格对其,可以自定义字符,但是如果是自定义字符串的话,那么自定义的字符串必须能被多余的空格整除,否则就会报错
    1 # rjust(self, width, fillchar=None)
2 name = "love PyThon"
3 result35 = name.rjust(50,'O') # 返回一个右边对其的原字符串,默认用空格对其,可以自定义字符,但是如果是自定义字符串的话,那么自定义的字符串必须能被多余的空格整除,否则就会报错
4 print('result35:%s'%result35)

    　　打印结果：

    1 result35:OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOlove PyThon
    •  rpartition(self, sep) 类似于partition 只不过是从右边开始查找
    1 # rpartition(self, sep)
2 test2 = 'Hello Python ,Hello Python , Hello WoPrld'
3 result36 = test2.rpartition('P') # 类似于partition 只不过是从右边开始查找
4 print('result36:',result36)

    　　打印结果：

    1 result36: ('Hello Python ,Hello Python , Hello Wo', 'P', 'rld')
    •  split(self, sep=None, maxsplit=-1) 根据指定字符串来分割字符串,如果指定最大分割字符串,那么久分割指定次数,如果不指定默认为-1也就是最大
    1 # split(self, sep=None, maxsplit=-1)
2 test3 = 'Hello Python ,Hello Python , Hello WoPrld'
3 result37 = test3.split('P',2) # 根据指定字符串来分割字符串,如果指定最大分割字符串,那么久分割指定次数,如果不指定默认为-1也就是最大
4 print('result37:',result37)

    　　打印结果：

    1 result37: ['Hello ', 'ython ,Hello ', 'ython , Hello WoPrld']
    •  splitlines(self, keepends=None) 按照行(' ', ' ', ')分隔,返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符.默认为False
    1 # splitlines(self, keepends=None)
2 test4 = 'Hello
 Pyth
on ,Hel
lo Python , Hello WoPrld'
3 result38 = test4.splitlines(True) # 按照行('
', '
', 
')分隔,返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符.默认为False
4 print('result38:',result38)

    　　打印结果：

    1 result38: ['Hello
', ' Pyth
', 'on ,Hel
', 'lo Python , Hello WoPrld']
    •  startswith(self, prefix, start=None, end=None) 查看是否 以指定字符串为开头 并可以指定范围
    1 # startswith(self, prefix, start=None, end=None)
2 test5 = 'Hello
 Pyth
on ,Hel
lo Python , Hello WoPrld'
3 result39 = test5.startswith('ell',0,30) # 查看是否 以指定字符串为开头 并可以指定范围
4 print('result39:',result39)

    　　打印结果：

    1 result39: False
    •  strip(self, chars=None) 对字符串执行 去掉左右两边的空格,默认为取消空格,可以设置为指定字符
    1 # strip(self, chars=None)
2 test6 = 'H    Hello Python ,Hello Python , Hello WoPrld    H'
3 result40 = test6.strip('H') # 对字符串执行 去掉左右两边的空格,默认为取消空格,可以设置为指定字符
4 print('result40:',result40)

    　　打印结果：

    1 result40:     Hello Python ,Hello Python , Hello WoPrld
    •  swapcase(self) 翻转字符串中的大小写
    1 # swapcase(self)
2 test7 = 'H    Hello Python ,Hello Python , Hello WoPrld    H'
3 result41 = test7.swapcase() # 翻转字符串中的大小写
4 print('result41:',result41)

    　　打印结果：

    1 result41: h    hELLO pYTHON ,hELLO pYTHON , hELLO wOpRLD    h
    •  title(self) 将字符串中每个单词首字母置为大写
    1 # title(self)
2 test8 = 'H    hello python ,hello python , hello woPrld    H'
3 result42 = test8.title() # 将字符串中每个单词首字母置为大写
4 print('result42:',result42)

    　　打印结果：

    1 result42: H    Hello Python ,Hello Python , Hello Woprld    H
    •  translate(self, table)  与maketrans(self, *args, **kwargs)配合使用 
    •  upper(self) 将字符串改变为大写
    1 # upper(self)
2 test9 = 'H    hello python ,hello python , hello woPrld    H'
3 result43 = test9.upper() # 将字符串改变为大写
4 print('result43:',result43)

    　　打印结果：

    1 result43: H    HELLO PYTHON ,HELLO PYTHON , HELLO WOPRLD    H
    •   zfill(self, width) 右边对齐,左边填充数字0,长度为自定义
    1 # zfill(self, width)
2 test10 = 'H    hello python ,hello python , hello woPrld    H'
3 result44 = test10.zfill(70) # 右边对齐,左边填充数字0,长度为自定义
4 print('result44:',result44)

    　　打印结果：

    1 result44: 0000000000000000000H    hello python ,hello python , hello woPrld    H
    • 暂未符号
    myString = 'Python'
number = 1
print('%s is best! is %d'%(myString,number))

    　　打印结果

    Python is best! is 1
  • 相关阅读:
    prototype.js超强的javascript类库
    MySQL Server Architecture
    Know more about RBA redo block address
    MySQL无处不在
    利用Oracle Enterprise Manager Cloud Control 12c创建DataGuard Standby
    LAMP Stack
    9i中DG remote archive可能导致Primary Database挂起
    Oracle数据库升级与补丁
    Oracle为何会发生归档日志archivelog大小远小于联机重做日志online redo log size的情况？
    Oracle Ksplice如何工作？How does Ksplice work?
  • 原文地址：https://www.cnblogs.com/wang-com/p/5836104.html
Copyright © 2011-2022 走看看