python字符串列表

1.字符串编码

编码	制定时间	作用	所占字节数
ASCII	1967	表示英语及西欧语言	8bit/1bytes
GB2312	1980	国家简体中文字符集，兼容ASCII	2bytes
Unicode	1991	国际标准组织统一标准字符集	2bytes
GBK	1995	GB2312的扩展字符集，支持繁体字，兼容GB2312	2bytes
UTF-8	1992	不定长编码	1-3bytes

1.1字符串编码本质：

本质上就是二进制数据与语言文字的一一对应关系

1.2Unicode：所有字符都是两个字节

好处：字符与数字之间转换速度更快一些

坏处：占用空间大

1.3UTF-8：精准，对不同字符用不同的长度表示

优点：节省空间

缺点：字符与数字的转换速度较慢，每次都需要计算字符要用多少个字节来表示。

1.4字符串编码的转换

1.4.1编码：encode()

将其他编码的字符串转换成Unicode编码

1.4.2解码：decode()

将Unicode编码转换成其他编码的字符串

a = 'hello'
print(a,type(a))  #str 字符串是以字符为单位进行处理
a1 = a.encode()
print(a1,type(a1)) #types,以字节为单位进行处理
a2 = a1.decode()
print(a2,type(a2))  

注意：对于types只需要知道他跟字符串类型之间的相互转换

b = '现在是2月'
b1 = b.encode('UTF-8')
print(b1,type(b1))
b2 = b1.decode('UTF-8')
print(b2,type(b2))

2.字符串常见操作

操作符	描述
+	字符串连接
*	重复输出字符串
[ ]	通过索引获取字符串中字符
[:]	截取字符串中一部分
in	成员运算符-如果字符串中包含给定字符返回True
not in	成员运算符-如果字符串中包含给定字符返回False
r/R	原始字符串-没有转义特殊或不能打印的字符，在引号前加上一个字母‘r'或者’R'

2.1 + 字符串拼接

print(10+10)  #20  整形相加，这里的+是算数相加
print('10'+'10')  #1010   字符串拼接

name1 = 'good'
name2 = 'morning'
print(name1,name2)  #good morning
print(name1+name2)  #goodmorning
print(name1,name2,sep="")  #goodmorning

可以是中文字符串 

2.2 * 重复输出

print("好好学习，天天向上\n"*5)

注意：需要输出多少次，*后面就写多少

2.3 in ，not in成员运算符 

作用：检查字符串中是否包含某个字符或多个字符

in：如果包含的话返回True，不包含的话返回False

not in：如果包含的话返回False，不包含的话返回True

name = 'panda'
print('p' in name)  #True
print('p' not in name)  #False
print('b' in name)  #False
print('b' not in name)  #True
print('pan' in name)  #True
print('paa' in name)  #False

可以是中文字符串

2.4 下标/索引

python中从左往右下标从0开始，从右往左下标从-1开始，通过下标能快速找到对应的数据

格式：字符串名[下标值]

name = 'panda'
#从左往右数，下标从0开始  0,1,2...
print(name[0])
print(name[1])
print(name[4])
#print(name[5])  #IndexError 索引错误取值的时候不能超出下标范围
#从右往左数，下标从-1开始  -1,-2,...
print(name[-1])
print(name[-2])
print(name[-3])

2.5切片

含义：指对操作的对象截取其中的一部分操作

语法：[开始位置:结束位置:步长]

遵循：包前不包后原则（range（）函数也是）：即从起始位开始到结束位的前一位结束，不包含结束位本身。

步长表示选取间隔，不写步，则默认是1.补偿的绝对值大小决定切取的间隔，正负号表示切取的方向。正数表示从左往右取值，负数表示从右往左取值。

a='abcdefghi'
#从左往右
print(a[0:4])  #abcd
print(a[3:5])  #de
print(a[3:])  #defghi 下标为3及之后的全部截取到
print(a[:4])  #abcd 下表为4之前的全部截取到，不包含4
print(a[0:7:2])  #aceg 步长为2
#从右往左
print(a[-1:])   #i 这里不步长是1，从左往右切，只切到了最后一位，这里可以将步长设置为-1，从右往左切
print(a[-1::-1])   #ihgfedcba
print(a[:-1])   #abcdefgh
print(a[-1:-5])  #输出为空，切的方向与步长方向不一致
print(a[-1:-5:-1])  #ihgf

注意：切取方向要一致，否则切取不到值。

2.6原始字符串R/r

print(r"好好学习\n"*2)

输出结果为：好好学习\n好好学习\n

2.7查找、判断、修改

2.7.1find（）：检测某个子字符串是否包含在字符串中，如果在返回这个子字符串的开始位置的下标，否则返回-1

