[004]Python数据类型二_python_全栈基础
2024-04-16 08:06:25
您好！此笔记的文本和代码以网盘形式分享于文末！
因个人能力有限，错误处欢迎大家交流和指正！基础部分内容简单，但多且零散！
| 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'] |
[{'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) |
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() |
文件名： E:\Lion狮王.txt |
|
.fileno() 返回文件描述符 |
.fileno() 无参数 返回整型文件描述符 |
f = open('E:\Lion狮王.txt', mode='r', encoding='utf-8') print("文件名：", f.name) fid = f.fileno() 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() f.close() |
文件名： E:\Lion狮王.txt 已连接其它终端： False |
|
.read() 读取文件 |
.read([size]) [size]: 设定从文件读取的字节数 |
f = open('E:\Lion狮王.txt', mode='r', encoding='gbk')
lin1 = f.read(6) f.close() |
（注意第二次的开始位置） 读取的内容为：a1A!&狮 读取的内容为：王^ 第二行 第三行 第四行 |
|
.readline() 读取整行 包含‘\n’字符 |
.readline([size]) [size]: 设定从文件读取的字节数 |
f = open('E:\Lion狮王.txt', mode='r', encoding='gbk')
lin1 = f.readline() f.close() |
读内容为：a1A!&狮王^
读内容为：第二 |
|
.readlines() 读取所有行， 并返回列表 |
.readlines 无参数 返回列表，包括所有行 |
f = open('E:\Lion狮王.txt', mode='r', encoding='gbk')
# lin1 = f.readlines() 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() f.seek(0, 0) for line in f.readlines(): f.close() |
结果为：['a1A!&狮王^\n', '第二行\n', '第三行\n', '第四行'] 读内容为： a1A!&狮王^ 读内容为： 第二行 读内容为： 第三行 读内容为： 第四行 |
|
.tell() 返回文件当前位置 |
.tell() 无参数 返回文件的当前位置 |
f = open('E:\Lion狮王.txt', mode='r', encoding='gbk')
lin1 = f.readline() pos = f.tell() f.close() |
结果为：a1A!&狮王^
当前位置：12 |
|
.truncate() 截取 |
truncate( [ size ]) 从文件的首行首字符开始截断， 截断文件为 size 个字符； Widnows 系统下的换行代表2个字符大小 参数可选 无返回值 |
f = open('E:\Lion狮王.txt', mode='r+', encoding='gbk')
f.truncate(20) f.close() |
读取为：a1A!&狮王^ 第二行 |
|
.write() 写入 返回写入字符长度 |
.write( [ str ]) [str] 要写入的字符串 返回写入的字符长度 |
f = open('E:\Lion狮王.txt', mode='r+', encoding='gbk')
s1 = '第五行%……&^&' f.seek(0, 0) f.close() |
写入字符长度： 9 读内容为：a1A!&狮王^ 第二行 第五行%……&^& |
|
.writelines() 写入 系列字符串列表 |
.writelines( [ str ]) [str] 要写入的字符串序列 无返回值 |
f = open('E:\Lion狮王.txt', mode='r+', encoding='gbk')
f.seek(0, 2) f.seek(0, 0) 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
提取码：暂无
[004]Python数据类型二_python_全栈基础相关推荐
- [003]python数据类型一__python_全栈基础
您好!此笔记的文本和代码以网盘形式分享于文末! 因个人能力有限,错误处欢迎大家交流和指正!基础部分内容简单,但多且零散! ...
- 《Python全栈基础教程》目录
专栏地址: <Python全栈基础教程> 更新进度(持续更新中~) 0.前言: ???作者介绍:[]-CSDN全栈领域优质创作者.HDZ核心组成员.华为云享专家Python全栈领域博主.C ...
- 撩课python视频下载_2018年撩课学院-Python+人工智能/JavaEE/Web全栈/全学科下载_IT教程网...
教程名称: Python+人工智能/JAVAEE/Web全栈 作为Python编程语言的一本指南或者教程.它主要是为新手而设计,不过对于有经验的程序员来说,它同样有用.即便你对计算机的了解只是如何在计 ...
- 不属于python数据类型的是_python基础3 ---python数据类型二
ython基础 一.python数据类型 ------列表(list) 1.定义:[]内以逗号分隔,按照索引,存放各种数据类型,每个位置代表一个元素 特性:可存放多个不同类型的值:可修改指定索 ...
- 洗礼灵魂，修炼python（73）--全栈项目实战篇（1）——【转载】前提准备之学习ubuntu...
本篇是为项目实战做准备,学习Linux是必备的,不然都不好意思叫全栈对吧?下面是一位资深大神写的文章,够详细,我也不用浪费时间再写了 原文链接:Ubuntu学习--第一篇 内容: 一. Ubuntu简 ...
- python自动化开发和全栈开发_python全栈开发devops运维自动化方向初到高级在线课程分享...
适用人群 面向想要devops方向发展的全栈python运维开发工程师 课程概述 课程范围:我们的课程由浅入深包含C01到C05五个等级:包含前后端知识,覆盖培养一个合格python全栈工程师所需要的 ...
- python 仪表盘监控_Python 全栈开发 -- 监控篇
如果你已经玩转了 Python 编程语言语法,肯定想用这些知识,开发一款应用程序,它可以是在网上,可以炫耀或出售,那就需要全栈式开发 Python.具体如何创建,部署和运行生产 Python Web ...
- python费用结算系统_python 全栈开发，Day104(DRF用户认证,结算中心,django-redis)
考试第二部分:MySQL数据库 6. MySQL中char和varchar的区别(1分) char是定长,varchar是变长. char的查询速度比varchar要快. View Code 7. ...
- python第一次考试_python 全栈开发，Day16(函数第一次考试)
考试题 Python11 期第二次考试(基础数据类型与函数部分) 考试时长:3个小时 满分:105分 一,选择题(每题2分,共24分) 1.python不支持的数据类型有 A.char B.int C ...
- python数据类型怎么定义_零基础如何学好Python 之int 数字整型类型 定义int()范围大小转换...
本文主题是讲python数字类型python int整型使用方法及技巧.它是不可变数据类型中的一种,它的一些性质和字符串是一样的,注意是整型不是整形哦. Python int有多种数字类型:整型int ...
最新文章
- Spring Cloud 注册中心在tomcat中部署
- java程序设计试题_《Java语言程序设计》期末考试模拟试题——填空题和编程题...
- 用python画烟花-python实现浪漫的烟花秀
- Adempiere 在Ubuntu下的安装方法(二）
- 【2018.3.31】模拟赛之二-ssl2407 负进制【贪心】
- 减治法在排序算法中的应用（JAVA）--插入排序
- 计算机开题报告中的研究方法,开题报告：经济学写论文用到的五种研究方法
- CentOS增加用户到sudo用户组
- python 核心编程 练习题
- 【软考系统架构设计师】2010年下系统架构师综合知识历年真题
- 《图书管理系统》毕业论文
- Java中面向接口编程的简单案例（电脑、鼠标、键盘、USB接口）
- 钽电容器为什么被要求降额到额定值的1/3使用
- 一文读懂ICO、IFO、IMO、IEO的区别，或许是全网最全科普
- js和css压缩工具
- DONT_UNCOMPRESS_PRIV_APPS_DEXS配置
- vrchat模型保存_VRchat下载别人的模型
- Webshell（网页后门）
- 面经-Iterator_FailFast_FailSafe
- redis之地理位置