一、string字符串类型
（一）用途
对事物性质、状态的描述
（二）定义
在单引号、双引号、三引号内包含的一串字符，如：
name = "Thomas" # name = str("Thomas")
数据类型转换：str() 可以把任意数据类型转换成字符串类型
（三）常用操作及内置使用方法
1.优先掌握的操作
（1）按照索引取值（正向取，反向取）：
1）正向取，从左往右
>>> str1="hello python!"
# 以上字符串共13个元素，正向索引位置为 0 1 2 3 ... 12
# 反向索引位置为 -13 -12 -11 -10 ... -1
>>> str1[6]
'p'
2）反向取，负号表示从右往左
>>> str1="hello python!"
>>> str1[-5]
't'
3）对于str来说，只能按照索引取值，不可以变更取值方式，也不能像列表一样对索引位置修改
>>> msg="hello"
>>> msg[0]="H"
TypeError: 'str' object does not support item assignment
（2）切片（顾头不顾尾，步长）
切片的本质是从目标字符串拷贝出一个新的字符串。
1）顾头不顾尾：取出索引为0-8的所有字符（第一个参数是起始位置，第二个参数是结束位置，第三个参数的绝对值是步长，步长如果不写默认是1，每次取值为序列加1的字符，然后按顺序拼接）。
>>> str1="hello python!"
>>> str1[0:9] # 省略步长，默认步长为1
'hello pyt'
2）步长：0:9:2，第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出0、2、4、6、8的字符
>>> str1="hello python!"
# 以上字符串共13个元素，正向索引位置为 0 1 2 3 ... 12
# 反向索引位置为 -13 -12 -11 -10 ... -1
>>> str1[:9:2] # 省略起始位置，默认起始位置为0
'hlopt'
>>> str1[-2:2:1]
'' # 无内容，正向步长取值，当起始位置在结束位置之后时，切片的内容为空，若进行反向取值，则可以取出内容。
>>> str1[2:-2:1]
'llo pytho' # 正向步长取值，无论起始位置与结束位置如何表示，只要当起始位置的**绝对位置**在结束位置之前时，可正常取值。
>>> str1[::] # 当省略起始位置，则默认起始位置是0,省略结束位置，默认一直到末尾全部都取到
>>> str1[:] # 省略步长，默认步长为1
3）反向切片，逆序截取
>>> str1="hello python!"
>>> str1[::-1] # 省略开始与结束位置，默认一直到末尾全部都取到
'!nohtyp olleh'
>>> str1[-2:2:-1]
'nohtyp ol' # 反向步长取值，只要当起始位置的**绝对位置**在结束位置之前时，即可正常取值。
（3）长度len
用于获取字符串的长度，即字符的个数，但凡存在于引号内的，都算作字符
>>> len(str1) # 空格也算字符
13
（4）成员运算 in 和 not in
1）in : 判断一个字符串是否在另一个字符串内
>>> 'hello' in str1
True
2）not in :判断一个字符串是否不在另一个字符串内
>>> 'tony' not in str1 # 不推荐使用 not 'tony' in str1 ,不便于阅读理解
True
（5）移除字符 strip
剥夺、移除字符串首尾指定的字符，默认移出的空格，得出的结果是新的字符串，未改变原字符串。
1）括号内不指定字符，默认移除首尾空白字符（空格、 换行符、 纵向制表符）
>>> str1=" zhangsan is not lisi! /t /n "
>>> str1.strip() # 默认去掉的是字符串左右两端的空白字符串
'zhangsan is not lisi!'
>>> str1.strip("! /t/n") # 组合去除字符串，则须将所有需去除的字符串都列出，包括
'zhangsan is not lisi'
user = input("用户名： ").strip() # 输入内容中误输入空格，可被纠正
password = input("密码： ").strip()
if user == "zhangsan" and password == "123":
print("账号密码正确")
else:
print("账号或密码错误")
2）括号内指定字符，则移除首尾指定的字符（实际实现原理：是在左右两边按照指定的一个或多个字符中，在字符串的左右开始寻找，碰到第一个不是指定的字符串的字符之后，就会停下来。）
>>> str2="****zhangsan****"
>>> str2.strip("*")
'zhangsan'
（6）切分 split
注意：切分得到的结果是列表数据类型
1）括号内不指定字符，默认以空格作为切分符号
>>> str3="hello world"
>>> str3.split()
['hello', 'world']
2）括号内指定分隔符号，则按照括号内指定的字符切割字符串
>>> ip1="192.168.1.1"
>>> ip1.split(".")
['192', '168', '1', '1']
（7）循环
即循环取值，使用for来操作
>>> str4="张三VS李四"
>>> for i in str4:
... print(i)
...
张
三
V
S
李
四
2.需要掌握的操作
（1）strip(), lstrip(), rstrip()
移除两端指定字符，只移除左边指定字符，只移除右边指定字符
>>> str1="****zhangsan****"
>>> str1.strip("*")
'zhangsan'
>>> str1.lstrip("*")
'zhangsan****'
>>> str1.rstrip("*")
'****zhangsan'
（2）lower(), upper()
将字符串全部变为小写，将字符串全部变为大写
>>> str2="My Name Is Zhangsan!"
>>> str2.lower()
'my name is zhangsan!'
>>> str2.upper()
'MY NAME IS ZHANGSAN!'
（3）startswith(), endswith()
检测开头字符，检测结尾字符
>>> str3="zhangsan lisi"
>>> str3.startswith("z") # 判断字符串是否以指定的字符开头，结果为布尔值True or False。
True
>>> str3.startswith("i")
False
>>> str3.endswith("i") # 判断字符是否以指定的字符结尾，结果为布尔值True or False。
True
（4）格式化输出之format
之前我们使用%s做字符串的格式化输出操作，在传值时，必须严格按照位置与%s一一对应，而字符串的内置方法format则提供了一种不依赖顺序位置的传值方式，按照参数进行传值。
>>> str4="my name is {name}, my age is {age}!"
>>> str4.format(age=99,name="zhangsan")
'my name is zhangsan, my age is 99!'
>>> str4="my name is {name}{name1}{name}, my age is {age}!"
>>> str4.format(age=99,name="zhangsan",name1="lisi")
'my name is zhangsanlisizhangsan, my age is 99!'
format的其他使用方法（了解）
# 类似%s的用法，传入的值会按照位置与{}一一对应
>>> str4="my name is {}, my age is {}!".format("zhangsan",99)
>>> str4
'my name is zhangsan, my age is 99!'
# 把format传入的多个值当作一个列表，然后用{索引}取值
>>> str4="my name is {0}, my age is {1}!".format("zhangsan",99)
>>> str4
'my name is zhangsan, my age is 99!'
>>> str4="my name is {1}, my age is {0}!".format("zhangsan",99)
>>> str4
'my name is 99, my age is zhangsan!'
>>> str4="my name is {1}, my name is {1}!".format("zhangsan",99)
>>> str4
'my name is 99, my name is 99!'
（5）格式化输出之f-Strings
这是一个python3.6的新特性，现阶段应用不多，待python3普及后可使用，更简洁。
name = "tom"
age = 2
print(f"猫的名字叫{name}，今年{age}岁了") # 猫的名字叫tom，今年2岁了
# 格式化时可以使用函数
print(F"猫的名字叫{name.upper()}，今年{age}岁了") # 猫的名字叫TOM，今年2岁了
# 格式化时可以使用字典
cat = {"name": "tom", "age": 2}
print(F"猫的名字叫{cat['name']}，今年{cat['age']}岁了") # 猫的名字叫tom，今年2岁了
（6）split(), rsplit()
我们之前了解到split()是切分操作，这个是正向顺序的切分，那么还有反向的切分，rsplit()即reverse split。
# split()会按照从左到右的顺序对字符串进行切分，可以指定切分的次数，切分的结果是列表类型数据
>>> str5="zhangsan/love/lisi"
>>> str5.split("/",1)
['zhangsan', 'love/lisi']
# rsplit()与split()相反，从右往左切割，可以指定切割次数，切分结果为列表类型数据
>>> str5="zhangsan/love/lisi"
>>> str5.rsplit("/",1)
['zhangsan/love', 'lisi']
（7）join()
字符串拼接操作，从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串。
>>> "%".join("zhangsan") # 从字符串“zhangsan”中取出多个字符串，然后按照%作为分隔符号进行拼接
'z%h%a%n%g%s%a%n'
>>> "%".join("Hello Python!")# 从字符串“Hello Python!”中取出多个字符串，然后按照%作为分隔符号进行拼接
'H%e%l%l%o% %P%y%t%h%o%n%!'
>>> "*".join(["我","秦始皇","打钱"]) # 从列表中取出多个字符串，然后按照“*”作为分隔符号进行拼接
'我*秦始皇*打钱'
>>> "秦始皇".join(["我","打钱","长生不老"])
'我秦始皇打钱秦始皇长生不老'
（8）replace()
使用新的字符串，替字符串中旧的字符串，也可以指定修改个数。
>>> str7="my name is zhangsan, my age is 99"
>>> str7.replace("99","66") # 语法：replace("原内容"，“新内容”)
'my name is zhangsan, my age is 66'
>>> str7.replace("my","My",1) # 指定修改个数，只把一个my改为My.
'My name is zhangsan, my age is 99'
（9）isdigit()
判断字符串是否是纯数字，返回结果为布尔值True或False
>>> str8="19491001"
>>> str8.isdigit()
True
>>> str8="1949.10.01"
>>> str8.isdigit() # 说明浮点型无法被判断，只能判断整型。
False
3.了解的操作
（1）find(), rfind(), index(), rindex(), count()
1) find：从指定范围内查找子字符串的起始索引，找得到则返回数字1，找不到则返回-1
print("=abcdefab".find("ab")) # 1 查找一个子字符串在大字符串中出现的起始位置，找到返回数字1
print("=adcabdefab".find("ab",0,5)) # -1 查找一个子字符串在大字符串中出现的起始位置，找不到返回数字-1
2）print("=adcabdefab".rfind("ab")) # 从后往前查找一个子字符串在大字符串中出现的起始位置
3）index:同find，找不到则报错，而find则会返回-1
4）count:统计字符串在大字符串中出现的次数
>>> msg = "hello everyone"
>>> msg.count('e') # 统计字符串e出现的次数
4
（2）center(), ljust(), rjust(), zfill()
>>> name='tony'
>>> name.center(30,'-') # 总宽度为30，字符串居中显示，不够用-填充
-------------tony-------------
>>> name.ljust(30,'*') # 总宽度为30，字符串左对齐显示，不够用*填充
tony**************************
>>> name.rjust(30,'*') # 总宽度为30，字符串右对齐显示，不够用*填充
**************************tony
>>> name.zfill(50) # 总宽度为50，字符串右对齐显示，不够用0填充
0000000000000000000000000000000000000000000000tony
（3）expandtabs()
>>> name = 'tony hello' # 表示制表符(tab键)
>>> name
tony hello
>>> name.expandtabs(1) # 修改 制表符代表的空格数
tony hello
（4）captalize(), swapcase(), title()
1) captalize：首字母大写
>>> message = 'hello everyone nice to meet you!'
>>> message.capitalize()
Hello everyone nice to meet you!
2) swapcase：大小写翻转
>>> message1 = 'Hi girl, I want make friends with you!'
>>> message1.swapcase()
hI GIRL, i WANT MAKE FRIENDS WITH YOU!
3) title：每个单词的首字母大写
>>> msg = 'dear my friend i miss you very much'
>>> msg.title()
Dear My Friend I Miss You Very Much
（5）is数字系列
#在python3中
num1 = b'4' #bytes
num2 = u'4' #unicode,python3中无需加u就是unicode
num3 = '四' #中文数字
num4 = 'Ⅳ' #罗马数字
#isdigt:bytes,unicode
>>> num1.isdigit()
True
>>> num2.isdigit()
True
>>> num3.isdigit()
False
>>> num4.isdigit()
False
#isdecimal:uncicode(bytes类型无isdecimal方法)
>>> num2.isdecimal()
True
>>> num3.isdecimal()
False
>>> num4.isdecimal()
False
#isnumberic:unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
>>> num2.isnumeric()
True
>>> num3.isnumeric()
True
>>> num4.isnumeric()
True
# 三者不能判断浮点数
>>> num5 = '4.3'
>>> num5.isdigit()
False
>>> num5.isdecimal()
False
>>> num5.isnumeric()
False
'''
总结:
最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
如果要判断中文数字或罗马数字,则需要用到isnumeric。
'''
（6）is的其他用法
>>> name = 'tony123'
>>> name.isalnum() #字符串中既可以包含数字也可以包含字母
True
>>> name.isalpha() #字符串中只包含字母
False
>>> name.isidentifier()
True
>>> name.islower() # 字符串是否是纯小写
True
>>> name.isupper() # 字符串是否是纯大写
False
>>> name.isspace() # 字符串是否全是空格
False
>>> name.istitle() # 字符串中的单词首字母是否都是大写
False
（四）该类型总结
1.存值个数
字符串类型只能存一个值
2.是否有序
字符串是有序的
3.是否可变
字符串是不可变的
二、list列表类型
（一）用途
按照位置存放多个值。
（二）定义
在[]内，用逗号隔开多个任意数据类型的值。
>>> l=[111,2.2,"abc",[]] # l=list(...)
>>> print(type(l))
<class 'list'>
类型转换：
# 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
>>> list('wdad') # 结果：['w', 'd', 'a', 'd']
>>> list([1,2,3]) # 结果：[1, 2, 3]
>>> list({"name":"jason","age":18}) # 结果：['name', 'age']
>>> list((1,2,3)) # 结果：[1, 2, 3]
>>> list({1,2,3,4}) # 结果：[1, 2, 3, 4]
（三）常用操作及内置使用方法
1.优先掌握的操作
（1）按索引存取值
正向存取+反向存取：既可存(改)也可以取，用法基本同字符串str
>>> my_friends=['tony','jason','tom',4,5]
>>> my_friends[0] # 正向取(从左往右)
tony
>>> my_friends[-1] # 反向取(负号表示从右往左)
5
>>> my_friends = ['tony','jack','jason',4,5] # 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错
>>> my_friends = ['tony','jack','jason',4,5]
>>> my_friends[1] = 'martthow'
>>> my_friends
['tony', 'martthow', 'jason', 4, 5]
（2）切片(顾头不顾尾，步长)
>>> my_friends[0:4]
['tony', 'jason', 'tom', 4]
>>> my_friends[0:4:2]
['tony', 'tom']
>>> my_friends[:] # 不指定起始位置，默认是0，不指定结束位置，默认是取到最后一位，不指定步长，默认是1
['tony', 'jason', 'tom', 4, 5]
>>> my_friends[::]
['tony', 'jason', 'tom', 4, 5]
>>> my_friends[::-1] # 不指定起始位置，默认是0，不指定结束位置，默认是取到最后一位，步长为负数，是逆序截取
[5, 4, 'tom', 'jason', 'tony']
>>> my_friends[-3:3:-1]
[]
# 无论正向还是逆序，都需要在指定方向上，开始位置在结束位置之前，不然无法取到值
（3）长度len()
>>> len(my_friends)
5
（4）成员运算in和not in
>>> 'tony' in my_friends
True
>>> 'xxx' not in my_friends
True
（5）添加
1) append()列表尾部追加元素
>>> l1 = ['a','b','c']
>>> l1.append('d')
>>> l1
['a', 'b', 'c', 'd']
2) insert()在指定位置插入元素，成为该位置的新元素，其他的元素序列向后顺延
>>> l1.insert(0,"first") # 0表示按索引位置插值
>>> l1
['first', 'a', 'b', 'c', 'alisa', 'a', 'b', 'c']
（6）删除
1) del 通用，非列表专属的删除方式
>>> l = [11,22,33,44]
>>> del l[2] # 删除索引为2的元素
2) remove() 列表专属的删除方式之指定元素删除，没有返回值，返回None
>>> l = [11,22,33,22,44]
>>> res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
>>> print(res)
None
3) pop() 列表专属的删除方式之指定索引删除，默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
>>> l = [11,22,33,22,44]
>>> res=l.pop()
>>> res
44
>>> res=l.pop(1)
>>> res
22
（7）循环
for item in my_friends:
print(item)
'tony'
'jack'
'jason'
4
5
2.需要掌握的操作
（1）count() 统计某元素出现了多少次
>>> l = [11,22,3,42,7,55]
>>> print(l.count(11))
1
（2）sort() 给列表内所有元素排序
1) 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
>>> l = [11,22,3,42,7,55]
>>> l.sort()
>>> l
[3, 7, 11, 22, 42, 55] # 默认从小到大排序
>>> l = [11,22,3,42,7,55]
>>> l.sort(reverse=True) # reverse用来指定是否颠倒排序，默认为False
>>> l
[55, 42, 22, 11, 7, 3]
2) 了解知识：
# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
>>> l1=[1,2,3]
>>> l2=[2,]
>>> l2 > l1
True
# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
>>> s1='abc'
>>> s2='az'
>>> s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b',所以s2>s1成立
True
# 所以我们也可以对下面这个列表排序
>>> l = ['A','z','adjk','hello','hea']
>>> l.sort()
>>> l
['A', 'adjk', 'hea', 'hello','z']
（3）clear() 清空列表
>>> l = [11,22,3,42,7,55]
>>> l.clear()
>>> l
[]
（4）reverse() 颠倒列表内元素顺序
>>> l = [11,22,33,44]
>>> l.reverse()
>>> l
[44,33,22,11]
（5）extend() 一次性在列表尾部添加多个元素，需要以列表的形式添加
>>> l1.extend(['a','b','c'])
>>> l1
['a', 'b', 'c', 'd', 'a', 'b', 'c']
# extend()相当于以下操作
for item in ['a','b','c']:
l.append(item)
（6）copy() 拷贝一个新列表
>>> l=[11,22,33,44]
>>> l1=l.copy() # 拷贝了内存地址，等同l1=l[:]
>>> l1[0]=1111 # 被拷贝列表的改变，不影响原列表，若是通过赋值得到的列表，修改一个，另一个会跟随改变，因为用的是同一个内存地址
>>> l
[11, 22, 33, 44]
>>> l1
[1111, 22, 33, 44]
（四）该类型总结
1.存值个数
list类型能存多个值
2.是否有序
list是有序的
3.是否可变
list是可变的