零py-(ep-19)

Nicole37

字符串2：
1、字符串查找功能：
count(sub[, start[, end]])
find(sub[, start[, end]])
rfind(sub[, start[, end]])
index(sub[, start[, end]])
rindex(sub[, start[, end]])

1. #count用于查找指定子字符串出现的次数
   
2. x = "今天有点烦躁奥，点杯牛奶吧"
   
3. x.count("点")
   
4. 2
   
5. #后面用来指定查找的下标范围
   
6. x.count("点",0,3)
   
7. 0
   
8. #find\rfind用于定位sub参数指定的子字符串在字符串中的索引下标值，find是从左往右找；rfind是从右往左找
   
9. x.find("点")
   
10. 3
    
11. x.rfind("点")
    
12. 8
    
13. #index和rindex也用于定位sub参数指定的子字符串在字符串中的索引下标值，同理 从左往右；从右往左，与find xfind的区别就是如果找不到索引值会报错，而find会返回负一
    
14. x.index("点")
    
15. 3
    
16. x.rindex("点")
    
17. 8
    
18. x.index("哈")
    
19. Traceback (most recent call last):
    
20.   File "<pyshell#15>", line 1, in <module>
    
21.     x.index("哈")
    
22. ValueError: substring not found
    
23. x.find("哈")
    
24. -1

复制代码

2、字符串替换功能：
expandtabs([tabsize=8])
replace(old,new,count=-1)
translate(table)

1. #替换
   
2. #expandtabs():将代码里的tab缩进转换为空格缩进，一个tab对应的空格个数为()内的数字
   
3. z="i wan \tyou"
   
4. print(z.expandtabs(10))
   
5. i wan     you
   
6. #replace(old,new,count=-1)返回一个将所有old的参数指定的子字符串替换为new参数指定的字符串，默认替换次数是-1（即替换全部）
   
7. a = "一起学习嘛"
   
8. b=a.replace("学习","逛街")
   
9. b
   
10. '一起逛街嘛'
    
11. #translate(table)返回根据table参数转换后的新字符串,table是一个表格，用str.maketrans(x[,y[,z]])来获得
    
12. #表格的前后要同等长度，一一对应
    
13. tab = str.maketrans("nicole","123456")
    
14. a = "i love china"
    
15. a.translate(tab)
    
16. '2 54v6 3h21a'
    
17. a.translate(str.maketrans("nicole","123456"))
    
18. '2 54v6 3h21a'
    
19. #maketrans还可以再加一个参数，用来将制定字符串忽略掉
    
20. a.translate(str.maketrans("nicole","123456","love"))
    
21. '2  3h21a'

复制代码

作业
0:2
1:报错的格式不一样
2：3
3：A
4：报错 表格前后个数不一致
5：'I  FishC.cm'
动手：

1. x = input("请输入第一个版本号，v1=")
   
2. y = input("请输入第一个版本号，v2=")
   
3. b = x.find(".")
   
4. c = y.find(".")
   
5. if int(x[b-1])>int(y[c-1]):
   
6.     print("v1")
   
7. if int(x[b-1])<int(y[c-1]):
   
8.     print("v2")
   
9. if int(x[b-1])==int(y[c-1]):
   
10.     if int(x[b+1])>int(y[c+1]):
    
11.         print("v1")
    
12.     if int(x[b+1])<int(y[c+1]):
    
13.         print("v2")
    

复制代码

1：

1. x = input("请输入需要加密的明文：")
   
2. y = input("请输入需要替换的字符：")
   
3. z = input("请输入将要替换的字符：")
   
4. p=[]
   
5. 
   
6. if len(y)!=len(z):
   
7.     print("字符数量不一致")
   
8. else:
   
9.     tab = str.maketrans(y,z)
   
10.     print("加密后的密文是",x.translate(tab))
    
11. 
    
12.     for i in y:
    
13.         for j in z:
    
14.             p.append(i)
    
15.             p.append(j)
    
16.     for i in range(len(p)):
    
17.         if p[i]==p[i+2]:
    
