python的数据类型：列表 元组 字典 集合 字符串

一、列表部分：（可变数据类型）

查找

lst.index(value [, begin[, end]]) 返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误

lst.count(x) 用于统计某个元素在列表中出现的次数

lst.pop([index]) 删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系

修改

lst.insert(index, obj) | 将某个元素插放到列表中指定的索引位置

lst.extend(lst) | 向列表追加另一个列表

lst.remove(x) | 从列表中删除第一次出现在列表中的值，并不是删除特定的索引

When you specify a on the left side of the = operator, you are using Python's normal assignment, which changes the name a in the current context to point to the new value. This does not change the previous value to which a was pointing. By specifying a[0:2] on the left side of the = operator, you are telling Python you want to use slice assignment. Slice assignment is a special syntax for lists, where you can insert, delete, or replace contents from a list:

a = [1, 2, 3, 4, 5, 6, 7, 8]
for i in a[:]:  # 使用列表切片
    if i > 5:
        pass
    else:
        a.remove(i)  # 注意这里remove删除元素后，整个列表的元素会往前移动，i是在最初就已经确定了，是不断增加的，所以要在前面使用a[:],不要用b=a for i in 这样的浅拷贝哦，明白了吗:)
print(a)

lst.clear() 清空列表,等同于 L[:] = []

lst.sort(reverse=False) 将列表中的元素进行排序，默认顺序按值的小到大的顺序排列

lst.reverse() 列表的反转，用来改变原列表的先后顺序

拷贝

lst.copy() 复制此列表（只复制一层，不会复制深层对象)

列表的其他操作：

两个列表的全排列,类似两个列表的连接

# 两个列表的全排列,类似两个列表的连接
list01 = []
list02 = ["香蕉", "苹果", "哈密瓜"]
list03 = ["可乐", "牛奶"]
for r in list02:
    for c in list03:
        list01.append(r + c)
print(list01)

list04 = ["香蕉", "苹果", "哈密瓜"]
list05 = ["可乐", "牛奶"]
print(list04 + list05)

"""
['香蕉可乐', '香蕉牛奶', '苹果可乐', '苹果牛奶', '哈密瓜可乐', '哈密瓜牛奶']
['香蕉', '苹果', '哈密瓜', '可乐', '牛奶']

"""


# 列表相连
list02 = [101, 102, 103]
list03 = ["张三丰", "张无忌", "赵敏"]
list04 = ["1", "5", "3"]
for item in zip(list02, list03, list04):
    print(item)
# 自己定义,两个列表相连
print("****************")
def my_zip(list02, list03):
    for index in range(len(list02)):
        yield (list02[index], list03[index])
for item in my_zip(list02, list03):
    print(item)


"""
(101, '张三丰', '1')
(102, '张无忌', '5')
(103, '赵敏', '3')
****************
(101, '张三丰')
(102, '张无忌')
(103, '赵敏')

"""

# 把列表转换成字符串并拼合在一起
ls1 = ['a', 1, 'b', 2]
ls2 = [str(i) for i in ls1]
# 字符串转换后ls2的结果为： ['a', '1', 'b', '2']
ls3 = ''.join(ls2)
print(ls3)
# 结果：'a1b2'

列表 lambda及 filter map reduce 

---filter(function, sequence)：对sequence中的item依次执行function(item)，将执行结果为True的item组成一个List/String/Tuple（取决于sequence的类型）。
---filter(function or None, sequence) ：入参为函数和列表/元组/字符串，返回值为item列表/元组/字符串。
---map(function, sequence) ：对sequence中的item依次执行function(item)，将执行结果function(item)组成一个List返回。
---map(function, sequence[, sequence, ...])：入参是为函数和列表/元组/字符串，返回值为function(item)列表。
---reduce(function, sequence, starting_value)：对sequence中的item顺序迭代调用function，如果有starting_value，还可以作为初始值调用。function接收的参数个数只能为2，先把sequence中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给function，然后只返回一个结果。
---reduce(function, sequence[, initial])：入参是为函数和列表/元组/字符串和初始值，返回值为数值。

# lambda用法，冒号之前的是入参，冒号之后的是表达式，返回的值，最简单的函数
print([(lambda x: x * x)(x)for x in range(11)])
# 结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 用filter条件过滤实现取出奇数
from functools import reduce
def odd(x):
    return x % 2
