Python笔记_第一篇_面向过程_第一部分_5.Python数据类型之字符串类型(string)

　　关于Python的字符串处理也如其他语言一样属于重点中的重点，主要是牵扯到的函数和内容较为多和乱一些。关于什么是字符串，Python中的定义是：以单引号或者双引号括起来的任意文本。

1.   字符串的简单应用

1.1   创建字符串

 str1 = "Thomas is a good man"
 str2 = "Thomas is a nice man"
 str3 = "Thomas is a handsome man"
 print(str1, str2, str3)
 print(type(str1), type(str2), type(str3))
 # 输出结果：
 # Thomas is a good man Thomas is a nice man Thomas is a handsome man
 # <class 'str'> <class 'str'> <class 'str'>

1.2   转换成字符串

 # 转换成字符串
 a = 18
 b = str(a)
 print(b, type(b))
 # 输出结果：18 <class 'str'>

1.3   字符串的运算（字符串的拼接和字符串的重复输出）

 # 字符串的运算
 # 字符串的拼接
 str6 = "Thomas is a "
 str7 = "good man"
 str8 = str6 + str7
 print(str8)
 # 输出结果：Thomas is a good man

 # 字符串的重复输出
 str9 = "good"
 str10 = str9 * 3
 print(str10)
 # 输出结果：goodgoodgood

1.4   字符串大小的比较

　　字符串大小的比较和数字类型的大小比较最大的不同，由于是字符串不能直接的比较数字大小。因此规则为：从第一个字符开始比较大小，谁的ASCII码大谁就大，如果相等会比较下一个字符的ASCII码值大小，那么谁的值大就大。和数字类型大小比较相同，返回值也是True 或者 False。

 # 字符串大小的比较
 print("a" > "b")
 # 输出结果：False
 print("Thomas" == "Thomas")
 # 输出结果：True
 print("-azzzz" < "-")  # 第二个字符串的值为0比z小所以返回为假
 # 输出结果：False

1.5   字符串的查找（访问）

　　字符串的访问最常用的方式是通过下标进行访问，下标的格式为：[ ]（[start] ：[end] ：[step]），下标可为正也可为负，为负为从右向左查找，默认某个具体的下标位置对应的字符，其中用：进行分割。另外说明一下，所有的计算机计数都是从0开始的。在字符串中，0表示字符串的第一个字符位置，空格也算一个字符。

　　字符串的访问，也可以叫“切片”，截取字符串中的一部分。

 # 通过下标的方式进行访问
 str11 = "Thomas is a good man"
 print(str11[12])  # 输出结果：g，第11个字符
 # 截取字符串中的一部分（切片）
 str13 = "Thomas is a good man"
 str15 = str13[6:16]  # 空格也是一个字符。从第七个字符位置到第十七个字符位置
 print(str15)  # 输出结果：is a good

 str16 = str13[0:6]  # str16 = str13[:5]这样也可以，不写起始位置默认都是从0开始
 print(str16)  # 输出结果：Thomas

 str17 = str13[7:]
 print(str17)  # 输出结果：is a good man

 str18 = str13[-1]
 print(str18)  # 输出结果：n  从右往左数第一个字符

 str19 = str13[::-1]
 print(str19)  # 输出结果：nam doog a si samohT，通过倒叙方式输出一遍，最有一个位置步长为1

 str20 = str13[0::2]
 print(str20)  # 输出结果：Toa sago a ，从开始到最后，按照2个字符步长进行切片

1.6   判断某个字符是否是字符串的一部分。

　　这里就用到了2个成员运算符和另外2个身份运算符。

　　符："in"、"not in" 和 "is"、"is not"

　　　　用：成员运算符：判断左边的成员是否属于右边的集合，如果是返回为True；如果非，返回为False。相反的是not in，如果是返回为False，如果非返回为True。

　　　　　　身份运算符：判断左边的成员是否和右边成员相等，如果是返回为True；如果非，返回为False。相反的是is not，如果是返回为False，如果非返回为True。

 # 成员运算符
 str21 = "Thoams is a good man"
 print("good" in str21)  # 输出结果：True
 print("good1" not in str21)  # 输出结果：True

 # 成员运算符
 print("good" is "good")  # 输出结果：True
 print("good1" is not "good")  # 输出结果：True

2. 字符串常用的内建函数

　　这部分的内容是非常重要的，通过内建函数（built-in func）可以实现字符串的增删改查。增删改查是对于各种数据类型常用的操作手段。

