1 >>> strs = "abcdefg"
2 >>> strs[0]
3 'a'
4 >>> strs[1]
5 'b'
6 >>> strs[-1]
7 'g'

1 >>> a = "12345678"
2 >>> a[0:3]
3 '123'
4 >>> a[:3]
5 '123'
6 >>> a[6:]
7 '78'
8 >>> a[6:-1]
9 '7'

1 >>> a[0::1]
2 '1'
3 >>> a[0::2]
4 '1357'
5 >>> a[::-1]
6 '87654321'
7 >>> a[::-2]
8 '8642'

1 >>> a = "abcd"
2 >>> list(a)
3 ['a', 'b', 'c', 'd']

 1 >>> a = ["a","b","c","d"]
 2 >>> a[1]
 3 'b'
 4 >>> for i in a:
 5 ...     print(i)
 6 ...
 7 a
 8 b
 9 c
10 d

 1 lists = ["a","b","c","d","e",]
 2
 3 #添加
 4 lists.append("f")
 5 print(lists)
 6
 7 #删除列表中的元素
 8 del(lists[0])#等于lists.__delitem__(1)
 9 del(lists[2:4])#删除序列片段
10 lists.remove("b")
11 print(lists)
12
13 #更改列表中的元素
14 lists = ["a","b","c","d","e",]
15 lists[2] = "C"
16 print(lists)
17
18 #判断序列的长度
19 print(len(lists))
20
21 #获取元素大小，单位字节
22 print(lists.__sizeof__())
23
24 #搜索列表中某个元素出现的次数
25 lists = ["a","b","c","d","c",]
26 print(lists.count("c"))
27
28 #查找某个元素第一次出现的下标
29 print(lists.index("c"))
30
31 #把元素插入到指定下标位置
32 print(lists[2])
33 lists[2] = "C"
34 print(lists[2])
35
36 #删除指定下标位的元素，并返回元素，如果不指定下标默认删除最后一个，并返回元素
37 print(lists)
38 c = lists.pop()
39 print(c)
40 c = lists.pop(1)
41 print(c)
42 print(lists)
43
44 #列表倒叙
45 lists = ["a","b","c","d"]
46 lists.reverse()
47 print(lists)
48
49 #按照大小排序，字符串比较unicode值
50 lists = ["c","b","a","d","2","1"]
51 lists.sort()
52 print(lists)
53
54 #__add__加
55 lists = ["a","b","c"]
56 test = ["d"]
57 lists = lists+test#其中的+号就是调用的__add__所以这样写也是可以的lists = lists.__add__(test)
58 print(lists)
59
60 #包含，查看列表是否包含某个元素,返回布尔值
61 print(lists.__contains__("a"))#同等于lists in "a"
62
63 #合并列表
64 lists = ["a","b"]
65 test = ["c","d"]
66 lists.extend(test)
67 print(lists)
68
69 #将列表中的元素以指定分隔符拼接成字符串
70 print("_".join(lists))

 1 >>> list1 = ["1","2",["a","b","c"],"3"]
 2 >>> list2 = list1
 3 >>> print("list1:",list1)
 4 list1: ['1', '2', ['a', 'b', 'c'], '3']
 5 >>> print("list2:",list2)
 6 list2: ['1', '2', ['a', 'b', 'c'], '3']
 7 >>> list1[0] = "11"
 8 >>> print("list1:",list1)
 9 list1: ['11', '2', ['a', 'b', 'c'], '3']
10 >>> print("list2:",list2)
11 list2: ['11', '2', ['a', 'b', 'c'], '3']
12 >>> list1[2][0] = "A"
13 >>> print("list1:",list1)
14 list1: ['11', '2', ['A', 'b', 'c'], '3']
15 >>> print("list2:",list2)
16 list2: ['11', '2', ['A', 'b', 'c'], '3']

 1 >>> import copy
 2 >>>
 3 >>> list1 = ["1","2",["a","b","c"],"3"]
 4 >>> list2 = copy.copy(list1)
 5 >>> print(id(list1),id(list2))
 6 8996584 7019896
 7 >>> print(id(list1[2]),id(list2[2]))
 8 8997184 8997184
 9 >>> list1[2][0] = "A"
