python学习列表字符串字典集合文件操作字符串编码与转换
Posted spring33410
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python学习列表字符串字典集合文件操作字符串编码与转换相关的知识，希望对你有一定的参考价值。
一、列表
1 names = "ZhangYang GuYun XiangPeng XuLiangchen" 2 names = ["ZhangYang", "GuYun", "XiangPeng", "ChengRongHua","XuLiangchen"] 3 names.append("LeiHaiDong") #在列表最后追加一个元素 4 names.insert(1,"ChengRongHua")#在列表中插入一个元素，insert后第一个参数是要插入的下表值，第二个参数是要插入的元素 5 names.insert(3,"XinZhiYu") 6 #names[2] = "XieDi" #替换列表下标为2的元素为XieDi 7 print(names) 8 #print(names[0],names[2]) #取列表值，第一个从0开始 9 #print(names[1:3])#切片 10 #print(names[-1])#切片取最后一个值 11 #print(names[-2:])#切片取最后两个值 12 #print(names[:3])#切片取前三个值 13 # delete 14 #names.remove("ChengRongHua") #按照查找元素删除 15 #del names[1] #删除下标为1的元素 16 #names.pop() #默认删除列表最后一个元素 17 #names.pop(1)#删除下标为1的元素与 del names[1] 效果相等 18 #print(names.index("GuYun")) #查找列表中GuYun所在的位置 19 #print(names[names.index("GuYun")])#查找列表中GuYun所在的位置,并将查找位置当列表值的下标 20 #print(names.count("ChengRongHua"))#统计列表中元素是ChengRongHua的数量 21 #names.clear()# 22 #names.reverse()#列表反转,最后一个元素与第一个元素对调，后续依次类推 23 #names.sort()#列表排序，排序规则按照ASCII排序 24 names2 = ["LiJian","LiLei"] 25 names.extend(names2) #将names2列表合并到names最后面 26 del names2 #删除names2整个列表
#列表copy 浅copy 和深copy 列表外层被完整复制，当原列表发生变化后，新复制的列表不变 import copy names = ["ZhangYang", "GuYun", "XiangPeng", "ChengRongHua","XuLiangchen"] names.insert(3,"XinZhiYu") #print(names) names2 = names.copy() print(names,‘ ‘,names2) names[3] = "向鹏" print("----------------") print(names,‘ ‘,names2) ‘‘‘ 执行结果 E:softwarepystudyvenvScriptspython.exe E:/software/pystudy/day2/names.py [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, ‘XinZhiYu‘, ‘ChengRongHua‘, ‘XuLiangchen‘] [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, ‘XinZhiYu‘, ‘ChengRongHua‘, ‘XuLiangchen‘] ---------------- [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, ‘向鹏‘, ‘ChengRongHua‘, ‘XuLiangchen‘] [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, ‘XinZhiYu‘, ‘ChengRongHua‘, ‘XuLiangchen‘] Process finished with exit code 0 ‘‘‘
#列表copy 浅copy 和深copy 列表外层被完整复制,但被复制的列表中的子列表发生改变时，新列表也会同时发生变化，这是由于子列表在内存中保存机制导致， #子列表打印时调用的是内存地址，并不是子列表本身元素值。
#当执行names.copy时，实际上子列表是copy的内存地址 import copy names = ["ZhangYang", "GuYun", "XiangPeng", ["alex", "Jack"], "ChengRongHua","XuLiangchen"] #print(names) names2 = names.copy() print(names, ‘ ‘, names2) names[2] = "向鹏" names[3][0] = "ALEX" print("----------------") print(names, ‘ ‘, names2) ‘‘‘ E:softwarepystudyvenvScriptspython.exe E:/software/pystudy/day2/names.py [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘] [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘] ---------------- [‘ZhangYang‘, ‘GuYun‘, ‘向鹏‘, [‘ALEX‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘] [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘ALEX‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘] Process finished with exit code 0 ‘‘‘
#列表copy 深copy 是完成创建一个相同的列表，完全独立的两个列表 import copy names = ["ZhangYang", "GuYun", "XiangPeng", ["alex", "Jack"], "ChengRongHua","XuLiangchen"] #print(names) names2 = copy.deepcopy(names) print(names, ‘ ‘, names2) names[2] = "向鹏" names[3][0] = "ALEX" print("----------------") print(names, ‘ ‘, names2) ‘‘‘ E:softwarepystudyvenvScriptspython.exe E:/software/pystudy/day2/names.py [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘] [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘] ---------------- [‘ZhangYang‘, ‘GuYun‘, ‘向鹏‘, [‘ALEX‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘] [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘] Process finished with exit code 0 ‘‘‘
#列表 循环 names = ["ZhangYang", "GuYun", "XiangPeng", ["alex", "Jack"], "ChengRongHua","XuLiangchen"] print(names ) print("------------") for i in names: print(i) print("------------") print(names[0:-1:2] )#切片步长取列表值，列表从第一个元素起，每间隔一个元素，打印一个元素 print(names[0:-1:2] )#与上面结果相同 ‘‘‘ E:softwarepystudyvenvScriptspython.exe E:/software/pystudy/day2/names.py [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘] ------------E:softwarepystudyvenvScriptspython.exe E:/software/pystudy/day2/names.py [‘ZhangYang‘, ‘GuYun‘, ‘XiangPeng‘, [‘alex‘, ‘Jack‘], ‘ChengRongHua‘, ‘XuLiangchen‘] ------------ ZhangYang GuYun XiangPeng [‘alex‘, ‘Jack‘] ChengRongHua XuLiangchen ------------ [‘ZhangYang‘, ‘XiangPeng‘, ‘ChengRongHua‘] [‘ZhangYang‘, ‘XiangPeng‘, ‘ChengRongHua‘] Process finished with exit code 0 ‘‘‘
二、 元组：
元组其实和列表差不多，也是存一组数，只是它一旦创建，便无法修改，所以又叫只读列表。
语法：
names("alex", "jack", "eric")
它只有两个方法，一个count，一个index，完毕
#购物车程序 ‘‘‘ 1、启动程序后，输入用户名密码后，让用户输入工资，然后打印商品列表 2、允许用户根据商品编号购买商品 3、用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒 4、可随时退出，退出时，打印已购买商品和余额 5、在用户使用过程中， 关键输出，如余额，商品已加入购物车等消息，需高亮显示 ‘‘‘ product_list = [ (‘Iphone‘, 5800,), (‘Mac Pro‘, 9800), (‘Bike‘, 800), (‘Watch‘, 10600), (‘Coffee‘, 31), (‘Alex Python‘, 120), ] shoping_list = [] #定义临时列表存放已购买的商品 salary = input("Input your salary:") if salary.isdigit(): #isdigit 判断整数 salary = int(salary) while True: for index, item in enumerate(product_list):#enumerate将列表下标取出来 print(index, item) user_choice = input("选择要购买的商品>>>:") if user_choice.isdigit():#isdigit判断是否是数字 user_choice = int(user_choice) if user_choice < len(product_list) and user_choice >= 0: p_item = product_list[user_choice] if p_item[1] <= salary: #工资够买选择的商品 shoping_list.append(p_item) salary -= p_item[1] print("Added %s into shopping cart, you current balance is 33[31;1m%s 33[0m" %(p_item,salary)) #打印字体为红色，31是红色，32是绿色 33 黄色 else: print(" 33[41;1m你的余额只剩[%s]啦，不够支付本次购买商品! 33[0m" % salary) #打印背景为红色 else: print("product code 33[34;1m[%s] 33[0m is not exists!" % user_choice) #34蓝色 elif user_choice == ‘q‘: print("--------------shopping list ------------") for item_list in shoping_list: print(item_list) print("you current balance is 33[33;1m%s 33[0m" % salary) exit() else: print("invalid option") else: print("invalid salary!") exit()
三、字符串
name = "my name is alex" name2 = "我是人民子弟兵" print(name2.encode("utf-8")) #将字符串转换成二进制 print(name.count("a")) #统计字符串中有多少个a print(name.capitalize())#字符串首字母大写 print(name.center(50, "-")) #字符串打印总长度50，不够用"-"补齐，并将name字符串居中显示 print(name.endswith("ex")) #以什么结尾 返回True or False name = "my name is alex" print(name.expandtabs(tabsize=5))# 将 table键 转换成多少空格 print(name.find(‘name‘)) #查找某个字符/字符串开始位置 字符串第一个字符从0开始， 算一个table键，所以name前面有4个字符 print(name[name.find(‘name‘):]) #字符串切片 name ="my name is {name} and i am {year} old" print(name.format(name=‘alex‘, year=23)) #format 将花括号中的变量赋值， 打印结果：my name is alex and i am 23 old print(name.format_map({‘name‘:‘alex‘,‘year‘:12}))#format_map 是用字典的形式给变量传值。此语法很少用 print(name.index(‘n‘))#字符串索引开始位置， 算一个table键，所以n前面有4个字符 打印结果：4 print(‘aA23‘.isalnum()) #判断是否是安拉博字符(英文字符和数字) 执行结果：True print(‘aA 23‘.isalnum()) #判断是否是安拉博字符(英文字符和数字) 执行结果：False print(‘aAb‘.isalpha()) #判断是否是纯英文字符 执行结果：True print(‘aA2b‘.isalpha()) #判断是否是纯英文字符 执行结果：False print(‘0x1A‘.isdecimal()) #判断是否是十进制 执行结果：False print(‘987‘.isdecimal()) #判断是否是十进制 执行结果：True print(‘1.2‘.isdigit()) #判断是否是一个整数 执行结果：False print(‘133‘.isdigit()) #判断是否是一个整数 执行结果：True print(‘__‘.isidentifier()) #判断是否是一个合法的标识符(变量名) 执行结果：True print(‘1__‘.isidentifier()) #判断是否是一个合法的标识符(变量名) 执行结果：False 变量名只能以_和英文字母开头，不能以数字开头 print(‘aa‘.isnumeric()) #判断是不是一个数字 执行结果：False print(‘33‘.isnumeric()) #判断是不是一个数字 执行结果：True print(" ".isspace()) #判断是否是一个空格 执行结果：True print(‘My Name Is‘.istitle()) #判断是否是一个标题 每个单词首字母要大写 执行结果：True print(‘My Name Is‘.isprintable()) #判断是否能打印，字符串都是可以打印的，只有linux中设备tty开头的文件不能打印的 print(‘My Name Is‘.isupper()) #判断字符串全是大写 print(‘,‘.join([‘1‘,‘2‘,‘3‘,‘4‘])) #把列表变成字符串 执行结果：1,2,3,4 print(‘+‘.join([‘1‘,‘2‘,‘3‘,‘4‘])) #把列表变成字符串 执行结果：1+2+3+4 print(name.ljust(50,‘*‘)) #长度50 不够用*补 补后面 print(name.rjust(50,‘-‘)) #长度50 不够补 补前面 print(‘ALEX‘.lower()) #把大写变成小写 print("alex".upper()) #小写变成大写 print(‘ Alex‘.lstrip()) #从左边去空格和回车 print(‘Alex ‘.rstrip()) #从右边去掉空格和回车 print(‘ Alex ‘.strip()) #去掉空格和回车 p = str.maketrans(‘abcdef‘,‘123456‘) print(‘abcdefalex li‘.translate(p)) #maketrans将字符串abcde替换成123456，a换成1，b换成2 称为加密 print(‘alex li‘.replace(‘l‘,‘L‘,1)) #替换字符串，将小写l替换成大写L，最后一个参数是替换几个， 执行结果：aLex li print(‘alex li‘.replace(‘l‘,‘L‘,2)) #替换字符串，将小写l替换成大写L，最后一个参数是替换几个， 执行结果：aLex Li print(‘alex li‘.rfind(‘ex‘)) #字符/字符串最后出现的位置 执行结果：2 print(‘alex li ex‘.rfind(‘ex‘)) #字符/字符串最后出现的位置 执行结果：8 print("alex".split(‘e‘)) #按照关键字将字符串分成列表 执行结果为：[‘al‘, ‘x‘] print(‘1+2+ 3+4‘.splitlines()) #按换行符分成列表 执行结果为：[‘1+2+‘, ‘3+4‘] print(‘1+2+ 3+4‘.startswith(‘1+‘)) #以关键字开头 执行结果：True print(‘1+2+ 3+4‘.startswith(‘+‘)) #以关键字开头 执行结果：False print(‘Alex Li‘.swapcase()) #大小写颠倒 执行结果：aLEX lI print(‘Alex i‘.title()) #把每个单词首字母变成大写 执行结果：Alex I print(‘lex li‘.zfill(50)) #50字符 不够用0左填充
四、字典
字典一种key-value的数据类型，使用就像我们上学用的字典，通过笔画、字母来查找对应页的详细内容。
语法：
#key - value
info = {
‘stu1101‘: ‘ZhangSan‘,
‘stu1102‘: ‘LiSi‘,
‘stu1103‘: ‘WangWu‘,
}
print(info)
执行结果：
{‘stu1101‘: ‘ZhangSan‘, ‘stu1102‘: ‘LiSi‘, ‘stu1103‘: ‘WangWu‘}
字典的特性：
dict是无序的。
key必须是唯一的，so天生去重
# 字典的增删改查 info = { ‘stu1101‘: ‘ZhangSan‘, ‘stu1102‘: ‘LiSi‘, ‘stu1103‘: ‘WangWu‘, } #print(info["stu1102"]) #根据字典的key值查找后面的value 执行结果：LiSi #print(info["stu1104"]) #根据字典的key值查找后面的value 执行结果：LiSi ,如果字典中没有key值，程序就抛异常 #print(info.get("stu1104"))#安全查找方法，如果有就返回，无就返回none #print("stu1103" in info ) #判断字典中的key值是否存在，存在返回True 不存在返回flase #info["stu1102"] = "李四"#根据字典的key值修改后面的value值 打印执行结果为：{‘stu1101‘: ‘ZhangSan‘, ‘stu1102‘: ‘李四‘, ‘stu1103‘: ‘WangWu‘} #info["stu1106"] = "李四" #如果要修改的字典的key值不存在，就添加到字典中 打印执行结果为：{‘stu1101‘: ‘ZhangSan‘, ‘stu1102‘: ‘LiSi‘, ‘stu1103‘: ‘WangWu‘, ‘stu1106‘: ‘李四‘} b = {‘stu1101‘: ‘ZhangSan‘, "stu1108": "zsy", "stu1109": "ts",} info.update(b) #字典合并，info中有的值保留，b字典中如果有info中的key值的，更新字典中的值。执行结果：{‘stu1101‘: ‘ZhangSan‘, ‘stu1102‘: ‘LiSi‘, ‘stu1103‘: ‘WangWu‘, ‘stu1108‘: ‘zsy‘, ‘stu1109‘: ‘ts‘} print(info.items())#将字典转换成列表：执行结果：dict_items([(‘stu1101‘, ‘ZhangSan‘), (‘stu1102‘, ‘LiSi‘), (‘stu1103‘, ‘WangWu‘), (‘stu1108‘, ‘zsy‘), (‘stu1109‘, ‘ts‘)]) # del #del info #删除整个字典 #del info["stu1102"] #删除字典中key值是stu1102的元素 ：执行结果：{‘stu1101‘: ‘ZhangSan‘, ‘stu1103‘: ‘WangWu‘} #info.pop("stu1102") #删除字典中key值是stu1102的元素 ：执行结果：{‘stu1101‘: ‘ZhangSan‘, ‘stu1103‘: ‘WangWu‘} #info.popitem()#随机删除字典中一个元素 执行结果为：{‘stu1101‘: ‘ZhangSan‘, ‘stu1102‘: ‘LiSi‘} print(info)
#字典的循环
for i in info:
print(i, info[i])
#dict1 = info.fromkeys([‘5‘,‘8‘,‘9‘]) #创建一个字典，每个value值都为空 dict1 = info.fromkeys([5, 8, 9], "ys") #创建一个字典，每个value值都为ys dict1[8] = "ysys" #如果字典value是字符串等简单的数据类型，修改value修改的只是对应的value print(dict1) dict1 = info.fromkeys([‘5‘, ‘8‘, ‘9‘] , ["776", {"name" : "alex"}, "98"]) #创建一个字典，每个value值都为列表 ["776",{"name" : "alex"},"98"] dict1[‘8‘][1] ["name"] = "spring" #如果字典value是列表，修改value值时，对应的每个key值的value都会修改，此时的value实际上对应的是内存地址。 print(dict1)
多级字典：
#字典的多级嵌套---三级菜单（三种方式） #要求： #1.可以进入子菜单 #2.可以返回上一级 #3.可以从任意一级直接退出 data = { ‘山东‘: { ‘青岛‘: [‘四方‘, ‘黄岛‘, ‘崂山‘, ‘李沧‘, ‘城阳‘], ‘济南‘: [‘历城‘, ‘槐荫‘, ‘高新‘, ‘长青‘, ‘章丘‘], ‘烟台‘: [‘龙口‘, ‘莱山‘, ‘牟平‘, ‘蓬莱‘, ‘招远‘] }, ‘江苏‘: { ‘苏州‘: [‘沧浪‘, ‘相城‘, ‘平江‘, ‘吴中‘, ‘昆山‘], ‘南京‘: {‘白下‘:[‘超市‘,‘便利店‘], ‘秦淮‘:[‘超市‘,‘便利店‘], ‘浦口‘:[‘超市‘,‘便利店‘], ‘栖霞‘:[‘超市‘,‘便利店‘], ‘江宁‘:[‘超市‘,‘便利店‘]}, ‘无锡‘: [‘崇安‘, ‘南长‘, ‘北塘‘, ‘锡山‘, ‘江阴‘] }, } # key值尽量不要写中文，可能会存在字符编码导致无法正常操作 #data["江苏"]["无锡"][2] = "北塘" #修改字典key对应的value值，执行结果为：{‘山东‘: {‘青岛‘: [‘四方‘, ‘黄岛‘, ‘崂山‘, ‘李沧‘, ‘城阳‘], ‘济南‘: [‘历城‘, ‘槐荫‘, ‘高新‘, ‘长青‘, ‘章丘‘], ‘烟台‘: [‘龙口‘, ‘莱山‘, ‘牟平‘, ‘蓬莱‘, ‘招远‘]}, ‘江苏‘: {‘苏州‘: [‘沧浪‘, ‘相城‘, ‘平江‘, ‘吴中‘, ‘昆山‘], ‘南京‘: [‘白下‘, ‘秦淮‘, ‘浦口‘, ‘栖霞‘, ‘江宁‘], ‘无锡‘: [‘崇安‘, ‘南长‘, ‘北塘‘, ‘锡山‘, ‘江阴‘]}} #data.setdefault("QH",{"XN" : "huangzhong"}) #字典中创建一个新值，如果要创建的值字典中存在，就保留原值不变，创建无效 #print(data) #城市只能选择南京，其他的数据最下层不对 exit_flag = False while not exit_flag: for i in data: print(i) choice = input("请选择进入省份》》：") if choice in data: while not exit_flag: for j in data[choice]: print(" ", j) choice2 = input("请选择进入城市》》：") if choice2 in data[choice]: while not exit_flag: for k in data[choice][choice2]: print(" ",k) choice3 = input("请选择进入区县》》：") if choice3 in data[choice][choice2]: for l in data[choice][choice2][choice3]: print(" ",l) choice4 = input("进入最后一层了，选择b返回，q退出》》：") if choice4 == "b": pass elif choice4 == "q": exit_flag = True elif choice3 == "b": break elif choice3 == "q": exit_flag = True elif choice2 == "b": break elif choice2 == "q": exit_flag = True elif choice == "q": exit_flag = True
五、集合
集合是一个无序的，不重复的数据组合，它的主要作用如下：
去重，把一个列表变成集合，就自动去重了，
关系测试，测试两组数据之间的交集、差集、并集等关系
list_1=[1, 3, 5, 7, 9] list_1 = set(list_1) #print(list_1, type(list_1)) #打印集合，以及集合类型 list_2 = set([2, 4, 6, 3, 9, 10]) print(list_1, list_2) # 执行结果：{1, 3, 5, 7, 9} {2, 3, 4, 6, 9, 10} #交集 print(list_1.intersection(list_2)) # 交集是将两个集合中共有的元素，执行结果:{9, 3} print(list_1 & list_2) #交集的运算符写法 #并集 print(list_1.union(list_2)) #并集是将两个集合合并，重复的元素只显示一次，执行结果：{1, 2, 3, 4, 5, 6, 7, 9, 10} print(list_1 | list_2) #差集 print(list_1.difference(list_2)) #差集是去掉两个集合中共有的元素，显示list_1剩余的元素，执行结果：{1, 5, 7} print(list_2.difference(list_1)) #差集是去掉两个集合中共有的元素，显示list_2剩余的元素，执行结果：{2, 10, 4, 6} print(list_1 - list_2) print(list_2 - list_1) #子集 list_3 = set([3,5,7]) print(list_3.issubset(list_1)) #子集是判断list_1中是否全部包含list_3的元素，执行结果：True print(list_3.issubset(list_2))# 执行结果：False #父集 print(list_1.issuperset(list_3)) #执行结果：True #对称差集 print(list_1.symmetric_difference(list_2)) #对称差集是将两个集合合并，两个集合中重复的元素全部去除掉，执行结果：{1, 2, 4, 5, 6, 7, 10} print(list_1 ^ list_2) #其他关系测试 list_4 = set([2,4,6]) print(list_1.isdisjoint(list_2)) #如果两个集合中没有交集，返回Ture,执行结果：False print(list_1.isdisjoint(list_4))#执行结果：True #集合添加操作 list_1.add(99) print(list_1) #执行结果：{1, 3, 99, 5, 7, 9} list_1.update([888, 444, 333]) print(list_1)#添加多个元素，执行结果：{1, 3, 99, 5, 7, 9, 333, 888, 444} #集合的删除，集合是去重的，不可能有重复的元素 list_1.remove(99) #删除如果不存在的元素，系统会提示异常 print(list_1)#执行结果：{1, 3, 5, 7, 9, 333, 888, 444} print(list_2.pop())#删除任意一个集合中的元素，并返回删除的元素，执行结果：2 list_2.discard(8)#删除不存在的元素不会提示异常 print(list_2)#执行结果：{3, 4, 6, 9, 10} list_2.discard(10)#删除不存在的元素不会提示异常 print(list_2)#执行结果：{3, 4, 6, 9} #集合的长度 print(len(list_1))#执行结果：8 #检查元素是否在集合中存在 print(9 in list_1)#执行结果：True #检查元素是否不是集合中的成员 print(9 not in list_1) #执行结果：False print(6 not in list_1) #执行结果：True
六、文件操作
#文件操作 #文件读取 r是文件读模式，w是文件的写模式是创建文件，如果原来有文件就会覆盖原来的文件；a=append是文件的追加模式，不能读取文件 f = open("yesterday",‘r‘,encoding="utf-8") #文件的句柄，也就是内存对象 data = f.read() #当文件被读取后，第二次再读取文件已经跳的行尾，所以再次读取文件是就读不到文件 data2 = f.read() f.close() print(data) print("--data2--", data2) #文件写操作，w模式 #读取到yesterday中内容，写入yesterday2中 f = open("yesterday",‘r‘,encoding="utf-8") #文件的句柄，也就是内存对象 data = f.read() #当文件被读取后，第二次再读取文件已经跳的行尾，所以再次读取文件是就读不到文件 f.close() f = open("yesterday2", ‘w‘, encoding="utf-8") #文件的句柄，也就是内存对象 f.write(data) f.close() #文件的追加操作 a=append,不能读取文件. f = open("yesterday2", ‘a‘, encoding="utf-8") #文件的句柄，也就是内存对象 f.write("我爱北京天安门 ") f.write("天安门上太阳升 ") f.close()
#文件的循环读取操作，要求第十行不打印,f.readlines()是默认将文件预先读取到内存中，如果文件太大就无法使用该方法. f = open("yesterday2",‘r‘,encoding="utf-8") #文件的句柄，也就是内存对象 for index, line in enumerate(f.readlines()):#f.readlines()是把文件读取成一个列表，enumerate取列表下标， if index == 9: print("------我是分割线--------") #为了标识清楚，打印成分割线 continue print(index,line.strip())#windows文件存储，默认每行后面有换行符，strip作用是去掉换行和回车 f.close() #文件的高效读取，逐行读取文件，读取完成后释放内存，使用迭代技术，后面会学到 count =0 f = open("yesterday2",‘r‘,encoding="utf-8") #文件的句柄，也就是内存对象 for line in f: if count == 9: print("------我是分割线--------") #为了标识清楚，打印成分割线 count += 1 continue print(count, line) count += 1 f.close()
#进度条 import sys, time for i in range(50): sys.stdout.write("#") #stdout标准输出方法 sys.stdout.flush() time.sleep(0.1)
#文件操作方法 f = open("yesterday2",‘r‘,encoding="utf-8") #文件的句柄，也就是内存对象 print(f.tell()) #查看文件光标，文件开始从0开始， print(f.readline()) #f.readline()读取文件中一行内容 #print(f.read(5)) #读取5个字符 print(f.encoding)#打印文件编码 print(f.fileno())#返回文件句柄在内存中的编号，python打开文件实际上是调用操作系统方法接口实现的，文件系统是给所有程序使用的。 基本上不用它 print(f.name) #打印文件名称 #f.readable() f.writable() #后面自己学习 print(f.flush()) #写文件时，系统不是把每次的操作都写入硬盘，有一个内存缓存，会先写入内存缓存中，在提交到硬盘中，执行f.flush()会立马将文件写入硬盘 print(f.tell()) #查看文件光标，文件开始从0开始，当用f.readlines()方法读取文件后，f.readlines()值变为32，tell的计数是按照字符串个数计数的，并不是读取一行后tell值变为1 f.seek(0)#将光标移到文件开始位置，也可以f.seek(10)的位置 #f.truncate() #清除全部文件，慎用 f.truncate(20)#截断文件，保留前20个字符
#文件的读写模式 r+ ，文件写的内容只能添加的文件最后，不能修改原文件原来的内容 f = open("yesterday2",‘r+‘,encoding="utf-8") #文件的句柄，也就是内存对象 print(f.readline()) print(f.readline()) print(f.readline()) f.write("你好，python")
文件操作还有w+模式 a+模式 基本不用，就不举例了，wb和rb模式是二进制文件，网络传输会用到。
#文件修改，将一个文件逐行读出，并查找到要修改的内容，将原来的内容替换成新的内容，将原文件逐行写入新文件中 f = open("yesterday2", ‘r‘, encoding="utf-8") #文件的句柄，也就是内存对象 f_new = open("yesterday3", ‘w‘, encoding="utf-8") #文件的句柄，也就是内存对象 for line in f: if "有那么多肆意的快乐等我享受" in line: #要查找的内容在这行存在 line = line.replace("有那么多肆意的快乐等我享受", "有那么多肆意的快乐等ALEX享受") f_new.write(line) f.close() f_new.close()
#with 语法 ,好处不用自己关闭文件。 print("------------with------------") with open("yesterday2", ‘r‘, encoding="utf-8") as f: for line in f: print(line) #同时打开多个文件， 新的写法，如果一行过长为了便于查看代码，可以用符号，再第二行再写 with open("yesterday2", ‘r‘, encoding="utf-8") as f, open("yesterday3", ‘r‘, encoding="utf-8") as f2: for line in f: print(line)
七、字符编码与转码
详细文章：https://www.cnblogs.com/luotianshuai/p/5735051.html
课程笔记地址：https://www.cnblogs.com/alex3714/articles/5717620.html
https://www.cnblogs.com/alex3714/articles/5740985.html
先说python2
- py2里默认编码是ascii
- 文件开头那个编码声明是告诉解释这个代码的程序 以什么编码格式 把这段代码读入到内存，因为到了内存里，这段代码其实是以bytes二进制格式存的，不过即使是2进制流，也可以按不同的编码格式转成2进制流，你懂么？
- 如果在文件头声明了#_*_coding:utf-8*_，就可以写中文了， 不声明的话，python在处理这段代码时按ascii，显然会出错， 加了这个声明后，里面的代码就全是utf-8格式了
- 在有#_*_coding:utf-8*_的情况下，你在声明变量如果写成name=u"大保健"，那这个字符就是unicode格式，不加这个u,那你声明的字符串就是utf-8格式
- utf-8 to gbk怎么转，utf8先decode成unicode,再encode成gbk
再说python3
- py3里默认文件编码就是utf-8,所以可以直接写中文，也不需要文件头声明编码了，干的漂亮
- 你声明的变量默认是unicode编码，不是utf-8, 因为默认即是unicode了（不像在py2里，你想直接声明成unicode还得在变量前加个u）, 此时你想转成gbk的话，直接your_str.encode("gbk")即可以
- 但py3里，你在your_str.encode("gbk")时，感觉好像还加了一个动作，就是就是encode的数据变成了bytes里，我擦，这是怎么个情况，因为在py3里，str and bytes做了明确的区分，你可以理解为bytes就是2进制流，你会说，我看到的不是010101这样的2进制呀， 那是因为python为了让你能对数据进行操作而在内存级别又帮你做了一层封装，否则让你直接看到一堆2进制，你能看出哪个字符对应哪段2进制么？什么？自己换算，得了吧，你连超过2位数的数字加减运算都费劲，还还是省省心吧。
- 那你说，在py2里好像也有bytes呀，是的，不过py2里的bytes只是对str做了个别名(python2里的str就是bytes, py3里的str是unicode)，没有像py3一样给你显示的多出来一层封装，但其实其内部还是封装了的。 这么讲吧， 无论是2还是三， 从硬盘到内存，数据格式都是 010101二进制到-->b‘xe4xbdxa0xe5xa5xbd‘ bytes类型－－>按照指定编码转成你能看懂的文字
编码应用比较多的场景应该是爬虫了，互联网上很多网站用的编码格式很杂，虽然整体趋向都变成utf-8，但现在还是很杂，所以爬网页时就需要你进行各种编码的转换，不过生活正在变美好，期待一个不需要转码的世界。
最后，编码is a piece of fucking shit, noboby likes it.
#encode编码 decode 解码 #python3中encode编码后除了将编码集修改，同时将字符串变成byte类型。 import sys print(sys.getdefaultencoding()) s = "你好" print("1-----", type(s)) s_to_gbk = s.encode("gbk") print("2-----", s_to_gbk)#python3中默认是unicode，python2中默认是ascii码， 所以在python3中不需要将中文先解码成utf-8，可以直接编码成gbk。执行结果：b‘xc4xe3xbaxc3‘ print(s_to_gbk.decode("gbk").encode("utf-8").decode()) #针对socket网络传输的bytes是gbk格式的，使用此语句就可以将bytes转码成utf-8正常显示。 gbk_to_unicode = s_to_gbk.decode("gbk") #将gbk解码变成unicode print("3------", gbk_to_unicode) print("4-------", type(gbk_to_unicode)) gbk_to_utf8 = gbk_to_unicode.encode("utf-8")#将unicode编码成utf-8 print(gbk_to_utf8) print(type(gbk_to_utf8)) gbk_to_utf8 = gbk_to_utf8.decode("utf-8") print(type(gbk_to_utf8)) print(gbk_to_utf8) #print(s.encode("gbk").decode("gbk").encode("utf-8").decode("utf-8"))
以上是关于python学习列表字符串字典集合文件操作字符串编码与转换的主要内容，如果未能解决你的问题，请参考以下文章