find（子字符串，开始位置下标，结束位置下标）（包前不包后）

注意：开始位置和结束位置下标可以省略，就表示在整个字符串中查找

a = 'banjksbuhkw'
print(a.find('a'))    #1
print(a.find('njk'))  #2
print(a.find('jpq'))  #-1
print(a.find('b',3))  #6 ,从第三个位置开始查找，就不包括第一个b
print(a.find('j',5))  #-1,超出范围
print(a.find('b',5,7)) #6,在下标5-7范围内寻找
print(a.find('b',6,7)) #6
print(a.find('b',5,6)) #-1 包前不包后

2.7.2 index（）：检测某个子字符串是否包含在字符串中，如果在返回这个子字符串的开始位置的下标，否则会报错

index（子字符串，开始位置下标，结束位置下标）开始位置和结束位置下标可以省略，就表示在整个字符串中查找（包前不包后）

name = "我命由我不由天"
print(name.index("命"))    #1
print(name.index("命",2))  #报错，从下标2开始找，没找到
print(name.index("命",1,3))  #1

2.7.3count（）：返回某个子字符串在整个字符串中出现的次数，没有就返回0

count（子字符串，开始位置下标，结束位置下标）开始位置和结束位置下标可以省略，就表示在整个字符串中查找（包前不包后）

name = 'chenchen'
print(name.count("c")) #2
print(name.count("a"))  #0
print(name.count("e",3)) #1

2.7.4 replace（）：替换

replace（旧内容，新内容，替换次数），替换次数可以省略，默认全部替换。

str = 'acquaint'
str1 = str.replace('a','c',1)  #表示替换一个a
str2 = str.replace('a','c',2)  #替换两个a
print(str1,str2)

2.7.5 split（）：分割

指定分隔符来切字符串，如果字符串中不包含分割内容就不进行分割，会作为一个整体返回

str='agriculture,agent'
print(str.split(','))  #['agriculture', 'agent'] 以，进行分割，以列表形式返回
print(str.split('w'))  #['agriculture,agent']
print(str.split('r'))  #['ag', 'icultu', 'e,agent']
print(str.split('r',1))  #['ag', 'iculture,agent']指定只分割一次

str = 'administer'
str1 = str.split(str[3])  #['adm', 'n', 'ster'] 这里的str[3]是代表字母i
str2 = str.split(str[2])  #['ad', 'inister']
print(str1,str2)

2.7.6 capitalize（）：第一个字符大写，其他都小写

str = 'accelerate'
print(str.capitalize())
str1 = 'aLLEy'
print(str1.capitalize())

2.7.7 statrswith（）：是否以某个字符开头

是的话返回True，不是返回False，如果设置开始结束位置下标则在指定范围内查找。

str = 'absolute'
print(str.startswith('a'))  #True
print(str.startswith('c'))  #False
print(str.startswith('abs'))  #True
print(str.startswith('acs'))  #False
print(str.startswith('o',3,5))  #True

2.7.8 endswith（）：是否以某字符结束

是的话返回True，不是返回False，如果设置开始结束位置下标则在指定范围内查找。

str = 'abstract'
print(str.endswith('t'))  #True
print(str.endswith('ct'))  #True
print(str.endswith('a'))  #False
print(str.endswith('a',0,6))  #True

2.7.9 lower（）：大写字符转化为小写

str = 'accORDanCe'
print(str.lower())

2.7.10 upper（）：小写字符转换为大写

str = 'agenda'
print(str.upper())

2.7.11 isupper（）：检测字符串中所有的字符是否都为大写，是的话返回True，否则返回False。

str = 'affluent'
print(str.isupper())  #False

str = 'ACCUMULATE'
print(str.isupper())  #Ture
print('adequate'.islower()) #True

3.列表

基本格式：列表名=[元素1，元素2，元素3，...]

注意：所有元素放在[ ]内，元素与元素之间用，隔开，元素之间的数据类型可以各不相同。

列表也是可迭代对象，可以for循环，遍历取值。

list1 = [1,2,3,4]
print(type(list1))    #<class 'list'>

list2 = [1,1.1,'a',-5]
print(type(list2))    #<class 'list'>

print(list2[2])  #根据下标查找元素
print(list2[0:3])  #切片操作 [1, 1.1, 'a']

for i in list2:
    print(i)

4.列表相关操作

4.1添加元素

append()   整体添加

extend()   里面需要添加可迭代对象，整形不是可迭代对象。分散添加，将另外一个类型中的元素逐一添加

insert()  需要指定下标进行添加，指定位置有元素，原有元素就会后移。不指定下标会报错

list = ['academy','accoringly','ace']
list.append('acute')
print(list)    #['academy', 'accoringly', 'ace', 'acute']