10 >>> print(list1)
11 ['1', '2', ['A', 'b', 'c'], '3']
12 >>> print(list2)
13 ['1', '2', ['A', 'b', 'c'], '3']
14 >>> list1[1] = "5"
15 >>> print(list1)
16 ['1', '5', ['A', 'b', 'c'], '3']
17 >>> print(list2)
18 ['1', '2', ['A', 'b', 'c'], '3']

 1 >>> import copy
 2 >>>
 3 >>> list1 = ["1","2",["a","b","c"],"3"]
 4 >>> list2 = copy.deepcopy(list1)
 5 >>> print(id(list1),id(list2))
 6 6414784 8996584
 7 >>> print(id(list1[2]),id(list2[2]))
 8 7019256 8997224
 9 >>> list1[2][0] = "A"
10 >>> print(list1)
11 ['1', '2', ['A', 'b', 'c'], '3']
12 >>> print(list2)
13 ['1', '2', ['a', 'b', 'c'], '3']
14 >>> list1[1] = "5"
15 >>> print(list1)
16 ['1', '5', ['A', 'b', 'c'], '3']
17 >>> print(list2)
18 ['1', '2', ['a', 'b', 'c'], '3']

 1 tuples = ("a","b","c","d","e")
 2 print(tuples[0])
 3 print(tuples[2:])
 4 #某个元素出现的次数
 5 tuples.count("a")
 6 #找到指定元素的下标
 7 tuples.index("d")
 8 #转换成列表
 9 list(tuples)
10 #字典中的系列不继承元祖不可修改的特点
11 tuples = ("a",[1,2,3])
12 tuples[1][1] = "a"
13 print(tuples)

1 dicts = {
2     "1":"a",
3     "2":"b",
4     "3":"c",
5     "4":"d",
6 }

1 >>> dicts = {"aa":"a","11":"1","bb":"b","22":"2",}
2 >>> print(dicts)
3 {'22': '2', '11': '1', 'aa': 'a', 'bb': 'b'}

 1 #字典的无序
 2 dicts = {"a":"1","b":"2","c":"3","d":"4","e":"5",}
 3 print(dicts)
 4
 5 #取出key对应的值(value)
 6 print(dicts["a"])
 7
 8 #返回key的值，如果存在则返回值，否则返回None
 9 print(dicts.get("s"))
10
11 #setdefault具有与get方法类似的行为,如果传入的key存在则返回对应的value，如果不存在则会在字典中，将会添加键并将值设为默认值（None）
12 print(dicts.setdefault("2"))
13 print(dicts)
14
15 #取出字典中所有的key
16 print(dicts.keys())
17
18 #取出字典中所有的值(value)
19 print(dicts.values())
20
21 #向字典添加键值对
22 dicts["f"] = "6"
23 print(dicts)
24
25 #更改对应key的value值
26 dicts["f"] = "f"
27 print(dicts)
28
29 #更新，将传入的字典添加到原字典中，如果有重名将会被覆盖
30 b = {"1":1}
31 dicts.update(b)
32 print(dicts)
33
34 #删除键值对
35 del dicts["f"]
36 print(dicts)
37
38 #删除键值对
39 dicts.pop("d")
40 print(dicts)
41
42 #任意删除一个键值对，并把删除的键值对返回一个元祖如字典为空，则返回KeyError异常
43 rm_data = dicts.popitem()
44 print(dicts)
45 print(rm_data)
46
47 #返回一个由元组构成的列表，每个元组包含一对键-值对
48 print(dicts.items())
49
50 #创建并返回字典的浅拷贝
51 new_dict = dicts.copy()
52 print(new_dict)
53
54 #从字典删除所有项
55 new_dict.clear()
56 print(new_dict)
57
58 #通过一个列表生成默认dict
59 test = {}
60 print(test.fromkeys([1,2,3],'test'))

1 #方法1
2 dicts = {"a":"1","b":"2","c":"3","d":"4","e":"5",}
3 for key in dicts:
4     print(key,dicts[key])
5
6 #方法2
7 for k,v in dicts.items(): #会先把dict转成list,数据里大时莫用
8     print(k,v)

 1 #创建一个数值集合
 2 s = set([3,5,9,10])
 3 #创建一个唯一字符的集合
 4 t = set("Hello")
 5 # t 和 s的并集
 6 a = t | s
 7 # t 和 s的交集
 8 b = t & s
 9 # 求差集（项在t中，但不在s中）
