字符串

字符串(str)

1.1字符串是容器型数据类型 标志’’或者’’’’’’或者””””””,引号中每个符号就是字符串的元素

1.2字符串内容换行时可以直接回车

1.3字符串不可变(不支持增删改),字符串有序(支持下标操作)

1.4引号中每个符号都是字符串的元素(又叫字符) 元素是任意的 空格也是一个字符

1.5分为普通字符和转义字符

1
2
3
4
5
str1 = '90,100'
str2 = "adwfef542"
str3 = '''abc
123'''
str4 = 'abc\ndef'

2.1 字符串元素 - 字符

2.1.1转义字符

1
2
3
4
5
\n - 换行
\t - 水平制表符(相当于tab键)
\' - 表示一个普通的单引号
\" - 表示一个普通的双引号
\\ - 表示一个普通的反斜杠

\u 4位的十六进制数 - 编码字符

1
2
3
str5 = 'it\'s me!'
print(str5)
# it's me!

3.1 字符编码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1.计算机只能直接存储数字(而且保存的数字的二进制的补码),文字符号是不能直接存储到计算机的
为了让计算机具备存储文字符号的能力,我们给所有的文字符号对应了一个固定的数字
每次存储文字符号时就将之对应的数字存储起来
符号对应的数字就是符号的编码值

2.编码表 - 保存符号和数字的对应关系表
1)ASCII码表 - 总共128个字符
2)Unicode 编码表 - 包含(ASCII码) - 又称万国码
a.中文范围 - 4e00 ~9fa5

3.编码值在python中的使用
a.chr函数:chr(编码值) - 获取编码值对应的字符
b.ord函数:ord(字符) - 获取字符的编码值
c.编码字符:\u4e00 4e00就是4位的十六进制
注意:python中需要字符的地方都必须使用长度为1的字符串赋值
1
2
3
4
5
6
7
8
9
# for i in range(0x4e00,0x9fa5):
# print(chr(i))

# for i in range(0x4dc0,0x4dff):
# print(chr(i))

# print(ord('徐'),ord('明'),ord('勇'))
# ## 24464 26126 21191
# print(chr(24464),chr(26126),chr(21191))

练习:将大写字母转换为对应的小写字母

1
2
3
4
c = 'F'
new_c = chr(ord(c)+32)
print(new_c)
## f

4.1 查 - 获取字符串的元素

字符串获取字符的语法和列表获取元素一模一样

1
2
3
str1 = 'abcdefg'
for index,item in enumerate(str1):
print(index,item)

4.2 数学运算符:+,*

1
2
print('hello'+'world')
print('='*20)

练习:提取字符中的小写字母

1
2
3
4
5
6
str1 = 'ssjjf大山洞IE偶见覅额35665'
new_str1 = ''
for i in str1:
if 97 <= ord(i) <=122:
new_str1+=i
print(new_str1)

4.3 比较运算符

1)比较是否相等:==,!=

1
2
print('abc'=='abc')  ##True
print('acb' == 'abc') ##False

2)比较大小:>,<,>=,<=

两个字符串比较大小是比较第一对不相等的字符的编码大小

1
2
print('Mnxy'>'ab') ##False
print('你好'>'hello') ##True

应用1

1
2
3
4
5
6
7
8

char = ?
判断是否是数字字符 '0' <= char <= '9'
判断是否是小写字母 'a' <= char <= 'z'
判断是否是大写字母 'A' <= char <= 'Z'
判断是否是字母 'a' <= char <= 'z' or 'A' <= char <= 'Z'
判断是否是中文 '\u4e00' <= char <= '\u9fa5'

练习2:

1
str3 = '你好loe--23=sks;M9JHkyu是-12山卡拉'

1)统计中文字符的个数

1
2
3
4
5
# count = 0
# for i in str3:
# if '\u4e00' <= i <= '\u9fa5':
# count += 1
# print(count)

2)打印字符串所有的数字字符

1
2
3
# for i in str3:
# if '0' <= i <= '9':
# print(i,end=' ')

3)提取字符串中所有的字母

1
2
3
4
5
new_str3 = ''
for i in str3:
if 'a' <= i <= 'z' or 'A' <= i <= 'Z':
new_str3 += i
print(new_str3)

5.1 in 和 not in