temp = range(10)
show = filter(odd, temp)
print(list(show))  # 结果： [1, 3, 5, 7, 9]

# 用filter实现取出奇数,改进一下
show = filter(lambda x: x % 2, range(10))
print("列表结果：",list(show))

lst = []
res = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6])
# print("=====>", list(res))
for i in res:
    lst.append(i)
print("结果1：", lst)

# 等价于下面的列表推导式：
lis = [x for x in [1, 2, 3, 4, 5, 6] if x % 3 == 0]
print("结果2：", lis)

# filter用法:返回执行结果为TRUE的入参（入参是列表、字符、元组,就是返回range(10)里的数值）
a = filter(lambda x: x * x - 4, range(10))
print(list(a))
# 结果：[0, 1, 3, 4, 5, 6, 7, 8, 9]

# map的用法：对列表入参依次执行函数。入参为列表，有多少个列表，就应该有多少个入参。
a = map(lambda x: x * x - 4, range(10))
print(list(a))
# 返回lambda函数计算的结果：[-4, -3, 0, 5, 12, 21, 32, 45, 60, 77]
b = map(lambda x, y: x * y - 4, range(3), [8, 9, 10])
print(list(b))
# 返回lambda函数计算的结果：结果：[-4, 5, 16]

# reduce用法：先导入from functools import reduce
# 把sequence中第一个值和第二个值当参数传给function，
# 再把function的返回值和第三个值当参数传给fuction,最终返回一个结果值,
# 接收的入参个数只能为2个
a = reduce(lambda x, y: x * y - 4, range(4))
print(a)  # 0 1-->-4 2-->-12 3 -->-40
# 结果：-40

# 计算0到100的和
b = reduce(lambda x, y: x + y, range(101))
print(b)
# 结果：5050

c = reduce(lambda x, y: x + y, range(101), 100)
print(c)
# 结果：5150

filter map reduce的更多例子：

li = []
for x in range(5):
    li.append(lambda x: x ** 2)
    # 输出每个数的平方
    print(li[0](x))
# 使用li列表里第1个函数，因为循环的x并没有传递给lambda里面的x ，只是让它生成多个x ** 2函数
print(li[0](2))
    
# 把参数添加到lambda函数提供的未知参数y中求和
def new_func(x):
    return lambda y: x + y
t = new_func(3)
u = new_func(2)
print(t(5))
print(u(3))

print('=============================')
# filter()方法用于根据一定的条件对给定的列表进行过滤
my_list = [2, 3, 4, 5, 6, 7, 8]
new_list = list(filter(lambda a: (a / 3 == 2), my_list))
print(new_list)
# map()函数是一个将给定的列表的值依次在所定义的函数关系中迭代并返回一个新列表
my_list = [2, 3, 4, 5, 6, 7, 8]
new_list = list(map(lambda a: (a / 3 != 2), my_list))
print(new_list)
# reduce()函数会对参数序列中元素进行累积(两两累加和)
from functools import reduce

res = reduce(lambda a, b: a + b, [2, 5, 10, 3])
print(res)

# 列表 使用 lambda
li = []
for x in range(5):
    li.append(lambda x: x ** 2)
    # 输出每个数的平方
    # print(li[0](x))
print(li)
# 1 ()中的lambda与for搭配 生成器，有一个函数
li2 = []
li2.append(lambda: x for x in range(5))
print(li2) # li2 生成器，下面依次输出1,2,3
print(next(li2[0])())
print(next(li2[0])())
print(next(li2[0])())
# 2 []中的lambda与for搭配  不是生成器，有10个函数,但结果都一样，
# 输出不了循环的各个数值的计算结果,输出的是10个函数(return x )地址
li3 = [lambda: x for x in range(10)]
print(li3)
print(li3[0]())
print(li3[1]())

列表推导式 

# 列表推导式的if else与for循环结合使用：
data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
test = [data[i] + 2 if (i + 1) % 2 == 0 else data[i] for i in range(len(data))]
print(test)

