006.Python基础数据类型之字符串与列表

一、string字符串类型
二、list列表类型

一、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是可变的