修炼Python基础篇-字符串（str）学习

字符串是Python中最常用的数量类型，我们可以使用单引号或双引号创建字符串；

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

1. 访问字符串中的值，也可以使用方括号来截取字符串中的值；

   1. a ="This is String!"
   2. print(a,a[1])
   3. ThisisString! h

    

2. 更新字符串中的值；

   1. a ="Hello World!"
   2. print(a[:6]+'Saviorsyang')
   3. HelloSaviorsyang

    

3. 字符串运算符之连接；

   1. a ='Hello '
   2. b ='World!'
   3. print(a+b)
   4. HelloWorld!

    

4. 字符串运算符之重复；

   1. a ='Hello '
   2. print(a*4)
   3. HelloHelloHelloHello

    

5. 字符串运算符之索引；

   1. a ='Hello World'
   2. print(a[0])
   3. H

    

6. 字符串运算符之截取；

   1. a ='Hello World'
   2. print(a[0:5])
   3. Hello
   4. print(a[:-1])
   5. HelloWorl
   6. print(a[:5])
   7. Hello
   8. print(a[:-5])
   9. Hello

    

7. 字符串运算符之in；

   1. a ='Hello World'
   2. print('l'in a)
   3. True
   4. print('x'in a)
   5. False

    

8. 字符串运算符之not in；

   1. a ='Hello World'
   2. print('l'notin a)
   3. False
   4. print('x'notin a)
   5. True

    

9. 字符串格式化之%s，格式化字符串；

   1. print("My Name is %s!!"%("Saviorsyang"))
   2. MyNameisSaviorsyang!!

    

10. 字符串格式化之%d，格式化整数；

    1. print("My Age %s!!"%('25'))
    2. MyAge25!!

     

11. 字符串格式化之%f，格式化浮点数，%2.f,保留小数点后2位；

    1. print("harry weight %f kg, tom weight '%.2f'kg。。"%(56.445,45.33))
    2. harry weight 56.445000 kg, tom weight '45.33'kg。。capitalize

12. capitalize：将第一个字符串大写；

    1. a ="hello world"
    2. print(a.capitalize())
    3. Hello world

     

13. casefold：将所有字符串小写；

    1. a ="HELLO WORLD"
    2. print(a.casefold())
    3. hello world

     

14.  

    center：返回一个原字符串居中，并使用*填充至长度的新字符串，默认使用空格填充；
    1. a ="HELLO WORLD"
    2. print(a.center(40,'*'))
    3. **************HELLO WORLD***************
    4. print(a.center(40))
    5. HELLO WORLD

     

15. count：统计某个字符串出现的次数；

    1. a ="HELLO WORLD"
    2. print(a.count('L'))
    3. 3

     

16. encode：

    1. a ="HELLO WORLD"
    2. print(a.encode('gbk'))#以gbk编码对unicode对像进行编码
    3. b'HELLO WORLD'
    4. print(a.encode('utf-8'))#以utf-8编码对unicode对像进行编码
    5. b'HELLO WORLD'

     

17. endswith：判断字符串是否以指定的后缀结尾，如果以指定的后缀结尾返回True，否则返回False；

    1. a ="HELLO WORLD"
    2. print(a.endswith('LD',0,15))
    3. True
    4. print(a.endswith('LD'))
    5. True
    6. print(a.endswith('LD',-1))
    7. False

     

18. expandtabs：把字符串中的tab符号转为空格，默认8个空格；

    1. name ='h\tarry'
    2. print(name)
    3. h arry
    4. print(name.expandtabs())
    5. h arry
    6. print(name.expandtabs(16))
    7. h arry

     

19. find：打印出在string中找到第一个匹配字符串值的索引位置；

    1. a ="HELLO WORLD"
    2. print(a.find('L'))
    3. 2
    4. print(a.find('L',1,5))
    5. 2
    6. print(a.find('L',2))
    7. 2

     

20. format：

    1. a ="Harry {0} as {1}!"
    2. print(a.format('BT','SB'))
    3. Harry BT as SB!
    4. a ="Harry {id1} as {id2}!"
    5. print(a.format(id1='BT',id2='SB'))
    6. Harry BT as SB!
     

     