2.1   函数：eval，这部分内容在数字型数据有所阐述，这里指举几个例子：

 # eval（str）
 # 作用1：将字符串str当成有效的表达式来求值，并返回计算结果
 num1 = eval("")
 print(num1)
 print(type(num1))
 print(eval("+123"))
 print(eval("-123"))
 print(eval("12-3"))
 # 作用2：实现list、dict、tuple与str之间的转化
 # 字符串转换成列表
 a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
 print(type(a))
 b = eval(a)
 print(b)
 # 字符串转换成字典
 a = "{1: 'a', 2: 'b'}"
 print(type(a))
 b = eval(a)
 print(type(b))
 print(b)
 # 字符串转换成元组
 a = "([1,2], [3,4], [5,6], [7,8], (9,0))"
 print(type(a))
 b=eval(a)
 print(type(b))
 print(b)

2.2    其他内建函数

　　函：len

　　　　语：len(string)

　　　　　　用：返回字符串的长度，一般用于查找字符串的循环中

 # len(str)
 # 作用：返回字符串的长度，一般用于找字符的循环中
 print(len("sunck is a good man"))
 # 输出结果：19

　　函：lower、upper

　　　　语：lower(string)、upper(string)

　　　　　　用：将字符串中的大写字母转换为小写字母，中文不变；将字符串中的小写字母转换成大写字母，中文不变。

 # lower()
 # 作用：将字符串中的大写字母转换为小写字母，中文不变
 str20 = "SUNCK is a Good Man"
 print(str20.lower())
 # 输出结果：sunck is a good man

 # upper()
 # 作用：将字符串中的小写字母转换成大写字母
 str21 = "SUNCK is a Good Man"
 print(str21.upper())
 # 输出结果：SUNCK IS A GOOD MAN

　　函：swapace

　　　　语：swapace(string)

　　　　　　用：字符串中大小写的互相转换，将大写字母转换成小写字母，将小写字母转换成大写字母。

 # swapcase()
 # 作用：字符串中的大小写的相互转换
 str22 = "SUNCK is a Good Man"
 print(str22.swapcase())
 # 输出结果：sunck IS A gOOD mAN

　　函：capitalize、title

　　　　语：capitalize(string)、title(string)

　　　　　　用：将字符串中的首句首字母大写，其他字母位置转换成小写；将每个单词（或者字母）第一个单词大写。

 # capitalize()
 # 作用：把首字母变成大写，其他字母位置都是小写
 str23 = "sunck is a good man"
 print(str23.capitalize())
 # 输出结果：Sunck is a good man

 # title()
 # 作用：把每个单词的首字母大写
 str24 = "sunck is a good man"
 print(str24.title())
 # 输出结果：Sunck Is A Good Man

　　函：center

　　　　语：center(self,width,fillchar)  fillchar = character

　　　　　　用：返回一个指定宽度的字符串（居中的字符串），fillchar为填充的字符，默认为空格填充。

 # center(self,width,fillchar) char = character
 # 作用：返回一个指定宽度的字符串（居中的字符串），fillchar为填充的字符，默认是空格填充
 str25 = "kaige is a nice man"
 print(str25.center(40, "*")) # 输出结果：**********kaige is a nice man***********
 print(str25.center(40))
 # 输出结果：          kaige is a nice man           

　　函：ljust、rjust

　　　　语：ljust(width, fillchar) fillchar = character、rjust(width,fillchar) fillchar = character

　　　　　　用：l=left，返回一个指定宽度的左对齐字符串，fillchar为填充字符，默认为空格。

　　　　　　　　r=right，返回一个指定宽度的右对齐字符串，fillchar为填充字符，默认为空格。

 # ljust(width [,fillchar])
 # rjust(width [,fillchar])
 # 作用：l = left，返回一个指定宽度的左对齐字符串，fillchar为填充字符，默认空格填充
 #      r = right，返回一个指定宽度的左对齐字符串，fillchar为填充字符，默认空格填充
 str26 = "Kaige is a nice man"
 print(str26.ljust(40, "%"))
 print(str26.rjust(40, "%"))
 # 输出结果：Kaige is a nice man%%%%%%%%%%%%%%%%%%%%%
 # 输出结果：%%%%%%%%%%%%%%%%%%%%%Kaige is a nice man

　　函：zfill

　　　　语：zfill(width)

