python是解释型语言
变量定义的规则：
变量名只能是字母、数字或下划线的任意组合
变量名的第一个字符不能是数字
以下关键字不能声明为变量名
【‘and’，‘as’,‘assert’，‘break’，‘class’，‘continue’，‘def’，‘elif’，‘else’，‘except’，‘exec’，‘finally’，‘for’，‘from’，‘global’，‘if’，‘import’，‘in’，‘is’，‘lambda’，‘not’，‘or’，‘pass’，‘print’，‘raise’，‘return’，‘try’，‘while’，‘with’，‘yield’】
字符编码
python解释器加载.py文件中的代码时，会对内容进行编码(默认ASCII)，ASCII码最多只能表示255个符号，一个字符占一个字节，8位bits
image.png
显然ASCII码无法将世界上的各种文字和符号全部表示，所以，就需要新出一种可以代表所有字符和符号的编码，即：Unicode，一个字符占两个字节，16位bits
UTF-8,，又进步为可变存储字节数，en:1bytes，zh:3bytes
image.png
注释
当行注释：#被注释内容
多行注释：'''被注释内容'''
注：多行注释也可以多行输出
image.png
用户交互程序
image.png
字符串的格式转换：
image.png
format方式：
1、
image.png
2、
image.png
密码密文显示
image.png
注：不在pycharm中运行，在cmd命令中可以运行
循环
while循环
image.png
次数达到限制，询问是否继续：
image.png
for循环
image.png
range
打印偶数：
image.png
continue
image.png
注：continue是跳出本次循环，进入下一次循环；break是结束循环
库
python的强大之处在于有非常丰富和强大的标准库和第三方库，几乎你想实现的任何功能都有相应的python库支持
sys库
打印环境变量
print(sys.path)
打印文件路径
print(sys.argv)
第三方库的安装位置
image.png
标准库的安装位置
image.png
OS库
import os
cmd_system=os.system('dir')#执行命令，不保存结果
print('cmd_system--',cmd_system)
cmd_popen=os.popen('dir').read()#通过read方法读取存在内存的信息
print('cmd_popen---',cmd_popen)
os.mkdir('new_dir')#在当前位置创建一个目录
image.png
数据类型
数字
int(整型)
在32位机器上，整数的位数为32位，取值范围为-2^31~ 2^31-1
在64位机器上，整数的位数为32位，取值范围为-2^63~ 2^63-1
long(长整型)
python的长整数没有指定位宽
float(浮点型)
浮点数用来处理实数，即带有小数的数字，类似于C语言中的double类型，占8个字节(64位)，其中52位表示底，11位表示指数，剩下的一位表示符号
修改浮点数的精度：
a=1.3455465457647
a=float('%0.2f'%a)#a=1.35
bytes类型
bytes-》string：decode
string-》bytes：encode
image.png
布尔值
对象的三个特征：id(is)、value(==)、type(isinstance)
真或假(1或0)
三元运算
result=值1 if 条件 else 值2
image.png
字符串
name='ha\tha'
print('name:',name)
print('len(name):',len(name))
print('name.capitalize():',name.capitalize())#首部大写
print("name.count('h'):",name.count('h'))#指定字母出现的次数
print("name.center(10,'-'):",name.center(10,'-'))#指定字符串的长度，将原本的字符串数据放在中间，不够的数据用‘-’补全
print("name.ljust(10,'-'):",name.ljust(10,'-'))#指定字符串的长度，将原本的字符串数据放在左边，不够的数据用‘-’补全
print("name.rjust(10,'-'):",name.rjust(10,'-'))#指定字符串的长度，将原本的字符串数据放在右边，不够的数据用‘-’补全
print("name.endswith('a'):",name.endswith('a'))#判断字符串是否是指定字母结尾
print('name.expandtabs(tabsize=6):',name.expandtabs(tabsize=6))#将tab键转换为指定个数的空格
print("name.find('a'):",name.find('a'))#找出指定字母的指针
print("name[name.find('a'):]:",name[name.find('a'):])#切片
name2='hello {haha} world'
print('name2:',name2)
print("name2.format(haha='enen'):",name2.format(haha='enen'))
print("name2.format_map({'haha':'enen'}):",name2.format_map({'haha':'enen'}))#通过字典传参
print("'---'.join(['1','2','3']):",'---'.join(['1','2','3']))#将列表转换为字符串并用制动数据隔开
print("'HINIjijhijHI'.lower():",'HINIjijhijHI'.lower())#将大写变小写
print("'HINIjijhijHI'.lower():",'HINIjijhijHI'.lower())
print(r'\nHINIjijhijHI','\nHINIjijhijHI')
print(r"' \nHINIjijhijHI '.lstrip():",' \nHINIjijhijHI '.lstrip())#去掉最左边的回车键
print(r"' HINIjijhijHI\n '.rstrip():",' HINIjijhijHI\n '.rstrip())#去掉最右边的回车键
print(r"' \nHINIjijhijHI \n'.strip():",' \nHINIjijhijHI \n'.strip())#去掉左右的的回车键和空格键
p=str.maketrans('nbyaneuf','09754216')#通过对应数据对字符串进行替换
print('yuan'.translate(p))
print("'HINIjijhijHI'.replace('H','8',1):",'HINIjijhijHI'.replace('H','8',1))#替换指定个数的字符串内数据
print("'1+2+3+4'.split('+'):",'1+2+3+4'.split('+'))#通过字符串内指定数据对字符串进行分割，分割成列表
print("'Haha'.swapcase():",'Haha'.swapcase())#交换字符串大小写
print("'aha yoy'.title():",'aha yoy'.title())#将字符串换成标题格式，每个单词首字母大写
输出内容：
image.png
列表
name=['haha','enen','lala','yoyo','hengheng','lala']
print(name[0])
print(name[2:4])#切片：顾头不顾尾，包含开头，不包含结束位置
print(name[-1])#取最后一个
print(name[-3:-1])
print(name[-2:])#取最后两个
print(name[:2])#取前面两个
name.append('qq')#插入数据到最后面
print(name)
name.insert(1,'pp')#插入数据到指定位置
print(name)
name[1]='KK'#修改指定位置的数据
print(name)
name.remove('KK')#删除指定数据
print(name)
del name[-1]#删除指定位置数据
print(name)
name.pop(1)#删除指定位置的数据，没有输入下标，默认删除最后一个数据
print(name.index('yoyo'))#查找指定数据的坐标
print(name.count('hengheng'))#查看指定数据的个数
name.reverse()#翻转列表
print(name)
name.sort()#排序(特殊符号，数字，大写字母，小写字母)
print(name)
name_num=[1,2,3,4]
name.extend(name_num)#合并2个列表
print(name,name_num)
name.clear()#清空列表
print(name)
输出内容：
import copy
name=['haha','enen','lala','yoyo',['yuan','jojo'],'hengheng','lala']
print(name[0:-1:2])#切片隔一个打印一个
#print(name[::2])#同上
name2=name.copy()#浅copy，复制第一层，其他的多层数据都是copy的内存地址
name3=copy.deepcopy(name)#深copy，全部复制，复制的就是数据
print(name3)
print(name2)
name[2]='啦啦'
print(name)
print(name2)
print(name3)
name[4][0]='YUAN'
print(name)
print(name2)
print(name3)
输出内容：
image.png
元组
元组和列表差不多，也是存一组数，不过它一旦创建，便不能修改，所以又叫只读列表
它只有2个方法，一个是count，一个是index；
name=('haha','enen','lala')
集合
集合是一个无序的，不重复的数据组合，他的主要作用如下：
去重，把一个列表变成集合，就自动去去重了
关系测试，测试两组数据之间的交集、差集、并集等关系
# Author:haha
list_1=[1,4,2,6,7,9,0,7,4,3,0]
list_1=set(list_1)
print('list1',list_1)
list_2=set([2,3,4,55,7,332])
print('list2',list_2)
list_3=set([0,1])
print('list_3',list_3)
#关系测试
print(list_1.intersection(list_2))#取交集
print('&交集',list_1&list_2)
print(list_1.union(list_2))#并集
print('|并集',list_1|list_2)
print(list_1.difference(list_2))#差集，list_1有，list_2没有的数据
print('1-2:-差集',list_1-list_2)
print(list_2.difference(list_1))#差集，list_2有，list_1没有的数据
print('2-1:-差集',list_2-list_1)
print(list_3.issubset(list_1))#判断list_3是否是list_1的子集
print(list_1.issuperset(list_3))#判断list_1是否是list_3的父集
print(list_1.symmetric_difference(list_2))#对称差集，将list_1、list_2中都互相没有的取都出来
print('^对称差集',list_1^list_2)
#其他遗漏关系
print('----------')
list_4=set([0,3])
print(list_3.isdisjoint(list_4))#判断list3是否和list4有交集，如果有，返回FALSE
list_3.add(999)
print('add 1项',list_3)
list_3.update([5,6,7])
print('update 多项',list_3)
#如果该元素不存在于集合中，则会抛出KeyError；如果存在集合中，则会移除该元素并返回None。
print('remove指定删除元素',list_3.remove(7))
#如果该元素不存在于集合中，则不会抛出KeyError；如果存在集合中，则会移除该元素并返回None。
print('discard指定删除元素',list_3.discard(5))
print('pop随机删除元素，并返回被删除的元素',list_3.pop())
print('len',len(list_3))
print(list_3)
输出结果：
image.png
字典
字典的特性：
·dict是无序的
·key必须是唯一的，所以天生去重
info={
'name':'haha',
'age':12,
'sex':'female'
}
info['name']='enen'#修改现有数据
print(info)
info['ID']='1'#添加数据
print(info)
print(info.keys())#打印所有的key
print(info.values())#打印所有的values
info.setdefault('pp','yoyo')#字典中取key值，能取到就返回value值，没取到，就创建key值，及新value值
print(info)
print('name' in info)#判断指定key是否在字典中
print(info.get('name'))#查找指定key值value，存在打印，不存在，打印none
print(info.get('oo'))
del info['ID']#删除指定key数据
print(info)
info.pop('name')#删除指定key数据
print(info)
输出内容：
image.png
a={'a':'aa','b':'bb','c':'cc'}
b={'a':'haha',1:11,2:22}
a.update(b)#将b合并大a中，如果有相同key值，b的value替换a中value值
print(a)
print(a.items())
c=dict.fromkeys([6,7,8],'test')#初始化字典
print(c)
#字典的循环
for i in a:#效率更高
print(i,a[i])
for i,j in a.items():
print(i,j)
输出内容：
image.png
进制转换
二进制数与十六进制数之间如何互相转换
16位表示方法：
十进制数
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
十六进制数
0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F
二进制数
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
二进制转换成十六进制方法：取四合一，如
image.png
16进制的表示法：比BH表示16进制数11；0x53表示16进制53
image.png
在向左(或向右)取四位时，取到最高位(最低位)如果无法凑足四位，就可以在小数点的最左边(或最右边)补0
image.png
十六进制转二进制：一分四
image.png
进制表示
二进制：0b(二进制数) 如：0b10=2(十进制数)
八进制：0o(八进制数) 如：0o10=8(十进制数)
十六进制：0x(十六进制数) 如：0x10=16(十进制数)
十进制：(十进制数) 如：10=10(十进制数)
转换
bin(除二进制数)->二进制
int(除十进制数)->十进制
hex(除十六进制数)->十六进制
oct(除八进制数)->八进制
ord(除ascll码)->ascll码
运算符
'hello'+'world'
#helloworld
[1,2,3]*3
#[1, 2, 3, 1, 2, 3, 1, 2, 3]
3-1
#2
3/2
#1.5
3//2(整除)
#1
5%2(求余)
#1
5**2(平法)
#25
5**5(次方)
#3125
赋值运算符(先计算再赋值)
=、-=、+=、=、/=、//=、%=、*=
逻辑运算符
优先级：
高：not(反)
中：and(且) 遇假为假
低：or(或) 遇真为真
位运算符(把数字当做二进制进行计算)
&(按位与)->10&11->10 见0是0
|(按位或)->10|11->11 见1是1
^(按位异或)
~(按位取反)
<
>>(右移动)
文件操作
对文件操作流程
1、打开文件，得到文件句柄并复制给一个变量
2、通过句柄对文件进行操作
3、关闭文件
#读文件
file=open('buweixia','r',encoding='utf-8')#文件句柄,默认读模式
data=file.read()#执行后文件指针已经知道文件末尾
data2=file.read()#所以data2为空
print(data)
print('---data2---',data2)
file.close()
file6=open('buweixia2','rb')#以二进制模式读取文件
print(file6.readline().strip())
print(file6.readline().strip())
file6.close()
#写文件
file2=open('buweixia2','w',encoding='utf-8')#使用写模式，是创建，如果文件存在，就会覆盖之前内容，如果文件不存在，就会创建文件
file2.write('不谓侠\n')
file2.write('歌词\n')
file2.close()
file7=open('buweixia2','wb')#以二进制模式写文件
file7.write('编曲：潮汐-tide\n')
file7.close()
#可读可写
file5=open('buweixia2','r+',encoding='utf-8')#使用读写模式，是创建，如果文件不存在，就会创建文件
print(file5.readline().strip())
print(file5.readline().strip())
file5.write('不谓侠\n')
file5.write('歌词\n')
file5.close()
#追加文件
file3=open('buweixia2','a',encoding='utf-8')#使用追加模式，是创建，如果文件不存在，就会创建文件
file3.write('词：迟意 ')
file3.write('曲：潮汐-tide\n')
file3.close()
file4=open('buweixia','r',encoding='utf-8')#文件句柄,默认读模式
#打印前5行内容
print('------打印前5行内容------')
for i in range(5):
print(file4.readline().strip())
#循环文件,大文件的话，占内存
print('--------循环文件，操作第10行---------')
for index,line in enumerate(file4.readlines()):
if index==9:
print('-----分割线-------')
continue
print(line.strip())
#高效循环文件，不占内存
file4=open('buweixia','r',encoding='utf-8')#文件句柄,默认读模式
count=0
for line in file4:
if count==9:
print('-----分割线-------')
count += 1
continue
count+=1
print(line.strip())
file=open('buweixia','r',encoding='utf-8')#文件句柄,默认读模式
print(file.tell())#打印当前指针的位置
print(file.read(5))#指定读取文件字符个数
print(file.tell())
file.seek(22)#移动指针到文件开头位置
print(file.readline())
print(file.encoding)#打印文件的编码格式
print(file.name)#打印文件名
print(file.flush())#实时更新硬盘数据
#例：
import sys,time
for i in range(10):
sys.stdout.write('#')
sys.stdout.flush()
time.sleep(0.1)
file.truncate(10)#没有参数，就清空文件；有参数，就从指定指针位置截断文件
#修改文件
f1=open('buweixia','r',encoding='utf-8')
f_new=open('buweixia_update','w',encoding='utf-8')
for line in f1:
if '潮汐-tide' in line:
line=line.replace('潮汐-tide','haha')
f_new.write(line)
f1.close()
f_new.close()
with:为了避免文件打开后忘记关闭，就通过with管理上下文
#可以同时打开多个文件
with open('buweixia','r',encoding='utf-8') as f,\
open('buweixia','r',encoding='utf-8') as f2:
for line in f:
print(line)
print(f2.readline())
函数
编程语言中的函数定义：函数是逻辑结构化和过程化的一种编程方法。
#python中函数定义方法
def test(x):
'The function definitions'
x+=1
return
'''
def:定义函数的关键字
test：函数名
()：内可定义形参
'':函数描述(非必要，但是强烈建议为你的函数添加描述信息)
x+=1：泛指代码块或程序处理逻辑
return:定义返回值
'''
使用函数的三大优点：
1、代码重用
2、保持一致
3、可扩展性
函数的返回值：
返回值数=0；返回None
返回值数=1；返回object
返回值数>0；返回tuple
传参
#默认参数特点：调用函数的时候，默认参数非必须传递
def test1(x=1):
print('test1',x)
test1()
#输出：1
#接收N个位置参数，转换成元组形式
def test2(*args):
print(args)
print(type(args))
test2(1,2,3,4)
test2(*[1,2,3,4,5])
#输出：(1, 2, 3, 4)
#
# (1, 2, 3, 4, 5)
#
#**kwargs:把N个关键字参数，转换成字典的方式
def test3(name,age=18,**kwargs):
print(name)
print(age)
print(kwargs)
test3('haha',sex= 'm',hobby='testing')
#输出：
# haha
# 18
# {'sex': 'm', 'hobby': 'testing'}
def test4(**kwargs):
print(kwargs)
test4(**{'name':'haha','sex':'m'})
#输出：{'name': 'haha', 'sex': 'm'}
局部变量和全局变量
在子程序中定义的变量为局部变量，在程序的一开始定义的变量为全局变量
全局变量的作用域是整个程序，局部变量作用域是定义该变量的子程序
当全局变量与局部变量同名时，在定义局部变量的子程序内，局部变量起作用，在其他地方全局变量起作用
#局部变量，所在函数就是这个变量的作用域
def test1(name):
print('before change %s'%name)
name='HAHA'
print('after change %s'%name)
name='haha'
test1(name)
print(name)
#输出：
# before change haha
# after change HAHA
# haha
#全局变量
def test2():
global name #申明变量的类型
print('before change %s'%name)
name='HAHA'
print('after change %s'%name)
name='haha'#全局变量
test2()
print(name)
#输出：
# before change haha
# after change HAHA
# HAHA
递归
在函数内部，可以调用其他函数，如果一个函数在内部调用自己本身，这个函数就是递归函数
递归特性：
必须有一个明确的结束条件
每次进入更深一层递归时，问题规模相比上次递归都应有所减少
递归效率不高，递归层次过高会导致栈溢出
def test(n):
print(n)
if int(n/2)>0:
return test(int(n/2))
print("->",n)
test(10)
#输出：
# 10
# 5
# 2
# 1
# -> 1
高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另外一个函数作为参数，这种函数就叫高阶函数
def add(a,b,f):
return f(a)+f(b)
res=add(2,-6,abs)#abs为取绝对值
print(res)
#输出：8
装饰器
定义：本质是函数，装饰其他函数就是为其他函数添加附加功能
原则：
不能修改被装饰的函数的源代码
不能修改被装饰的函数的调用方式
简单装饰器：
import time
def timer(func):
def wrapper():
print('before time',time.time())
func()
print('after time',time.time())
return wrapper
@timer
def test():
time.sleep(1)
print('haha')
test()
复杂装饰器：
username='haha'
passwd='123'
def login(type):
def outwrapper(func):
def wrapper(*args,**kwargs):
if type=='qq':
name=input('your username:')
psd=input('your password:')
if name==username and passwd==psd:
print('welcome...')
return func(*args, **kwargs)
else:print('username or passwd error')
else:
print('还不支持此登录方式！')
return wrapper
return outwrapper
@login(type='qq')
def first_page(name):
print('this is first page ',name)
@login(type='weixin')
def second_page():
print('this is second page ')
first_page('haha')
second_page()
生成器
只有在调用时才会生成相应的数据
只记录当前位置
只有一个next()方法
>>> g = (x * x for x in range(10))
>>> g
at 0x1022ef630>
>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
复杂生成器：
def cals(max):
n=0
a=0
b=1
while n
yield b
a,b=b,a+b
n+=1
return 'done'
print(cals(10))
输出结果：
捕获错误信息：
def cals(max):
n=0
a=0
b=1
while n
yield b
a,b=b,a+b
n+=1
return 'done'
c=cals(6)
while True:
try:
print(next(c))
except StopIteration as s:
print('StopIteration',s.value)
break
输出结果：
1
1
2
3
5
8
StopIteration done
还可通过yield实现在单线程的情况下实现并发运算的效果：
import time
def eat(name):
print('%s,来了，点了包子'%name)
while True:
num=yield
print('%s正在吃了第%s个包子'%(name,num))
def make():
c=eat('A')
c2=eat('B')
c.__next__()
c2.__next__()
print('包子拿来了')
time.sleep(1)
for i in range(8):
time.sleep(1)
print('上了第%s个包子'%i)
c.send(i)
c2.send(i)
make()
输出结果：
A,来了，点了包子
B,来了，点了包子
包子拿来了
上了第0个包子
A正在吃了第0个包子
B正在吃了第0个包子
上了第1个包子
A正在吃了第1个包子
B正在吃了第1个包子
上了第2个包子
A正在吃了第2个包子
B正在吃了第2个包子
上了第3个包子
A正在吃了第3个包子
B正在吃了第3个包子
上了第4个包子
A正在吃了第4个包子
B正在吃了第4个包子
上了第5个包子
A正在吃了第5个包子
B正在吃了第5个包子
上了第6个包子
A正在吃了第6个包子
B正在吃了第6个包子
上了第7个包子
A正在吃了第7个包子
B正在吃了第7个包子
迭代器
可以直接作用于for循环的对象统称为可迭代对象：Iterable
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True
内置方法
print('all:',all([2,0,6]))#数据内，有假，就为假
print('any:',any([2,0,6]))#数据内，有真，就为真
print('bin:',bin(8))#将十进制转为二进制
print('hex:',hex(8))#将十进制转成十六进制
print('oct:',oct(8))#将十进制转成八进制
def test():pass
print('callable:',callable(test))#判断数据是否可以调用
print('chr:',chr(77))#输入ASCII码，找出对应字符
print('ord:',ord('m'))#输入字符，找出对用ASCII码
print('dir:',dir([]))#取出数据有哪些方法
print('eval:',eval("{'name':'haha'}"))#将字符串转成表达式
print('pow:',pow(2,8))#取出指定数据的指定次幂
print('round:',round(2.445,2))#保留几位小数
print('frozenset:',frozenset([1,23,4,3,5,7,1]))#冻结集合，使集合不能更改
输出结果：
all: False
any: True
bin: 0b1000
hex: 0x8
oct: 0o10
callable: True
chr: M
ord: 109
dir: ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
ecal: {'name': 'haha'}
pow: 256
round: 2.44
frozenset: frozenset({1, 3, 4, 5, 7, 23})
a=bytearray('456778',encoding='utf-8')
print(a)
print(a[0])
a[0]=99
print(a)#修改字符串
#输出：
# bytearray(b'456778')
# 52
# bytearray(b'c56778')
res=filter(lambda n:n>5,range(10))#
for i in res:
print(i)
#输出：
# 6
# 7
# 8
# 9
res2 = map(lambda n: n > 5, range(10))#
for i in res2:
print(i)
#输出：
# False
# False
# False
# False
# False
# False
# True
# True
# True
# True
from functools import reduce
res3=reduce(lambda x,y:x+y,range(100))
print(res3)
#输出：
# 4950
a={3:4,-6:3,2:7}
print(sorted(a.items()))#使字典变为列表按key值排序
print(sorted(a.items(),key=lambda x:x[1]))#使字典变为列表按value值排序
#输出：
# [(-6, 3), (2, 7), (3, 4)]
# # [(-6, 3), (3, 4), (2, 7)]
a=[1,2,3,4,5,6]
b=['a','b','c','d']
for i in zip(a,b):
print(i)
#输出：
# (1, 'a')
# (2, 'b')
# (3, 'c')
# (4, 'd')
序列化和反序列化(json、pickle)
用于序列化的两个模块
json，用于字符串 和 python数据类型间进行转换
pickle，用于python特有的类型 和 python的数据类型间进行转换
Json模块提供了四个功能：dumps、dump、loads、load
pickle模块提供了四个功能：dumps、dump、loads、load
import json
data={'a':1,'b':2}
j_str=json.dumps(data)
print(j_str)
j_json=json.loads(j_str)
print(j_json['a'])
with open('./test.txt','w') as f:
json.dump(data,f)
with open('./test.txt','r') as f1:
data_j=json.load(f1)
print(data_j['b'])
#输出结果：
{"a": 1, "b": 2}
1
2
import pickle
data={'a':1,'b':2}
p_str=pickle.dumps(data)
print(p_str)
p_json=pickle.loads(p_str)
print(p_json['a'])
with open('./test.txt','wb') as f:#以二进制形式存入文件
pickle.dump(data,f)
with open('./test.txt','rb') as f1:
data_j=pickle.load(f1)
print(data_j['b'])
#输出结果：
b'\x80\x03}q\x00(X\x01\x00\x00\x00aq\x01K\x01X\x01\x00\x00\x00bq\x02K\x02u.'
1
2
671
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
