a12_Python字符串-字符串--学习笔记
字符串类型在Python中是最流行的。可以通过在引号包围的字符简单地创建它们。Python使用单引号和双引号来表示字符串是一样的。创建字符串很简单，只要将值分配给一个变量。例如：var1 = 'Hello World!'var2 = "Python Programming"访问字符串值：Python不支持字符类型;这些都被视为一个长度的字符串，因此也被认为是一个子串。要访问子字符串，用方括号随着指
字符串类型在Python中是最流行的。可以通过在引号包围的字符简单地创建它们。Python使用单引号和双引号来表示字符串是一样的。
创建字符串很简单，只要将值分配给一个变量。例如：
var1 = 'Hello World!'
var2 = "Python Programming"访问字符串值：
Python不支持字符类型;这些都被视为一个长度的字符串，因此也被认为是一个子串。
要访问子字符串，用方括号随着指数或索引来获得子切片。下面是一个简单的例子：
#!/usr/bin/python
var1 = 'Hello World!'
var2 = "Python Programming"
print( "var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])执行上面的代码中，产生以下结果：
var1[0]: H
var2[1:5]: ytho可以在“更新”现有的由（重新）分配一个变量赋值给另一个字符串的字符串。新的值可以与它以前的值或一个串完全不同。下面是一个简单的例子：
#!/usr/bin/python
var1 = 'Hello World!'
print "Updated String :- ", var1[:6] + 'Python'当执行上面的代码中，产生以下结果：
Updated String :- Hello Python转义字符：
下表是未转义非打印字符的列表，可以用反斜线符号来表示。
转义字符被解释;在一个单引号和双引号字符串。
|
反斜线 符号 |
十六进制 字符 |
描述 |
|---|---|---|
| a | 0x07 | 铃声或警报 |
| b | 0x08 | 退格键 |
| cx | Control-x | |
| C-x | Control-x | |
| e | 0x1b | 转义 |
| f | 0x0c | 换页 |
| M-C-x | Meta-Control-x | |
| n | 0x0a | 新一行 |
| nnn | 八进制表示法，其中n的范围为0.7 | |
| r | 0x0d | 回车 |
| s | 0x20 | 空格 |
| t | 0x09 | Tab键 |
| v | 0x0b | 垂直制表 |
| x | 字符x | |
| xnn | 十六进制表示法，其中n的范围是从0.9，a.f，或AF |
字符串特殊操作符：
假设字符串变量中保存'Hello'和变量b持有'Python'：
| 操作符 | 描述 | 例子 |
|---|---|---|
| + | 串联- 对操作符的两侧值增加 | a + b 的值为 HelloPython |
| * | 重复 - 创建新的字符串，链接相同的字符串的多个副本 | a*2 的值为 -HelloHello |
| [] | 切片- 从给定的索引字符指定 | a[1] 的值为 e |
| [ : ] | 范围切片 - 给定的范围内的字符 | a[1:4] 的值为 ell |
| in | 成员 - 如果一个字符存在给定的字符串中，则返回true | H in a 结果值为 1 |
| not in | 成员 - 如果输入的字符不给定的字符串中不存在，则返回true | M not in a 结果值为 1 |
| r/R | 原始字符串- 禁止转义字符的实际意义。语法原始字符串是完全一样的普通字符串，除了原始的字符串运算符，字母“r”，这之前的引号。在“r”可以小写（r）或大写字母（R）的，必须立即放置在第一引号前面。 | print r'n' 打印 n 并且 print R'n' 打印 n |
| % | 格式 - 执行字符串格式化 | 请参阅下一节 |
字符串格式化操作：
Python最酷的功能是字符串格式运算符％。这种操作是唯一的字符串，弥补了C语言的printf()系列函数功能。下面是一个简单的例子：
#!/usr/bin/python
print "My name is %s and weight is %d kg!" % ('Zara', 21) 当执行上面的代码中，产生以下结果：
My name is Zara and weight is 21 kg!下面是完整的，它可以与％符号使用列表：
| 格式符号 | 转换 |
|---|---|
| %c | 字符 |
| %s | 通过str() 字符串转换来格式化 |
| %i | 有符号十进制整数 |
| %d | 有符号十进制整数 |
| %u | 无符号十进制整数 |
| %o | 八进制整数 |
| %x | 十六进制整数（小写字母） |
| %X | 十六进制整数（大写字母） |
| %e | 索引符号（小写'e'） |
| %E | 索引符号（大写“E”） |
| %f | 浮点实数 |
| %g | ％f和％e 的简写 |
| %G | ％f和％E的简写 |
其他支持的符号和功能如下表：
| 符号 | 功能 |
|---|---|
| * | 参数指定宽度和精度 |
| - | 左对齐 |
| + | 显示符号 |
| <sp> | 一个正数前留一个空格 |
| # | 添加前导零（'0'）或十六进制前导0x“或”0X“，取决于”x“或”X“是否使用八进制。 |
| 0 | 从键盘左边添加零（而不是空格） |
| % | '％％'给留下一个文字'％' |
| (var) | 映射变量（字典参数） |
| m.n. | m是最小的总宽度和n是数字，显示小数点后的位数（如果appl） |
三重引号：
Python三重引号允许字符串跨越多行，包括逐字换行符，制表符和其他特殊字符。
三重引号语法由三个连续的单引号或双引号。
#!/usr/bin/python
para_str = """this is a long string that is made up of
several lines and non-printable characters such as
TAB ( t ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [ n ], or just a NEWLINE within
the variable assignment will also show up.
"""
print para_str;当执行上面的代码中，产生以下结果。请注意如何每一个特殊字符被转换到打印形式，一直到最后的换行符之间的字符串“up”结束闭三重引号。还要注意的是发生或者使用显式回车在一行或它的转义代码（ n）的尾部的换行：
this is a long string that is made up of
several lines and non-printable characters such as
TAB ( t ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [ n ], or just a NEWLINE within
the variable assignment will also show up.
原始字符串不把反斜杠作为一个特殊字符。把一个原始字符串的每个字符保持写的方式：
#!/usr/bin/python
print('C:nowhere')当执行上面的代码中，产生以下结果：
C:nowhere现在利用原始的字符串。我们表达如下：
#!/usr/bin/python
print (r'C:nowhere')执行上面的代码中，产生以下结果：
C:nowhere
C:nowhereUnicode字符串：
在Python普通字符串在内部存储为8位ASCII，而Unicode字符串被作为16位Unicode存储。这使得一组字符更加多样化，包括大多数语言在世界上的特殊字符。限制处理Unicode字符串，注意以下几点：
#!/usr/bin/python
print (u'Hello, world!')当执行上面的代码，产生以下结果：
Hello, world!正如你所看到的，Unicode字符串使用前缀 u，就像原始字符串使用前缀 r
字符串内置方法：
Python的包括以下内建的方法操作字符串：
| SN | 方法及描述 |
|---|---|
| 1 | capitalize() 字符串的第一个字母大写 |
| 2 | center(width, fillchar) 返回一个空格填充字符串为中心，以总宽度列的原始字符串 |
| 3 | count(str, beg= 0,end=len(string)) 开始索引beg和结束索引结束str多少次出现在字符串或字符串的子串 |
| 4 | decode(encoding='UTF-8',errors='strict') 使用注册编码的编解码器的字符串进行解码。编码默认为默认的字符串编码。 |
| 5 | encode(encoding='UTF-8',errors='strict') 返回编码字符串的字符串版本;对错误，默认是引发ValueError除非错误被赋予了“ignore”或“replace”。 |
| 6 | endswith(suffix, beg=0, end=len(string)) 判断字符串或字符串的一个子串（如果起始索引beg和给出end结束索引）与后缀结尾;如果是则返回true，否则为false， |
| 7 | expandtabs(tabsize=8) 扩展选项卡中的字符串多个空格;如果未提供tab大小默认为每片8位 |
| 8 | find(str, beg=0 end=len(string)) 确定str开始索引beg和end索引并返回索引，如果找到出现在字符串或字符串的子串，否则返回-1 |
| 9 | index(str, beg=0, end=len(string)) 与find()一样，但会引发一个异常如果str没找到 |
| 10 | isalnum() 如果string至少有1个字符，所有字符为字母数字则返回true，否则为false |
| 11 | isalpha() 如果string至少有1个字符，所有字符都是字母，否则为false，则返回true |
| 12 | isdigit() 如果字符串只包含数字则返回true，否则为false |
| 13 | islower() 如果字符串至少有1个字符，所有字符是小写则返回true，否则为false |
| 14 | isnumeric() 如果一个Unicode字符串只包含数字字符则返回true，否则为false。 |
| 15 | isspace() 如果字符串只包含空格字符则返回true，否则返回false， |
| 16 | istitle() 返回true如果字符串是正确的“首字母大写”，否则为false |
| 17 | isupper() 返回true如果字符串至少有一个小写字符，所有字符符为大写字母，否则返回false。 |
| 18 | join(seq) 合并（会连接）序列seq元素连接成一个字符串的字符串表示形式，用分隔符的字符串 |
| 19 | len(string) 返回字符串的长度 |
| 20 | ljust(width[, fillchar]) 返回一个空格填充字符串，原始字符串左对齐，以总宽列 |
| 21 | lower() 将所有大写字母的字符串转化为小写 |
| 22 | lstrip() 删除字符串中的所有前导空格 |
| 23 | maketrans() 返回要用于转换功能的转换表 |
| 24 | max(str) 从字符串str返回的最大字母字符 |
| 25 | min(str) 从字符串str返回最小字母字符 |
| 26 | replace(old, new [, max]) 取代了旧的所有出现在字符串使用新的或max，如果给定max |
| 27 | rfind(str, beg=0,end=len(string)) 与find()一样，但反向搜索字符串 |
| 28 | rindex( str, beg=0, end=len(string)) 与index()一样，但反向搜索字符串 |
| 29 | rjust(width,[, fillchar]) 返回一个空格填充字符串右对齐，以原始字符串总宽度列。 |
| 30 | rstrip() 删除字符串的所有行尾空白 |
| 31 | split(str="", num=string.count(str)) 根据分隔符str （如果没有提供空间）和子字符串返回分割字符串列表;分成最多num子字符串。 |
| 32 | splitlines( num=string.count('n')) Splits string at all (or num) NEWLINEs and returns a list of each line with NEWLINEs removed |
| 33 | startswith(str, beg=0,end=len(string)) 判断字符串或字符串的一个子串（如果起始索引beg和end索引）开始字符串str;如果是则返回true，否则为false |
| 34 | strip([chars]) 在字符串执行两种lstrip()和rstrip() |
| 35 | swapcase() 反转大小写，在字符串中的所有字母 |
| 36 | title() 返回“标题大字”版本字符串，也就是所有的字以大写，其余为小写 |
| 37 | translate(table, deletechars="") 根据转换表str（256字）转换字符串，删除那些del字符串 |
| 38 | upper() 字符串小写转换为大写字母 |
| 39 | zfill (width) 返回leftpadded零合共宽字符原字符串;用于数字zfill()保留给予任何迹象（减去一个零） |
| 40 | isdecimal() 如果一个Unicode字符串只包含十进制字符则返回true，否则返回false |
capitalize()方法的语法结构：
capitalize()方法返回字符串的一个副本，只有它的第一个字母大写。对于8位的字符串，这个方法与语言环境相关。
str.capitalize()参数:NA
返回值:此方法返回的字符串只有它的第一个字符大写的副本。
例子:
#!/usr/bin/python
str = "this is string example....wow!!!";
print("str.capitalize():",str.capitalize())运行上面的程序，它会产生以下结果：
str.capitalize() : This is string example....wow!!!
center()方法的语法结构：
center()方法返回集中在长度宽度的字符串。填充是通过使用specifiedfillchar。默认填充字符是一个空格。
str.center(width[, fillchar])返回一个空格填充字符串为中心，以总宽度列的原始字符串
参数：width -- 这是字符串的总宽度。fillchar -- 这是填充符。
返回值：此方法返回集中在长度宽度的字符串。
例子：
#!/usr/bin/python
str = "this is string example...wow!!!";
print("str.center(40,'-'):",str.center(40,'-'))运行上面的程序，它会产生以下结果：
str.center(40,'-'): ----this is string example...wow!!!-----
count()方法的语法结构：
str.count(sub, start= 0,end=len(string))count()方法返回出现在范围内串子数range [start, end]。可选参数的start和end都解释为片符号。
参数：sub -- 这是子串用来进行搜索。start -- 搜索从这一索引。第一个字符从0开始的索引。默认情况下搜索从0开始的索引。end -- 搜索从该索引结束。第一个字符从0开始的索引。默认情况下搜索结束的最后一个索引。
返回值：此方法返回集中在长度宽度的字符串。
例子：
#!/usr/bin/python
str = "this is string example....wow!!!";
sub = "i"
print("str.count(sub,4,40) :"，str.count(sub,4,40))
sub = "wow";
print("str.count(sub,4,40):",str.count(sub))运行上面的程序，它会产生以下结果：
str.count(sub, 4, 40) : 2
str.count(sub, 4, 40) : 1decode()方法的语法结构：
decode()方法使用注册编码的编解码器的字符串进行解码。它默认为默认的字符串编码。
str.decode(encoding='UTF-8',errors = 'strict')参数:encoding -- 这是所使用的编码。对于所有的编码方案的列表，请访问：标准编码库,errors -- 这可能是给定一个不同的错误处理机制。默认的错误是“严格”，即编码错误提出UnicodeError。其他可能的值是ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 并通过codecs.register_error().注册的任何其他名称。
返回值:此方法返回的字符串的解码版本。
例子:
#!/usr/bin/python
str = "this is string example....wow!!!";
str = str.encode('base64','strict');
print("Encoded String:" + str;)
print("Decoded String:" + str.decode('base64','strict'))
#Py3.8执行不成功，跳过：
#!/usr/bin/python
encode()方法的语法结构：
encode() 方法返回字符串的编码版本。默认编码是当前的默认字符串编码。可给予设置不同的错误处理机制。
str.encode(encoding='UTF-8',errors='strict')参数:encoding -- 这是所使用的编码。对于所有的编码方案的列表，请访问：标准编码库，errors -- 这可能是给定一个不同的错误处理机制。默认的错误是“严格”，即编码错误提出UnicodeError。其他可能的是ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 并通过codecs.register_error().注册的任何其他名称。
返回值：此方法返回的字符串的编码版本。
例子：
#!/usr/bin/python
#str = "this is string example...wow!!!";
#print("Encoded String:" + str.encode('base64','strict')) #python3.7以上不支持
print ("Encoded String: " + str)
运行上面的程序，它会产生以下结果：
Encoded String: this is string example....wow!!!endswith()方法的语法结构：
endswith()方法返回true，如果字符串以指定后缀结尾，否则返回(False可选限制的匹配从给定的索引开始和结束)。
str.endwith(suffix[,start[,end]])参数:suffix -- 这可能是一个字符串或者是元组用于查找后缀,start -- 切片从此开始,end -- 切片到此为止
返回值:如果字符串以指定的后缀结束此方法返回true，否则返回false。
例子:
#!/usr/bin/python
str = "this is string example....wow!!!";
suffix = "wow!!!";
print (str.endswith(suffix));
print (str.endswith(suffix,20));
suffix = "is";
print( str.endswith(suffix, 2, 4));
print (str.endswith(suffix, 2, 7));
print (str.endswith(suffix, 2));
print (str.endswith(suffix, 5,7));运行上面的程序，它会产生以下结果：
True
True
True
True
False
Trueexpandtabs()方法的语法结构：
expandtabs()方法返回制表符，即该字符串的一个副本。 't'已经使用的空间，可选择使用给定的tabsize(默认8)扩展。
str.expandtabs(tabsize=8)参数:tabsize -- 此选项指定要替换为制表符“t' 的字符数.
返回值:此方法返回在制表符，即通过空格进行了扩展字符串，'t'的副本。
例子:
#!/usr/bin/python
str = "this iststring example....wow!!!";
print ("Original string: " + str);
print ("Defualt exapanded tab: " + str.expandtabs());
print ("Double exapanded tab: " + str.expandtabs(16));
print ("Double exapanded tab: " + str.expandtabs(30));运行上面的程序，它会产生以下结果：
Original string: this iststring example....wow!!!
Defualt exapanded tab: this iststring example....wow!!!
Double exapanded tab: this iststring example....wow!!!
Double exapanded tab: this iststring example....wow!!!find()方法的语法结构：
find()方法判断字符串str，如果起始索引beg和结束end索引能找到在字符串或字符串的一个子串中。
str.find(str, beg=0 end=len(string))参数：str -- 此选项指定要搜索的字符串。eg -- 这是开始索引，默认情况下为 0。end -- 这是结束索引，默认情况下它等于字符串的长度。
返回值：如果找到此方法返回的索引，否则返回-1。
例子：
#!/usr/bin/python
str1 = "this is string example...wow!!!";
str2 = "exam";
print(str1.find(str2));
print(str1.find(str2,10));
print(str1.find(str2,40));运行上面的程序，它会产生以下结果：
15
15
-1index()方法的语法结构：
index()方法确定字符串str，如果起始索引beg和结束索引end在末尾给出了找到字符串或字符串的一个子串。这个方法与find()方法一样，只是如果没有找到子符趾会抛出一个异常。
str.index(str, beg=0 end=len(string))参数：str -- 此选项指定要搜索的字符串。beg -- 这是开始索引，默认情况下是 0。end -- 这是结束索引，默认情况下它等于该字符串的长度。
返回值：方法返回索引，如果找到这个str；如果没有找到则抛出一个异常。
例子：
#!/usr/bin/python
str1 = "this is string example....wow!!!";
str2 = "exam";
print(str1.index(str2));
print(str1.index(str2, 10));
print(str1.index(str2, 40));运行上面的程序，它会产生以下结果：
Traceback (most recent call last):
15
File "F:/pythonDEV/简明python笔记/基本语法001/字符串001/index()字符串索引.py", line 8, in <module>
15
print(str1.index(str2, 40));
ValueError: substring not foundisalnum()方法的语法结构：
isalnum()方法检查判断字符串是否包含字母数字字符。
str.isa1num()参数：NA
返回值：如果字符串中的所有字符字母数字和至少有一个字符此方法返回 true，否则返回false。
例子：
#!/usr/bin/python
#isalnum全部字母为真，否则为假
str = "this2009"; # No space in this string 该字符串中没有空格
print str.isalnum();
str = "this is string example....wow!!!";
print str.isalnum();运行上面的程序，它会产生以下结果：
True
Falseislpha()方法的语法结构:
isalpha()方法检查字符串是否仅由字母组成。
str.isalpha()参数:NA
返回值:如果字符串中的所有字符字母和至少有一个字符此方法返回true，否则返回false。
例子:
#!/usr/bin/python
str = "this"; # No space & digit in this string
print (str.isalpha());
str = "this is string example....wow!!!";
print (str.isalpha());运行上面的程序，它会产生以下结果：
True
False
isdigit()方法的语法结构：
isdigit()方法检查字符串是否只包含数字(全由数字组成)。
str.isdigit()参数：NA
返回值：如果字符串中的所有字符都是数字，并至少有一个字符此方法返回true，否则返回false。
例子：
#!/usr/bin/python
str = "123456"; # only digit in this string
print(str.isdigit();)
str = "this is string example...wow!!!";
print(str.isdigit());运行上面的程序，它会产生以下结果：
True
Falseislower()方法的语法结构：
str.islower()参数：NA
返回值：如果字符串中的所有字符是小写且有至少有一个字符此方法返回true，否则返回false。
例子：
#!/usr/bin/python
# islower()确定字符串是小写
str = "THIS is string example....wow!!!";
print( str.islower());
str = "this is string example....wow!!!";
print (str.islower());
str = "this is STRING example....wow!!!";
print (str.islower());
运行上面的程序，它会产生以下结果：
False
True
Falseisnumeric()方法的语法结构：
isnumeric()方法检查字符串是否仅由数字组成。这种方法只表示为Unicode对象。
注意：要定义一个字符串为Unicode，只需前缀分配'u'引号。以下是示例。
str.isnumeric()参数：NA
返回值：如果字符串中的所有字符都是数字此方法返回true，否则返回false。
例子：
#!/usr/bin/python
str = u"this2009"
print(str.isnumeric());
str = u"23423232"
print(str.isnumeric());运行上面的程序，它会产生以下结果：
False
Trueisspace()方法的语法结构：
isspace()方法检查字符串是否包含空格。
str.isspace()参数：NA
返回值：如果有字符串中只有空白字符并且至少有一个字符此方法返回true，否则返回false。
例子：
#!/usr/bin/python
str = " ";
print(str.isspace());
str = "This is string example...wow!!";
print(str.isspace());运行上面的程序，它会产生以下结果：
True
Falseistitle()方法的语法结构：
istitle()方法检查在字符串中的非casebased字母所有字符是否为大写字母，并且其他字符基于小写。
str.istitle()参数:NA
返回值:如果该字符串是一个titlecased字符串，至少有一个字符，比如大写字符，只能跟着无封装字符小写字符此方法返回true。它，否则返回false。
例子:
#!/usr/bin/python
#判断自字母大写
str = "This Is String Example...Wow!!!";
print (str.istitle());
str = "This is string example...wow!!!";
print (str.istitle());运行上面的程序，它会产生以下结果：
True
Falseisupper()方法的语法结构：
isupper()方法检查字符串的所有基于大小写的字符(字母)是否是大写。
str.isupper()参数:NA
返回值:如果字符串中的所有字符是大写字母并且至少有一个可大小写字符此方法返回true，否则返回false。
例子:
#!/usr/bin/python
str = "THIS IS STRING EXAMPLE....WOW!!!";
print(str.isupper());
str = "THIS is string example....wow!!!"
print(str.isupper());
运行上面的程序，它会产生以下结果：
True
Falsejoin()方法的语法结构：
join()方法方法返回一个在序列的字符串元素被加入了由str分隔的字符串。
str.join(sequence)参数：sequence -- 这是要连接的元素的顺序。
返回值：此方法返回一个字符串，在序列seq字符串的连接。元素之间的分离器是字符串 str。
例子：
#!/usr/bin/python
str = "-";
seq = ("a","b","c");#This is sequence of strings.
print(str.join(seq));
运行上面的程序，它会产生以下结果：
a-b-clen()方法的语法结构：
len()方法返回字符串的长度。
len( str )参数：NA
返回值：此方法返回的字符串的长度。
例子：
#!/usr/bin/python
str = "this is string example....wow!!!";
print "Length of the string: ", len(str);运行上面的程序，它会产生以下结果：
Length of the string: 32ljust()方法的语法结构：
ljust()方法返回字符串左对齐的字符串长度宽度。填充是通过使用指定的fillchar（默认为空格）。如果宽度小于len(s)返回原始字符串。
str.ljust(width[, fillchar])参数：width -- 这是填充后字符串的总长度。fillchar -- 这是填充符，默认为空格。
返回值：此方法返回字符串左对齐的字符串的长度宽度。填充是通过使用指定fillchar（默认为空格）。如果宽度小于len(s)，返回原始字符串。
例子：
#!/usr/bin/python
str = "this is string example....wow!!!";
print(str.ljust(50,'0'));
运行上面的程序，它会产生以下结果：
this is string example....wow!!!000000000000000000lower()方法的语法结构：
lower()方法返回所有基于大小写的字符被转换为小写字符串的一个副本。
str.lower()参数:NA
返回值:此方法返回的所有基于大小写字符被转化为小写字符串的一个副本。
例子:
#!/usr/bin/python
str = "THIS IS STRING EXAMPLE....WOW!!!";
print(str.lowr());
运行上面的程序，它会产生以下结果：
this is string example....wow!!!lstrip()方法的语法结构：
lstrip()方法返回所有字符被去除开头字符串(缺省为空格字符)的一个复本。
str.lstrip([chars])参数：chars -- 您提供要剪裁的字符。
返回值：此方法返回所有字符都被去除字符串开头(缺省为空格字符)的字符串的一个复本。
例子：
#!/usr/bin/python
str = " this is string example...WOW!!!"
print (str.lstrip());
str = "8888888888888888888888888888888this is string example...wow!!!88888888";
print(str.lstrip('8'))
运行上面的程序，它会产生以下结果：
this is string example...WOW!!!
this is string example...wow!!!88888888maketrans()方法的语法结构：返回要用于转换功能的转换表
maketrans()方法返回的字符串intab每个字符映射到字符的字符串outtab相同位置的转换表。然后这个表被传递到translate()函数。
注意：两个intab和outtab必须具有相同的长度。
str.maketrans(intab, outtab]);参数：intab -- 这是实际字符的字符串。outtab -- 这是相应的映射的字符的字符串。
返回值：此方法返回时使用转换表translate()函数。
例子：
#!/usr/bin/python
from string import maketrans #Required to call maketrans function.需要调用maketrans函数。
intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab,outtab)
str = "this is string example...wow!!!";
print(str.translate(trantab))
运行上面的程序，它会产生以下结果：
th3s 3s str3ng 2x1mpl2....w4w!!!#3.0已经被弃用，以后有时间继续解决max()方法的语法结构：
max()方法返回字符串str中的最大字母字符。
max(str)参数：str --这是被返回的最大值字母字符的字符串。
返回值：此方法从字符串str中返回最大值字母字符。
例子：
#!/usr/bin/python
str = "this is really a string example....wow!!!";
print( "Max character: " + max(str));
str = "this is a string example....wow!!!";
print ("Max character: " + max(str));运行上面的程序，它会产生以下结果：
Max character: y
Max character: xmin()方法的语法结构：
min()方法返回字符串str中的最小字母字符。
min(str)参数：str -- 这是最小字母字符需要被返回的字符串。
返回值：此方法从字符串str中返回最小值字母字符。
例子：
#!/usr/bin/python
str = "this-is-real-string-example...wow!!!";
print("Min chracter:" + min(str));
str = "this-is-a-string-example...wow!!!"
print("Min character: " + min(str));运行上面的程序，它会产生以下结果：
Min character: !
Min character: !replace()方法的语法结构：
（取代了旧的所有出现在字符串使用新的或max，如果给定max）
replace()方法返回当前old换成new，可选择的替代限制到最大数量的字符串的副本。
str.replace(old, new[, max])参数：old -- 这是要进行更换的旧子串。new -- 这是新的子串，将取代旧的子字符串。max -- 如果这个可选参数max值给出，仅第一计数出现被替换。
返回值：此方法返回字符串的拷贝与旧子串出现的所有被新的所取代。如果可选参数最大值给定，只有第一个计数发生替换。
例子：
#!/usr/bin/python
str = "this is string example....wow!!! this is really string is o is";
print (str.replace("is", "was"));
print (str.replace("is", "was", 3));
print (str.replace("is", "was", 2));
print (str.replace("is", "was", 1));运行上面的程序，它会产生以下结果：
thwas was string example....wow!!! thwas was really string was o was
thwas was string example....wow!!! thwas is really string is o is
thwas was string example....wow!!! this is really string is o is
thwas is string example....wow!!! this is really string is o isrfind()方法的语法结构：
与find()一样，但反向搜索字符串
rfind()方法返回所在子str 被找到的最后一个索引，或者-1，如果没有这样的索引不存在，可选择限制搜索字符串string[beg:end].
str.rfind(str, beg=0 end=len(string))参数：str -- 此选项指定要搜索的字符串、beg -- 这是开始索引，默认情况下为 0、end -- 这是结束索引，默认情况下它等于该字符串的长度
返回值：此方法如果找到返回最后一个索引，否则返回-1
例子：
#!/usr/bin/python
str = "this is really a string example ... wow!!!";
str2 = "is";
print(str.rfind(str));
print(str.rfind(str,0,10));
print(str.rfind(str,10,0));
print(str.find(str));
print(str.find(str,0,10));
print(str.find(str,10,0));
运行上面的程序，它会产生以下结果：
5
5
-1
2
2
-1
rindex()方法的语法结构：
rindex()方法返回所在的子str被找到的最后一个索引，可选择限制搜索的字符串string[beg:end] 如果没有这样的索引存在，抛出一个异常。
str.rindex(str, beg=0 end=len(string))参数：str -- 此选项指定要搜索的字符串。beg -- 这是开始索引，默认情况下为 0、len -- 这是最后的索引，默认情况下它等于字符串的长度。
返回值：此方法如果找到返回最后一个索引，否则如果没有找到str引发一个异常。
例子：
#!/usr/bin/python
str1 ="this is string example...wow!!!";
str2 = "is";
print (str1.rindex(str2))
print(str1.index(str2))运行上面的程序，它会产生以下结果：
5
2rjust()方法的语法结构：
rjust()该方法返回字符串合理字符串的右边的长度宽度。填充是通过使用指定的fillchar(默认为空格)。如果宽度小于len(s)返回原始字符串。
str.rjust(width[,fillchar])参数:width -- 这是字符串填充后总共的长度。fillchar -- 这是填充字符，默认为空格。
返回值:此方法返回字符串合理字符串的右边的长度宽度。填充是通过使用指定的fillchar(默认为空格)。如果宽度小于 len(s)返回原始字符串。
例子:
#!/usr/bin/python
str = "this is string example...wow!!!";
print (str.rjust(50,'0'));
#print(str.just(50,'0'));
print(str.ljust(50,'0'));
print(str.center(50,'0'));
print(str.zfill(50));运行上面的程序，它会产生以下结果：
0000000000000000000this is string example...wow!!!
this is string example...wow!!!0000000000000000000
000000000this is string example...wow!!!0000000000
0000000000000000000this is string example...wow!!!rstrip()方法的语法结构：
rstrip()方法返回所有字符都被去除的字符串(缺省为空格字符)结束字符串的副本。
str.rstrip([chars])参数：chars -- 可以提供要去除的字符。
返回值：此方法返回的所有字符都被去除的字符串(缺省为空格字符)结束字符串的副本。
例子：
#!/usr/bin/python
str = "this is string example...wow!!!";
print(str.rstrip());
str = "88888888this is string example....wow!!!8888888";
print(str.rstrip('8'));
print(str.lstrip('8'));
print(str.strip('8'));
运行上面的程序，它会产生以下结果：
this is string example...wow!!!
88888888this is string example....wow!!!
this is string example....wow!!!8888888
this is string example....wow!!!
split()方法的语法结构：
split()方法返回的字符串中的所有单词的列表，使用str作为分隔符(如果在未指定的所有空格分割)，可选择限当前分割为数量num。
str.split(str="",num=string.count(str)).参数:str -- 这是任何分隔符，默认情况下是空格。num -- 这是要分割的行数。
返回值:此方法返回行列表。
例子:
#!/usr/bin/python
#split()方法返回的字符串中的所有单词的列表
str = "Line1-abcdef nLine2-abc nLine4-abcd";
print(str.split());
print(str.split(' ',1));
print (str.split(' ',2));
运行上面的程序，它会产生以下结果：
['Line1-abcdef', 'nLine2-abc', 'nLine4-abcd']
['Line1-abcdef', 'nLine2-abc nLine4-abcd']
['Line1-abcdef', 'nLine2-abc', 'nLine4-abcd']
splitlines()方法的语法结构：
splitlines()方法返回一个字符串的所有行，可选包括换行符列表(如果num提供，则为true)
str.splitlines( num=string.count('n'))参数：num -- 这是任何数，如果存在它会被认为换行需要被包括行数。
返回值：如果找到匹配的字符串此方法返回true，否则为false。
例子：
#!/usr/bin/python
#str.splitlines( num=string.count('\n'))
#返回splitlines()方法返回一个字符串的所有行
str = "Line1-a b c d e f\nLine2- a b c\n\nline4- a b c d";
print(str.splitlines());
print(str.splitlines(0));
print(str.splitlines(1));
print(str.splitlines(2));
print(str.splitlines(3));
print(str.splitlines(4));
print(str.splitlines(5));
运行上面的程序，它会产生以下结果：
['Line1-a b c d e f', 'Line2- a b c', '', 'line4- a b c d']
['Line1-a b c d e f', 'Line2- a b c', '', 'line4- a b c d']
['Line1-a b c d e f\n', 'Line2- a b c\n', '\n', 'line4- a b c d']
['Line1-a b c d e f\n', 'Line2- a b c\n', '\n', 'line4- a b c d']
['Line1-a b c d e f\n', 'Line2- a b c\n', '\n', 'line4- a b c d']
['Line1-a b c d e f\n', 'Line2- a b c\n', '\n', 'line4- a b c d']
['Line1-a b c d e f\n', 'Line2- a b c\n', '\n', 'line4- a b c d']startswith()方法的语法结构：
startswith()方法检查字符串是否以str开始，任选限制匹配与给定索引的开始和结束。
str.startswith(str, beg=0,end=len(string));参数：str -- 这是要检查的字符串。beg -- 这是可选的参数设置匹配边界的初始索引。end -- 这是可选的参数设置匹配边界的结束索引。
返回值：“”如果找到匹配的字符串此方法返回true，否则为false。
例子：
#!/usr/bin/python
str = "this is string example...wow!!!";
print(str.startswith('this'));
print(str.startswith('is',2,4));
print(str.startswith('this',2,4));
运行上面的程序，它会产生以下结果：
True
True
Falsestrip()方法的语法结构：
strip()方法返回所有字符从开始及字符串的末尾(默认空格字符)被去除后的字符串的一个副本。
str.strip([chars]);参数：chars -- 字符-从开始或结束的字符串被删除去除。
返回值：此方法返回所有字符从开始及字符串的末尾(默认空格字符)被去除后的字符串的一个副本。
例子：
#!/usr/bin/python
str = "0000000this is string example....wow!!!0000000";
print (str.strip( '0' ));
运行上面的程序，它会产生以下结果：
this is string example....wow!!!swapCase()方法的语法结构：
str.swapcase();swapCase()方法返回所有可大小写，基于字符大小写交换字符串的一个副本。
参数：NA
返回值：此方法返回其中所有基于大小写字符交换字符串的一个副本。
例子：
#!/usr/bin/python
str = "this is string example...wow!!!";
print(str.swapcase());
str = "THIS IS STARING EXAMPLE...WOW!!!";
print(str.swapcase());运行上面的程序，它会产生以下结果：
THIS IS STRING EXAMPLE....WOW!!!
this is string example....wow!!!title()方法的语法结构：
title()方法返回所有单词的第一个字符大写的字符串的一个副本。
str.title();参数：NA
返回值：此方法返回其中所有单词的前几个字符都是大写的字符串的一个副本。
例子：
#!/usr/bin/python
str = "this is string example...wow!!!"
print(str.title());运行上面的程序，它会产生以下结果：
This Is String Example....Wow!!!translate()方法的语法结构：
translate()方法返回的所有字符都被翻译usingtable字符串的拷贝(用maketrans()函数构造(string模块))，选择性删除的字符串在deletechars中找到的所有字符。
str.translate(table[,deletechars]);
参数:table -- 可以使用maketrans()辅助函数的字符串模块来创建一个转换表。deletechars -- 可以从源字符串中删除的字符的列表。
返回值:此方法返回字符串的翻译件。
例子:
#!/usr/bin/python
intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab,outtab)
str = "this is string examp...wow!!!";
print(str.translate(trantab));运行上面的程序，它会产生以下结果：
th3s 3s str3ng 2x1mp...w4w!!!以下是从字符串中删除'x'和'm'字符的示例：
#!/usr/bin/python
intab = "aeiou"
outtab = "12345"
remove='w'
trantab = str.maketrans(intab,outtab,remove)
str = "this is string example...wow!!!";
print(str.translate(trantab));运行上面的程序，它会产生以下结果：
th3s 3s str3ng 21pl2....w4w!!!upper()方法的语法结构：
upper()方法返回所有基于大小写字符被转换为大写字符串的一个副本。
str.upper参数:NA
返回值:此方法返回所有基于字符被转换为大写的字符串的一个副本。
例子:
#!/usr/bin/python
str = "tis is string example...wow!!!";
print("str.capitalize():",str.upper())运行上面的程序，它会产生以下结果：
str.capitalize(): TIS IS STRING EXAMPLE...WOW!!!
zfill()方法的语法结构：
zfill()方法用零垫串来填充左边宽度。
str.zfill(width)参数：width -- 这是字符串的最终宽度，即填充零后得到的宽度。
返回值：此方法返回补齐的字符串。
例子：
#!/usr/bin/python
str = "this is string example....wow!!!";
print(str.zfill(40));
print(str.zfill(50));运行上面的程序，它会产生以下结果：
00000000this is string example....wow!!!
000000000000000000this is string example....wow!!!isdecimal()方法的语法结构：
str.isdecimal()参数：NA
返回值：如果字符串中的所有字符为十进制此方法返回true，否则返回false。
例子：
#!/usr/bin/python
str = u"this2009";
print (str.isdecimal());
str = u"23443434";
print (str.isdecimal());运行上面的程序，它会产生以下结果：
False
True
CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！
更多推荐
0
0- 0
已为社区贡献5条内容
所有评论(0)