Python学习（四）数据结构 —— str

Python 字符串 str

　　　　本章大致介绍了 Python 的字符串类型 str，包括字符串的赋值及转义、字符串运算符、字符串格式化输出 以及 一些字符串的内建函数等。

字符串赋值及转义

　　　　我们可以使用引号来创建字符串（单引号、双引号）

　　　　字符串需要使用特殊字符时，python用反斜杠(\)转义字符，注意引号和换行

 s1 = "Hello \"World\""            # 可用""  注意引号的转义
 s2 = 'Welcome to Fees\'s land'    # 也可用''  注意引号的转义
 print(s1)
 print(s2)
 print("a\n    b")                 # \n表示换行 注意空格保留

字符串运算符

　　　　字符串在python中的使用很方便，简单介绍如下几个：

　　　　　in； not in  简单判断字符串是否包含字符

 s = "python study"
 print("p" in s)                    # 若字符包含在字符串中，返回True
 print("p" not in s)                # 字符不包含在字符串中，返回True
 print("tho" in s)                  # 多字符寻找
 print("P" in s)                    # 区分大小写
 print("n s" in s)                  # 注意空格
 print("n  s" in s)                 # 返回False

　　　　字符串拼接、重复输出

 print('p'+'y'+'t'+'h'+'o'+'n')      # + 做字符串的拼接
 print("p"*5)                        # * 做字符串重复输出
 print(3*"hi ")                      # 注意空格，字符串最后一个字符仍为空格

　　　　取出字符串的某个字符

 s = "abc de"
 print(s[0])                        # 从0开始计算
 print(s[3])                        # 空格
 # print(s[6])                      # 会报错 out of range

　　　　取出部分字符，可设置截取起始及截止，可设置步长，步长可设置为负数，表示反向截取；具体参考下例来理解

 s = ""
 print(s[0:0])
 print(s[0:1])
 print(s[0:2])
 print(s[0:6:2])                    # 从下标为0的字符 隔2个
 print(s[0:7:2])
 print(s[3:0:-1])                   # 反向输出
 print(s[3:2:-1])
 print(s[7:0:-2])                   # 反向输出,从下标为7的字符开始
 print(s[6:0:-2])
 print(s[::-1])                     # 反向输出全部

　　　　输出字符串长度  len(s)

 s = "python study"                    # 空格为一个字符
 print(len(s))
 print(len("   "))                     # 3个空格 返回3
 print(len("python\nstudy"))           # 换行符为一个字符

字符串格式化输出

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

　　　　在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。详细参考 python字符串相关参考

 name = "fee"
 age = 18
 print("My name is %s, I'm %d year old." %(name,age))                # 老的表示方法 均可使用
 print('The value of PI is approximately %.3f.' %(3.1415926))        # 表示取小数点后三位

　　　　另外，可用 str.format() 函数来格式化输出；字符串的format函数可以接受的参数个数不限，位置可以不按顺序，可以不用或者用多次，不过2.6不能为空{}，2.7才可以。

　　　　通过 str.format() 可以将list、tuple、dict 传值，比较灵活；通过对象定位输出也比较方便，且不易出错（class 的例子看不懂可看完 class 对象后再来看）

 name = "fee"
 age = 18
 print("My name is {}, I'm {} year old.".format(name,age))                    # 2.6后出现的方法 str.format() ；2.6不能为 {},2.7 可以
 print("My name is {1}, I'm {0} year old.".format(age,name))                    # {0}对应age；{1}对应name
 print("My name is {name}, I'm {age} year old.".format(name="fei",age=20))    # 关键字参数可自定义
 print("My name is {name}, I'm {age} year old.".format(name=name,age=age))    # 关键字跟变量是不同的

 class User():                             # 构造对象
     def __init__(self,name,age):
         self.name=name
         self.age=age
     def print_name(self):
         print("My name is {self.name}.\nI'm {self.age} year old.".format(self=self))    # 通过对象属性可准确定位输出
 user1 = User("Fee",18)                    # 对象实例
 user1.print_name()                        # 调用对象方法

字符串内建函数

　　　　仅列出常用函数。详细参考 python字符串相关参考

　　　　str.lower()    str.upper()    str.capitalize()       str.title()

 s = "Python STUDY"
 s.lower()                # Return a copy of the string with all the cased characters [4] converted to lowercase.
 print(s)                 # 不改变s本身
 print(s.lower())
 print(s.upper())         # Return a copy of the string with all the cased characters converted to uppercase.
 print(s.capitalize())    # Return a copy of the string with its first character capitalized and the rest lowercased.
 print(s.title())         # Return a titlecased version of the string where words start with an uppercase character and the remaining characters are lowercase.
 print(s.swapcase())      # Return a copy of the string with uppercase characters converted to lowercase and vice versa. 