list = ['adopt','advertise','advocate主张']
list.extend('aerial')
print(list)    #['adopt', 'advertise', 'advocate主张', 'a', 'e', 'r', 'i', 'a', 'l']

list = ['affection','agenda','aircraft']
list.insert(2,'aisle过道')  #['affection', 'agenda', 'aisle过道', 'aircraft']
list.insert(3,'aisle过道')  #['affection', 'agenda', 'aircraft', 'aisle过道']
list.insert(5,'aisle过道')  #['affection', 'agenda', 'aircraft', 'aisle过道']

print(list)

应用：在列表[1,2,3]后添加4

list1 = [1,2,3]
list1.append(4)
print(list1)   #[1, 2, 3, 4]

list2 = [1,2,3]
list2.insert(3,4)
print(list2)   #[1, 2, 3, 4]

4.2修改元素

直接通过下标就可以修改

list = ['album','alcohol','alert警告']
list[1] = 'algebra代数'
print(list)  #['album','algebre代数','alert警告']

4.3查找元素

4.3.1  in：判断指定元素是否在列表中，存在则返回True，不存在返回False

4.3.2  not in：判断指定元素是否在列表中，存在则返回False，不存在返回True

list = ['allege断言','allowance津贴','ally结盟']
print('allege' in list)  #False
print('allege断言' in list)  #True
print('ally结盟' not in list) #False

应用：用户定义一个昵称，重复则不能使用

name_list = ['alphabet','absolute','abstract']
while 1:
    name = input("请输入昵称")
    if name in name_list:
        print(f"该昵称{name}已被使用")
    else:
        print("设置成功")
        name_list.append(name)  #把新的昵称放列表里
        break

4.3.4  index：返回指定数据所在位置的下标

4.3.5  count：统计指定数据在当前列表出现的次数，跟字符串中的用法相同

4.4删除元素

4.4.1 del

del  list：删除列表   

del  list[2]:根据下标删除

list = ['academy专科院校私立中学','accelerrate使加快','accommodate容纳','accomplish完成']
del list[2]
print(list)  #['academy专科院校私立中学', 'accelerrate使加快', 'accomplish完成']

list = ['accord给予，使一致','accordance按照某事物','accordingly因此，所以']
del list
print(list)  #<class 'list'>

4.4.2 pop()：删除指定下标的数据

python3版本会默认删除最后一个元素

只能根据下标（index）进行删除，不能指定元素删除，（下标不能超出范围，超出范围会报错）

list.pop()

list = ['account账目，解释','accountable可解释的','accumulate累积，积聚','ace幺点']
list.pop()
print(list)  #['account账目，解释', 'accountable可解释的', 'accumulate累积，积聚']

list = ['acquaint使认识，使熟悉','acute严重的','addict','adequate充足的']
list.pop(1)   #将下标为1的元素删除
print(list)  #['acquaint使认识，使熟悉', 'addict', 'adequate充足的']

4.4.3 remove（）：根据元素的值进行删除

默认删除最开始的指定元素，有重复的话删除第一个出现的元素

list = ['adjective','administer管理','adopt收养','adverb']
list.remove('administer管理')
print(list)  #['adjective', 'adopt收养', 'adverb']

#list.remove('advertise通知，做广告') #报错 ValueError列表中不存在元素

4.5排序

4.5.1  sort（）：将列表按特定顺序重新排列，默认从小到大

list = [11,25,64,37,89,21]
list.sort()
print(list) #[11, 21, 25, 37, 64, 89]

4.5.2 reverse（）：倒序，将列表倒置（反过来）

list = [18,2,98,35,15,90,56,4]
list.reverse()
print(list)  #[4, 56, 90, 15, 35, 98, 2, 18]

4.6列表推导式

格式一：[表达式 for 变量 in 列表]

注意：in后面不仅可以放列表，还可以放range（）、可迭代对象

list = [1,2,3,4,5]
[print(i*5) for i in list]  #5 10 15 20 25

list = []
for i in range(1,6):
    list.append(i)
print(list)  #[1, 2, 3, 4, 5]

list = []
[list.append(i) for i in range(1,6)]
print(list)  #[1, 2, 3, 4, 5]

格式二：[表达式 for 变量 in 列表 if 条件]

如：把奇数放在列表里

list = []
for i in range(1,11):
    if i%2 == 1:
        list.append(i)
print(list)   #[1, 3, 5, 7, 9]

list = []
[list.append(i) for i in range(1,11) if i%2 == 1]
print(list)   #[1, 3, 5, 7, 9]

4.7列表嵌套

含义：一个列表里面又有一个列表

list = [1,2,3,[4,5,6]]
print(list[2])  #3
print(list[3])  #[4,5,6]
print(list[3][0]) #4 取出内列表中的元素