1
字符串1 in 字符串2 - 判断字符串2中是否包含字符串1(字符串1是否是字符串2的子串)
1
2
print('1' in 'abc123')  ##True
print('ac' in 'abc123') ##False

5.2 r语法(r-string) - 在字符串的面前加r/R

如果在字符串前加r/R,那么字符串中所有的转义字符的功能都会消失

1
2
str1 = r 'abc\n'
print(str1)

path = r’C:\Users\Public\Win’

print(path)

6.1 相关函数

1
2
3
4
len(字符串)
str(数据) - 将数据转换成字符串(任何类型的数据都可以转换成字符串)
# 转换的时候是在数据的打印值的外面加引号
eval(字符串) - 去掉字符串外面的引号,如果字符串中是一个正确的表达式,会计算其结果
1
2
3
4
5
6
7
8
9

str(100) #'100'
str([10,20,30]) # '[10, 20, 30]'
str({'a':10,'b':20}) #"{'a':10,'b':20}"

print(eval('100')) #100
print(eval('[10,20,30]')) ##[10, 20, 30]
print(eval('100+200')) ##300

7.1 字符串的相关方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
capitalize()
将字符串的第一个字符转换为大写
center(width, fillchar)
返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。
count(str, beg= 0,end=len(string))
返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
bytes.decode(encoding="utf-8", errors="strict")
Python3 中没有 decode 方法,但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象,这个 bytes 对象可以由 str.encode() 来编码返回。
encode(encoding='UTF-8',errors='strict')
以 encoding 指定的编码格式编码字符串,如果出错默认报一个ValueError 的异常,除非 errors 指定的是'ignore'或者'replace'
endswith(suffix, beg=0, end=len(string))
检查字符串是否以 obj 结束,如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束,如果是,返回 True,否则返回 False.
expandtabs(tabsize=8)
把字符串 string 中的 tab 符号转为空格,tab 符号默认的空格数是 8
find(str, beg=0, end=len(string))
检测 str 是否包含在字符串中,如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-1
index(str, beg=0, end=len(string))
跟find()方法一样,只不过如果str不在字符串中会报一个异常。
isalnum()
如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False
isalpha()
如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
isdigit()
如果字符串只包含数字则返回 True 否则返回 False..
islower()
如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False
isnumeric()
如果字符串中只包含数字字符,则返回 True,否则返回 False
isspace()
如果字符串中只包含空白,则返回 True,否则返回 False.
istitle()
如果字符串是标题化的(见 title())则返回 True,否则返回 False
isupper()
如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False
join(seq)
以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
len(string)
返回字符串长度
ljust(width[, fillchar])
返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串,fillchar 默认为空格。
lower()
转换字符串中所有大写字符为小写.
lstrip()
截掉字符串左边的空格或指定字符。
maketrans()
创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。
max(str)
返回字符串 str 中最大的字母。
min(str)
返回字符串 str 中最小的字母。
replace(old, new [, max])
把 将字符串中的 old 替换成 new,如果 max 指定,则替换不超过 max 次。
rfind(str, beg=0,end=len(string))
类似于 find()函数,不过是从右边开始查找.
rindex( str, beg=0, end=len(string))
类似于 index(),不过是从右边开始.
rjust(width,[, fillchar])
返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串
rstrip()
删除字符串末尾的空格或指定字符。
split(str="", num=string.count(str))
str 为分隔符截取字符串,如果 num 有指定值,则仅截取 num+1 个子字符串
splitlines([keepends])
按照行('\r', '\r\n', \n')分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。
startswith(substr, beg=0,end=len(string))
检查字符串是否是以指定子字符串 substr 开头,是则返回 True,否则返回 False。如果beg 和 end 指定值,则在指定范围内检查。
strip([chars])
在字符串上执行 lstrip()和 rstrip()
swapcase()
将字符串中大写转换为小写,小写转换为大写
title()
返回"标题化"的字符串,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle())
translate(table, deletechars="")
根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
upper()
转换字符串中的小写字母为大写
zfill (width)
返回长度为 width 的字符串,原字符串右对齐,前面填充0
isdecimal()
检查字符串是否只包含十进制字符,如果是返回 true,否则返回 false。

7.2 join