21. index：检测字符串中是否包含字符串str，如果指定开始和结束范围，则检查是否包含在指定范围内，在则显示索引位置，否则报一个异常；

    1. a ="harry"
    2. print(a.index('y'))
    3. 4
    4. print(a.index('y',4))
    5. 4

     

22. isalnum：如果string至少有一个字符并且所有字符都是字母或数字则返回True，否则返回False；

    1. a ="20170116Student"
    2. print(a.isalnum())
    3. True
    4. a ="20170116 Student"
    5. print(a.isalnum())
    6. False

     

23. isalpha：如果string至少有一个字符并且所有字符都是字母则返回True，否则返回False；

    1. a ="20170116Student"
    2. print(a.isalpha())
    3. False
    4. a ="Student"
    5. print(a.isalpha())
    6. True

     

24. isdecimal：如果string至少有一个字符并且所有字符都是十进制字符则返回True，否则返回False；

    1. a ="20170116Student"
    2. print(a.isdecimal())
    3. False
    4. a ="20170116"
    5. print(a.isdecimal())
    6. True

     

25. isdigit：如果string至少有一个字符并且所有字符都是数字则返回True，否则返回False；

    1. a ="20170116Student"
    2. print(a.isdigit())
    3. False
    4. a ="20170116"
    5. print(a.isdigit())
    6. True

     

26. islower：判断所有字符是不是小写，是则True,否则False；；

    1. a ="Student"
    2. print(a.islower())
    3. False
    4. a ="student"
    5. print(a.islower())
    6. True

     

27. isnumeric：如果string中只包含数字字符则返回True,否则返回False；

    1. a ="20170116Student"
    2. print(a.isnumeric())
    3. False
    4. a ="20170116"
    5. print(a.isnumeric())
    6. True

     

28. isspace：如果string中只包含空格则返回True,否则返回False；

    1. a ="20170116 Student"
    2. print(a.isspace())
    3. False
    4. a =" "
    5. print(a.isspace())
    6. True

     

29. isupper：判断所有字符是不是大写，是则True,否则False；

    1. a ="Student"
    2. print(a.isupper())
    3. False
    4. a ="STUDENT"
    5. print(a.isupper())
    6. True

     

30. join：将序列中的元素以指定的字符连接生成一个新的字符串；

    1. a ="_"
    2. b =('a','b','c')
    3. print(a.join(b))
    4. a_b_c

     

31. ljust：返回一个原字符串左对齐，并使用*填充至指定长度的新字符串，默认使用空格填充；

    1. a ="this is test ljust..."
    2. print(a.ljust(50,'*'))
    3. this is test ljust...*****************************

     

32. lower：转换所有大写字母为小写；

    1. a ="STUDENT"
    2. print(a.lower())
    3. student

     

33. lstrip：去除左边的空格；

    1. a =" Student Python"
    2. print(a)
    3. StudentPython
    4. print(a.lstrip())
    5. StudentPython

     

34. maketrans：创建字符串映射的转换表，接受两个参数的最简单调用方式，第一参数是字符串，表示需要转换的字符，第二个参数也是字符串，表示转换的目标，配合translate使用；

35. translate：字符串的一一映射，每个字符只要出现都会被替换为对应的字符；

    1. a ="Hello Wolrd!"
    2. b = a.maketrans('l','L')
    3. a.translate(b)
    4. 'HeLLo WoLrd!'
    5. a ="Hello Wolrd!"
    6. b = a.maketrans('eordl','EORDL')
    7. a.translate(b)
    8. 'HELLO WOLRD!'

     

36. partition：根据指定的分隔符将字符串进行分割，如果字符串包含指定的分隔符，则返回一个三元的元组，第一个为分隔符左边的字串，第二个为分隔符本身，第三个为分隔符右边的字串；

    1. a ="http://www.baidu.com"
    2. print(a.partition('://'))
    3. ('http','://','www.baidu.com')

     

