码迷,mamicode.com
首页 > 编程语言 > 详细

Python_Day_02 str内部方法总结

时间:2016-09-03 19:46:56      阅读:253      评论:0      收藏:0      [点我收藏+]

标签:

刚开始学习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:bHello 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\tPython
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 = I\aPython.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) 按照行(‘\r‘, ‘\r\n‘, \n‘)分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符.默认为False
1 # splitlines(self, keepends=None)
2 test4 = Hello\r Pyth\non ,Hel\r\nlo Python , Hello WoPrld
3 result38 = test4.splitlines(True) # 按照行(‘\r‘, ‘\r\n‘, \n‘)分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符.默认为False
4 print(result38:,result38)

  打印结果:

1 result38: [Hello\r,  Pyth\n, on ,Hel\r\n, lo Python , Hello WoPrld]

 

  •  startswith(self, prefix, start=None, end=None) 查看是否 以指定字符串为开头 并可以指定范围
1 # startswith(self, prefix, start=None, end=None)
2 test5 = Hello\r Pyth\non ,Hel\r\nlo 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

 

Python_Day_02 str内部方法总结

标签:

原文地址:http://www.cnblogs.com/wang-com/p/5836104.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!