18.             print("冲突")
    
19.             break
    
20.     for i in range(1,len(p)):
    
21.         if p[i]==p[i+2]:
    
22.             print("冲突")
    
23.             break
    
24.    

复制代码

作业答案：
0：count(sub[, start[, end]]) 方法是返回 sub 在字符串中不重叠的出现次数。什么叫“不重叠”呢？就是一个元素不能被重复匹配。

1. str1 = "xxxxx"
   
2. str1.count("xx")

复制代码

答案为2
1：

1. print(x)
   
2. print(x.expandtabs(2))
   
3. print(x.expandtabs(5))
   
4. print(x.expandtabs(10))

复制代码

结果：

1. Hello***FishC
   
2. Hello*FishC
   
3. Hello*****FishC
   
4. Hello*****FishC

复制代码

不懂。。。
5：

1. "I love FishC.com".translate(str.maketrans("love", "1234", "love"))

复制代码

'I  FishC.cm'，str.maketrans() 方法是先执行忽略操作，再执行替换操作
动手：
0：

1. v1 = input("请输入第一个版本号，v1 = ")
   
2. v2 = input("请输入第二个版本号，v2 = ")
   
3.    
   
4. n, m = len(v1), len(v2)  #获取两版本号的长度
   
5. i, j = 0, 0 #初始下标值
   
6.    
   
7. while i < n or j < m: #用while来写循环，最终截止条件为：下标在长度范围内
   
8.     x = 0
   
9.     while i < n and v1[i] != '.':
   
10.         x = x * 10 + int(v1[i])
    
11.         i += 1
    
12.     i += 1
    
13.     y = 0
    
14.     while j < m and v2[j] != '.':
    
15.         y = y * 10 + int(v2[j])
    
16.         j += 1
    
17.     j += 1
    
18.     if x > y:
    
19.         print("v1")
    
20.         break
    
21.     elif x < y:
    
22.         print("v2")
    
23.         break
    
24.    
    
25. if x == y:
    
26.     print("v1 = v2")
    

复制代码

不懂。。。
1：

1. plain = input("请输入需要加密的明文：")
   
2. x = input("请输入需要替换的字符：")
   
3. y = input("请输入将要替换的字符：")
   
4.    
   
5. # 加密的代码
   
6. if len(x) != len(y):
   
7.     print("需要替换的字符数量必须跟将要替换的字符数量一致！")
   
8. else:
   
9.     cipher = plain.translate(str.maketrans(x, y))
   
10.     print("加密后的密文是：" + cipher)
    
11.    
    
12. # 检测冲突的代码
    
13. # flag 变量标志是否退出检测（只要找到一个冲突，就可以直接退出）
    
14. flag = 0
    
15.    
    
16. # 如果 x 中存在相同的字符，那么 y 对应下标的字符也应该是相同的
    
17. for each in x:
    
18.     if x.count(each) > 1 and flag == 0: #连用x.count()判断x中是否有相同字符，x.find()找出重复字符的下标
    
19.         i = x.find(each)
    
20.         last = y[i]
    
21.         while i != -1: #使用while 循环，其条件是最终结果，在未到头之前，判断y 对应下标的字符是否相同
    
22.             if last != y[i]:
    
23.                 print("由于替换字符出现冲突，该密文无法解密！")
    
24.                 flag = -1
    
25.                 break
    
26.    
    
27.             i = x.find(each, i+1)#从下标i+1开始继续搜索下一个each的下标 返回while
    
28.    
    
29. # 如果 y 中存在相同的字符，那么 x 对应下标的字符也应该是相同的
    
30. for each in y:
    
31.     if y.count(each) > 1 and flag == 0:
    
32.         i = y.find(each)
    
33.         last = x[i]
    
34.         while i != -1:
    
35.             if last != x[i]:
    
36.                 print("由于替换字符出现冲突，该密文无法解密！")
    
37.                 flag = -1
    
38.                 break
    
39.    
    
40.             i = y.find(each, i+1)
    
41.             

复制代码