# 列表推导式1，只有if的：
data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
test = [item for item in data if item % 2 == 0]
print(test)
# 列表推导式2，有if else的:
infos = ['2室1厅', '|', '89.9㎡', '|', '中层（共18层）', '|', '南向']
a = [x if '厅' in x else None for x in infos]
print(a)
# 得到一个数组，不好解决，可直接用列表推导式1的方式：
b = [x for x in infos if '厅' in x]
print(b)


# 生成器表达式（小括号与中括号有区别）
list01 = [2, 3, 4, 5, 8]
result = (i ** 2 for i in list01)  # 生成式推导式返回一个生成器
# result = [i ** 2 for i in list01]  # 列表推导式返回一个已经计算好的列表
print(result)
for item in result:
    print(item)

# 生成器表达式  和上面的一样
list01 = [2, 3, 4, 5, 8]

def fun01(target):
    for item in target:
        yield item ** 2
print(fun01(list01))
for item in fun01(list01):
    print(item)

列表去重后，还按原来的顺序排列输出 

# 单个列表去重后，还按原来的顺序排列
lst = ['cc', 'bbbb', 'afa', 'sss', 'bbbb', 'cc', 'shafa']
lst_new = list(set(lst)) # 列表去重后，无序
lst_new.sort(key=lst.index)# 列表还按原来的顺序排列
print(lit_new)
# 结果：['cc', 'bbbb', 'afa', 'sss', 'shafa']

二、元组部分：（不可变数据类型）

len(tuple)
计算元组元素个数

max(tuple)
返回元组中元素最大值

min(tuple)
返回元组中元素最小值

tuple(iterable)
将可迭代系列转换为元组

# 元组有索引,元组也是一个序列,元组是不可变的
a = (2, 'b', 8, 'aa')
print(a[2])
tup = (50) # 类型为int
tup = (50,) # 类型为元组

# 组合元组
tup1 = "a","b"
tup2 = 1,2
tup3 = tup1 + tup2

# 删除元组
del tup

三、字典部分：（可变数据类型/映射类型）

查找

get(key, default=None)
返回指定键的值，如果值不在字典中返回default值

setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

popitem()
随机返回并删除字典中的一对键和值(一般删除末尾对)。

items()
以列表返回可遍历的(键, 值) 元组数组

keys()
返回一个迭代器，可以使用 list() 来转换为列表

values()
返回一个迭代器，可以使用 list() 来转换为列表

修改

update(dict2)
字典记录的累加，即：把一个字典追加到另一个字典当中去

clear()
删除字典内所有元素

字典键值对互换： 

dic = {"name":"Felix"}
a = {v: k for k, v in dic.items()} 
print(a)

字典清空： 

# 字典清空：D.clear()与 D = {} 区别
# {}清空
dict1 = {1: 'one', 2: "two", 3: "three"}
dict2 = dict1
print(id(dict1), id(dict2))
dict1 = {}
print(dict1, dict2)
print(id(dict1), id(dict2))
# 结果：
# 139677776724800 139677776724800
# {} {1: 'one', 2: 'two', 3: 'three'}
# 139677776724864 139677776724800
print("--------------分割线---------------")

# clear()清空
dict3 = {1: 'one', 2: "two", 3: "three"}
dict4 = dict3.copy()  # 浅拷贝：深拷贝父对象(一级目录)，子对象(二级目录)不拷贝，还是引用，clear()后一个不为空
# dict4 = dict3  # 浅拷贝: 引用对象 , 与上面有区别,id是相同的，clear()执行后都为空
dict3.clear()
print(id(dict3), id(dict4))
print(dict3, dict4)
# 结果：
# 140601913161856 140601914059072
# {} {1: 'one', 2: 'two', 3: 'three'}

字典推导式： 

# 字典推导式, 字典拆分并进行拼接
cookie01 = "csrftoken=JfnuMOvgMGZTxtCjvgfZ…6246vb2; username=chengyangkj"
cookies_01 = {i.split("=")[0]: i.split("=")[1] for i in cookie01.split("; ")}
print(cookies_01)

cookie02 = {'PHPSESSID': 'ef8bm150c3i50edqbtdv7i8282'}
cookie_02 = {i: cookie02[i] for i in cookie02.keys()}
print(cookie_02)