字符串.join(序列) - 将序列中的元素用指定的字符串拼接成一个字符串(序列中的元素必须是字符串)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
list1 = ['abc','def','123']
result = ''.join(list1)
print(result)
## abcdef123
result2 = '+'.join(list1)
print(result2)
## abc+def+123
result3 = '123'.join(list1)
print(result3)
## abc123def123123
list2 = ['abc',100,True,'hello']
result4 = ''.join([str(x) for x in list2])
print(result4)
## abc100Truehello
## 如果拼接对象中有不是字符串的元素,需要转换成字符串

练习2:将list2中所有的字符串拼接成一个字符串

1
2
3
list2 = ['abc', 100, True, 'hello']     # abchello
result = ''.join([x for x in list2 if type(x)==str])
print(result)

7.3 count

字符串1.count(字符串2) - 统计字符串1在字符串2中出现的次数

1
2
3
message = 'how are you? i am fine! thank you! and you?'
result = message.count('you')
print(result)

7.4 index/find

字符串1.index(字符串2) - 获取字符串2第一次出现在字符串1中的位置(下标)

1
2
3
4
5
6
7
8
9
10
11
12
message = 'how are you? i am fine! thank you! and you?'
result = message.index('you')
print(result)
## 在字符串不存在时,会报错

result1 = message.find('you')
print(result1)
## 在字符串不存在时,不报错,并且返回-1

result2 = message.rfind('you')
print(result2)
## 获取字符串2最后一次出现在字符串1中的位置(下标)

7.5 split

字符串1.split(字符串2) - 将字符串1中所有的字符串2作为切割点对字符串1进行切割

切完后的结果是列表保存每一个小字符串,小字符串的个数是字符串2在字符串1中的个数加1

1
2
3
4
message = 'mnabc123abcxyzabcoop'
result1 = message.split('abc')
print(result1)
## ['mn', '123', 'xyz', 'oop']

字符串1.split(字符串2,n) - 最多切割n次

1
2
3
4
message = 'mnabc123abcxyzabcoop'
result2 = message.split('abc',1)
print(result2)
## ['mn', '123abcxyzabcoop']

8.1 replace

字符串1.replace(字符串2,字符串3)

将字符串1中的所有的字符串2替换成字符串3

1
2
3
message = 'how are you? i am fine! thank you! and you?'
result = message.replace('you','me')
print(result)

字符串1.replace(字符串2,字符串3,n)

将字符串1中的所有的字符串2替换成字符串3 n限制替换次数

1
2
3
message = 'how are you? i am fine! thank you! and you?'
result = message.replace('you','me',2)
print(result)

9.1 center\rjust\ljust\zfill

字符串1.center(总长度,填充字符) - 将字符串1转换成指定长度的新字符串,不够的用指定字符填充

1
2
3
4
5
str1 = 'abc' #000abc000
print(str1.center(9,'0')) #000abc000
print(str1.center(8,'x')) #xxabcxxx
print(str1.rjust(8,'x')) #xxxxxabc
print(str1.ljust(8,'x')) #abcxxxxx

zfill 与rjust方法相同 填充字符固定为’0’ - 字符串1.rjust(总长度,’0’)

10.1 strip/rstrip/lstrip 删除空白

1
2
3
4
5
6
7
8
9
10
11
str1 = '\t   abc  123   \n'
print(str1)
print('-'*20)
print(str1.strip())
## 删除两边空白
print('-'*20)
print(str1.lstrip())
## 删除左边空白
print('-'*20)
print(str1.rstrip())
## 删除右边空白

作业

1. 输入一个字符串,打印所有奇数位上的字符(下标是1,3,5,7…位上的字符)

例如: 输入**’abcd1234 ‘ ** 输出**’bd24’**

1
2
3
4
5
6
str1 = 'abcd1234 '
new_str1 = ''
for index in range(len(str1)):
if index % 2:
new_str1+=str1[index]
print(new_str1)

2. 输入用户名,判断用户名是否合法(用户名长度6~10位)

1
2
3
4
5
a = input("请输入用户名:")
if 6 <= len(a) <=10:
print("用户名合法")
else:
print("用户名不合法")

3. 输入用户名,判断用户名是否合法(用户名中只能由数字和字母组成)

例如: ‘abc’ — 合法 ‘123’ — 合法 ‘abc123a’ — 合法

1
2
3
4
5
6
7
8
9
a = input("请输入用户名:")
for i in a:
if '0' <= i <= '9' or 'a' <= i <= 'z':
continue
else:
print('不合法')
break
else:
print('合法')

