您好!此笔记的文本和代码以网盘形式分享于文末!
因个人能力有限,错误处欢迎大家交流和指正!基础部分内容简单,但多且零散!
Python数据类型二 | ||
1、数字(int、float、complex)数字数据类型用于存储数值,数字类型是不允许改变的, 改变数值需重新分配内存空间 | ||
int:整型,正或负整数 | ||
float:浮点型,由整数部分与小数部分组成 | ||
complex:复数,由实数部分和虚数部分构成,复数的实部和虚部都是浮点型 | ||
用法 | 栗子 | 结果 |
十六进制和八进制 | a = 0x0F # 十六进制 b = 0o17 # 八进制 print(a, b) | 15 15 |
.bit_length() | # int类型 转换为二进制的至少有效位数 a = 1 b = 2 c = 4 d = 8 e = 15 print(a.bit_length(), b.bit_length(), c.bit_length(), d.bit_length(), e.bit_length()) | 1 2 3 4 4 |
数字类型转换 | x = 18 y = 2 z = 19.535 p = 19.435 print(int(z), int(p), float(x), complex(x), complex(x, y)) | 19 19 18.0 (18+0j) (18+2j) |
2、布尔值(bool)布尔值仅有Ture和False两种;反应条件的正确与否, | ||
用法 | 栗子 | 结果 |
int ---> bool | # 非零即True,零即False a = 100 b = 0 print(bool(a), bool(b)) | True False |
bool ---> int | # True就是1,False就是零 a = True b = False print(int(a), int(b)) | 1 0 |
str ---> bool | # 非空即True 空即False s1 = 'trglion' s2 = '' print(bool(s1), bool(s2)) | True False |
bool ---> str | a = True b = False c = str(a) d = str(b) print(a, c, b, d, type(a), type(c)) | True True False False <class 'bool'> <class 'str'> |
int ---> str | a = 108 b = str(a) print(a, b, type(a), type(b)) | 108 108 <class 'int'> <class 'str'> |
str ---> int | # 必须是数字组成的字符串才能转换 s1 = '109' b = int(s1) print(s1, b, type(s1), type(b)) | 109 109 <class 'str'> <class 'int'> |
3、字符串(str) 用引号引起来的数据可以称为字符串类型,存储少量数据, 组成字符串的每个元素称之为字符 | ||
用法 | 栗子 | 结果 |
索引 | # 索引,下标从0开始 # s1 = 'six六6' 共有5个字符 s1 = 'six六6' print(s1[0], s1[2], s1[-1], s1[-2]) | s x 6 六 |
切片 | # 切片,截取一段字符串成新字符串 # 取值范围: a =< x < b s1 = 'six六6777seven7七666' print(s1[:5]) # 从零开始可不写 print(s1[2:5], s1[:], s1[:-1]) print(s1[0:6:3]) # 其中3为间隔字符步长 print(s1[-1:-7:-2]) # 其中-2 为反向步长 # 避免s1[:7:-3]、s1[-1:-5]、s1[-1:0]、s1[-1:-7:3]等这些形式 | six六6 x六6 six六6777seven7七666 six六6777seven7七66 s六 667 |
仅首字母大写 .capitalize() | s2 = s1.capitalize() print(s2) | Six六6777seven7七666 |
字母全部大写 .upper() | s2 = s1.upper() print(s2) | SIX六6777SEVEN7七666 |
字母全部小写 .lower() | s3 = "sixSEVENSIX" s2 = s3.lower() print(s2) | sixsevensix |
字母大小写翻转 .swapcase() | s2 = s3.swapcase() print(s2) | SIXsevensix |
标题模式 .title() | # 标题方式,单词首字母大写 s4 = "disc on the app of multi" s2 = s4.title() print(s2) | Disc On The App Of Multi |
居中,自动填充 .center() | s5 = "trglion" s2 = s5.center(20, "*") # 20为总字符个数 print(s2) | ******trglion******* |
是否仅有数字组成 .isdigit() | ret1 = s1.isdigit() print(ret1) | FALSE |
是否仅字母组成 .isalpha() | ret1 = s1.isalpha() print(ret1) | FALSE |
字符数 len() | # 字符串的字符数 a = len(s1) print(a) | 18 |
某元素的个数 .count() | # 字符串中元素出现的个数 ret1 = s1.count("e") ret2 = s1.count("e", 0, 10) ret3 = s1.count("e", -1, -10) # 不要使用这种格式 print(ret1, ret2, ret3) | 2 1 0 |
否以…开头或结尾 .startswith() .endswith() | # 判断字符串是否以…开头或结尾 ret1 = s1.startswith("si") ret2 = s1.endswith("666") ret3 = s1.endswith("666", 10, 17) # 切片的取值范围 print(ret1, ret2, ret3) | True True False |
切分 以…为分割为一个列表 .split() | # 以…为分割且形成一个列表 ret1 = s1.split("6") ret2 = s1.split("6", 1) # 其中1为分割次数 ret3 = s1.split("6", 2) ret4 = s1.split("6", 3) ret5 = s1.split("6", 3)[0] print(ret1, type(ret1)) print(ret2) print(ret3) print(ret4) print(ret5, type(ret5)) | ['six六', '777seven7七', '', '', ''] <class 'list'> ['six六', '777seven7七666'] ['six六', '777seven7七', '66'] ['six六', '777seven7七', '', '6'] six六 <class 'str'> |
查找元素 .find() | # 查找元素,返回索引,找不到返回-1 a = s1.find("s") b = s1.find("A") print(a, b, type(a), type(b)) | 0 -1 <class 'int'> <class 'int'> |
查找元素 .find() | # 查找元素,返回索引,找不到报错 a = s1.index("s") print(a, type(a)) | 0 <class 'int'> |
去除指定字符 .strip() | # strip 默认去除字符串首尾空格 # 去除指定字符, s6 = " x 567 x " s7 = "six666SEVEN77si" s2 = s6.strip() sa = s7.strip("7") sb = s7.strip("6") sc = s7.strip("si") se = s7.rstrip("si") # 自左删除 sd = s7.lstrip("si") # 自右删除 print(s2, sa, sb, sc, se, sd) | x 567 x six666SEVEN77si six666SEVEN77si x666SEVEN77 six666SEVEN77 x666SEVEN77si |
替换相关字符 .replace(old,new,count) | sa = s1.replace("6", "8", 1) sb = s1.replace("6", "8", 2) sc = s1.replace("6", "8", 5) print(sa, sb, sc) | six六8777seven7七666 six六8777seven7七866 six六8777seven7七888 |
格式化输出 format 这几个字符串输出的内容是一样的 | sx = "我是{},我在{},我学{}, I am {}".format("trglion", "上海", "python", "trglion") sy = "我是{0},我在{1},我学{2}, I am {0}".format("trglion", "上海", "python") sz = "我是{name},我在{city},我学{tech}, I am {name}".format(name="trglion", city="上海", tech="python") name = input('请输入名字:') sn = "我是{name},我在{city},我学{tech}, I am {name}".format(name=name, city="上海", tech="python") print(sx, sy, sz, sn) | 我是trglion,我在上海,我学python, I am trglion |
4、列表(list) 属于容器类的数据类型,可以存储稍大量的数据 | ||
用法 | 栗子 | 结果 |
创建列表 | li = [123, "trglion", "天涯社区", [1, 'abs', '小明13岁'], "Lilei12"] | |
索引 | l1 = li[0] l2 = li[3] l3 = li[3][2] print(l1, type(l1)) print(l2, type(l2)) print(l3, type(l3)) | 123 <class 'int'> [1, 'abs', '小明13岁'] <class 'list'> 小明13岁 <class 'str'> |
切片 | l1 = li[0:3] l2 = li[0:6:2] l3 = li[-1:-6:-2] print(l1, l2, l3) | [123, 'trglion', '天涯社区'] [123, '天涯社区', 'Lilei12'] ['Lilei12', '天涯社区', 123] |
追加 .append 在最后追加元素 | li.append(456) li.append([7, '1a']) print(li) | [123, 'trglion', '天涯社区', [1, 'abs', '小明13岁'], 'Lilei12', 456, [7, '1a']] |
迭代追加 .extend 在最后迭代追加元素 | li.extend(["8e", [1, '9F']]) li.extend("王7D") print(li) | [123, 'trglion', '天涯社区', [1, 'abs', '小明13岁'], 'Lilei12', '8e', [1, '9F'], '王', '7', 'D'] |
插入 .insert 在任意位置插入元素 | li.insert(2, '2c') print(li) | [123, 'trglion', '2c', '天涯社区', [1, 'abs', '小明13岁'], 'Lilei12'] |
删除 .pop 通过索引删除 并返回被删除元素 | ret = li.pop(2) print(ret, li) | 天涯社区 [123, 'trglion', [1, 'abs', '小明13岁'], 'Lilei12'] |
删除. .remove 通过元素删除 无此元素则报错 | li.remove(123) li.remove("Lilei12") print(li) | ['trglion', '天涯社区', [1, 'abs', '小明13岁']] |
清空列表 clear | li.clear() print(li, type(li)) | [] <class 'list'> |
索引删除 不能删除li[3]中的元素 | del li[3] print(li) | [123, 'trglion', '天涯社区', 'Lilei12'] |
切片删除 | del li[0:2] print(li) | ['天涯社区', [1, 'abs', '小明13岁'], 'Lilei12'] |
切片(步长)删除 | del li[::2] print(li) | ['trglion', [1, 'abs', '小明13岁']] |
改 按索引改 | li[1] = "tianya" print(li) | [123, 'tianya', '天涯社区', [1, 'abs', '小明13岁'], 'Lilei12'] |
改 按切片改 | li[1:3] = "王7De[2,c]" print(li) | [123, '王', '7', 'D', 'e', '[', '2', ',', 'c', ']', [1, 'abs', '小明13岁'], 'Lilei12'] |
改 按照切片(步长) 必须一一对应 | li[::2] = "对应值" print(li) | ['对', 'trglion', '应', [1, 'abs', '小明13岁'], '值'] |
查 切片和 循环 | for i in li: print(i) print(li[0:2]) | 123 trglion 天涯社区 [1, 'abs', '小明13岁'] Lilei12 [123, 'trglion'] |
查看元素的个数 len() | ret = len(li) print(ret) | 5 |
浅拷贝 .copy | l1 = li.copy() print(l1) | [123, 'trglion', '天涯社区', [1, 'abs', '小明13岁'], 'Lilei12'] |
查看某个元素出现次数 .count | print(li.count("i")) l1 = ['t', 'r', 'g', 'l', 'i', 'o', 'n'] print(l1.count("i")) | 0 1 |
找出某元素的索引 无此元素则报错 .index | ret = li.index(123) ret1 = li.index("trglion") print(ret, ret1) | 0 1 |
排序 正向排序 仅适字符串和整型元素 | l1 = ['c', 'f', 'b', 'a', 'e', 'dog'] l1.sort() print(l1) l2 = [1, 0, 8, 9, 10, 7] l2.sort() print(l2) | ['a', 'b', 'c', 'dog', 'e', 'f'] [0, 1, 7, 8, 9, 10] |
倒序 reverse = True | l2 = [1, 0, 8, 9, 10, 7] l2.sort(reverse=True) print(l2) | [10, 9, 8, 7, 1, 0] |
反转 .reverse | l2 = [1, 0, 8, 9, 10, 7] l2.reverse() print(l2) | [7, 10, 9, 8, 0, 1] |
列表的相乘和相加 | l1 = [1, 'a'] l2 = [5, 'b', [2, '3C']] print(l1+l2) print(l2+l1) print(l1*3) | [1, 'a', 5, 'b', [2, '3C']] [5, 'b', [2, '3C'], 1, 'a'] [1, 'a', 1, 'a', 1, 'a'] |
列表的嵌套 | print(li[1][2]) li[1] = li[1].capitalize() print(li) print(li[2].replace("社区", "论坛")) print(li) li[2] = li[2].replace("社区", "论坛") print(li) li[3][1] = li[3][1].upper() print(li) | g [123, 'Trglion', '天涯社区', [1, 'abs', '小明13岁'], 'Lilei12'] 天涯论坛 [123, 'Trglion', '天涯社区', [1, 'abs', '小明13岁'], 'Lilei12'] [123, 'Trglion', '天涯论坛', [1, 'abs', '小明13岁'], 'Lilei12'] [123, 'Trglion', '天涯论坛', [1, 'ABS', '小明13岁'], 'Lilei12'] |
字符串与列表 | s = 'lion' s1 = 'trg'.join(s) print(s1) li = ["123", 'tan', "天Ya5"] s2 = '++'.join(li) print(s2) | ltrgitrgotrgn 123++tan++天Ya5 |
5、元组 tuple:容器类的数据类型,存储稍大量的数据,是元素不可增删改的列表, 元素不可以改,但是元素的“元素(非元组)”可以修改 | ||
用法 | 栗子 | 结果 |
元组的创建 | tu = (123, "Lion", "4R9f6e", [1, 'LeeLei', '3c6E'], 'Lion') | |
索引 | print(tu[0], type(tu[0])) print(tu[1][2], type(tu[1][2])) print(tu[2][0], type(tu[2][0])) print(tu[2][1], type(tu[2][1])) | 123 <class 'int'> o <class 'str'> 4 <class 'str'> R <class 'str'> |
切片 | print(tu[0:3]) print(tu[::2]) print(tu[::-2]) | (123, 'Lion', '4R9f6e') (123, '4R9f6e', 'Lion') ('Lion', '4R9f6e', 123) |
循环 | for i in tu: print(i) | 123 Lion 4R9f6e [1, 'LeeLei', '3c6E'] Lion |
查找元素索引 .index | ret = tu.index(123) ret1 = tu.index("Lion") print(ret, ret1) | 0 1 |
查找元素的出现次数 .count | tu = (123, "Lion", "3c6E", [1, 'LeeLei', '3c6E'], 'Lion') ret = tu.count("3c6E") ret1 = tu.count('Lion') print(ret, ret1) | 1 2 |
查看元素的个数 len() | print(len(tu)) | 5 |
元素的“元素”可变 | tu[3][1] = tu[3][1].upper() print(tu) tu[3].append("Trg") print(tu) | (123, 'Lion', '3c6E', [1, 'LEELEI', '3c6E'], 'Lion') (123, 'Lion', '3c6E', [1, 'LEELEI', '3c6E', 'Trg'], 'Lion') |
6、字典dict:容器型的数据类型,按照键值对的方式存储关系型数据,其中key是不可变数据类型, 且唯一不可重复;Value任意数据,py3.6后字典为第一次插入的顺序。 | ||
不可变(可哈希)的数据类型:int,str,bool,tuple。可变(不可哈希)的数据类型:list,dict,set。 | ||
用法 | 栗子 | 结果 |
字典的创建 | dic = {'name': 'Lion', 'age': '8', 'sex': 'Male'} | |
增 键值对直接增加 无则增加,有则变值 | dic['weight'] = 300 dic['age'] = 9 print(dic) | {'name': 'Lion', 'age': 9, 'sex': 'Male', 'weight': 300} |
增 .setdefault 无则增加,有则不动作 | dic.setdefault('weight', '300') dic.setdefault('age', '9') ret = dic.setdefault('age') print(dic, ret) | {'name': 'Lion', 'age': '8', 'sex': 'Male', 'weight': '300'} 8 |
删 .pop 删除相应键值对, 返回键值对的值; 无键值对则无动作, 可设置返回值 | ret1 = dic.pop('name') print(ret1, dic) ret2 = dic.pop('n', None) print(ret2, dic) ret3 = dic.pop('age', None) print(ret3, dic) | Lion {'age': '8', 'sex': 'Male'} None {'age': '8', 'sex': 'Male'} 8 {'sex': 'Male'} |
删 .popitem py3.6后为删除最后一个 有返回值 | ret1 = dic.popitem() print(ret1, type(ret1), dic) | ('sex', 'Male') <class 'tuple'> {'name': 'Lion', 'age': '8'} |
删 del 无保留删除 | del dic['name'] print(dic) del dic # 将字典无保留删除 # print(dic) # 报错 | {'age': '8', 'sex': 'Male'} |
删 .clear 清空字典 | dic.clear() print(dic) | {} |
改 通过键值对改值 | dic['age'] = 7 print(dic) | {'name': 'Lion', 'age': 7, 'sex': 'Male'} |
改 .update 字典升级 | dic.update(sex='Female', height='100') print(dic) dic.update([('sex', '男'), ('weight', '300')]) print(dic) dic1 = {'age': '6', 'sex': 'Male', 'color': 'brown'} dic.update(dic1) print(dic) | {'name': 'Lion', 'age': '8', 'sex': 'Female', 'height': '100'} {'name': 'Lion', 'age': '8', 'sex': '男', 'height': '100', 'weight': '300'} {'name': 'Lion', 'age': '6', 'sex': 'Male', 'height': '100', 'weight': '300', 'color': 'brown'} |
查 查看字典的键、值、 键和值; | print(dic.keys(), type(dic.keys())) print(dic.values()) print(dic.items()) | dict_keys(['name', 'age', 'sex']) <class 'dict_keys'> dict_values(['Lion', '8', 'Male']) dict_items([('name', 'Lion'), ('age', '8'), ('sex', 'Male')]) |
查看键和值 | for k, v in dic.items(): print(k, v) | name Lion age 8 sex Male |
查看键和值 以元组形式 | for i in dic.items(): print(i) | ('name', 'Lion') ('age', '8') ('sex', 'Male') |
查 通过键查询, 无此键则报错 | v = dic['name'] print(v) | Lion |
查 .get 可设置返回值 | print(dic.get('sex')) v = dic.get('age') print(v) v1 = dic.get('name') print(v1) v2 = dic.get('name1') print(v2) v3 = dic.get('name2', '无此名') print(v3) | Male 8 Lion None 无此名 |
创建字典 .fromkeys | dic1 = dict.fromkeys('abcd', 'Lion') print(dic1) dic2 = dict.fromkeys([1, 2, 3, 4], 'Lion') print(dic2) | {'a': 'Lion', 'b': 'Lion', 'c': 'Lion', 'd': 'Lion'} {1: 'Lion', 2: 'Lion', 3: 'Lion', 4: 'Lion'} |
字典的嵌套 1、获取狮王第一个孩子的名字 2、添加狮王的第三个孩子的信息 | dic1 = { 'name': 'LionKing', 'age': '7', 'children': [{'first': 'XiaoMing', 'age': '3', }, {'second': 'XiaoHong', 'sex': 'Female'}] } v1 = dic1['children'] print(v1, type(v1)) v2 = dic1['children'][0] print(v2, type(v2)) first_name = dic1['children'][0]['first'] print(first_name, type(first_name)) dic1['children'].append({'three': 'XiaoDong', 'weight': '200'}) print(dic1) | [{'first': 'XiaoMing', 'age': '3'}, {'second': 'XiaoHong', 'sex': 'Female'}] <class 'list'> {'first': 'XiaoMing', 'age': '3'} <class 'dict'> XiaoMing <class 'str'> {'name': 'LionKing', 'age': '7', 'children': [{'first': 'XiaoMing', 'age': '3'}, {'second': 'XiaoHong', 'sex': 'Female'}, {'three': 'XiaoDong', 'weight': '200'}]} |
7、集合set:可变的数据类型,但元素必须是不可变的数据类型, 无序、不可重复 | ||
不可变(可哈希)的数据类型:int,str,bool,tuple;元组内不可出现可变数据类型的元素 | ||
用法 | 栗子 | 结果 |
创建集合 | set1 = {1, 'Ab3', True, } | |
增 .add | set1.add(123) set1.add('狮王') set1.add(('ghs', 123, )) print(set1) | {False, 1, '狮王', ('ghs', 123), 123, 'Ab3'} |
增 .update 迭代增加, 参数为可迭代对象 | # set1.update(123) #错误的 set1.update('狮王') set1.update(('ghs', 123, )) set1.update([1, 8, 9]) set1.update({'d': 3, 'e': 'f', }) print(set1) | {False, 1, 'Ab3', 'ghs', 8, 9, 123, 'd', 'e', '王', '狮'} |
删 .remove 删除一个元素, 无则报错 | set1.remove('Ab3') print(set1) | {False, 1} |
删 .pop 随机删除一个元素 | set1.pop() print(set1) | {1, 'Ab3'} |
删 .clear 清空集合 | set1.clear() print(set1) | set() |
删 del 无保留删除 | del set1 print(set1) | 报错 not defined |
集合的其他操作 | set2 = {1, 2, 3, 'a', 'b', } set3 = {3, 4, 'a', 'c', 'd', } set4 = {1, 2, 3, } set5 = {1, 2, 3, 'a', 'b', } | |
集合的交集 & intersection | print(set2 & set3) print(set2.intersection(set3)) | {3, 'a'} {3, 'a'} |
集合的并集 | union | print(set2 | set3) print(set2.union(set3)) | {1, 2, 3, 4, 'a', 'b', 'c', 'd'} {1, 2, 3, 4, 'a', 'b', 'c', 'd'} |
集合的差集 - difference | print(set2 - set3) print(set3.difference(set2)) | {1, 2, 'b'} {'c', 4, 'd'} |
集合的反交集 ^ symmetric_difference | print(set2 ^ set3) print(set3.symmetric_difference(set2)) set2.symmetric_difference_update(set3) print(set2) | {1, 2, 4, 'd', 'b', 'c'} {1, 2, 4, 'd', 'b', 'c'} {1, 2, 4, 'b', 'd', 'c'} |
集合的子集 < .issubset | print(set4 < set2) print(set2.issubset(set4)) | True False |
集合的超集 > .issuperset | print(set2 > set4) print(set5 > set2) print(set4.issuperset(set4)) | True False True |
不可变集合 forzenset | set6 = frozenset({1, 2, 3, }) print(set6) s1 = frozenset([1, 2, 'aB3']) print(s1) s2 = frozenset({'a': 1, 'b': 2, }) print(s2) | frozenset({1, 2, 3}) frozenset({1, 2, 'aB3'}) frozenset({'a', 'b'}) |
8、其他 | ||
enumerate:枚举,对于一个可迭代的(iterable)/可遍历的对象(如列表、字符串), enumerate将其组成一个索引序列,利用它可以同时获得索引和值 | ||
用法 | 栗子 | 结果 |
li = [1, '23', 'a3B4', 'Lion', '狮王'] | ||
for i in enumerate(li): print(i, type(i)) | (0, 1) <class 'tuple'> (1, '23') <class 'tuple'> (2, 'a3B4') <class 'tuple'> (3, 'Lion') <class 'tuple'> (4, '狮王') <class 'tuple'> | |
for index, nam in enumerate(li, 0): print(index, nam) | 0 1 1 23 2 a3B4 3 Lion 4 狮王 | |
for index, nam in enumerate(li, 50): print(index, nam) | 50 1 51 23 52 a3B4 53 Lion 54 狮王 | |
range:指定范围,生成指定数字 | ||
用法 | 栗子 | 结果 |
for i in range(1, 7): print(i) | 1 2 3 4 5 6 | |
指定步长 | for i in range(1, 7, 2): print(i) | 1 3 5 |
反向步长 | for i in range(7, 1, -2): print(i) | 7 5 3 |
Python运算符的优先级 | ||
优先级 | 运算符 | 描述 |
1 | lambda | Lambda表达式 |
2 | or | 布尔“或” |
3 | and | 布尔“与” |
4 | not x | 布尔“非” |
5 | in,not in | 成员测试 |
6 | is,is not | 同一性测试 |
7 | <,<=,>,>=,!=,== | 比较 |
8 | | | 按位或 |
9 | ^ | 按位异或 |
10 | & | 按位与 |
11 | <<,>> | 移位 |
12 | +,- | 加法与减法 |
13 | *,/,% | 乘法、除法与取余 |
14 | +x,-x | 正负号 |
15 | ~x | 按位翻转 |
16 | ** | 指数 |
17 | x.attribute | 属性参考 |
18 | x[index] | 下标 |
19 | x[index:index] | 寻址段 |
20 | f(arguments...) | 函数调用 |
21 | (experession,...) | 绑定或元组显示 |
22 | [expression,...] | 列表显示 |
23 | {key:datum,...} | 字典显示 |
24 | 'expression,...' | 字符串转换 |
Python小数据池和深浅拷贝 | |||||||
副标题:“你以为你把数据备份好了!” | |||||||
1、bytes类型:py3后以Unicode编码方式存储,bytes的编码方式为非Unicode | |||||||
| |||||||
用法 | 栗子 | 结果 | |||||
编码 .encode 把str转换成bytes, unicode转换成 utf-8或gbk | s1 = 'sun' s2 = '太阳' print(s1.encode('utf-8')) print(s2.encode('utf-8')) print(s1.encode('gbk')) print(s2.encode('gbk')) | b'sun' b'\xe5\xa4\xaa\xe9\x98\xb3' b'sun' b'\xcc\xab\xd1\xf4' | |||||
解码 .decode 把bytes,utf-8 转换成unicode | s3 = s1.encode() s4 = s2.encode() s5 = s2.encode('gbk') print(s3) print(s3.decode('utf-8')) print(s3.decode('gbk')) print(s4) print(s4.decode('utf-8')) print(s5) print(s5.decode('gbk')) | b'sun' sun sun b'\xe5\xa4\xaa\xe9\x98\xb3' 太阳 b'\xcc\xab\xd1\xf4' 太阳 | |||||
2、代码块:块是一个python程序的文本,他是作为一个单元执行的,一个模块, 一个函数,一个类,一个文件等都是一个代码块 | |||||||
补充id is == : id就是内存地址,is是比较对象的内存地址,==比较对象的值 | |||||||
代码块缓存机制:在同一代码块内,执行初始化对象时会将其内的“变量”和“值”存储在一个字典中 如果两个变量值相同,则指向1个对象 所以满足缓存机制则他们在内存中只存在一个,即:id相同。适用对象: int(float),str,bool。 | |||||||
优点:值相同的字符串和整数,直接从“字典”取出,避免重复的创建和销毁,提升效率节约内存 | |||||||
用法 | 栗子 | 结果 | |||||
整型 | a = 55 b = 55 print(a is b) | True | |||||
浮点 | c = 63.57 d = 63.57 print(c is d) | True | |||||
非乘法字符串 | s1 = 'Lion$~' s2 = 'Lion$~' print(s1 is s2) | True | |||||
乘法字符串, 仅含大小写字母、数字 下划线; 相乘后总长度<=20 | s3 = 'Ab6_' * 5 s4 = 'Ab6_' * 5 print(s3 is s4) s5 = 'Ab6_' * 6 s6 = 'Ab6_' * 6 print(s5 is s6) | True False | |||||
3、小数据池:不同代码块的缓存机制,为节省内存,适用对象:int、str、bool; 两个值相同的变量指向小数据池里的同一地址,整数数字范围-5~256。 | |||||||
补充:在cmd进入python解释器称为交互方式,交互方式下输入的每个指令都是一个代码块 | |||||||
用法 | 栗子 | 结果 | |||||
整型 |
| ![]() | |||||
字符串 字符串长度<=1时, 默认驻留 |
| ![]() | |||||
字符串 字符串长度>1时, 仅含字母、数字、下划线 默认驻留 |
| ||||||
乘法字符串 乘 <= 1 时 默认驻留 |
| ||||||
乘法字符串 乘数>1时, 仅含字母、数字、下划线 总长度<=20 时 默认驻留 |
| ![]() | |||||
指定驻留 from sys import intern |
| ||||||
4、深浅拷贝(你以为你把数据备份好了) | |||||||
浅拷贝:数据半共享,复制的数据独立存放在其他内存中,但是只复制第一层。 如果是列表等可变数据类型,拷贝的是内存地址,所以修改这类元素,还是会全都改变。 | |||||||
深拷贝:数据完全不共享,复制的数据完全独立放到另一个内存中,包括可变数据类型的内容 | |||||||
用法 | 栗子 | 结果 | |||||
浅拷贝 .copy 数据半共享 | li1 = [1, 3, [5, 6]] li2 = li1.copy() li1[1] = 4 print(li1) print(li2) li1[2][0] = 7 li2[2][1] = 8 print(li1) print(li2) | [1, 4, [5, 6]] [1, 3, [5, 6]] [1, 4, [7, 8]] [1, 3, [7, 8]] | |||||
深拷贝 copy.deepcopy 数据完全不共享 | import copy li1 = [1, 3, [5, 6]] li2 = copy.deepcopy(li1) li1[1] = 4 print(li1) print(li2) li1[2][0] = 7 li2[2][1] = 8 print(li1) print(li2) | [1, 4, [5, 6]] [1, 3, [5, 6]] [1, 4, [7, 6]] [1, 3, [5, 8]] |
python文件处理 | |||
1、文件操作的方法 | |||
方法 | 用法 | 栗子 | 结果 |
打开文件 open() | open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True): file: 必需,文件路径(相对或者绝对路径)mode: 可选,文件打开模式 buffering: 设置缓冲 encoding: 一般使用utf8 errors: 报错级别 newline: 区分换行符 closefd: 传入的file参数类型 | r模式打开文件:只读模式 f = open('E:\Lion狮王.txt', mode='r', encoding='utf-8') rb模式:二进制打开文件只读,操作非文字文件 w模式:写模式 wb模式:二进制格式写入,操作图片、音频、视频等 a模式:追加模式,最后位置追加内容 r+模式:用于文件的读写,默认光标在开头 先读后写,避免写入覆盖原有内容。 | |
.close() 关闭文件 | .close() 无参数 该方法无返回值 | f = open('E:\Lion狮王.txt', mode='r', encoding='utf-8') print("文件名:", f.name) f.close() | 文件名: E:\Lion狮王.txt |
flush() 主动将缓冲区数据立即写入文件 | .flush() 无参数 该方法无返回值 | f = open('E:\Lion狮王.txt', mode='r', encoding='utf-8') print("文件名:", f.name) f.flush() f.close() (栗子不好) | 文件名: E:\Lion狮王.txt |
.fileno() 返回文件描述符 | .fileno() 无参数 返回整型文件描述符 | f = open('E:\Lion狮王.txt', mode='r', encoding='utf-8') print("文件名:", f.name) fid = f.fileno() print("文件描述符:", fid) f.close() | 文件名: E:\Lion狮王.txt 文件描述符: 3 |
.isatty() 是否连接到终端 | ..isatty() 无参数 如果连接到一个终端设备返回 True, 否则返回 False。 | f = open('E:\Lion狮王.txt', mode='r', encoding='utf-8') print("文件名:", f.name) ret = f.isatty() print("已连接其它终端:", ret) f.close() | 文件名: E:\Lion狮王.txt 已连接其它终端: False |
.read() 读取文件 | .read([size]) [size]: 设定从文件读取的字节数 | f = open('E:\Lion狮王.txt', mode='r', encoding='gbk') lin1 = f.read(6) print("读取的内容为:%s" % (lin1)) lin2 = f.read() print("读取的内容为:%s" % (lin2)) f.close() | (注意第二次的开始位置) 读取的内容为:a1A!&狮 读取的内容为:王^ 第二行 第三行 第四行 |
.readline() 读取整行 包含‘\n’字符 | .readline([size]) [size]: 设定从文件读取的字节数 | f = open('E:\Lion狮王.txt', mode='r', encoding='gbk') lin1 = f.readline() print("读内容为:%s" % (lin1)) lin2 = f.readline(2) print("读内容为:%s" % (lin2)) lin3 = f.readline(15) print("读内容为:%s" % (lin3)) f.close() | 读内容为:a1A!&狮王^ 读内容为:第二 读内容为:行 |
.readlines() 读取所有行, 并返回列表 | .readlines 无参数 返回列表,包括所有行 | f = open('E:\Lion狮王.txt', mode='r', encoding='gbk') # lin1 = f.readlines() # print("结果为:%s" % (lin1)) # # 结果为:['a1A!&狮王^\n', '第二行\n', '第三行\n', '第四行'] for line in f.readlines(): line = line.strip() # 去掉每行头尾空白 print("读内容为: %s" % (line)) f.close() | 读内容为: a1A!&狮王^ 读内容为: 第二行 读内容为: 第三行 读内容为: 第四行 |
.seek() 设置光标的位置 | seek(self, offset: int, whence: int = 0) offset: 开始的偏移量,负数为倒数第几位; whence:默认为0,从哪个位置开始偏移; 0代表从头,1代表当前位置,2代表文末 返回值:操作成功返回新的位置, 操作失败则返回-1 | f = open('E:\Lion狮王.txt', mode='r', encoding='gbk') lin1 = f.readlines() print("结果为:%s" % (lin1)) f.seek(0, 0) for line in f.readlines(): line = line.strip() # 去掉每行头尾空白 print("读内容为: %s" % (line)) f.close() | 结果为:['a1A!&狮王^\n', '第二行\n', '第三行\n', '第四行'] 读内容为: a1A!&狮王^ 读内容为: 第二行 读内容为: 第三行 读内容为: 第四行 |
.tell() 返回文件当前位置 | .tell() 无参数 返回文件的当前位置 | f = open('E:\Lion狮王.txt', mode='r', encoding='gbk') lin1 = f.readline() print("结果为:%s" % (lin1)) pos = f.tell() print("当前位置:%d" % pos) f.close() | 结果为:a1A!&狮王^ 当前位置:12 |
.truncate() 截取 | truncate( [ size ]) 从文件的首行首字符开始截断, 截断文件为 size 个字符; Widnows 系统下的换行代表2个字符大小 参数可选 无返回值 | f = open('E:\Lion狮王.txt', mode='r+', encoding='gbk') f.truncate(20) s1 = f.read() print("读取为:%s" % s1) f.close() | 读取为:a1A!&狮王^ 第二行 |
.write() 写入 返回写入字符长度 | .write( [ str ]) [str] 要写入的字符串 返回写入的字符长度 | f = open('E:\Lion狮王.txt', mode='r+', encoding='gbk') s1 = '第五行%……&^&' f.seek(0, 2) ret1 = f.write(s1) print('写入字符长度: %d' % ret1) f.seek(0, 0) lin1 = f.read() print('读内容为:%s' % lin1) f.close() | 写入字符长度: 9 读内容为:a1A!&狮王^ 第二行 第五行%……&^& |
.writelines() 写入 系列字符串列表 | .writelines( [ str ]) [str] 要写入的字符串序列 无返回值 | f = open('E:\Lion狮王.txt', mode='r+', encoding='gbk') f.seek(0, 2) sli1 = ['第六行', 'ENDING'] f.writelines(sli1) f.seek(0, 0) lin1 = f.read() print('读内容为:%s' % lin1) f.close() | 读内容为:a1A!&狮王^ 第二行 第五行%……&^& 第六行ENDING |
2、各种模式下的文件操作 | |||
方法 | 栗子 | 结果 | |
rb + wb 模式 复制图片 | # 第1步,将原图片通过rb模式读取出来 f = open('sexy1.png', mode='rb') content = f.read() f.close() # 第2步,将读取到的content数据写入新的文件 f1 = open('sexy2.png', mode='wb') f1.write(content) f1.close() | 得到另外一张新图片 | |
W模式 无文件则创建文件 | f = open('L1', encoding='utf-8', mode='w') f.write('这是一次测试内容') f.close() | 创建了L1,且添加了内容 | |
W模式 文件存在 则先清空文件 | f = open('L1', encoding='utf-8', mode='w') f.write('第二次输入内容') f.flush() # 强制保存 f.close() | 文件内容仅剩第二次的输入内容 | |
a 追加模式 无文件则创建文件 有则在文末追加 | f = open('L1', encoding='utf-8', mode='a') f.write('第三次输入内容') f.flush() # 强制保存 f.close() | 在文末追加了新写入的内容 | |
r+模式 打开文件用于读写 写读后写是保障 | f = open('L1', encoding='utf-8', mode='r+') content = f.read() print(content) f.write('模式R+写入内容') f.flush() f.seek(0, 0) con1 = f.read() print(con1) f.close() | 第二次输入内容第三次输入内容 第二次输入内容第三次输入内容模式R+写入内容 | |
with 打开文件方式 | with open('L1',encoding='utf-8') as f1, open('E:\Lion狮王.txt',encoding='gbk') as f2: s1 = f1.read() s2 = f2.read() print(s1) print(s2) | 第二次输入内容第三次输入内容模式R+写入内容 a1A!&狮王^ 第二行 第五行%……&^& 第六行ENDING | |
文件的修改 |
愿有更多的朋友,在网页笔记结构上分享更逻辑和易读的形式:
链接:https://pan.baidu.com/s/1PaFbYL1sYoUcRj0xgm8W8Q
提取码:暂无