cookies03 = "snmc=1; _snsr=baidu%7Cbrand%7C%7Ctitle%7C%25E8%258B%258F%25E5%25AE%2581%25E6%2598%2593%25E8%25B4%25AD*%3A*brand; _snvd=1618085790482d5TwDNAHW3i; tradeMA=37; streetCode=5510199; SN_CITY=110_551_1000002_9001_01_10008_2_0; cityCode=551; districtId=10008; cityId=9001; _snzwt=TH18ZM178bd6dc765Vtx35501; hm_guid=26dd52f4-5368-4d60-89c1-03fcf3d8e5db; totalProdQty=0; _df_ud=f1eeef60-a60a-433d-93fe-cb277f8c6d32; SN_SESSION_ID=c27d7574-ce34-4341-afa3-55d90e098759; sesab=ACBAABC; sesabv=3%2C12%2C16%2C1%2C2%2C8%2C3; _snma=1%7C161808579006273892%7C1618085790062%7C1618088305512%7C1618089356686%7C22%7C1; _snmp=161808935620315024; _snmb=161808579050356870%7C1618089356719%7C1618089356693%7C22; authId=sijtxkLKcRlzF1OWfcOZeWpEtUH5H7LN6O; secureToken=1A69E01223B7898D3C649AAB12C377FE; token=7c9a5630-8282-4e99-9110-d159998a4d0e"
cookies_03 = {i.split('=')[0]: i.split('=')[1] for i in cookies03.split('; ')}
print(cookies_03)

查找字典的键是否相同： 

# 查找字典里的键是否相同，
class votes:
    def __init__(self):
        self.voted = {}

    def check_vote(self, name):
        if self.voted.get(name):
            print('已经有了')
        else:
            self.voted[name] = 1
            print('没有，加进来')


aa = votes()
aa.check_vote('张三')
aa.check_vote('李四')
aa.check_vote('张三')

将对象当作字典操作：

# 将对象当作字典操作
class MyDict(dict):
    def __init__(self, *args, **kwargs):
        # super(MyDict, self).__init__(*args, **kwargs)
        super().__init__()
        self['wang'] = 55

    # 将对象当作字典操作，设置键值对时会触发该方法. 可以优先使用自己的字典
    def __setitem__(self, k, v):
        self.__dict__[k] = v

    # 将对象当作字典操作，根据键获取值时会触发该方法
    def __getitem__(self, item):
        print("--->",item)
        return self.__dict__.get(item)

    # 将对象当作字典操作，删除指定的键值对时自动触发
    def __delitem__(self, key):
        del self.__dict__[key]


xiaoming = MyDict()
print("查看1：",xiaoming)
xiaoming.__setitem__("bb", 22)
print("查看2：", xiaoming.__getitem__("bb"))
xiaoming['name'] = '小明'
print("***",xiaoming.__dict__)  # 查看所有字典
print(xiaoming['name'])  # 小明
print(xiaoming['wang'])  # 55
del xiaoming['name']  # 删除字典

字典排序：

# 字典排序
import operator

dic = {'aa': 2, 'cc': 3, 'bb': 4}
type(dic)
# a1 = sorted(dic.items(), key=operator.itemgetter(0))
aa = sorted(dic.items(), key=operator.itemgetter(1), reverse=True)  # 按值排序
bb = sorted(dic.items(), key=operator.itemgetter(0), reverse=True)  # 按键排序
print(aa)
print(bb)

# 记住字典添加的顺序
import collections

set1 = {'133', '533', '322'}
a = collections.OrderedDict.fromkeys(set1)
print("a:", a, type(a))
c = collections.OrderedDict(a.items())
print("c:", c, type(c))
print(c.keys())  # 字典的顺序

四、集合部分：（可变数据类型）

update() 给集合添加元素

clear() 移除集合中的所有元素

copy() 拷贝一个集合

pop() 随机移除元素

集合的差集、并集、交集：

a = set('abcdefg')
b = set('abcdh')
print(a,b)
print(a - b)  # 差集， 集合a中包含而集合b中不包含的元素 {'f', 'g', 'e'}
print(a | b)  # 并集， 集合a或b中包含的所有元素 {'b', 'g', 'a', 'e', 'f', 'h', 'c', 'd'}
print(a & b)  # 交集， 集合a和b中都包含了的元素 {'d', 'a', 'c', 'b'}
print(a ^ b)  # 不同时包含于a和b的元素 {'f', 'h', 'g', 'e'}

