>>> strs = "abcdefg"

 >>> strs[0]

 'a'

 >>> strs[1]

 'b'

 >>> strs[-1]

 'g'

 >>> a = ""

 >>> a[0:3]

 ''

 >>> a[:3]

 ''

 >>> a[6:]

 ''

 >>> a[6:-1]

 ''

 >>> a[0::1]

 ''

 >>> a[0::2]

 ''

 >>> a[::-1]

 ''

 >>> a[::-2]

 ''

 >>> a = "abcd"

 >>> list(a)

 ['a', 'b', 'c', 'd']

 >>> a = ["a","b","c","d"]

 >>> a[1]

 'b'

 >>> for i in a:

 ...     print(i)

 ...

 a

 b

 c

 d

 lists = ["a","b","c","d","e",]

 #添加

 lists.append("f")

 print(lists)

 #删除列表中的元素

 del(lists[0])#等于lists.__delitem__(1)

 del(lists[2:4])#删除序列片段

 lists.remove("b")

 print(lists)

 #更改列表中的元素

 lists = ["a","b","c","d","e",]

 lists[2] = "C"

 print(lists)

 #判断序列的长度

 print(len(lists))

 #获取元素大小，单位字节

 print(lists.__sizeof__())

 #搜索列表中某个元素出现的次数

 lists = ["a","b","c","d","c",]

 print(lists.count("c"))

 #查找某个元素第一次出现的下标

 print(lists.index("c"))

 #把元素插入到指定下标位置

 print(lists[2])

 lists[2] = "C"

 print(lists[2])

 #删除指定下标位的元素，并返回元素，如果不指定下标默认删除最后一个，并返回元素

 print(lists)

 c = lists.pop()

 print(c)

 c = lists.pop(1)

 print(c)

 print(lists)

 #列表倒叙

 lists = ["a","b","c","d"]

 lists.reverse()

 print(lists)

 #按照大小排序，字符串比较unicode值

 lists = ["c","b","a","d","",""]

 lists.sort()

 print(lists)

 #__add__加

 lists = ["a","b","c"]

 test = ["d"]

 lists = lists+test#其中的+号就是调用的__add__所以这样写也是可以的lists = lists.__add__(test)

 print(lists)

 #包含，查看列表是否包含某个元素,返回布尔值

 print(lists.__contains__("a"))#同等于lists in "a"

 #合并列表

 lists = ["a","b"]

 test = ["c","d"]

 lists.extend(test)

 print(lists)

 #将列表中的元素以指定分隔符拼接成字符串

 print("_".join(lists))

 >>> list1 = ["","",["a","b","c"],""]

 >>> list2 = list1

 >>> print("list1:",list1)

 list1: ['', '', ['a', 'b', 'c'], '']

 >>> print("list2:",list2)

 list2: ['', '', ['a', 'b', 'c'], '']

 >>> list1[0] = ""

 >>> print("list1:",list1)

 list1: ['', '', ['a', 'b', 'c'], '']

 >>> print("list2:",list2)

 list2: ['', '', ['a', 'b', 'c'], '']

 >>> list1[2][0] = "A"

 >>> print("list1:",list1)

 list1: ['', '', ['A', 'b', 'c'], '']

 >>> print("list2:",list2)

 list2: ['', '', ['A', 'b', 'c'], '']

 >>> import copy

 >>>

 >>> list1 = ["","",["a","b","c"],""]

 >>> list2 = copy.copy(list1)

 >>> print(id(list1),id(list2))

 8996584 7019896

 >>> print(id(list1[2]),id(list2[2]))

 8997184 8997184

 >>> list1[2][0] = "A"

 >>> print(list1)

 ['', '', ['A', 'b', 'c'], '']

 >>> print(list2)

 ['', '', ['A', 'b', 'c'], '']

 >>> list1[1] = ""

 >>> print(list1)

 ['', '', ['A', 'b', 'c'], '']

 >>> print(list2)

 ['', '', ['A', 'b', 'c'], '']

 >>> import copy

 >>>

 >>> list1 = ["","",["a","b","c"],""]

 >>> list2 = copy.deepcopy(list1)

 >>> print(id(list1),id(list2))

 6414784 8996584

 >>> print(id(list1[2]),id(list2[2]))

 7019256 8997224

 >>> list1[2][0] = "A"

 >>> print(list1)

 ['', '', ['A', 'b', 'c'], '']

 >>> print(list2)

 ['', '', ['a', 'b', 'c'], '']

 >>> list1[1] = ""

 >>> print(list1)

 ['', '', ['A', 'b', 'c'], '']

 >>> print(list2)

 ['', '', ['a', 'b', 'c'], '']

 tuples = ("a","b","c","d","e")

 print(tuples[0])

 print(tuples[2:])

 #某个元素出现的次数

 tuples.count("a")

 #找到指定元素的下标

 tuples.index("d")

 #转换成列表

 list(tuples)

 #字典中的系列不继承元祖不可修改的特点

 tuples = ("a",[1,2,3])

 tuples[1][1] = "a"

 print(tuples)

 dicts = {

     "":"a",

     "":"b",

     "":"c",

     "":"d",

 }

 >>> dicts = {"aa":"a","":"","bb":"b","":"",}

 >>> print(dicts)

 {'': '', '': '', 'aa': 'a', 'bb': 'b'}

 #字典的无序

 dicts = {"a":"","b":"","c":"","d":"","e":"",}

 print(dicts)

 #取出key对应的值(value)

 print(dicts["a"])

 #返回key的值，如果存在则返回值，否则返回None

 print(dicts.get("s"))

 #setdefault具有与get方法类似的行为,如果传入的key存在则返回对应的value，如果不存在则会在字典中，将会添加键并将值设为默认值（None）

 print(dicts.setdefault(""))

 print(dicts)

 #取出字典中所有的key

 print(dicts.keys())

 #取出字典中所有的值(value)

 print(dicts.values())

 #向字典添加键值对

 dicts["f"] = ""

 print(dicts)

 #更改对应key的value值

 dicts["f"] = "f"

 print(dicts)

 #更新，将传入的字典添加到原字典中，如果有重名将会被覆盖

 b = {"":1}

 dicts.update(b)

 print(dicts)

 #删除键值对

 del dicts["f"]

 print(dicts)

 #删除键值对

 dicts.pop("d")

 print(dicts)

 #任意删除一个键值对，并把删除的键值对返回一个元祖如字典为空，则返回KeyError异常

 rm_data = dicts.popitem()

 print(dicts)

 print(rm_data)

 #返回一个由元组构成的列表，每个元组包含一对键-值对

 print(dicts.items())

 #创建并返回字典的浅拷贝

 new_dict = dicts.copy()

 print(new_dict)

 #从字典删除所有项

 new_dict.clear()

 print(new_dict)

 #通过一个列表生成默认dict

 test = {}

 print(test.fromkeys([1,2,3],'test'))

 #方法1

 dicts = {"a":"","b":"","c":"","d":"","e":"",}

 for key in dicts:

     print(key,dicts[key])

 #方法2

 for k,v in dicts.items(): #会先把dict转成list,数据里大时莫用

     print(k,v)

 #创建一个数值集合

 s = set([3,5,9,10])

 #创建一个唯一字符的集合

 t = set("Hello")

 # t 和 s的并集

 a = t | s

 # t 和 s的交集

 b = t & s

 # 求差集（项在t中，但不在s中）

 c = t – s

 # 对称差集（项在t或s中，但不会同时出现在二者中）

 d = t ^ s          

 基本操作：

 # 添加一项

 t.add('x')

 # 在s中添加多项

 s.update([10,37,42]) 

 #使用remove()可以删除一项：

 t.remove('H')

 #set 的长度

 len(s)

 #测试 x 是否是 s 的成员

 x in s

 #测试 x 是否不是 s 的成员

 x not in s

 #测试是否 s 中的每一个元素都在 t 中

 s.issubset(t)

 s <= t

 #测试是否 t 中的每一个元素都在 s 中

 s.issuperset(t)

 s >= t

 #返回一个新的 set 包含 s 和 t 中的每一个元素

 s.union(t)

 s | t

 #返回一个新的 set 包含 s 和 t 中的公共元素

 s.intersection(t)

 s & t

 #返回一个新的 set 包含 s 中有但是 t 中没有的元素

 s.difference(t)

 s - t

 #返回一个新的 set 包含 s 和 t 中不重复的元素

 s.symmetric_difference(t)

 s ^ t

 #返回 set “s”的一个浅复制

 s.copy()

 #foo是创建的对象，userdata.txt是要打开的文件名，"r"是打开文件的方法，打开文件有多种方法，详见下面表格

 >>> foo = open(r”data\userdata.txt','r')

 >>> print(foo)

 <_io.TextIOWrapper name='data\\userdata.txt' mode='r' encoding='cp936'>

 foo = open('userdata.txt','r',encoding="utf-8")

 #读取一行，每次只读取一行

 print(foo.readline())

 使用readline()对文件操作

 # while True:

 #     line = foo.readline()

 #     if not line: break

 #     if 条件 in line:

 #         xxx操作

 # foo.close()

 #自动将文件内容分析成一个行的列表

 print(foo.readlines())

 #将指针重新定位到文件开头

 foo.seek(0, 0)

 #读取剩下的所有内容,文件大时不要用

 print(foo.read())

 #关闭文件

 foo.close()

files: #文件的路径列表，默认是stdin方式，多文件['1.txt','2.txt',...]

inplace: #是否将标准输出的结果写回文件，默认不取代

backup: #备份文件的扩展名，只指定扩展名，如.bak。如果该文件的备份文件已存在，则会自动覆盖。

bufsize: #缓冲区大小，默认为0，如果文件很大，可以修改此参数，一般默认即可

mode: #读写模式，默认为只读

openhook: #该钩子用于控制打开的所有文件，比如说编码方式等;

 import fileinput

 for line in fileinput.input(r'userdata.txt',openhook=fileinput.hook_encoded("utf-8")):

     print(line)

 常用方法：

 fileinput.input()       #返回能够用于for循环遍历的对象

 fileinput.filename()    #返回当前文件的名称

 fileinput.lineno()      #返回当前已经读取的行的数量（或者序号）

 fileinput.filelineno()  #返回当前读取的行的行号

 fileinput.isfirstline() #检查当前行是否是文件的第一行

 fileinput.isstdin()     #判断最后一行是否从stdin中读取

 fileinput.close()       #关闭队列

 #w,与w+方法会覆盖原文件的内容，他俩的区别是w+可以读

 foo = open('userdata.txt','w',encoding="utf-8")

 foo.write("Helloworld\n")

 foo.close()

 #a,与a+都是用于追加的

 foo = open('userdata.txt','a+',encoding="utf-8")

 foo.write("Helloworld\n")

 foo.close()

 #r+默认的指针会放在文件开始位置所有会替换掉第一行

 foo = open('userdata.txt','r+',encoding="utf-8")

 foo.write("aaaaaaaa")

 foo.close()

 ########文件内容########

 breathe again

 Have you wounder how it feels when it's all over.

 你是否想过一切结束时会是怎样的感觉?

 Wound how it feels when you just have to start?a new.

 想过要重新开始又会是怎样的感觉?

 Never knowing?where you're going.

 从不知道你往哪里去?

 ####################

 #其思路是，把原文件加载到内存，然后处理并保存到变量，然后在写入原文件

 with open("test","r",encoding="utf-8") as file :

     content = []

     for lien in file.readlines():

         if "Wound" in lien:

             lien = "我是被替换的内容\n"

         content.append(lien)

     with open("test","w",encoding="utf-8") as file_w:

         for i in content:

             file_w.write(i)

 #方法一，将文件按行读取，并进行判断，写入临时文件然后进行替换，文件替换需要借助 os模块 中的功能

 import os

 file_name = "test"

 new_filename = file_name+".bk"

 with open(file_name,"r",encoding="utf-8") as file, open(new_filename,"w",encoding="utf-8") as file_w:

     while True:

         line = file.readline()

         if not line: break

         if "Wound" in line:

             line = "我是被替换的内容\n"

         file_w.write(line)

 os.remove(file_name)

 os.rename(new_filename,file_name)

 #方法二 借助我们之前学习的 fileinput 模块

 import fileinput

 file_name = "test"

 for line in fileinput.input(file_name,inplace=1):

     line = line.replace("Wound","我是被替换的内容")

     print(line.strip("\n"))

 fileinput.close()

 file = open("test","r",encoding="utf-8")

 # 1    关闭文件。关闭后文件不能再进行读写操作。

 file.close()

 # 2    刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。

 #一般情况下，文件关闭后会自动刷新缓冲区，但有时你需要在关闭前刷新它，这时就可以使用 flush() 方法。

 file.flush()

 # 3    返回一个整型的文件描述符(file descriptor FD 整型), 可用于底层操作系统的 I/O 操作

 file.fileno()

 # 4    如果文件连接到一个终端设备返回 True，否则返回 False。

 file.isatty()

 # 5    返回文件下一行。

 next(file)

 # 6    从文件读取指定的字节数，如果未给定或为负则读取所有。size是字节的意思

 file.read([size])

 # 7    从文件读取指定的字节数，如果未给定或为负则读取所有。

 file.readline([size])

 # 8    读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。

 file.readlines([sizehint])

 # 9    读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。

 file.seek(offset[, whence])

 # 10 返回文件当前位置。

 file.tell()

 # 11 截取文件，截取的字节通过size指定，默认为当前文件位置。

 file.truncate([size])

 # 12 将字符串写入文件，没有返回值。

 file.write(str)

 # 13 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

 file.writelines(sequence)

 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径

 os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd

 os.curdir  返回当前目录: ('.')

 os.pardir  获取当前目录的父目录字符串名：('..')

 os.makedirs('dirname1/dirname2')    可生成多层递归目录

 os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

 os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname

 os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

 os.unlink(path) 删除文件路径

 os.utime(path, times)返回指定的path文件的访问和修改的时间。

 os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

 os.remove()  删除一个文件

 os.rename("oldname","newname")  重命名文件/目录

 os.stat('path/filename')  获取文件/目录信息

 os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

 os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"

 os.pathsep    输出用于分割文件路径的字符串

 os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

 os.path.abspath(path)  返回path规范化的绝对路径

 os.path.split(path)  将path分割成目录和文件名二元组返回

 os.path.dirname(path)  返回path的目录。其实就是os.path.split(path)的第一个元素

 os.path.basename(path)  返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

 os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False

 os.path.isabs(path)  如果path是绝对路径，返回True

 os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False

 os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False

 os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

 os.path.getatime(path)  返回path所指向的文件或者目录的最后存取时间

 os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间