　　　　　　用：z = zero，返回一个长度为width的字符串，元字符右对齐，左侧填充0。

 # zfill(width)
 # 作用：返回一个长度为width的字符串，原字符串右对齐，前面补0
 str28 = "kaige is a nice man"
 print(str28.zfill(40))
 # 输出结果：000000000000000000000kaige is a nice man

　　函：count

　　　　语：count(str,[,start] [,end])

　　　　　　用：返回字符串中str出现的次数，可以指定一个start和end字符串中的范围，默认从头到尾。

 # count(str [,start] [,end])
 # 作用：返回字符串中str出现的次数，可以指定一个start和end字符串中的范围，默认从头到尾
 str29 = "kaige is a very very good man"
 print(str29.count("very", 11, len(str29)))  # 从第几个字符位置开始查找
 print(str29.count("very", 12, len(str29)))  # 从第几个字符位置开始查找
 # 输出结果：2
 # 输出结果：1

　　函：find、rfind

　　　　语：find(str, [,start] [,end])、rfind(str, [,start] [,end])

　　　　　　用：从左向右，检测str字符串是否在包含的字符串中，可以指定范围，默认从头到尾。得到的是第一次出现的开始下标，只不过如果str不存的，返回为-1。

　　　　　　　　从右向左，检测str字符串是否在包含的字符串中，可以指定范围，默认从尾到头。得到的是第一次出现的开始下标，只不过如果str不存的，返回为-1。

 # find(str [,start] [,end])
 # 作用：从左向右，检测str字符串是否包含在字符串中,可以指定范围，默认从头到尾。得到的是第一次出现的开始下标
 # 只不过如果str不存在的时候，没有返回为 -1
 str30 = "kaige is a very very nice man"
 print(str30.find("very"))
 print(str30.find("good"))
 print(str30.find("very", 16, len(str30)))
 # 输出结果：11
 # 输出结果：-1
 # 输出结果：16

 # rfind(str[,start][,end])
 # 作用：从右向左，检测str字符串是否包含在字符串中,可以指定范围，默认从尾到头。得到的是第一次出现的开始下标
 # 只不过如果str不存在的时候，没有返回为 -1
 print(str30.rfind("very"))
 print(str30.rfind("good"))
 print(str30.rfind("very", 16, len(str30)))
 # 输出结果：16
 # 输出结果：-1
 # 输出结果：16

　　函：index、rindex

　　　　语：index(str,, [,start] [,end])、rindex(str,, [,start] [,end])

　　　　　　用：用法与find和rfind一样，但是如果str不存的话，会报告一个异常。

 # index(str,start=0, end=len(str)
 # rindex(str,start=0, end=len(str)
 # 作用：跟find方法一样，只不过如果str不存在的时候，他会报一个异常
 str31 = "kaige is a very very nice man"
 str32 = "kaige is a very very nice man"
 # print(str31.index("good"))
 # 输出结果：
 # Traceback (most recent call last):
 #   File "C:/Users/Administrator/Desktop/Python-1704/day03/String(字符串).py", line 162, in <module>
 #     print(str31.index("good"))
 # ValueError: substring not found
 print(str31.index("very"))
 # 输出结果：11
 print(str32.rindex("very"))
 # 输出结果：16

　　函：operator.eq(cmp)

　　　　语：operator.eq(str1, str2)

　　　　　　用：比较两个字符串的大小，在Python3中，原先的cmp函数比较字符大小的方式被取代，调用operator库的方式来比较两个字符串的大小

 # operator.eq = cmp
 # 字符串的比较，在python3中已经没有cmp这个命令了，要调用operator库
 import operator
 print(operator.eq("hello", "name"))
 print(operator.eq("hello", "hello"))
 # 输出结果：False
 # True

　　函：lstrip、rstrip、strip

　　　　语：lstrip(char)、rstrip(char)、strip(char)

　　　　　　用：高级切片功能。从左侧开始截取指定的字符、从右侧开始截取指定的字符、从任意位置截取指定的字符（默认为空格，包括换行符\n，也包括制表符\t等）

 # lstrip()、rstrip()
 # 作用：截掉字符串左侧指定的字符，默认为空格
 # 作用：截掉字符串右侧指定的字符，默认为空格
 str33 = "**********kaige is a nice man"
 str34 = "kaige is a nice man%*%*******"
 print(str33.lstrip("*"))
 # 输出结果：kaige is a nice man
 print(str34.rstrip("*"))  # 备注：这两个命令是按照顺序截取，遇到kaige is a nice man%*%一个非截取，返回
 # 输出结果：kaige is a nice man%*%

 # strip()
 # 作用：任意截取字符串指定的字符，默认为空格
 str35 = "*********%kaige is a nice man*%%%%******"
 print(str35.strip("%*"))
 # 输出结果：kaige is a nice man