# difference()	返回多个集合的差集
res1 = a.difference(b)
print("差集:", res1)  # {'f', 'g', 'e'}
# union()	返回两个集合的并集
res2 = a.union(b)  # {'f', 'h', 'b', 'c', 'e', 'a', 'g', 'd'}
print("并集:", res2)
# intersection() 返回集合的交集
res3 = a.intersection(b)  # {'f', 'h', 'b', 'c', 'e', 'a', 'g', 'd'}
print("交集:", res3)  # {'d', 'a', 'c', 'b'}

集合生成字典：

# 把集合生成字典
a = {'133', '533', '322'}
b = {}
b = b.fromkeys(a, 1)  # dict.fromkeys(seq[, value])用于创建一个新字典,value默认为None
print(b,type(b))

五、字符串部分：（不变数据类型）

判断

isspace() 如果字符串中只有空白字符，则返回 True，否则返回 False.

字符串的其他判断函数：

s.isalnum() 所有字符都是数字或者字母(包括汉字），为真返回 True，否则返回 False。
s.isalpha() 所有字符都是字母，为真返回 True，否则返回 False。
s.isdigit() 所有字符都是数字，为真返回 True，否则返回 False。
s.islower() 所有字符都是小写，为真返回 True，否则返回 False。
s.isupper() 所有字符都是大写，为真返回 True，否则返回 False。
s.istitle() 所有单词都是首字母大写，为真返回True，否则返回 False。

startswith(substr, beg=0,end=len(string))

检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

endswith(substr, beg=0, end=len(string))

检查字符串是否以 substr 结尾，如果beg 或者 end 指定，则检查指定的范围内是否以 substr 结束，如果是，返回 True,否则返回 False.

查找

find(str, beg=0 end=len(string))

a = 'abcdefg'

b = a.find("e",0,5) # 找不到，返回-1

检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含则返回开始的索引值，否则返回-1

rfind(str, beg=0,end=len(string))

类似于 find()函数，不过是从右边开始查找.

count(str, beg= 0,end=len(string))

返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定，则返回指定范围内 str 出现的次数

修改（替换）

replace(old, new [, max])

把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。

lstrip()

截掉字符串左边的空格或指定字符。

rstrip()

删除字符串字符串末尾的空格.

strip([chars])

在字符串上执行 lstrip()和 rstrip()

lower()

转换字符串中所有大写字符为小写.

upper()

转换字符串中的小写字母为大写

swapcase()

将字符串中的字母由大写转换为小写，如果是小写则转换为大写

对齐

center(width, fillchar)

a="abcdefg"
b = a.center(11,'*')
print(b)
# 结果：**abcdefg**

返回一个指定的总宽度的width 居中的字符串，fillchar 为填充的字符，默认为空格。

zfill (width)

返回长度为 width 的字符串，原字符串右对齐，前面填充0

ljust(width[, fillchar])

返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 

其他相关字符串的操作：

 1、字符串格式化操作

# %s ：占位符str()
# %d ：十进制整数，%03d 右对齐，不足左边补0
# %x ： 十六进制
# %f  ：浮点型,%f 默认是输出6位有效数据,%.2f 保留小数点后2位
# %5.3f 其中5代表整个浮点数的长度，3是小数位，只有当字符串的总长度大于5位才起作用.不足5位空格补足，可以用%05.3使用0补足整数位的空格

a = 10
print('a的值：%s' % a)

for i in range(1, 10):
    # 至少三位，不足前面补0
    s = "%03d" % i
    print('这是第' + s + '集')

n = 9999
s = "%04d" % n
assert s == "00123","不相等，错啦"  # 出错
assert s == "9999","错误就显示" # 正确,通过

b = 1.2561
print('浮点数：%05.5f' % b)
# 结果：浮点数：1.25610
print('浮点数：%05.2f' % b)
# 结果：浮点数：01.26

# 顺序填坑：{} 占位符
print('姓名是 {}，年龄是 {}'.format('Tom', 20))
# 下标填坑
print('姓名是:{1}，年龄是:{0}'.format(20, 'Tom'))
# 变量填坑
print('姓名是:{name}，年龄是:{age}'.format(name='Tom', age=20))
# 在字符串的前面加上f 是Python3.6新引入的一种字符串格式化方法
comedian = {'name': 'Tom', 'age': 20}
print(f"The comedian is {comedian['name']}, aged {comedian['age']}.")

# 中间对齐 ^  不足的长度用*表示
print('姓名是:{0:*^11}\n年龄是:{1:*^11}'.format('Tom',20))
# 使用   <左对齐   >右对齐 
print('姓名是:{0:*<11}\n年龄是:{1:*>11}'.format('Tom',20))
# 输出结果：
# 姓名是:Tom********
# 年龄是:*********20

2、判断字符串中存在的中文字符数量 

def get_chinese_char_count(str_target):
    """
        判断字符串中存在的中文字符数量
    :param str_target: 给定一个字符串
    :return: 中文字符的数量
    """
    count_char = 0
    for item in str_target:
        # 汉字的unicode范围是：0x4E00~0x9FA5
        if 0x4e00 <= ord(item) < 0x9fa6:
            count_char += 1
    return count_char
    

3、列出目录中指定字符串的文件 

import os
# 查找是否有te的文件
sub_str = "te"
# 获取当前路径
cur_dir = os.getcwd()
# 获取所有目录及文件
files = os.listdir(cur_dir)
for item in files:
    # 当前的路径与每个文件拼接，如果文件存在成立的话
    if os.path.isfile(os.path.join(cur_dir, item)):
        # 再去判断这个文件是不是包含sub_str字符，如果找不到就返回-1
        if item.find(sub_str) != -1:
            # 如果包含有子字符串则返回文件整个路径，否则返回-1,但不影响后续程序的执行
            print(os.path.join(cur_dir, item))

4、字符串的序列化和反序列化文件 

import pickle
obj = 123, "abcdefg", ["ac", 123], {"key": "value", "key1": "value1"}
print(obj)

# 序列化到文件，以字符串的形式保存
with open(r"1.txt", "wb") as f:
    pickle.dump(obj, f)
# 读取序列化后的文件
with open(r"1.txt", "rb") as f:
    print(pickle.load(f))
# 输出：(123, 'abcdefg', ['ac', 123], {'key': 'value', 'key1': 'value1'})

# 序列化到内存，以字符串格式保存，然后对象可以以任何方式处理如通过网络传输
obj1 = pickle.dumps(obj)
print(type(obj1))  # 输出
print(obj1)  # 输出：python专用的存储格式b'\x80\x04\x95<\x00\x00\x00\x....
# 从内存中读取序列化后的文件
obj2 = pickle.loads(obj1)
print(type(obj2))  # 输出：
print(obj2)  # 输出：(123, 'abcdefg', ['ac', 123], {'key': 'value', 'key1': 'value1'})

5、json（JavaScript Object Notation）字符串和python数据类型间进行转换 

dumps把数据类型转换成字符串， dump把数据类型转换成字符串并存储在文件中。

 loads把字符串转换成数据类型 ，load把文件打开从字符串转换成数据类型。

json是可以在不同语言之间交换数据的，而pickle只在python之间使用。

json只能序列化最基本的数据类型，只能把常用的数据类型序列化（列表、字典、列表、字符串、 数字、），如果是日期格式、类对象，josn就不行了。而pickle可以序列化所有的数据类型，包括类，函数都可以序列化。

# json.dump()和json.load()
# 主要用来读写json文件函数
# 不带s的用于操作文件，带s的用于数据类型的转换。

import json


def store(data):
    with open('1.json', 'w') as f:
        # json.dumps()函数 将python字典格式转化为json字符串
        json_str = json.dumps(data)
        f.write(json_str)
        # 上面两句等同于下面这句
        # json.dump(data, f)


# load json data from file
def load():
    with open('1.json', 'r') as f:
        # 读取json字符串，返回python字典格式
        data = json.load(f)
        # data = json.loads(f.read())
        return data


if __name__ == "__main__":
    json_data = '{"login":[{"username":"aa","password":"001"},{"username":"bb","password":"002"}],"register":[{"username":"cc","password":"003"},{"username":"dd","password":"004"}]}'
    # json.loads()函数将json字符串格式数据转换为字典
    data = json.loads(json_data)
    store(data)

    data = load()
    print(data)
    print(type(data))