12.1-创建字符串：
第一种方式：
>>> s = "hello world"
>>> type(s)
<class 'str'>
第二种方式：
>>> s = str("hello world")
>>> type(s)
<class 'str'>
12.2-字符串（str）内部方法介绍：
capitalize(self)：
说明：首字母变大写。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abc"
# capitalize() 表示首字母变大写
s2 = s1.capitalize()
print(s2)
运行结果：
casefold(self)：
说明：字符串变小写，Unicode 编码中凡是有对应的小写形式的，都会转换。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "ABC"
# casefold() 表示字符串变小写
s2 = s1.casefold()
print(s2)
运行结果：
center(self, width, fillchar=None)：
说明：内容居中， width 定义总长度，fillchar 表示空白处填充内容，默认无。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abc"
# 内容居中，总长度为 20 ，填充内容为 "*"
s2 = s1.center(20,"*")
print(s2)
运行结果：
count(self, sub, start=None, end=None)：
说明：查看指定子序列在字符串中出现的次数， sub 表示要指定的子序列， start 指定开始搜索的位置，默认从第一个字符开始，第一个字符索引位置为0， end 指定结束搜索的位置，默认为最后一位。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabcabc"
# 查看 "b" 在这个字符串里出现的次数
s2 = s1.count("b")
print(s2)
# 指定范围，查看 "b" 在这个字符串里出现的次数
s3 = s1.count("b",2,5)
print(s3)
运行结果：
encode(self, encoding='utf-8', errors='strict')：
说明：以指定的编码格式编码字符串，编码后的字符串是一个 bytes 对象， encoding 表示要使用的编码，默认为 utf-8 ， errors 指定不同的错误处理方案。
注：由于Python3中字符串没有 decode() 方法，所以可以使用 bytes 对象的 decode() 方法来进行解码。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "中文"
s2_utf = s1.encode("utf-8")
print("utf-8编码：",s2_utf)
s3_gbk = s1.encode("gbk")
print("gbk编码：",s3_gbk)
s4_utf = s2_utf.decode("utf-8")
print("utf-8解码：",s4_utf)
s5_gbk = s3_gbk.decode("gbk")
print("gbk解码：",s5_gbk)
运行结果：
endswith(self, suffix, start=None, end=None)：
说明：判断字符串是否以xxx结尾，如果是以xxx结尾返回 True ，否则返回 False ， suffix 表示指定后缀 start 表示开始的位置， end 表示结束的位置。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabcabc"
# 查看这个字符串是否以 "abc" 结尾
s2 = s1.endswith("abc")
print(s2)
# 指定范围，查看这个字符串是否以 "c" 结尾
s3 = s1.endswith("c",0,6)
print(s3)
# 指定范围，查看这个字符串是否以 "c" 结尾
s4 = s1.endswith("b",0,6)
print(s4)
运行结果：
expandtabs(self, tabsize=8)：
说明：将字符串中的 tab 符号（即制表符 \t ），转换成空格， tabsize 表示将字符串中的一个 tab 符号转换为多少个空格，默认为8个。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabc\tabc"
# 将一个 tab 符号 (即制表符 \t ) 转换为 20 个空格
s2 = s1.expandtabs(20)
print(s2)
运行结果：
find(self, sub, start=None, end=None)：
说明：在字符串中查找指定子序列的位置，如果存在返回指定子序列的索引值，否则返回-1， sub 表示指定的子序列， start 表示开始的位置， end 表示结束的位置。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabcabc"
# 查找 "c" 所在的位置（从左往右查找，找到第一个后就不会往下继续查找了）
s2 = s1.find("c")
print(s2)
#指定范围查找 "c" 所在的位置
s3 = s1.find("c",3,6)
print(s3)
# 如果 "d" 不存在字符串中，就会返回 -1
s4 = s1.find("d")
print(s4)
运行结果：
format(*args, **kwargs)：
说明：字符串格式化，动态参数。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 如果不设置指定位置，按默认顺序（"{}" 相当于占位符）
s1 = "Hello {} , Hello {}"
s2 = s1.format("World","China")
print(s2)
# 如果设置指定位置，可以不按顺序
s3 = "Hello {1} , Hello {0} , Hello {1}"
s4 = s3.format("World","China")
print(s4)
运行结果：
format_map(self, mapping)：
说明：字符串格式化，和 format(*args, **kwargs) 类似，只不过 mapping 是一个字典对象。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
dic = {
"name" : "L",
"age" : 18
}
s1 = "hello {name} , age {age}".format_map(dic)
print(s1)
运行结果：
index(self, sub, start=None, end=None)：
说明：与 find() 类似，在字符串中查找指定子序列的位置，如果存在返回指定子序列的索引值，否则报错，sub 表示指定的子序列， start 表示开始的位置， end 表示结束的位置。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabcabc"
# 查找 "d" 的位置，如果没有找到报错
s2 = s1.index("d")
print(s2)
运行结果：
isalnum(self)：
说明：判断字符串是否是字母和数字的任意组合，如果是返回 True ，否则返回 False 。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 是 字母 和 数字 的任意组合，返回 True
s1 = "abcabc123"
s2 = s1.isalnum()
print(s2)
# 只包含字母或数字 返回 True
s3 = "abc".isalnum()
print(s3)
s4 = "123".isalnum()
print(s4)
# 如包含空格、小数点等符号则返回 False
s5 = "abc 123".isalnum()
print(s5)
s6 = "abc123.".isalnum()
print(s6)
运行结果：
isalpha(self)：
说明：判断字符串是否只由字母组成，如果是返回 True ，否则返回 False 。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 只包含 字母 返回 True
s1 = "abcabc"
s2 = s1.isalpha()
print(s2)
# 包含 字母 和 数字 返回 False
s3 = "abc123".isalpha()
print(s3)
运行结果：
isdecimal(self)：
说明：判断字符串是否只包含十进制数字，如果是返回 True ，否则返回 False ，定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 只包含 十进制数字 返回 True
s1 = "123".isdecimal()
print(s1)
# 包含 其它 返回 False
s2 = "root123".isdecimal()
print(s2)
运行结果：
isdigit(self)：
说明：判断字符串是否只由数字组成，如果是返回 True ，否则返回 False 。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 只包含 数字 返回 True
s1 = "123".isdecimal()
print(s1)
# 包含 其它 返回 False
s2 = "root123".isdecimal()
print(s2)
运行结果：
isidentifier(self)：
说明：判断字符串是否为合法的标识符，如果是返回 True ，否则返回 False 。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "statr".isidentifier()
print(s1)
s2 = "start_123".isidentifier()
print(s2)
s3 = "123start".isidentifier()
print(s3)
s4 = "start#".isidentifier()
print(s4)
运行结果：
islower(self)：
说明：判断字符串中所有字母是否为小写，如果是返回 True ，否则返回 False 。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 都是小写，返回 True
s1 = "abcabc".islower()
print(s1)
# 包含数字、中文，但是字母为小写，返回 True
s2 = "abc123中文".islower()
print(s2)
# 只要有一个字母为大写，则返回 False
s3 = "aBc".islower()
print(s3)
运行结果：
isnumeric(self)：
说明：字符串是否只由数字组成。这种方法是只针对unicode对象，定义一个字符串为Unicode，只需要在字符串前添加 'u' 前缀即可。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 只由 数字 组成 返回 True
s1 = u"123456".isnumeric()
print(s1)
# 包含 数字 和 字母 返回 False
s2 = u"abc123".isnumeric()
print(s2)
运行结果：
isprintable(self)：
说明：判断字符串中所有的字符是否为可打印字符或字符串为空，如果是返回 True ，否则返回 False 。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 可打印，返回 True
s1 = "abc123".isprintable()
print(s1)
# 字符串为空，返回 True
s2 = "".isprintable()
print(s2)
运行结果：
isspace(self)：
说明：判断字符串是否全部为空格，如果是返回 True ，否则返回 False 。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 全部为 空格 返回 True
s1 = " ".isspace()
print(s1)
#不全部为 空格 返回 False
s2 = "abc 123".isspace()
print(s2)
运行结果：
istitle(self)：
说明：判断字符串是否为标题，如果是返回 True ，否则返回 False ，所有首字母大写的为标题。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 为 标题 返回 True
s1 = "Abc".istitle()
print(s1)
# 为 标题 返回 True
s2 = "Abc Abc".istitle()
print(s2)
# 不为 标题 返回 False
s3 = "ABc".istitle()
print(s3)
运行结果：
isupper(self)：
说明：判断字符串中的所有字符是否为大写，如果是返回 True ，否则返回 False 。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 字母 全部为 大写 返回 True
s1 = "ABCABC".isupper()
print(s1)
# 字母 和 数字 组合 ，字母为大写 返回 True
s2 = "ABC123".isupper()
print(s2)
# 字母 其中有小写 返回 False
s3 = "ABCabc".isupper()
print(s3)
运行结果：
join(self, iterable)：
说明：用指定字符串，将可迭代对象拼接起来并生成一个新的字符串， iterable 表示接受可迭代的对象。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
l1 = ["abc","def","ghi"]
# 这个方法会去循环 "l1" 中的每一个元素，让元素与元素之间通过 "_" 拼接起来，并变成字符串
s1 = "_".join(l1)
print(s1)
运行结果：
ljust(self, width, fillchar=None)：
说明：内容左对齐， width 定义总长度，fillchar 表示右侧空白处填充内容，默认无。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabc"
# 内容左对齐，总长度为 20 ，填充内容为 "_"
s2 = s1.ljust(20,"_")
print(s2)
运行结果：
lower(self)：
说明：字符串变小写，对 ASCII 编码的字母有效。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "ABC"
# lower() 表示字符串变小写
s2 = s1.lower()
print(s2)
运行结果：
lstrip(self, chars=None)：
说明：截掉字符串左侧的空格或指定字符， chars 表示指定截掉的字符，默认为空格。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#截掉左侧空格
s1 = " abcabc"
s2 = s1.lstrip()
print(s2)
# 截掉左侧指定字符 "*"
s3 = "***abcabc"
s4 = s3.lstrip("*")
print(s4)
运行结果：
maketrans(self, *args, **kwargs)：
说明：创建字符映射的转换表，以供 translate 方法使用，如果接收两个参数，字符串的长度必须相等，而且两个参数需要形成映射，第一个参数是字符串表示需要转换的字符，第二个参数也是字符串表示转换后的字符。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabc"
# 根据 maketrans() 创建一个转换表
dic = str.maketrans("ac","xl")
# 根据 translate() 进行转换
s2 = s1.translate(dic)
print(s2)
运行结果：
partition(self, sep)：
说明：根据指定分隔符将字符串分割为前、中、后三部分，并返回一个元组， sep 表示指定分隔符。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abc def ghi"
# 根据 "def" 进行分割为三部分，并生成一个元组
s2 = s1.partition("def")
print(s2)
print(type(s2))
运行结果：
replace(self, old, new, count=None)：
说明：将字符串中的字符进行替换， old 表示将被替换的字符， new 表示替换后的字符， count 表示替换的次数，默认全部替换。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabcabcabc"
#将 "ab" 全部替换为 "cc"
s2 = s1.replace("ab","cc")
print(s2)
#从左侧开始替换，只替换两个
s3 = s1.replace("ab","cc",2)
print(s3)
运行结果：
rfind(self, sub, start=None, end=None)：
说明：和 find() 类似，在字符串中查找指定子序列的位置，如果存在返回指定子序列的索引值，否则返回-1，只不过是从右侧开始查找。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabcabc"
# 查找 "c" 所在的位置（从右往左查找）
s2 = s1.rfind("c")
print(s2)
#指定范围查找 "c" 所在的位置
s3 = s1.rfind("c",3,6)
print(s3)
# 如果 "d" 不存在字符串中，就会返回 -1
s4 = s1.rfind("d")
print(s4)
运行结果：
rindex(self, sub, start=None, end=None):
说明：和index() 类似，在字符串中查找指定子序列的位置，如果存在返回指定子序列的索引值，否则报错，只不过是从右侧开始查找。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabcabc"
# 查找 "d" 的位置，如果没有找到报错（从右侧开始查找）
s2 = s1.rindex("d")
print(s2)
运行结果：
rjust(self, width, fillchar=None)：
说明：内容右对齐， width 定义总长度，fillchar 表示左侧空白处填充内容，默认无。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabc"
# 内容右对齐，总长度为 20 ，填充内容为 "_"
s2 = s1.rjust(20,"_")
print(s2)
运行结果：
rpartition(self, sep)：
说明：和 partition() 类似，根据指定分隔符将字符串分割为前、中、后三部分，并返回一个元组，只不过是从右侧开始查找分隔符。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abc abc ghi"
# 根据 "abc" 进行分割为三部分，并生成一个元组（从右侧开始查找分隔符）
s2 = s1.rpartition("abc")
print(s2)
print(type(s2))
运行结果：
rsplit(self, sep=None, maxsplit=-1)：
说明：从右到左通过指定分隔符对字符串进行切片，并返回一个列表， sep 表示指定分割符，默认为空格， maxsplit 表示分割次数，默认全部分割。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abc_def_ghi"
# 根据 "_" 进行分割，并返回一个列表
s2 = s1.rsplit("_")
print(s2)
print(type(s2))
# 指定了分割次数（从右侧开始查找分隔符）
s3 = s1.rsplit("_",1)
print(s3)
print(type(s3))
运行结果：
rstrip(self, chars=None)：
说明：和 lstrip() 类似，截掉字符串右侧的空格或指定字符， chars 表示指定截掉的字符，默认为空格。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#截掉右侧空格
s1 = "abcabc "
s2 = s1.rstrip()
print(s2)
# 截掉右侧指定字符 "*"
s3 = "abcabc***"
s4 = s3.rstrip("*")
print(s4)
运行结果：
split(self, sep=None, maxsplit=-1)：
说明：和 rsplit() 类似，从左到右通过指定分隔符对字符串进行切片，并返回一个列表， sep 表示指定分割符，默认为空格， maxsplit 表示分割次数，默认全部分割。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abc_def_ghi"
# 根据 "_" 进行分割，并返回一个列表
s2 = s1.split("_")
print(s2)
print(type(s2))
# 指定了分割次数（从左侧开始查找分隔符）
s3 = s1.split("_",1)
print(s3)
print(type(s3))
运行结果：
splitlines(self, keepends=None)：
说明：根据换行进行分割，并返回一个列表， keepends 表示列表中是否包含换行符，默认不包含。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = """abc
def
ghi"""
# 根据换行分割 返回一个包含各行作为元素的列表,换行符不包括在结果列表里
l1 = s1.splitlines()
print(l1)
# 参数 keepends 为 True 则包含换行符 否则 不包含换行符
l2 = s1.splitlines(1)
print(l2)
运行结果：
startswith(self, prefix, start=None, end=None)：
说明：判断字符串是否是以指定字符开头，如果是返回 True ，start 表示开始的位置， end 表示结束的位置。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "hello world"
# 查看这个字符串是否以 "he" 开头
s2 = s1.startswith("he")
print(s2)
# 指定范围，查看这个字符串是否以 "l" 开头
s3 = s1.startswith("l",4,7)
print(s3)
运行结果：
strip(self, chars=None)：
说明：和 lstrip() 、 rstrip() 类似，截掉字符串左右两侧的空格或指定字符， chars 表示指定截掉的字符，默认为空格。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
#截掉左右两侧侧空格
s1 = " abcabc "
s2 = s1.strip()
print(s2)
# 截掉左右两侧指定字符 "*"
s3 = "***abcabc***"
s4 = s3.strip("*")
print(s4)
运行结果：
swapcase(self)：
说明：字符串的大小写字母进行转换，大写变小写，小写变大写。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcABC"
#大写变小写，小写变大写
s2 = s1.swapcase()
print(s2)
运行结果：
title(self)：
说明：返回 标题化 的字符串,就是说所有单词都是以大写开始，其余字母均为小写。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "hEelo woRld"
s2 = s1.title()
print(s2)
运行结果：
translate(self, table)：
说明：根据参数 table 给出的表将字符串中的字符进行转换， table 表示转换表，就是通过maketrans方法创建的表。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabc"
# 根据 maketrans() 创建一个转换表
dic = str.maketrans("ac","xl")
# 根据 translate() 进行转换
s2 = s1.translate(dic)
print(s2)
运行结果：
upper(self)：
说明：将字符串中的小写字母转换为大写字母。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabc"
# 将小写字母 转换为 大写字母
s2 = s1.upper()
print(s2)
运行结果：
zfill(self, width)：
说明：返回指定长度的字符串，原字符串右对齐，左侧填充 "0" ，width 定义总长度。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcabc"
# 原字符串右对齐，左侧填充 "0"
s2 = s1.zfill(20)
print(s2)
运行结果：
12.3-索引：
可以根据每个元素的位置索引来找到对应的元素，位置索引又称为下标，下标都是从 0 开始的。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcdefg"
# 获取字符串中的第一个元素
print("第一个元素:",s1[0])
# 获取字符串中的第四个元素
print("第四个元素:",s1[3])
# 获取字符串中最后一个元素
print("最后一个元素:",s1[-1])
# 获取字符串中倒数第三个元素
print("倒数第三个元素:",s1[-3])
运行结果：
12.4-查看字符串长度：
可以通过 len() 函数来查看字符串的长度。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcdefg"
# 获取字符串的长度
print(len(s1))
运行结果：
12.5-切片：
即指定范围来获取多个元素， s1[2:8:2] 第一个数字表示起始下标称为 下限 ，第二个数字表示结束下标称为 上限 ，第三个数字表示间隔数称为 步长 ，默认步长为 1 ，表示下限和上限之间的每一个元素都会出现在结果中。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcdefg"
# 获取字符串中前三个元素
print("前三个元素:",s1[0:3])
# 从头开始获取时，可以忽略 下限
print("忽略下限:",s1[:3])
#取全部，不能填写 -1
print("取全部填写-1的:",s1[:-1])
print("取全部未填写-1的:",s1[0:])
#每隔两个两个元素就获取一个
print("隔两个元素:",s1[::3])
运行结果：
12.6-str类型和bytes类型相互转换
以 UTF-8 编码，一个汉字三个字节，以 GBK 编码，一个汉字两个字节，一个字节是八位。
Python 3.5.1：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "zhongwen"
for i in s1:
print(i)
s2 = "中文"
for i in s2:
print(i)
运行结果：
通过上面的实例可以看出，在 Python 3.5.1 ，通过 for 循环字符串时，不管是字母还是中文，都是一个字符一个字符输出的。
Python 2.7.2：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "zhongwen"
for i in s1:
print(i)
s2 = "中文"
for i in s2:
print(i)
运行结果：
通过上面的实例可以看出，而在 Python 2.7.2 中，通过 for 循环字符串时，是按照字节进行输出的，所以在输出中文的时候是乱码，因为 UTF-8 编码，一个汉字是三个字节，所以会输出六个乱码的字符。
str类型和bytes类型相互转换：
在 Python 3.5.1 中，既可以把字符转换成字节，也可以把字节转换成字符，通过 bytes() 函数即可，可以将字符串转换成字节。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "中"
for i in s1:
print(i)
b1 = bytes(i,encoding="utf-8")
#输出十六进制，"\xe4"是十六进制的字符
print(b1)
# 字节默认是以 十六进制 表示，而用 for 循环输出每一个元素的时候，默认会输出 十进制
# "228" 表示 十进制，"0b11100100" 表示 二进制
for s in b1:
print("十进制:",s,"二进制:",bin(s))
运行结果：
def __init__(self, value='', encoding=None, errors='strict'): # known special case of str.__init__
"""
str(object='') -> str
str(bytes_or_buffer[, encoding[, errors]]) -> str
说明：通过源码可以看出，str 接受两个参数时，第一个参数需要是 bytes 对象， encoding 表示以什么编码将字节转换成字符串。
>>> b1 = bytes("中文",encoding="gbk")
>>> b1
b'\xd6\xd0\xce\xc4'
>>> s1 = str(b1,encoding="gbk")
>>> s1
'中文'
12.7-练习题：
通过while循环输出a、b、c....案例：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcdefg"
start = 0
while start < len(s1):
print(s1[start])
start += 1
运行结果：
通过for循环输出a、b、c....案例：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcdefg"
for i in s1:
print(i)
运行结果：
通过for循环遇到c不输出案例：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcdefg"
for i in s1:
if i == "c":
continue
print(i)
运行结果：
通过for循环只输出a案例：
#!/usr/bin/env python
# -*- coding:utf-8 -*-
s1 = "abcdefg"
for i in s1:
if i == "b":
break
print(i)
运行结果：
网友评论