　　　　str.isalnum()    str.isalpha()    str.isdigit()    str.isspace()    str.islower()    str.isupper()    str.istitle()

 a = ""
 b = "abc"
 c = "abc012"
 d = "Abc012"
 e = "ABC012"
 f = ""
 g = "      "
 h = "Python Study"
 i = "It's funny."
 print(c.isalnum(),b.isalnum(),f.isalnum())        # 是否全是字母和数字，并至少有一个字符
 print(b.isalpha(),c.isalpha(),f.isalpha())        # 是否全是字母，并至少有一个字符
 print(a.isdigit(),c.isdigit(),f.isdigit())        # 是否全是数字，并至少有一个字符
 print(b.islower(),c.islower(),f.islower())        # str中的字母是否全是小写
 print(e.isupper(),d.islower(),f.islower())        # str中的字母是否全是大写
 print(h.istitle(),i.istitle(),f.istitle())        # str是否是首字母大写的，指的是每个单词首字母大写
 print(g.isspace(),a.isspace(),f.isspace())        # 是否全是空白字符，并至少有一个字符

　　　　str.startwith(prefix[,start[,end]])        str.endwith(suffix[,start[,end]])

 s = "Python Study"
 print(s.startswith("Py"),s.startswith("py"),s.startswith("St",7))     # str.startwith(prefix[,start[,end]]) 是否以prefix开头; 注意大小写、空格
 print(s.endswith("dy"),s.endswith(" dy"),s.endswith("Python",0,6))    # str.endwith(suffix[,start[,end]]) 是否以suffix结尾

　　　　str.index(sub[, start[, end]])       str.rindex(sub[, start[, end]])

　　　　str.find(sub[, start[, end]])         str.rfind(sub[, start[, end]])

　　　　　　str.index 和 str.find 的区别是，index 找不到会报错；find 找不到返回-1

 s = "abbccaacad"
 print(s.index("a"))             # 输出第一次出现"a"的下标
 print(s.index("aa"))            # 输出第一次出现"aa"的下标
 print(s.index("a",6,9))         # 从下标6算起，输出第一次出现"a"的下标
 print(s.rindex("a"))            # 从结尾开始搜索
 # print(s.index("aaa"))         # 找不到会报错
 # print(s.index("a",7,8))       # 同样报错
 print()
 print(s.find("a"))              # find用法基本同index 但没有找到会返回-1  而不是报错
 print(s.find("aa"))
 print(s.find("a",6,9))
 print(s.rfind("a"))             # 从结尾开始搜索
 print(s.find("aaa"))            # find 找不到不会报错，返回 -1
 print(s.find("a",7,8))            

　　　　str.count(sub[, start[, end]])

 s = "abbccaacad"
 print(s.count("a"))                 # "a"出现的次数
 print(s.count("ca"))                # "ca"出现的次数
 print(s.count("aaa"))               # 出现次数为0

　　　　str.replace(old, new[, count])

 s = "abAccaacad"
 print(s.replace("a","x"))              # 用"x"替换"a"
 s_r = s.replace("a","")                # 相当于删除所有的"a"
 print(s_r,len(s),len(s_r))
 print(s.replace("a","x",2))            # 仅替换2次
 print(s.replace("ca","xx"))            # 用"xx"替换"ca"
 print(s.replace("a ","x"))             # 无匹配，无替换，注意空格

　　　　str.strip([chars])    str.lstrip([chars])    str.rstrip([chars])

　　　　　　去头尾字符，缺省为删除空格，注意的是头尾去除按每一个字符来算，非 prefix 或 suffix

 s = "  hello hi "
 s_strip = s.strip()                  # 去前后空格
 s_lstrip = s.lstrip()                # 去左边空格
 s_rstrip = s.rstrip()                # 去右边空格
 print(s_strip  + 'x')
 print(s_lstrip + 'x')
 print(s_rstrip + 'x')
 print(len(s),len(s_strip),len(s_lstrip),len(s_rstrip))
 print(s.strip(' h'))                 # 头尾去空格或者h
 print(s.strip('hi '))                # 头尾去h、i或者空格

　　　　str.split(sep=None, maxsplit=-1)

　　　　　　根据 sep 来分割字符串 str，会返回一个list，具体理解详见下面例子

 s = "a b c"
 print(s.split())                    # 返回list，可直接输出，默认以空格分割
 s = "a,b,c"
 print(s.split())                    # 无法分割，为一个元素
 print(s.split(','))                 # 设置分割符
 s = "a,b,,c"
 print(s.split(','))                 # 分割符补位空格，会输出空元素
 s = "a b   c"
 print(s.split())                    # 可做多个空格的分割，无空元素
 print(s.split(' '))                 # 会输出空元素

　　　　str.join(iterable)

　　　　　　用str来链接序列的元素，返回的是一字符串，（例子看不懂可看完后续list tuple set后再来看）

 s = "-"
 print(s.join(["P","y","t","h","o","n"]))    # list有序
 print(s.join(("P","y","t","h","o","n")))    # tuple有序
 print(s.join({"P","y","t","h","o","n"}))    # set无序