10 c = t – s
11 # 对称差集（项在t或s中，但不会同时出现在二者中）
12 d = t ^ s
13
14 基本操作：
15
16 # 添加一项
17 t.add('x')
18 # 在s中添加多项
19 s.update([10,37,42])
20
21 #使用remove()可以删除一项：
22 t.remove('H')
23
24 #set 的长度
25 len(s)
26
27 #测试 x 是否是 s 的成员
28 x in s
29
30 #测试 x 是否不是 s 的成员
31 x not in s
32
33 #测试是否 s 中的每一个元素都在 t 中
34 s.issubset(t)
35 s <= t
36
37 #测试是否 t 中的每一个元素都在 s 中
38 s.issuperset(t)
39 s >= t
40
41 #返回一个新的 set 包含 s 和 t 中的每一个元素
42 s.union(t)
43 s | t
44
45 #返回一个新的 set 包含 s 和 t 中的公共元素
46 s.intersection(t)
47 s & t
48
49 #返回一个新的 set 包含 s 中有但是 t 中没有的元素
50 s.difference(t)
51 s - t
52
53 #返回一个新的 set 包含 s 和 t 中不重复的元素
54 s.symmetric_difference(t)
55 s ^ t
56
57 #返回 set “s”的一个浅复制
58 s.copy()

