回顾总结
前言：字符串特点及定义
- 1、字符串不可变、字符串不可变、字符串不可变，可以作为字典的key
- 2、字符串定义：由若干个字符组成的一个序列被称为字符串，其中的字符可以是字母，数字，符号，中文等
- 3、总结：【这是对字符串知识的概览（★★★★★★）】
- 字符串系统功能：转换、查找、填充、去除、合并分割、替换、判断、编码和解码、格式化；
- 字符串string模块：生成所有字母字符串、生成小写字母字符串、生成大写字母字符串、生成0~9数字字符串；
1、创建字符串
- 1、单引号创建
- 2、双引号创建（如果使用过程中会出现歧义就要交替使用单引号，双引号进行区分）
- 3、三引号（该方法相对上面两种会保留字符串当中的空格）
- 4、转义字符（\x）
#1、创建
#1.1、方法一：单引号
str1 = 'adcc'
str2 = '"1111"'
print(f'str1{str1},str2{str2}') # str1adcc,str2"1111"
#1.2、方法二：双引号
str1 = "abdjd"
print(str1) # abdjd
#1.3、方法三：三引号（内部的内容可以使用换行，而且可以原样输出）
str3 = '''adjfjaj
fasfaf'''
print(str3) # 输出部分包含换行
'''
adjfjaj
fasfaf
'''
str3 = '''adjfjaj\
fasfaf'''
print(str3) # 输出部分包含换行
'''
adjfjajfasfaf
'''
str3 = 'adjfjaj\nfasfaf'
print(str3) # 输出部分包含换行
'''
adjfjaj
fasfaf
'''
str3 = 'adjfjaj\\nfasfaf'
print(str3) # 输出部分包含换行
'''
adjfjaj\nfasfaf
'''
# 1.4.转义字符
# 语法：\x
"""
因为字符串中可以是数字，字母，符号或中文
作用：
a.可以将一个普通字符转换为特殊字符
b.可以将一个特殊字符转换为普通字符
n ----->\n 换行
t ----->\t 制表符【tab键】
r ------>\r 回车
b ------>\b backsapce
"""
s1 = "\"hello\""
print(s1) #"hello"
s1 = "'hello'"
print(s1) #'hello'
s1 = '"hello"'
print(s1) #"hello"
s2 = 'hello\npython'
print(s2) #输出结果会换行
print('===='*30)
# s2 = 'hello\rpython' #输出完hello之后，光标会回到之前的开始位置。
# print(s2) #python
s2 = 'hello\tpython'
print(s2) #hello python
s3 = 'aaa\bbb\ccc\ddd' #\b是Backspace（删除）
print(s3) # aabb\ccc\ddd
# 注意：r"xxx",可以将字符串中的特殊字符进行转义，无需手动转义，常用于路径的表示或者正则表达式中（让转义字符失去作用变成普通字符）
s3 = r'aaa\nbbb\ccc\ddd'
print(s3) #aaa\nbbb\ccc\ddd
2、操作字符串
1、访问字符串当中的元素
2、字符串拼接
3、字符串重复
4、判断字符串当中是否存在某个字符
5、字符串遍历
# 2.1.字符的访问
str1 = 'ghajkghajk'
print(str1[0]) #g
print(str1[-len(str1)]) #g
str1 = 'ghajkghajk'
for i in range(len(str1)):
print(str1[- (len(str1) - i)],end=' ')
'''
g h a j k g h a j k
'''
print(str1[-1]) #k
print(str1[len(str1) - 1]) #k
# 2.2.+:拼接
s1 = 'abc'
s2 = '123'
print(s1 + s2) #abc123
# 2.3.*:重复
print("#" * 30) ###############################
print(s1 * 3) #abcabcabc
# 2.4.in/not in:判断是否存在
print('a' in s1) #True
print('a' not in s1) #False
# 5.遍历
data = 'hello'
for ch in data:
print(ch)
'''
h
e
l
l
o
'''
for i in range(len(data)):
print(data[i])
'''
h
e
l
l
o
'''
for i,ch in enumerate(data): #转化为枚举
print(i,ch)
'''
0 h
1 e
2 l
3 l
4 o
'''
3、字符串系统功能
1、转换：
- eval(str):可以识别一个字符串str中的有效的python语句并执行该语句（evaluation n.评价、评估）
- upper():将小写字母转换为大写
- lower():大—》小
- swapcase():大—》小 小----》大
- capitalize():首单词的首字母变大写，其他全部变小写，英文句子
- title():每个单词的首字母大写，其他全部小写
- chr和ord
chr(num):获取十进制数字num在ASCII表中对应的字符【由ASCLL码推对应字符】
ord(ch):获取字符ch在ASCII表中对应的十进制数字【由对应字符推ASCLL码】
2、查找：（find不报错，index会报错）
- find():从左往右进行检索，返回被查找的子字符串在原字符串中第一次出现的位置，如果查找不到返回-1
- rfind():从右往左进行检索
- index()：从左往右进行检索，返回被查找的子字符串在原字符串中第一次出现的位置，如果查找不到则直接报错
- rindex():从右往左进行检索
3、填充：
- center(width,fillchar):用fillchar填充指定的字符串，填充之后的长度为width,原字符串居中显示
- ljust(width,fillchar):用fillchar填充指定的字符串，填充之后的长度为width,原字符串居左显示
- rjust(width,fillchar):用fillchar填充指定的字符串，填充之后的长度为width,原字符串居右显示
- zfill(width)：原字符串居右显示，剩余的字符默认用0填充
4、去除：
- strip():去除一个指定字符串中两端指定的子字符 【strip v. 除去，撕掉（外皮或表层）】
- lstrip():去除一个指定字符串中左边指定的子字符
- rstrip():去除一个指定字符串中右边指定的子字符
5、合并和分割：（★★★★★）
- join()：使用指定的子字符串将列表中的元素连接【列表-----》字符串】
- split():使用指定的子字符串将原字符串进行分割，得到一个列表 【字符串-----》列表】
li = ['gou', 'guo', 'qi']
n = "_".join(li)
print(n) #gou_guo_qi
name = "gouguoQoabco123"
e1 = name.split('o')
print(e1) # ['g', 'ugu', 'Q', 'abc', '123']
6、替换：
- replace(old,new):将原字符串中的old替换为new
映射替换：
maketrans():生成映射表
translate():根据映射表将指定字符串中的指定字符替换为映射表中对应的字符
7、判断：
- isalpha():一个字符串非空并字符全部是字母才返回True
- isalnum():一个字符串非空并字符是字母或者数字才返回True
- isupper()/islower()/istitle():和upper，lower,title有关
- isdigit()/isdecimal():一个字符串非空并字符全部是数字才返回True
- startswith()；判断一个字符串是否是以指定自字符串开头【前缀】
- endswith():判断一个字符串是否是以指定自字符串结尾【后缀】
8、编码和解码：（编码就是把字符串转换为字节，解码反之）
- encode():编码
在编码和解码格式相同的情况下，encode()编码之后可以用decode()解码，也可以用str()解码。 - decode()；解码
在编码和解码格式相同的情况下，encode()编码或者bytes()编码之后，都可以用decode()解码。
9、格式化：
- 占位符
- format()
- f""
#upper()
s = 'AAAaa'
print(s.upper()) #AAAAA （注意，字符串不可变，upper生成的是一个新的字符串）
print(s) #AAAaa
#lower()
s = 'AAAaa'
print(s.lower()) #aaaaa （注意，字符串不可变）
print(s) #AAAaa
#swapcase() （swap v. 交换；case n. 具体情况，实例；）
s = 'AAAaa'
print(s.swapcase()) #aaaAA （注意，字符串不可变）
print(s) #AAAaa
#capitalize() （capitalize v. 把……首字母大写）
s = 'AAAaa dog'
print(s.capitalize()) #Aaaaa dog （注意，字符串不可变）
print(s) #AAAaa dog
#title() （title n. 称号）
s = 'AAAaa dog'
print(s.title()) #Aaaaa Dog （注意，字符串不可变）
print(s) #AAAaa dog
#ord():字符的Ascall码/chr():ASCALL码对应的字符
print(ord('A')) #65 （注意，字符串不可变）
print(chr(98)) #b
print(ord('a')) #97
#查找
#find和rfind
s = 'abcdefaghijaklmnaopa'
print(s.find('a', 0, -1)) # 0
print(s.find('a', 1, -1)) # 6
print(s.find('a', -3, -1)) # -1 （find有区间还是左闭右开的特点，-1表示没找到）
print(s.find('a', 7, 11)) # -1 （find有区间还是左闭右开的特点，-1表示没找到）
print(s.find('a', 7, 12)) # 11
s = 'abcdefaghijaklmnaopa'
print(s.rfind('a',0,7)) #6
print(s.rfind('a',0,7)) #6
print(s.rfind('a',-3,-1)) #-1
#index和rindex
#print(s.index('a',-3,-1)) #ValueError: substring not found
print(s.index('a',0,3)) #0
print(s.rfind('b',0,-1)) #1
#填充
#center() (center n. （地理位置）中间)
s = 'abc'
print(s.center(4,'_')) #abc_
print(s.center(5,'_')) #_abc_
#print(s.center(5,'__')) #TypeError: The fill character must be exactly one character long
print(s.center(3,'_')) #abc
print(s.center(2,'_')) #abc （如果给定填充后长度小，原样输出）
print(s)
#ljust()、rjust() (just adv. 正好，恰好)
s = 'abc'
print(s.ljust(5,'-')) #abc--
print(s.ljust(3,'-')) #abc
print(s.ljust(2,'-')) #abc
print(s.rjust(5,'-')) #--abc
print(s.rjust(3,'-')) #abc
print(s.rjust(2,'-')) #abc
#zfill()
print(s.zfill(5)) #00abc
#去除(strip v. 除去)
s = 'abc'
print(s.strip('b')) #abc
print(s.strip('c')) #ab
print(s.rstrip('b')) #abc
print(s.rstrip('c')) #ab
print(s.lstrip('a')) #bc
#合并和分割：
s = 'adcc'
# a = ['a',1,'c']
# print(s.join(a)) #TypeError: sequence item 1: expected str instance, int found
a = ['1', '2', '3']
print(s.join(a)) # 1adcc2adcc3 （使用指定子字符串将列表元素链接）
s = '+'
print(s.join(a)) # 1+2+3
b = ['1afaafa', '2_+', '3%%']
z = ''.join(b)
print(z,type(z)) # 1afaafa2_+3%% <class 'str'>【这条语句体现了字符串列表转字符串的方法】
s = 'adccdeedffd'
print(s.split('d')) # ['a', 'cc', 'ee', 'ff', ''] 【这里体现了将字符串转字符串列表的方法】
#替换
s = 'adccdeedffd'
print(s.replace('d','+',2)) #a+cc+eedffd【字符串.replace(要替换的字符,替换后的字符,从左到右替换几个位置)】
s = 'adccdeedffd'
print(s.replace('d','+',10)) #a+cc+ee+ff+【替换个数超出已有数量，全部替换，不报错】
s = 'adccdeedffd'
print(s.replace('ad', '**', 10)) # **ccdeedffd
z = s.maketrans('ad','12')
print(s.translate(z)) # 12cc2ee2ff2 （按照z规则进行把s字符串进行替换）
#判断
s = ''
s1 = 'adfafaf'
s2 = '1adaf'
s3 = '中'
s4 = 'AAAABBBXX'
#isalpha (alpha n. 希腊字母表的第一个字母)【检查字符串当中是否全是字母】
print(s.isalpha()) #False
print(s1.isalpha()) #True
print(s2.isalpha()) #False
print(s3.isalpha()) #True （isalpha有坑，他会把汉字也当做字母）
print(s4.isalpha()) #True 【全是大写字母也可以】
#isalnum 【检查一个字符串是否由字母或数字组成；al:alpha；num:number】
print(s.isalnum()) #False
print(s1.isalnum()) #True
print(s2.isalnum()) #True
print(s4.isalnum()) #True
s3 = 'AA'
s4 = 'Aa'
s5 = 'aa'
s6 = '11aa'
s7 = 'A11aa'
s8 = 'Aaa Bbb'
s9 = 'AAA BBB'
s10 = 'A6'
s11 = '112'
print(s3.isupper()) #True 【字符串.isupper()：检查是否字符串全为大写】
print(s4.isupper()) #False 【只要有小写字母就报错】
print(s5.isupper()) #False
print(s6.isupper()) #False
print(s7.isupper()) #False
print(s8.isupper()) #False
print(s9.isupper()) #True
print(s10.isupper()) #True 【有坑，字符串当中有数字和大写字母，也对】
print(s11.isupper()) #False 【纯数字会报错】
print(s3.islower()) #False
print(s4.islower()) #False
print(s5.islower()) #True
print(s6.islower()) #True 【有坑，字符串当中有数字和小写字母，也对】
print(s7.islower()) #False
print(s8.islower()) #False
print(s9.islower()) #False
print(s11.islower()) #False 【纯数字会报错】
print(s3.istitle()) #False （只有首字母大写才行）
print(s4.istitle()) #True
print(s5.istitle()) #False
print(s6.istitle()) #False
print(s7.istitle()) #False 【只有首字母大写且全部都为字母才行】
print(s8.istitle()) #True
print(s9.istitle()) #False 【有坑，只有首字母大写，不能全部都为大写】
print('*'*11)
s1 = '12345'
s2 = '1a2345'
s3 = '1.23'
print(s1.isdigit()) #True
print(s2.isdigit()) #False 【必须全部为数字】
print(s3.isdigit()) #False 【必须全部为纯数字，小数不可以】
print(s1.isdecimal()) #True （decimal adj. 十进位的，小数的）
print(s2.isdecimal()) #False
print(s3.isdecimal()) #False
print(s1.startswith('1')) #True
print(s1.startswith('12')) #True
print(s1.endswith('345')) #True
print(s1.endswith('6')) #False
#编码和解码
# 1.编码（字符串转字节）
str1 = "3454jgjgj计算机%￥#"
# a.bytes()
r1 = bytes(str1,encoding="utf-8") # int()/float()/list().... （bytes：转为字节）
print(r1) #b'3454jgjgj\xe8\xae\xa1\xe7\xae\x97\xe6\x9c\xba%\xef\xbf\xa5#'
print(type(r1)) #<class 'bytes'>
# b.encode()
r2 = str1.encode(encoding="gbk")
print(r2) #b'3454jgjgj\xbc\xc6\xcb\xe3\xbb\xfa%\xa3\xa4#'
print(type(r2)) #<class 'bytes'>
# 2.解码（字节转字符串）
# a.str()
# 注意：字符串的编解码的格式一定要保持一致，否则无法操作
s1 = str(r1,encoding="utf-8")
print(s1) #3454jgjgj计算机%￥#
print(type(s1)) #<class 'str'>
s1 = r1.decode(encoding="utf-8") # r2.decode("gbk")
print(s1) #3454jgjgj计算机%￥#
print(type(s1)) #<class 'str'>
# b.decode()
s2 = r2.decode(encoding="gbk") # r2.decode("gbk")
print(s2) #3454jgjgj计算机%￥#
print(type(s2)) #<class 'str'>
#格式化
# 1.占位符 ******
"""
%d:可以匹配数字，一般匹配整型【整数】
%f：可以匹配数字，一般匹配浮点型【小数】
%s：可以匹配Python中的一切数据类型
"""
# 语法："使用占位符设置格式" % (实际的数据)
# 作用：使用实际的数据将占位符占用的位置进行填充
print(13,'abc')
print('年龄：%d，爱好:%s' % (10,'篮球'))
# 注意1：实际数据的数量和占位符的数量需要完全一致
# print('年龄：%d，爱好:%s' % (10)) # TypeError: not enough arguments for format string
# 注意2：从前往后进行一一匹配，实际数据的类型和占位符的类型要匹配
# print('年龄：%d，爱好:%s' % ('篮球',10)) # TypeError: %d format: a number is required, not str
print('年龄：%s，爱好:%s' % (10,'篮球'))
print('===')
# 注意3：%d匹配到浮点数会自动取整，%f匹配到整型会自动转换为浮点型
print('年龄：%d，爱好:%s,体重：%f' % (10.85,'篮球',55)) #年龄：10，爱好:篮球,体重：55.000000
# 注意4：%.nd,n表示整数显示的位数，不够的话在原数字的前面补0
# %.nf,n表示保留小数点后n位 *****
print('年龄：%.5d，爱好:%s,体重：%.2f' % (10,'篮球',55.2463563234))
# print('年龄：%s，爱好:%s,体重：%s' % (10.85,'篮球',55.2463563234))
# 2.format()
# 注意1：format和占位符相比，优点：不需要考虑类型的问题
print('年龄：{}，爱好:{}'.format(10,'篮球'))
# 注意2：format和占位符相比，优点：也可以不需要考虑数量的问题
print('名次:{},年龄：{}，爱好:{}'.format(10,10,'篮球')) # 默认，数量一致
print('名次:{0},年龄：{0}，爱好:{0}'.format(10,'篮球')) # 同一个数据可以重复使用
# 注意3：format也可以限制类型,{编号:s},s表示字符串类型,f表示浮点型，d表示整型，
print('年龄：{0}，爱好:{1},体重：{2}'.format(10,'篮球',55.6347)) #年龄：10，爱好:篮球,体重：55.6347
print('年龄：{0}，爱好:{1},体重：{2:f}'.format(10,'篮球',55.6347)) #年龄：10，爱好:篮球,体重：55.634700
# 3.f"",推荐 *******
print(f'年龄：{10}，爱好:{"篮球"}')
print(f'年龄：{10}，爱好:{"篮球"},体重：{55.6347}')
4、 string模块：生成所有“字母（大小写）、数字的”大小写
#2、string模块
import string
print(string.ascii_lowercase,type(string.ascii_lowercase)) # abcdefghijklmnopqrstuvwxyz <class 'str'>
print(string.ascii_uppercase,type(string.ascii_uppercase)) # ABCDEFGHIJKLMNOPQRSTUVWXYZ <class 'str'>
print(string.ascii_letters,type(string.ascii_letters)) # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ <class 'str'>
print(string.digits,type(string.digits)) # 0123456789 <class 'str'>
751
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