37. replace：字符串替换，字符串完整出现后被整体替换，replace的两个字符串参数长度可以不同，如果指定替换次数，则不超过替换次数；

    1. a ="Hello Wolrd!"
    2. print(a.replace('l',"L"))
    3. HeLLoWoLrd!
    4. print(a.replace('l',"L",2))
    5. HeLLoWolrd!

     

38. rfind：从右边开始查找，如果没有匹配的值则返回-1；

    1. a ="Hello Wolrd!"
    2. print(a.rfind('l'))
    3. 8
    4. print(a.rfind('l',0,3))
    5. 2
    6. print(a.rfind('l',0,1))
    7. -1

     

39. rindex：从右边开始查找str在字符串中出现的位置，可以指定查找的区域，如果没有匹配则报错误；

    1. a ="Hello Wolrd!"
    2. print(a.rindex('l'))
    3. 8
    4. print(a.rindex('l',0,3))
    5. 2
    6. print(a.rindex('l',0,1))
    7. Traceback(most recent call last):
    8. File"<input>", line 1,in<module>
    9. ValueError: substring not found

     

40. rjust：返回一个原字符串右对齐，并使用*填充至指定长度的新字符串，默认使用空格填充；

    1. a ="Hello Wolrd!"
    2. print(a.rjust(20,'*'))
    3. ********HelloWolrd!
    4. print(a.rjust(20))
    5. HelloWolrd!

     

41. rpartition：根据指定的分隔符将字符串从右边进行分割，如果字符串包含指定的分隔符，则返回一个三元的元组，第一个为分隔符左边的字串，第二个为分隔符本身，第三个为分隔符右边的字串；

    1. a ="www.qq.com"
    2. print(a.rpartition('.'))
    3. ('www.qq','.','com')

     

42. rsplit：通过指定的分隔符对字符串从右边开始进行切片，默认为所有的空字符，包括空格、换行、制表符等；

    1. a ="Hello Wolrd !!!"
    2. print(a.rsplit())
    3. ['Hello','Wolrd','!!!']
    4. print(a.rsplit(' ',1))
    5. ['Hello Wolrd','!!!']

43. rstrip：去除右边的空格；

    1. a ="Hello Wolrd!!! "
    2. print(a.rstrip())
    3. HelloWolrd!!!

44. split：通过指定的分隔符对字符串进行切片，默认为所有的空字符，包括空格、换行、制表符等；

    1. a ="Hello Wolrd !!!"
    2. print(a.split())
    3. ['Hello','Wolrd','!!!']
    4. print(a.split(' ',1))
    5. ['Hello','Wolrd !!!']

45. splitlines：按行分割字符串，返回值也是一个列表。默认splitelines参数keepend为False，不保留每行结尾的\n，反之则保留；

    1. a ='a b\n \n de fg \rk1 \r\n'
    2. print(a)
    3. a b
    5. de fg
    6. k1
    7. print(a.splitlines())
    8. ['a b',' ',' de fg ','k1 ']
    9. print(a.splitlines(True))
    10. ['a b\n',' \n',' de fg \r','k1 \r\n']

46. startswith：判断字符串是否以指定的前缀结尾，如果以指定的前缀结尾返回True，否则返回False；

    1. a="Hello world!"
    2. print(a.startswith('H'))
    3. True
    4. print(a.startswith('j'))
    5. False

47. strip：去除左右两边的空格；

    1. a=" Hello world! "
    2. print(a.strip())
    3. Hello world!

48. swapcase：翻转大小写字母；

    1. a ="Hello World!"
    2. print(a.swapcase())
    3. hELLO wORLD!

49. title：所有单子的首字母大写；

    1. a ="hello world"
    2. print(a.title())
    3. HelloWorld

50. upper：将所有小写字母转换为大写字母；

    1. a ="hello world"
    2. print(a.upper())
    3. HELLO WORLD

51. zfill：指定长度的字符串，原字符串靠右，填充0；

    1. a ="Hello World!"
    2. print(a.zfill(15))
    3. 000HelloWorld!
    4. print(a.zfill(20))
    5. 00000000HelloWorld!