1 #foo是创建的对象，userdata.txt是要打开的文件名，"r"是打开文件的方法，打开文件有多种方法，详见下面表格
2
3 >>> foo = open(r”data\userdata.txt','r')
4 >>> print(foo)
5 <_io.TextIOWrapper name='data\\userdata.txt' mode='r' encoding='cp936'>

 1 foo = open('userdata.txt','r',encoding="utf-8")
 2 #读取一行，每次只读取一行
 3 print(foo.readline())
 4
 5 使用readline()对文件操作
 6 # while True:
 7 #     line = foo.readline()
 8 #     if not line: break
 9 #     if 条件 in line:
10 #         xxx操作
11 # foo.close()
12
13 #自动将文件内容分析成一个行的列表
14 print(foo.readlines())
15 #将指针重新定位到文件开头
16 foo.seek(0, 0)
17 #读取剩下的所有内容,文件大时不要用
18 print(foo.read())
19 #关闭文件
20 foo.close()

files: #文件的路径列表，默认是stdin方式，多文件['1.txt','2.txt',...]
inplace: #是否将标准输出的结果写回文件，默认不取代
backup: #备份文件的扩展名，只指定扩展名，如.bak。如果该文件的备份文件已存在，则会自动覆盖。
bufsize: #缓冲区大小，默认为0，如果文件很大，可以修改此参数，一般默认即可
mode: #读写模式，默认为只读
openhook: #该钩子用于控制打开的所有文件，比如说编码方式等;

 1 import fileinput
 2
 3 for line in fileinput.input(r'userdata.txt',openhook=fileinput.hook_encoded("utf-8")):
 4     print(line)
 5
 6
 7 常用方法：
 8 fileinput.input()       #返回能够用于for循环遍历的对象
 9 fileinput.filename()    #返回当前文件的名称
10 fileinput.lineno()      #返回当前已经读取的行的数量（或者序号）
11 fileinput.filelineno()  #返回当前读取的行的行号
12 fileinput.isfirstline() #检查当前行是否是文件的第一行
13 fileinput.isstdin()     #判断最后一行是否从stdin中读取
14 fileinput.close()       #关闭队列

 1 #w,与w+方法会覆盖原文件的内容，他俩的区别是w+可以读
 2 foo = open('userdata.txt','w',encoding="utf-8")
 3 foo.write("Helloworld\n")
 4 foo.close()
 5
 6 #a,与a+都是用于追加的
 7 foo = open('userdata.txt','a+',encoding="utf-8")
 8 foo.write("Helloworld\n")
 9 foo.close()
10
11 #r+默认的指针会放在文件开始位置所有会替换掉第一行
12 foo = open('userdata.txt','r+',encoding="utf-8")
13 foo.write("aaaaaaaa")
14 foo.close()

 1 ########文件内容########
 2 breathe again
 3 Have you wounder how it feels when it's all over.
 4 你是否想过一切结束时会是怎样的感觉?
 5 Wound how it feels when you just have to start?a new.
 6 想过要重新开始又会是怎样的感觉?
 7 Never knowing?where you're going.
 8 从不知道你往哪里去?
 9 ####################
10
11 #其思路是，把原文件加载到内存，然后处理并保存到变量，然后在写入原文件
12 with open("test","r",encoding="utf-8") as file :
13     content = []
14     for lien in file.readlines():
15         if "Wound" in lien:
16             lien = "我是被替换的内容\n"
17         content.append(lien)
18     with open("test","w",encoding="utf-8") as file_w:
19         for i in content:
20             file_w.write(i)

 1 #方法一，将文件按行读取，并进行判断，写入临时文件然后进行替换，文件替换需要借助 os模块 中的功能
 2 import os
 3 file_name = "test"
 4 new_filename = file_name+".bk"
 5 with open(file_name,"r",encoding="utf-8") as file, open(new_filename,"w",encoding="utf-8") as file_w:
 6     while True:
 7         line = file.readline()
 8         if not line: break
 9         if "Wound" in line:
10             line = "我是被替换的内容\n"
11         file_w.write(line)
12 os.remove(file_name)
13 os.rename(new_filename,file_name)
14
15
16 #方法二 借助我们之前学习的 fileinput 模块
17 import fileinput
18 file_name = "test"
19 for line in fileinput.input(file_name,inplace=1):
20     line = line.replace("Wound","我是被替换的内容")
21     print(line.strip("\n"))
22 fileinput.close()

 1 file = open("test","r",encoding="utf-8")
 2
 3 # 1    关闭文件。关闭后文件不能再进行读写操作。
 4 file.close()
 5
 6 # 2    刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
 7 #一般情况下，文件关闭后会自动刷新缓冲区，但有时你需要在关闭前刷新它，这时就可以使用 flush() 方法。
 8 file.flush()
 9
10 # 3    返回一个整型的文件描述符(file descriptor FD 整型), 可用于底层操作系统的 I/O 操作
11 file.fileno()
12
13 # 4    如果文件连接到一个终端设备返回 True，否则返回 False。
14 file.isatty()
15
16 # 5    返回文件下一行。
17 next(file)
18
19 # 6    从文件读取指定的字节数，如果未给定或为负则读取所有。size是字节的意思
20 file.read([size])
21
22 # 7    从文件读取指定的字节数，如果未给定或为负则读取所有。
23 file.readline([size])
24
25 # 8    读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。
26 file.readlines([sizehint])
27
28 # 9    读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。
29 file.seek(offset[, whence])
30
31 # 10 返回文件当前位置。
32 file.tell()
33
34 # 11 截取文件，截取的字节通过size指定，默认为当前文件位置。
35 file.truncate([size])
36
37 # 12 将字符串写入文件，没有返回值。
38 file.write(str)
39
40 # 13 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。
41 file.writelines(sequence)

 1 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
 2 os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd
 3 os.curdir  返回当前目录: ('.')
 4 os.pardir  获取当前目录的父目录字符串名：('..')
 5 os.makedirs('dirname1/dirname2')    可生成多层递归目录
 6 os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
 7 os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
 8 os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
 9 os.unlink(path) 删除文件路径
10 os.utime(path, times)返回指定的path文件的访问和修改的时间。
11 os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
12 os.remove()  删除一个文件
13 os.rename("oldname","newname")  重命名文件/目录
14 os.stat('path/filename')  获取文件/目录信息
15 os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
16 os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
17 os.pathsep    输出用于分割文件路径的字符串
18 os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
19 os.path.abspath(path)  返回path规范化的绝对路径
20 os.path.split(path)  将path分割成目录和文件名二元组返回
21 os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素
22 os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
23 os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
24 os.path.isabs(path)  如果path是绝对路径，返回True
25 os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
26 os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
27 os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
28 os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间
29 os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间