　　函：join

　　　　语："(拼接内容)".join([拼接变量A,拼接变量B])

　　　　　　用：字符串拼接函数

 # join
 # ""(按照什么拼接内容进行拼接).join([拼接变量1，拼接变量n])
 # ""(按照什么拼接内容进行拼接).join((拼接变量1，拼接变量n))
 # 作用：字符串拼接
 a = ""
 b = "abc"
 str36 = "****".join([a, b])
 # str36 = a.join(b) # a123b123c123
 print(str36)
 print(type(str36))
 # 输出结果：
 # 123****abc
 # <class 'str'>

　　函：startswith、endswith

　　　　语：startswith(str [,start] [,end])、endswith(str [,start]  [,end])

　　　　　　用：判断以什么字符串（字符）作为开头、判断以什么字符串（字符）作为结尾。

 # startswith(str,[,start] [,end])
 # endswith(str,[,start] [,end])
 # 作用：以什么字符串（字符）作为开头；以什么字符串（字符）作为结尾，返回为真假，有大小写
 str37 = "hello kitty"
 print(str37.endswith("tty3"))
 print(str37.startswith("he"))
 # 输出结果：
 # False
 # True

　　函：expandtabs

　　　　语：expandtabs(tabsize = 10)

　　　　　　用：与\t结合使用，在字符串中\t的位置加入空格。

 # expandtabs(tabsize = 10)
 # 作用：与\t结合使用，在字符串中\t的位置空加空格
 str38 = "h\tello kitty"
 print(str38.expandtabs(tabsize = 20))
 # 输出结果：h                   ello kitty

　　函：replace

　　　　语：replace(“被替换”,“替换内容”)

　　　　　　用：用一个字符串（字符）去替换字符串（字符）当中的内容。

 # replace("替换"，"替换内容")
 # 作用：替换字符串内容
 print("My title title".replace("title", "Good"))
 # 输出结果：My Good Good

　　函：split、rsplit

　　　　语：split("", section) section = 0、split("", section) section = 0

　　　　　　用：按照什么分割, 按照第几次出现分割字符的位置开始分割，section=分割成次数、从右侧开始按照什么分割, 按照第几次出现分割字符的位置开始分割，section=分割成次数。

 # split()、rsplit()
 # split(按照什么分割, 按照第几次出现分割字符的位置开始分割)
 # 作用：按照什么进行分割，生成一个列表；从右侧
 print("My title title".split("t", 2)) #分割的位置将没有
 print("My title title".split(" ")) # 按照空格进行分割
 print("My title title".rsplit("t", 3)) # 按照空格进行分割
 # 输出结果：
 # ['My ', 'i', 'le title']
 # ['My', 'title', 'title']
 # ['My ti', 'le ', 'i', 'le']

2.3   is... 几种判断字符串的函数（返回的都是True和False两种结果）

　　函：isnumeric、isalpha、isalnum

　　　　语：isnumeric(str)、isalpha(str)、isalum(str)

　　　　　　用：判断是否是包含或全包含数字，是返回为真，否则为假。

　　　　　　　　判断是否是包含或者全包含字母，是返回为真，否则为假。

　　　　　　　　拆分：is alpha number，如果字符串中包含或全包含字母、数字、中文返回为真，否则返回为假。

　　　　　　　　其他诸如里面有空格或者其他字符，返回都为假。

 # isnumeric()
 # 作用：判断是否是一个数字（必须是整型）
 print("123.00".isnumeric())
 # 输出结果：False
 print("".isnumeric())
 # 输出结果：True
 print("123  ".isnumeric())  # 因为有一个空格
 # 输出结果：False

 # isalpha()
 # 作用：判断是否是一个字母
 print("abc".isalpha())
 # 输出结果：True
 print("".isalpha())
 # 输出结果：False
 print("abc ".isalpha())  # 因为有一个空格
 # 输出结果：False

 # isalnum()
 # 作用：如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
 print("abc123中国".isalnum())
 # 输出结果：True
 print(" abc123中国".isalnum())  # 有一个空格
 # 输出结果：False

　　函：isdecimal

　　　　语：isdecimal(str)

