1 """
2 字符串的三种表示形式：
3 1.单引号
4 2.双引号
5 3.三引号（三双，三单）
6 """
7 # string_01 = "How are you?"
8 # print(string_01)
9 # string_02 = "it's very good"
10 # # 字符串内容中有单引号，字符串就不能使用单引号包裹。
11 # print(string_02)
12 # string_03 = '''it' very good''' # 字符串内容中有单引号，可以使用三引号包裹
13 # print(string_03)
14 # string_04 = """it' very good""" # 三双引号可以包裹单引号
15 # print(string_04)
16 # string_05 = 'he said:"he is happy' # 字符串内容中有双引号，字符串就使用其他符号内容包裹
17 # print(string_05)
18 # string_06 = '''he said:"he is happy''' # 三引号可以包裹双引号
19 # print(string_06)
20 # string_07 = """he said:"he is happy""" # 三双引号可以包裹双引号。单引号
21
22 """
23 转义字符，\...
24 常用的转义字符：
25 \b back，退一格
26 \t tab 横向制表符，向右空四格
27 \r 回车不换行
28 \f 表示的是换页
29 """
30 # string_01 = 'let\'s go' # 代表当前只是普通的单引号，不是字符串开始结束标记
31 # print(string_01)
32 # string_02 = "a\\c" # \\... 代表一个普通的\而不是转义字符的开始标记
33 # print(string_02)
34 # a = 10 + 50 + 40 +\
35 # (100 - 30 * 20) # \在行尾代表换行
36 # print(a)
37 # string_03 = "hello every,\n glad to meet you"
38 # print(string_03)
39 # print("abcd\refg") # \r回车不换行，回车当前行的行首
40 # print("abcd\befg") # \b退格
41 # print("abcd\tefg") # \t横向制表符，空四个格，相当于按一次tab键
42
43 """
44 不想转义时，可以使用r\R加在字符串的前面，表示原始字符
45 print("abc\ndef") # \n换行
46 print(r"abc\ndef") # r,原始字符，\n变为普通字符，不在表示换行
47 print(R"abc\ndef") # R,原始字符，\t变为普通字符，不在表示制表符
48 字符串的输入输出，input（），print（）
49 字符串的格式化输出：%。。 （占位）
50 1%d 表示十进制整数
51 2%f 表示十进制浮点数
52 3%s 表示字符串
53 2%i 表示有符号十进制整数
54 格式化字符串的另一种方法:"{}".format(a,b)
55 {0},{1} 含义：参数的位置，默认的顺序是从0开始依次递增
56 {0:#>6} 含义：0，参数为止，#填充符号，>向右对齐，六个字符位置
57 对齐方式:<左对齐，^居中，>右对齐
58 :冒号后面如果跟字符，只能跟一个，如果没有字符默认以空格填充。
59 """
60 name = "小明"
61 age = 18
62 print("我的名字叫%s，今年%d岁" % (name, age))
63 print("我的名字叫{},今年{}岁".format(name, age))
64 print("我的名字叫{0:>6},今年{1:<3}岁".format(name, age))
65
66 # print("Hello everyone,\nglad to mite you")
67 # print(r"Hello everyone,\nglad to mite you")
68 # print(R"Hello everyone,\nglad to mite you")
69 # name = "小明"
70 # age = 20
71 # # 占位符，后面跟多个变量用括号括起来，逗号隔开，元祖
72 # print("我叫%s,今年%d岁" % (name, age))
73 # a = 4.3
74 # print("a的值为%2.3d" % a) # %2.3,2代表整数占的位数，3代表小数占的位数
75
76 # 九九乘法表
77 # for i in range(1,10): # 生成一个数字序列
78 # for j in range(1, i+1):
79
80 """
81 %5d 中的5的作用：占位，整数占五个字符的位置，如果是数字的长度
82 # 小于5，扩展至五位，前边空着，右对齐，如果数字的长度大于5，
83 # 保留数字本身的长度。
84 """
85 # print("%d * %d = %2d" % (i, j, i*j), end="")
86 # print("")
87 # range(start,end,step)生成一个数字序列，整数。
88 # start 开始，生成的数字序列包含开始，默认是0
89 # end 结束，生成的数字序列不包含结束，在结束之前的一个数字
90 # step 步长，从开始到结尾，每个数字之间的差，默认是1,。取值为整数，可以为正负
91 # range(10) 生成的数字序列为：0.1.2.3.4.5.6.7.8.9.
92 # range(1,10,2) 生成的序列为：1.3.5.7.9
93 # range(10,1,-1) 生成的数字序列为：10.9.8.7.6.5.4.3.2.
94 # print(range(10, 1, -1))
95 # for i in range(10, 1, -1): # 生成空的数字序列
96 # print(i, end="")
97
98 """
99 格式化字符串是另一种方式，“{}”.formal（）
100 {0}{1}{2}......，花括号中可以写整数没代表format中参数的位置，从0开始
101 接上行，可以不写，默认的顺序就是0,1,2,3...
102 {0:!>8} 含义：0代表参数的位置,!代表填充的字符,>右对齐，8代表8个字符的位置
103 默认左对齐，默认以空格填充多余的位置
104 """
105 # print("我叫%s，今年%d岁" % ("张三", 20))
106 # print("我叫{0:!<6},今年{1:*^4}岁, 家住{2:@>8}".format("张三", 20, "山西"))
107 # name = "小明"
108 # score = 100
109 # print("%s的考试成绩为%d" % (name, score))
110 # print("{}的考试成绩为{}".format(name, score))
111 # format写九九乘法表
112 # for i in range(1, 10):
113 # for j in range(1, i+1):
114 # # print("{0:2}*{1:2}={2:3}".format(i, j, i*j), end="")
115 # print("{0:☂>3}*{1:☺>3}={2:☂>5}\t".format(i, j, i*j), end="")
116 # print("")
117
118 """
119 字符串中的值，用的是索引或下标
120 字符串的索引从左至右，从0开始，一次+1 ， 到 长度-1
121 索引从右至左，从-1开始，依次-1（减一） 到 -（负）字符串长度
122 """
123 # string_01 = "python"
124 # print(string_01[0]) # p
125 # print(string_01[-6]) # p
126 # print(string_01[5]) # n
127 # print(string_01[-1]) # n
128 # print(string_01[4]) # o
129 # print(string_01[-2]) # 0
130 # print(string_01[6]) # IndexError: string index out of range
131
132 """
133 字符串是不可变的!如果想要修改字符串的值，会报错
134 字符串的拼接，会生成一个新的字符串，+
135 """
136 # string_01 = "python"
137 # print(id(string_01)) # 查看变量地址
138 # print(string_01)
139 # string_01 += "hello"
140 # print(id(string_01)) # 查看变量地址
141 # print(string_01)
142
143 """
144 切片，对字符串进行截取一段
145 字符串变量名[start:end:step] start开始（包含）， end结束（不包含），step步长（默认为1 ）
146 切片，左闭右开
147 方向：从左至右，从右至左
148 步长：下标加的数字，比如0开始，步长为2:0，+2-->2， +2-->4, +2-->6
149 """
150 # string_02 = "hel love one"
151 # # 开始，结束，步长，都省略，表示整个字符串，默认从0开始到最后结束，步长为1
152 # print(string_02[::])
153 # print(string_02[::-1]) # 步长为-1，字符串逆序输出
154 # string_03 = "good good study,day day up"
155 # a = string_03[0:4:1] # 第一个good
156 # print(a)
157 # b = string_03[5:9:1] # 第二个good
158 # print(b)
159 # # 切出 study，
160 # c = string_03[10:16:1]
161 # print(c)
162 # # .pu
163 # d = string_03[-1:-4:-1]
164 # print(d)
165 # # 从开始到结尾，步长为2
166 # e = string_03[0:28:2]
167 # print(e)
168 # # 从开始到结尾，步长为3
169 # f = string_03[2:28:1]
170
171 """
172 字符串常用的函数：
173 1.len(str) 求字符串的长度
174 2.max(str) 求字符串中ASCII最大的那个字符
175 2.min(str) 求字符串中ASCII最小的那个字符
176 enumerate(str,start=) 生成一个下标，数值对应的对象(序列)；
177 通常与for循环使用字符串的遍历：for，while
178 """
179 # word = "123abcABC"
180 # print(len(word)) # 9
181 # print(max(word)) # 'c'
182 # print(min(word)) # '1'
183 # for i in word: # for循环遍历字符串
184 # print(i)
185 # for i, j in enumerate(word): # enumerate()中的start默认为0
186 # print(i, j)
187 # temp = 0
188 # while temp < len(word): # while循环遍历字符串
189 # print(word[temp])
190 # temp += 1
191
192 """
193 函数作用于的变量使用函数时写在函数后面的括号中，方法要跟在变量.后边
194 字符串的:
195 内建方法，常用的有：
196 1。find() 格式：str.find(子串，开始(默认为0)，结束(默认为最后))
197 查找子串,找到了就返回第一个匹配的对象的下标值，没有就返回-1
198 2.rfind() 查找子串，从右边开始查找
199 """
200 # word = "Hello,welcome to china"
201 # print(word.find("china")) # 17
202 # print(word.find("ccc")) # -1，没找到
203 # print(word.find("o")) # 4,从最开始第一个o
204 # print(word.rfind("o")) # 15，从右开始第一个o
205 # print(word.rfind("o", 5, 15)) # 10，切片范围内的第一个o
206
207 # word = "abc123dABCefg"
208 # # 求字符串的长度
209 # print(len(word)) # 13
210 # # 求字符串中的最大值
211 # print(max(word)) # g
212 # # 求字符串中的最小值
213 # print(min(word)) # 1
214 # # 使用for、while循环来遍历字符串
215 # for i in word:
216 # print(i)
217 # temp = 0
218 # while temp < len(word):
219 # print(word[temp])
220 # temp += 1
221 # # enumerate 生成下标数据对应的序列，与for循环结合
222 # for i, j in enumerate(word):
223 # print("i, j")
224 # # 查找"e"所在的下标位置。
225 # print(word.find("e")) # 10
226
227 """
228 while 条件表达式1： 当条件为1成立，为True时，循环,代码块1才会执行
229 代码块1
230 """
231 # while True: # 死循环
232 # print("abc")
233 # word = "abc123"
234 # while循环遍历字符串word，从哪一个字符开始至最后一个字符终止，全部访问到
235 # 字符串怎么访问到每一个字符，使用下标（索引）
236 # word[0],word[1],...word[n-1]
237 # i = 0 # 变量双重作用，1：while循环条件2：字符串下标
238 # while i < len(word)
239 # print(word[i]) # 使用下标访问字符串
240 # i += 1
241 # print("程序结束运行")
242 # # for循环遍历
243 # for i in word: # i取值范围就是字符串中的每一个字符
244 # print(i)
245 # 字符串，"word hello"。使用while循环遍历字符串，找到字母e，如果字母为e时就停止遍历，结束循环
246 # string_01 = "word hello"
247 # i = 0
248 # while i < len(string_01):
249 # print(string_01[i])
250 # if string_01[i] == "e":
251 # break # 跳出并结束循环
252 # i += 1
253 # list_01 = [1, 2, 3,"abc", "hello"] # 列表
254 # # for 循环遍历列表
255 # for i in list_01:
256 # print(i)
257 # # while 循环遍历列表
258 # temp = 0
259 # while temp < len(list_01):
260 # print(list_01[temp])
261 # temp += 1
262
263 """
264 字符串的内建方法：
265 1.find() 查找子串，如果找到了就返回第一个匹配的下标值，没有找到返回-1
266 2.rfind() 查找子串，从右边开始查找
267 3.index() 查找子串，如果找到了就返回第一个匹配的下标值，(用法同find)没有找到报错
268 """
269 # my_str = "hello,hello,hello."
270 # print(my_str.index("hello")) # 0
271 # print(my_str.index("hll"))
272 # ValueError: substring not found 抛出异常 值异常，
273 # print(my_st.find("hll"))
274 # NameError: name 'my_st' is not defined 名称错误
275 # for i in range(10)
276 # SyntaxError: invalid syntax 无效的语法 语法错误
277 # print(i)
278 # print(my_str[30])
279 # IndexError: string index out of range 索引异常，字符串索引超出了范围
280
281 """
282 ValueError: substring not found 抛出异常 值异常，字符串没有找到
283 NameError: name 'my_st' is not defined 名称错误 名称为my_st的变量没有被定义
284 SyntaxError: invalid syntax 无效的语法 语法错误
285 IndexError: string index out of rang 索引异常：字符串索引超出了范围
286 """
287 """
288 1.字符串可以存那些数据？数字，字母，下划线"abc123%^*"
289 2.字符串创建的形式，三种，分别是：'',"",'''''',""""""
290 3.转义字符，\,\b,\t,\n
291 4.特殊字符，r/R
292 5.字符串的输入输出：input(),print()
293 6.格式化字符串的两种方法:%(%s,%d5,%f),{0/1}.format(a,b)
294 """
295 # 复习
296 # 有一个字符串"today is sunny"索引下标（从左往右0-10，从右往左-1--10）
297 # string_1 = "today is sunny"
298 # print(string_1[2]) # d
299 # print(string_1[0:6]) # today
300 # print(string_1[0:6:2]) # tdy
301 # # 遍历字符串 for，while
302 # for i in string_1:
303 # print(i)
304 # print("while循环")
305 # temp = 0
306 # while temp < len(string_1):
307 # print(string_1[temp])
308 # temp += 1
309 # # 输出字符串的下标和值得对应序列
310 # for i, j in enumerate(string_1):
311 # print(i,j)
312 # 使用格式化输出的两种方式，实现"我叫小明，今年18岁”输出
313 # name = "小明"
314 # age = 18
315 # print("我叫%s,今年%d岁" % (name, age))
316 # print("我叫{0:&<6}，今年{1:&<3}岁".format(name, age))
317
318 """
319 字符串内建方法，str.count(subs, start=0, end=len(str)
320 参数说明: subs代表查找的字母
321 star开始查找位置，默认为0
322 end查找结束的位置，默认为len(str)
323 """
324 # my_str = "hello,hello,hello,how are you?"
325 # temp = my_str.count("hello", 0, len(my_str))
326 # print(temp) # 3
327 # temp = my_str.count("hello", 6, len(my_str))
328 # print(temp) # 2
329 # temp = my_str.count("hhh")
330 # print(temp) # 0
331 # # 问my_str 字符串中字母o出现的次数
332 # temp = my_str.count("o") # 5
333 # print(temp)
334
335 """
336 字符串的内建方法，str.replace(old,new,[max])
337 将原字符串中的旧字符替换为新的字符
338 max为可选项，当指明max的值时，最多可替换max次
339 """
340 # my_str = "ha ha ha , happy"
341 # my_str1 = my_str.replace("ha", "hi") # hi hi hi,hippy
342 # print(my_str1)
343 # my_str1 = my_str.replace("ha", "haa") # haa haa haa,haappy
344 # print(my_str1)
345 # temp = my_str[3:11] # ha ha ,
346 # print(temp)
347 # temp = temp.replace("ha", "hi") # hi hi ,
348 # print(temp)
349 # temp_01 = my_str[0:3] + temp + my_str[11:] # ha hi hi,happy
350 # print(temp_01)
351
352 """
353 字符串内建方法，str.split([str = ""],[count])
354 以指定的字符对原字符串进行分隔，切片，生成一个新的列表包含，
355 切完后的每一个子字符串就是列表的一个元素
356 两个参数，分别为:指定分割的字符，默认为空格，换行\n,制表符\t
357 指定的分割个数
358 """
359 # word = "1 2 3 4 5"
360 # word_1 = word.split() # 默认以空格来分割，全部分开 ['1', '2', '3', '4', '5']
361 # print(word_1)
362 # word = "a,b,c,d,e"
363 # word_2 = word.split(",", 3) # 指定以，来分割，分三次 ['a', 'b', 'c', 'd,e']
364 # print(word_2)
365
366 # 5.编程实现，字符串“abc123ABC”,求字符串的长度，ASCII码最大值、最小值，并写出结果。（15分）
367 # word_01 = "abc123ABC"
368 # print(len(word_01)) # 9
369 # print(max(word_01)) # 16
370 # print(min(word_01)) # 1
371 # # 6.编程实现，字符串“hi,what’s your name”,查找字符”a”的索引下标位置（任一方法即可），字符”A”的索引下标位置（find,index都要用），并写出结果，（index报错的信息可以写中文）（20分）
372 # word_02 = "hi,what’s your name"
373 # print(word_02.find("a")) # 5
374 # print(word_02.rfind("a")) # 16
375 # print(word_02.index("a")) # 5
376 # print(word_02.find("A")) # -1
377 # print(word_02.index("A")) # ValueError: substring not found
378 # # 7.编程实现，统计”abcabcaabbcc“字符串中字符”a”出现的次数，并对其进行全部替换，替换为”A”.（20分）
379 # word_03 = "abcabcaabbcc"
380 # print(word_03.count("a")) # 4
381 # word_04 = word_03.replace("a", "A")
382 # print(word_04) # AbcAbcAAbbcc
383 # # 8.编程实现，字符串”a b c d e f g“，对其使用空格进行切片，生成新的列表。（15分）
384 # word_05 = "a b c d e f g"
385 # list_01 = word_05.split()
386 # print(list_01) # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
387
388 """
389 ctrl+x 删除整行
390 1.capitalize 将字符串的首字母大写，其余小写
391 2.title 将字符串中的所有单词首字母大写，其余小写
392 3.upper 将字符串中的所有单词大写
393 4.lower 将字符串中的所有单词小写
394 """
395 # word = "goodbye, see you tomorrow"
396 # print(word.capitalize())
397 # print(word.title())
398 # print(word.upper())
399 # print(word.lower())
400 # 运行结果
401 # Goodbye, see you tomorrow
402 # Goodbye, See You Tomorrow
403 # GOODBYE, SEE YOU TOMORROW
404 # goodbye, see you tomorrow
405
406 """
407 字符串的内建方法，检查字符是否以指定的子串开头或结尾
408 1.startswith 开头
409 2.endswith 结尾
410 """
411 # word = "abcdefghigklmn"
412 # print(word.startswith("a"))
413 # print(word.startswith("a", 5, 10))
414 # print(word.startswith("f", 5, 10))
415 # print(word.endswith("n"))
416 # print(word.endswith("n", 5, 10))
417 # print(word.endswith("g", 5, 10)) # 左闭右开，包含起始字符不包含结尾字符
418 # print(word[5:10]) # 切片
419 # # 运行结果：
420 # TTrue
421 # False
422 # True
423 # True
424 # False
425 # True
426 # fghig
427
428 """
429 字符串的内建方法，调整字符串至指定的长度，指明对齐方式以及填充的字符(默认空格)
430 1.ljust 调整至指定宽度，原字符靠左
431 2.rjust 调整至指定宽度，原字符靠右
432 3.center 调整至指定宽度，原字符居中
433 """
434 # word = "1907c"
435 # print(word.ljust(20))
436 # print(word.rjust(20))
437 # print(word.center(20))
438 # print(word.ljust(20, "*"))
439 # print(word.rjust(20, "$"))
440 # print(word.center(20, "@"))
441 # 运行结果:
442 # 1907c
443 # 1907c
444 # 1907c
445 # 1907c***************
446 # $$$$$$$$$$$$$$$1907c
447 # @@@@@@@1907c@@@@@@@@
448
449 """
450 字符串的内建方法，截掉字符串左边或者右边或者左右两边的空格或指定字符
451 1.lstrip 截掉字符串左边的空格或指定字符
452 2.rstrip 截掉字符串右边的空格或指定字符
453 3.strip 截掉字符串左右两边的空格或指定字符
454 """
455 # word = " python "
456 # print(word.lstrip())
457 # print(word.rstrip())
458 # print(word.strip())
459 # word_01 = "**python*******"
460 # print(word_01.lstrip("*"))
461 # print(word_01.rstrip("*"))
462 # print(word_01.strip("*"))
463 # 运行结果:
464 # python
465 # python
466 # python
467 # python*******
468 # **python
469 # python
470
471 # # 去掉字符串左右的空格
472 # word = " abc "
473 # print(word.strip())
474 # # 拆分开并且保存
475 # word_1 = "a,b,c,d"
476 # print(word_1.split())
477 # list_01 = list(word) # 将一个字符串转为列表
478 # # 把左右两边空格去掉
479 # word_2 = "hello "
480 # word_3 = " python"
481 # word_2 = word_2.rstrip()
482 # word_3 = word_3.lstrip()
483 # print(word_2.rstrip(",").center(10, "#"))
484 # print(word_3.lstrip(",").center(10, "#"))
485 # print(word_2.rstrip(",").ljust(10, "#"))
486 # print(word_3.lstrip(",").ljust(10, "#"))
487 # print(word_2.rstrip(",").ljust(10, "#"))
488 # print(word_3.lstrip(",").ljust(10, "#"))
489
490 # word_4 = "my name is xiaoming, my age is 18."
491 # # 整个字符串首字母大写,其余小写
492 # print(word_4.capitalize())
493 # # 字符串中的每个单词首字母改为大写，其余大写
494 # print(word_4.title())
495 # # 字符串中所有单词改为大写
496 # print(word_4.upper())
497 # # 字符串中所有单词改为小写
498 # print(word_4.lower())
499 """
500 2.假设，以下内容是从网络上抓取的:
501 word = “\t\n登鹳雀楼\t王之涣\n白日依山尽\t\n黄河入海流\t\t更上一层楼”
502 要求：
503 将字符串中的空白字符全部去除，再使用空格作为分隔符，拼接成一个整齐的字符串。
504 以诗词原有的方式，居中显示
505 在使用空格作为分隔符，拼接成一个整齐的字符串
506 """
507 # word = "\t\nThe stork towers\tWang Zhihuan\nThe Sun along the mountain bows\t\n" \
508 # "The Yellow River seawards flows\t\tscale new heights"
509 # word_01 = word.split() # 先拆分
510 # print(word_01)
511 # for temp in word_01: # 遍历列表
512 # print("｜", temp.center(11, " "), "｜")
513 # word_02 = " ".join(word_01) # 使用join方法
514 # print(word_02)
515
516 """
517 假设，以下内容是从网络上抓取的:
518 word = "\t\nHigh\txiaoming\nlovepython\t\n" \
519 "aaaaaaa\t\tbbccccdddd"
520 要求：
521 将字符串中的空白字符全部去除，
522 以诗词原有的方式，居中显示，
523 再使用空格作为分隔符，拼接成一个整齐的字符串。
524 """
525 # word = "\t\nHigh\txiaoming\nlovepython\t\n" \
526 # "aaaaaaa\t\tbbccccdddd"
527 # word_01 = word.split() # 先拆分
528 # print(word_01)
529 # for temp in word_01: # 遍历列表
530 # print("|", temp.center(11, " "), "|")
531 # word_02 = " ".join(word_01) # 使用join方法
532 # print(word_02)
533
534 # 编写一个程序，用于统计字符串“ab2b3n5n2n67mm4n2”中字符n出现的次数。
535
536 # my_str = "ab2b3n5n2n67mm4n2"
537 # temp = my_str.count("n")
538 # print(temp) # 4
539 # count_1 = 0
540 # for i in my_str:
541 # if i == "n":
542 # count_1 += 1
543 # print(count_1)
544
545 # 为什么i可以直接用，而count_1要先定义再使用
546 # Python中的变量是不可提前定义，什么时候用就能直接拿来用
547 # 但是如果这个变量要跟其他的数据进行运算，首先这个变量要有值，就要先定义
548
549 # 输出0-10之间的整数，用while
550 # i = 0
551 # while i < 11:
552 # print(i)
553 # i += 1
554 # for i in range(11):
555 # print(i)
