基本数据类型

字符串

字符串定义和初始化

字符串是一个个字符组成的有序的序列，是字符的集合。使用单引号、双引号、三引号引住的字符序列，字符串是不可变对象，同时，从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("
".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 	a super student."
s1.split()

结果为：

["I'm", 'a', 'super', 'student.']

s1.split("s")

结果为：

["I'm 	a ", 'uper ', 'tudent.']

s1.split('super')

结果为：
["I'm 	a ", ' student.']

s1.split(' ')

结果为：

["I'm", '	a', 'super', 'student.']

s1.split(' ',maxsplit=2)

结果为：
["I'm", '	a', 'super student.']

s1.split('	',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 	a super student."
s1.rsplit()

结果为：
["I'm", 'a', 'super', 'student.']

s1.rsplit('s')
结果为：
["I'm 	a ", 'uper ', 'tudent.']

s1.rsplit('super')
结果为：
["I'm 	a ", ' student.']

s1.rsplit(' ')
结果为：
["I'm", '	a', 'super', 'student.']

s1.rsplit(' ',maxsplit=2)
结果为：
["I'm 	a", 'super', 'student.']

s1.rsplit('	',maxsplit=2)
结果为：
["I'm ", 'a super student.']

splitlines([keepends]) -> list of strings ，按照行来切分字符串 ，keepends 指的是是否保留行分隔符 ，行分隔符包括 、 、 等 。

'ab c

de fg
kl
'.splitlines()

结果为：
['ab c', '', 'de fg', 'kl']

'ab c

de fg
kl
'.splitlines(True)

结果为：

['ab c
', '
', 'de fg
', 'kl
']

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.
", "You're a super teacher."]

"abc

".splitlines()

结果为:
['abc', '']

"abc

".splitlines(True)
结果为：
['abc
', '
']

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	eggon"
print(s6)
print(s6.expandtabs(8)) # 可以改变	的长度, 默认长度更改为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 = "
 
 	 Hello Python 
 	"
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() 是否只包含空白字符 。

" 
	".isspace()

结果为：

True

"abc 
".isalnum()

结果为：
False

"abc 
".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