　　　　　　用：判断字符串中是否是一个十进制数

 # isdecimal()
 # 作用：判断是否是一个十进制数
 print("".isdecimal())
 print("0b0010".isdecimal())  # 里面有个b表示二进制
 # 输出结果：
 # True
 # False

　　函：isdigit

　　　　语：isdigit(str)

　　　　　　用：判断字符串中是否是一个数字（必须是数字，和isnumeric用法一样）

 # isdigit()
 # 作用：判断是否是一个数字（必须是整型）
 print("126.9999".isdigit())
 print("".isdigit())
 # 输出结果：
 # False
 # True

　　函：islower、isupper

　　　　语：islower(str)、isupper(str)

　　　　　　用：判断字符串中是否都是小写（忽略里面有空格情况）；判断字符串中是否都是大写（忽略里面有空格情况）

 # islower()、isupper
 # 作用：判断是否是全小写；断点是否为全大写
 print("adf  ".islower(), "ABc".isupper())  # 忽略空格
 # 输出结果：True  False

　　函：isspace

　　　　语：isspace(str)

　　　　　　用：判断字符串是否是一个只包含空格的字符串，如果里面存在字符返回为假，否则为真。

 # isspace()
 # 作用：判断是否是一个空格
 print("  ".isspace())  # 只要里面有一个字符就是假
 # 输出结果：True

　　函：istitle

　　　　语：istitle(str)

　　　　　　用：判断字符串中是否每个单词都是大写，如果是返回为真，否则为假。

 # istitle()
 # 作用：判断标题是否是首字母大写
 print("My Title".istitle())
 # 输出结果：True

　　函：isidentifier　　　　

　　　　语：isidentifier()

　　　　　　用：判断字符串是否一个变量名（按照变量命名规则来，首字母不允许数字等等）

 # isidentifier()
 # 作用：判断是否是一个变量名
 print("34abc".isidentifier())
 # 输出结果：False

 　　函：isinstance

　　　　语：isinstance(object, (classinfo1,classinfo2,classinfon))

　　　　　　用：判断一个对象是否是已知的类型，类似于type()。其中object---实例对象；classinfo---可以是直接或者间接类名、基本类型或者有他们组成的元组。如果object判断为真，返回为True，如果object判断为假，返回为False。其中classinfo可以是一个单独进行判断，如果是多个表示object的类型是括号里面的其中一个（用括号括起来是表示由classinfo组成的元组）。

　　另外：isinstance和type的区别如下：

　　1. type可以只接收一个参数，打印其位置所属的类型；而isinstance智能是否属于某个已知的类型。

　　2. isinstance 可以判断子类对象是否继承了父类；而type不可以。

 # isinstance
 a = 2
 isinstance(a, int)
 print(isinstance(a, int))
 isinstance(a, str)
 print(isinstance(a, str))
 isinstance(a, (int, str, list))
 print(isinstance(a, (int, str, list)))  # 是元组中的一个，返回为True
 # 输出结果：
 # True
 # False
 # True

 # type和isinstance的区别
 class A:
     pass
 class B(A):
     pass

 isinstance(A(), A)
 print(isinstance(A(), A))  # returns True

 type(A()) == A
 print(type(A()) == A)  # returns True

 isinstance(B(), A)
 print(isinstance(B(), A) )  # returns True

 type(B()) == A
 print(type(B()) == A )  # returns False

 　　函：isatty

　　　　语：isatty()

　　　　　　用：返回是否是一个终端设备（不常用）

　　举例：略

3.   字符串的映射

　　3.1 字符串还可以通过映射的方式进行修改。

 　　函：maketrans  translate

　　　　语：str.maketrans  str.translate

　　　　　　用：创建表字符串映射转换表（不常用）

　　　　　　　　str.maketrans(x:intab , y:outtab, z:delchars)   

　　　　　　　　inttab -- 字符串中要替代的字符组成的字符串。

　　　　　　　　outtab -- 相应的映射字符的字符串

　　　　　　　　delchars -- 可选参数，表示要删除的字符组成的字符串（Python3有，Python2没有）

　　　　　　　　str.translate(self, table:dict[int,Any])

intab = "ab"
outtab = "12"
delchars = "i"
trantab = str.maketrans(intab, outtab, delchars)
# a 替换1  b 替换 2  i删除

str = "China is a big National"
print("{}".format(str))
print ("{}".format(str.translate(trantab)))

# 输出结果：
# China is a big National
# Chn1 s 1 2g N1ton1l
# a 已经替换成1，i删除了，b替换了2