字符串
字符串定义和初始化
字符串是一个个字符组成的有序的序列，是字符的集合。使用单引号、双引号、三引号引住的字符序列，字符串是不可变对象，同时，从Python3起，字符串默认就是Unicode类型。
字符串访问——索引和切片
字符串支持使用索引访问，索引也就是下标。下标从0开始，同时支持负向索引。索引不能越界，越界会报错。
s1 = "abcdefghigklmnopqrst" print(s1[0]) # 获取第0个 print(s1[1]) 结果为： a b print(s1[-1]) # -1 表示倒数. print(s1[-2]) # 倒数第2个 结果为： t s print(s1[30]) 结果为： IndexError Traceback (most recent call last) <ipython-input-28-dbf7bde6c69e> in <module> ----> 1 print(s1[30]) IndexError: string index out of range
a = "abc"#有序的字符集合
for c in a:
print(c)
print(type(c))
结果为：
a
<class 'str'>
b
<class 'str'>
c
<class 'str'>
s = "abcd"#不可变对象
print(s[3])
s[3] = "ab"
结果为：
d
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-38-7b68ab5a92b8> in <module>
1 s = "abcd"
2 print(s[3])
----> 3 s[3] = "ab"
TypeError: 'str' object does not support item assignment
a = "abc"#可迭代
list(a)
结果为：
['a', 'b', 'c']
切片：也就是使用下标来截取部分字符串的内容
语法: str[start: end]
规则: 顾头不顾腚, 从start开始截取. 截取到end位置. 但不包括end。
s2 = "ABCDEFGHI" print(s2[-1:-5]) # 从-1 获取到 -5 这样是获取不到任何结果的. print(s2[-5:-1]) print(s2[-5:]) # 什么都不写就是最后了 print(s2[:-1]) # 这个是取到倒数第2个 print(s2[:])复制 结果为： EFGH EFGHI ABCDEFGH ABCDEFGHI
s2 = "ABCDEFGHI"
print(s2[1:5:2]) # 从第1个开始取, 取到第5个,每2个取1个
print(s2[:5:2]) # 从头开始到第五个. 每两个取1个
print(s2[4::2]) # 从4开始取到最后. 每两个取1个
print(s2[-5::2]) # 从-5取到最后.每两个取1个
print(s2[-1:-5]) # -1:-5什么都没有. 因为是从左往右获取的.
print(s2[-1:-5:-1]) # 步长是-1. 这时就从右往左取值了
print(s2[-5::-3]) # 从倒数第5个开始. 到最开始. 每3个取1个
print(s2[-5::-1])
结果为：
BD ACE EGI EGI IHGF EB EDCBA
字符串相关操作
字符串拼接
“+”，将2个字符串连接在一起，返回一个新字符串。
a = "123" b = "456" print(a+b) 结果为： 123456
"string".join(iterable) ，将可迭代对象连接起来，使用string作为分隔符 ，应该注意可迭代对象本身元素都是字符串，不然会报错，同时join返回的是一个新的字符串。
a = ["1","2","3"]
print("ac".join(a))
结果为：
1ac2ac3
a = ["1","2","3"]
print("".join(a))
结果为：
123
print("\n".join(a))
结果为：
1
2
3
lst = ["1",["a","b"],"3"]
print("".join(lst))
结果为：
TypeError Traceback (most recent call last)
<ipython-input-8-f7b095fd7311> in <module>
1 lst = ["1",["a","b"],"3"]
----> 2 print("".join(lst))
TypeError: sequence item 1: expected str instance, list found
lst = [1,"a","b"]
print("".join(lst))
结果为：
TypeError Traceback (most recent call last)
<ipython-input-12-8a54e8b948ce> in <module>
1 lst = [1,"a","b"]
----> 2 print("".join(lst))
TypeError: sequence item 0: expected str instance, int found
字符串分割
字符串的分割分为两类，一类为split系，一类为partition系。split将字符串按照分隔符分割成若干字符串，并返回列表，而partition将字符串按照分隔符分割成2段，返回这2段和分隔符的元组。
split(sep=None, maxsplit=-1) -> list of strings，从左至右 ，sep 指定分割字符串，缺省的情况下空白字符串作为分隔符，maxsplit 指定分割的次数，-1 表示遍历整个字符串。
s1 = "I'm \ta super student."
s1.split()
结果为：
["I'm", 'a', 'super', 'student.']
s1.split("s")
结果为：
["I'm \ta ", 'uper ', 'tudent.']
s1.split('super')
结果为：
["I'm \ta ", ' student.']
s1.split(' ')
结果为：
["I'm", '\ta', 'super', 'student.']
s1.split(' ',maxsplit=2)
结果为：
["I'm", '\ta', 'super student.']
s1.split('\t',maxsplit=4)
结果为：
["I'm ", 'a super student.']
s11 = "银王哈哈银王呵呵银王吼吼银王"
lst = s11.split("银王") #如果切割符在左右两端. 那么定会出现空字符串.深坑请留意
print(lst)
结果为:
['', '哈哈', '呵呵', '吼吼', '']
rsplit(sep=None, maxsplit=-1) -> list of strings，从右向左 ，sep 指定分割字符串，缺省的情况下空白字符串作为分隔符 ，maxsplit 指定分割的次数，-1 表示遍历整个字符串 。
s1 = "I'm \ta super student."
s1.rsplit()
结果为：
["I'm", 'a', 'super', 'student.']
s1.rsplit('s')
结果为：
["I'm \ta ", 'uper ', 'tudent.']
s1.rsplit('super')
结果为：
["I'm \ta ", ' student.']
s1.rsplit(' ')
结果为：
["I'm", '\ta', 'super', 'student.']
s1.rsplit(' ',maxsplit=2)
结果为：
["I'm \ta", 'super', 'student.']
s1.rsplit('\t',maxsplit=2)
结果为：
["I'm ", 'a super student.']
splitlines([keepends]) -> list of strings ，按照行来切分字符串 ，keepends 指的是是否保留行分隔符 ，行分隔符包括\n、\r\n、\r等 。
'ab c\n\nde fg\rkl\r\n'.splitlines() 结果为： ['ab c', '', 'de fg', 'kl'] 'ab c\n\nde fg\rkl\r\n'.splitlines(True) 结果为： ['ab c\n', '\n', 'de fg\r', 'kl\r\n'] s1 = '''I'm a super student. You're a super teacher.''' print(s1) print(s1.splitlines()) print(s1.splitlines(True)) 结果为： I'm a super student. You're a super teacher. ["I'm a super student.", "You're a super teacher."] ["I'm a super student.\n", "You're a super teacher."]"abc\n\n".splitlines()结果为:['abc', '']"abc\n\n".splitlines(True)结果为：['abc\n', '\n']
partition(sep) -> (head, sep, tail) ，从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；如果没有找到分隔符，就返回头、2个空元素的三元组 。sep 分割字符串，必须指定。
s1 = "I'm a super student."
s1.partition('s')
结果为:
("I'm a ", 's', 'uper student.')
s1.partition('stu')
结果为:
("I'm a super ", 'stu', 'dent.')
s1.partition('')
结果为:
ValueError Traceback (most recent call last)
<ipython-input-68-6703bd698c63> in <module>
----> 1 s1.partition('')
ValueError: empty separator
s1.partition('abc')
结果为:
("I'm a super student.", '', '')
rpartition(sep) -> (head, sep, tail) ,从右至左，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；如果没有找到分隔符，就返回2个空元素和尾的三元组。
字符串大小写
upper，lower，capitalize,title,swapcase。
"abc".upper()#全部转为为大写
结果为：
'ABC'
"ABC".lower()#全部转换为小写
结果为：
'abc'
"Bcd".swapcase()#大小写互换
结果为：
'bCD'
"abc".capitalize()#首字母大写
结果为：
'Abc'
# 应用, 校验⽤户输⼊的验证码是否合法
verify_code = "abDe"
user_verify_code = input("请输入验证码:")
if verify_code.upper() == user_verify_code.upper():
print("验证成功")
else:
print("验证失败")
# 每个被特殊字符隔开的字母首字母大写
s3 = "alex eggon,taibai*yinwang_麻花藤"
ret = s3.title()
print(ret)
# 中文也算是特殊字符
s4 = "ale傻逼usir"
print(s4.title())
结果为：
Alex Eggon,Taibai*Yinwang_麻花藤
Ale傻逼Usir
字符串排版
title() -> str ，标题的每个单词都大写 ，capitalize() -> str ，首个单词大写，center(width[, fillchar]) -> str ，width 打印宽度 ，fillchar 填充的字符，zfill(width) -> str ，width 打印宽度，居右，左边用0填充 。ljust(width[, fillchar]) -> str 左对齐，rjust(width[, fillchar]) -> str 右对齐 。
s5 = "abc"
ret = s5.center(10, "*") # 拉长成10, 把原字符串放中间.其余位置补*
print(ret)
结果为：
***abc****
# 更改tab的长度
s6 = "alex wusir\teggon"
print(s6)
print(s6.expandtabs(8)) # 可以改变\t的长度, 默认长度更改为8
print(s6.expandtabs(10))
结果为：
alex wusir eggon
alex wusir eggon
alex wusir eggon
print("abc".zfill(10))
print("abc".ljust(10,"Y"))
print("abc".rjust(10,"Y"))
结果为：
0000000abc
abcYYYYYYY
YYYYYYYabc
字符串修改
replace(old, new[, count]) -> str，字符串中找到匹配替换为新子串，返回新字符串 ，count表示替换几次，不指定就是全部替换。
'www.abc.com'.replace('w','p')
结果为：
'ppp.abc.com'
'www.abc.com'.replace('w','p',2)
结果为：
'ppw.abc.com'
'www.abc.com'.replace('w','p',3)
结果为：
'ppp.abc.com'
'www.abc.com'.replace('ww','p',2)
结果为：
'pw.abc.com'
'www.abc.com'.replace('www','python',2)
结果为：
'python.abc.com'
strip([chars]) -> str，从字符串两端去除指定的字符集chars中的所有字符 ，如果chars没有指定，去除两端的空白字符。lstrip([chars]) -> str ，从左开始，而rstrip([chars]) -> str则从右开始。
s = "\r \n \t Hello Python \n \t"
s.strip()
结果为：
'Hello Python'
s = " I am very very very sorry "#是以空格开始的，所以没有变。
s.strip('Iy')
结果为：
' I am very very very sorry '
s.strip('Iy ')#前后有空格，所以去除了空格，还去除了以I和y开头和结尾的。
结果为：
'am very very very sorr'
# 应用, 模拟用户登录. 忽略用户输入的空格
username = input("请输入用户名:").strip()
password = input("请输入密码: ").strip()
if username == 'abc' and password == '123':
print("登录成功")
else:
print("登录失败")
s7 = "abcdefgcba"
print(s7.strip("abc"))
结果为：
defg
字符串查找
find(sub[, start[, end]]) -> int ，在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到返回-1 ，rfind(sub[, start[, end]]) -> int，在指定的区间[start, end)，从右至左，查找子串sub。找到返回索引，没找到返回-1。
s = "I am very very very sorry"
s.find('very')
结果为：
5
s.find('very', 5)
结果为：
5
s.find("very", 6, 13)#不包括13
结果为：
-1
s.rfind('very', 10)
结果为：
15
s.rfind('very', 10, 15)
结果为：
10
s.rfind('very',-10,-1)
结果为：
15
index(sub[, start[, end]]) -> int ，在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError ，rindex(sub[, start[, end]]) -> int ，在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError 。
s = "I am very very very sorry"
s.find('very')
结果为：
5
s.find('very', 5)
结果为：
5
s.find("very", 6, 13)#不包括13
结果为：
ValueError Traceback (most recent call last)
<ipython-input-153-fe342f207469> in <module>
----> 1 s.index('very', 6, 13)
ValueError: substring not found
s.rfind('very', 10)
结果为：
15
s.rfind('very', 10, 15)
结果为：
10
s.rfind('very',-10,-1)
结果为：
15
count(sub[, start[, end]]) -> int ，在指定的区间[start, end)，从左至右，统计子串sub出现的次数。
s = "I am very very very sorry"
s.count('very')
结果为：
3
s.count('very', 5)
结果为：
3
s.count('very', 10, 14)
结果为：
1
字符串判断
endswith(suffix[, start[, end]]) -> bool ，在指定的区间[start, end)，字符串是否是suffix结尾 ，startswith(prefix[, start[, end]]) -> bool ，在指定的区间[start, end)，字符串是否是prefix开头 。
s = "I am very very very sorry"
s.startswith('very')
结果为：
False
s.startswith('very', 5)
结果为：
True
s.startswith('very', 5, 9)
结果为：
True
s.endswith('very', 5, 9)
结果为：
True
s.endswith('sorry', 5, -1)#不包括最后一个
结果为：
False
s.endswith('sorry', 5, 100)
结果为：
True
字符串判断is系列
isalnum() -> bool 是否是字母和数字组成 ，isalpha() 是否是字母 ，isdecimal() 是否只包含十进制数字 ，isdigit() 是否全部数字(0~9) ，isidentifier() 是不是字母和下划线开头，其他都是字母、数字、下划线 ，islower() 是否都是小写 ，isupper() 是否全部大写 ，isspace() 是否只包含空白字符 。
" \n\t".isspace() 结果为： True "abc \n".isalnum() 结果为： False "abc \n".isalpha() 结果为： False "123456789".isdecimal() 结果为： True
#判断一个数是不是小数
s17 = "-123.12"
s17 = s17.replace("-", "") # 替换掉负号
if s17.isdigit():
print("是整数")
else:
if s17.count(".") == 1 and not s17.startswith(".") and not s17.endswith("."):
print("是小数")
else:
print("不是小数")
字符串格式化
字符串的格式化是一种拼接字符串输出样式的手段，更灵活方便，join拼接只能使用分隔符，且要求被拼接的是可迭代对象 ，+ 拼接字符串还算方便，但是非字符串需要先转换为字符串才能拼接 。
在2.5版本之前，只能使用printf style风格的print输出，printf-style formatting，来自于C语言的printf函数，它的格式要求是:
- 占位符：使用%和格式字符组成，例如%s、%d等 s调用str()，r会调用repr()。所有对象都可以被这两个转换。
- 占位符中还可以插入修饰字符，例如%03d表示打印3个位置，不够前面补零
- format % values，格式字符串和被格式的值之间使用%分隔
- values只能是一个对象，或是一个和格式字符串占位符数目相等的元组，或一个字典
"I am %03d" % (20,) 结果为: 'I am 020' 'I like %s.' % 'Python' 结果为: 'I like Python.' '%3.2f%% , 0x%x, 0X%02X' % (89.7654, 10, 15) 结果为: '89.77% , 0xa, 0X0F' "I am %-5d" % (20,) 结果为: 'I am 20 '"I am %5d" % (20,)'I am 20'
format函数格式字符串语法——Python鼓励使用，"{} {xxx}".format(*args, **kwargs) -> str ，args是位置参数，是一个元组 ，kwargs是关键字参数，是一个字典 ，花括号表示占位符 ，{}表示按照顺序匹配位置参数，{n}表示取位置参数索引为n的值 ，{xxx}表示在关键字参数中搜索名称一致的 ，{{}} 表示打印花括号 。
"{}:{}".format('192.168.1.100',8888)
结果为：
'192.168.1.100:8888'
"{server} {1}:{0}".format(8888, '192.168.1.100', server='Web Server Info : ')
结果为：
'Web Server Info : 192.168.1.100:8888'
"{0[0]}.{0[1]}".format(('ABC','com'))
结果为：
'ABC.com'
#对象属性访问
from collections import namedtuple
Point = namedtuple('Point','x y')
p = Point(4,5)
"{{{0.x},{0.y}}}".format(p)
结果为：
'{4,5}'
#对齐
'{0}*{1}={2:<2}'.format(3,2,2*3)
结果为：
'3*2=6 '
'{0}*{1}={2:<02}'.format(3,2,2*3)
结果为：
'3*2=60'
'{0}*{1}={2:>02}'.format(3,2,2*3)
结果为：
'3*2=06'
'{:^30}'.format('centered')
结果为：
' centered '
'{:*^30}'.format('centered')
结果为：
'***********centered***********'
#进制
"int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)
结果为：
'int: 42; hex: 2a; oct: 52; bin: 101010'
"int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42)
结果为：
'int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010'
octets = [192, 168, 0, 1]
'{:02X}{:02X}{:02X}{:02X}'.format(*octets)
结果为：
'C0A80001'
s20 = "I am sylar, I'm 14 years old, I have 2 dogs!"
lst = s20.split()
print(lst)
count = 0
for c in lst:
if c.isdigit():
print(c)
count = count + 1
print(count)
结果为：
['I', 'am', 'sylar,', "I'm", '14', 'years', 'old,', 'I', 'have', '2', 'dogs!']
14
2
2