4. 输入用户名,判断用户名是否合法(用户名必须包含且只能包含数字和字母,并且第一个字符必须是大写字母)

例如: ‘abc’ — 不合法 ‘123’ — 不合法 ‘abc123’ — 不合法 ‘Abc123ahs’ — 合法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
a = input("请输入用户名:")
flag = False
if 'A' <= a[0] <= 'Z':
flag = True
else:
print('用户名不合法')
nums = 0
if flag:
for i in a:
if 'a' <= i <= 'z' or 'A' <= i <= 'Z' or '0' <= i <= '9':
if '0' <= i <= '9':
nums+=1
continue
else:
print('用户名不合法')
break
else:
if nums >=1:
print('用户名合法')
else:
print('用户名不合法')

5. 输入一个字符串,将字符串中所有的数字字符取出来产生一个新的字符串

例如:输入**’abc1shj23kls99+2kkk’** 输出:**’123992’**

1
2
3
4
5
6
str1 = 'abc1shj23kls99+2kkk'
new_str1 = ''
for i in str1:
if '0' <= i <= '9':
new_str1+=i
print(new_str1)

6. 输入一个字符串,将字符串中所有的小写字母变成对应的大写字母输出 (用upper方法和自己写算法两种方式实现)

例如: 输入**’a2h2klm12+’ ** 输出 ‘A2H2KLM12+’

方法1

1
2
3
4
5
6
7
8
str1 = 'a2h2klm12+'
new_str1 = ''
for i in str1:
if 'a' <= i <= 'z':
new_str1+=chr(ord(i)-32)
else:
new_str1+=i
print(new_str1)

方法2

1
2
3
4
5
6
7
8
str1 = 'a2h2klm12+'
new_str1 = ''
for i in str1:
if 'a' <= i <= 'z':
new_str1 += i.upper()
else:
new_str1+=i
print(new_str1)

7. 输入一个小于1000的数字,产生对应的学号

例如: 输入**’23’,输出‘py1901023’** 输入**’9’, 输出‘py1901009’** 输入**’123’,输出‘py1901123’**

1
2
3
4
5
str1 = 'py1901'
a = input("请输入一个小于1000的数字:")
result = str1.ljust(9-len(a),'0')
result += a
print("对应的学号为:",result)

8. 输入一个字符串,统计字符串中非数字字母的字符的个数

例如: 输入**’anc2+93-sj胡说’** 输出:4 输入**’===’** 输出:3

1
2
3
4
5
6
7
8
str1 = input("请输入:")
count = 0
for i in str1:
if 'a' <= i <= 'z' or 'A' <= i <= 'Z' or '0' <= i <= '9':
continue
else:
count += 1
print("非数字字母的个数为:",count)

9. 输入字符串,将字符串的开头和结尾变成’+’,产生一个新的字符串

例如: 输入字符串**’abc123’, 输出‘+bc12+’**

1
2
3
str1 = input("请输入一个字符串:")
new_str1 = (str1[1:len(str1)-1]).center(len(str1),'+')
print("新的字符串为:",new_str1)

10. 输入字符串,获取字符串的中间字符

例如: 输入**’abc1234’** 输出:‘1’ 输入**’abc123’** 输出**’c1’**

1
2
3
4
5
a = input("请输入字符串:")
if len(a) % 2:
print(a[len(a)//2])
else:
print(a[len(a)//2-1],a[len(a)//2],sep='')

11. 写程序实现字符串函数find/index的功能(获取字符串1中字符串2第一次出现的位置)

例如: 字符串1为:how are you? Im fine, Thank you! , 字符串2为:you, 打印8

1
2
3
4
5
6
7
8
9
10
11
str1 = input("请输入字符串1:")
str2 = input("请输入字符串2:")
count = 0
if str2 in str1:
for item in str1:
count+=1
if item == str2[0]:
break
else:
print("字符串2不在字符串1中")
print("字符串1中字符串2第一次出现的位置为:",count-1)

12. 获取两个字符串中公共的字符

例如: 字符串1为:abc123, 字符串2为: huak3 , 打印:公共字符有:a3

1
2
3
4
5
6
7
8
str1 = 'abca123'
str2 = 'huak3'
sum_str = ''
for i in str1:
if i in str2:
if i not in sum_str:
sum_str+=i
print(sum_str)