python如何对model序列化

目录

• 列表 list

• 1 列表简介
• 2 列表的方法
• 3 列表对象支持的运算符
• 4 部分内置函数对列表的操作

• 元组 tuple

• 1 元组简介
• 2 元组与列表的异同点

• 字符串 str
• 字典 dict反映对应关系的映射类型

• 1 字典简介
• 2 字典的基本操作

• 21 创建字典
• 22 字典元素的访问
• 23 常用字典方法
• 24 例子词频统计

• 集合 set

• 1 集合简介
• 2 集合操作与运算

• 21 set
• 22 集合元素增加与删除
• 23 集合的运算

• 总结

1 列表 list

1.1 列表简介

• 列表（list）是最重要的Python内置对象之一，是包含若干元素的有序连续内存空间。
• Python列表的内存自动管理功能可以大幅度减少程序员的负担，但插入和删除非尾部元素时涉及到列表中大量元素的移动，会影响效率。
• 在形式上，列表的所有元素放在一对方括号[]中，相邻元素之间使用英文逗号分隔。
• 在Python中，同一个列表中元素的数据类型可以各不相同，可以同时包含整数、实数、字符串等基本类型的元素，也可以包含列表、元组、字典、集合、函数以及其他任意对象。
• 如果只有一对方括号而没有任何元素则表示空列表。
• Python采用基于值的自动内存管理模式，变量并不直接存储值，而是存储值的引用或内存地址，这也是python中变量可以随时改变类型的重要原因。同理，Python列表中的元素也是值的引用，所以列表中各元素可以是不同类型的数据。即，Python列表中元素存储的是地址而不是值。

1.2 列表的方法

1. list()
   使用list()函数把元组、range对象、字符串、字典、集合或其他可迭代对象转换为列表。

# (1)将元组转换为列表
>>> list( (3,5,7,9,11) )               
[3, 5, 7, 9, 11]

# (2-1)将字符串转换为列表
>>> list( 'hello world' )               
['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

# (2-2)将字符列表转换为字符串
>>> ''.join(['e', 't', 'ffffff', 'k', '.', 'h', 'l'])
'etffffffk.hl'

# (3)将集合转换为列表
>>> list( {3,7,5} )                     
[3, 5, 7]

# (4-1)将字典的“键”转换为列表
>>> list( {'a':3, 'b':9, 'c':78} )      
['a', 'c', 'b']

# (4-2)将字典的“键:值”对转换为列表
>>> list( {'a':3, 'b':9, 'c':78}.items() )
[('b', 9), ('c', 78), ('a', 3)]

# (5)将range对象转换为列表
>>> list( range(1, 10, 2) )             
[1, 3, 5, 7, 9]

# (6)创建空列表
>>> x = list()

1.3 列表对象支持的运算符

（1）加法运算符 +

• 可以实现列表增加元素的目的，但不属于原地操作，而是返回新列表，涉及大量元素的复制，效率非常低。
• 使用复合赋值运算符+=实现列表追加元素时属于原地操作，与append()方法一样高效。

>>> x = [1, 2, 3]
>>> id(x)
53868168

#连接两个列表
>>> x = x + [4]                        
>>> x
[1, 2, 3, 4]
>>> id(x)                              #内存地址发生改变
53875720

#为列表追加元素
>>> x += [5]                           
>>> x
[1, 2, 3, 4, 5]
>>> id(x)                              #内存地址不变
53875720

（2）乘法运算符 *

• 可以用于列表和整数相乘，表示序列重复，返回新列表。
• 运算符*=也可以用于列表元素重复，属于原地操作。

1.4 部分内置函数对列表的操作

2 元组 tuple

2.1 元组简介

• 从形式上，元组的所有元素放在一对圆括号中，元素之间使用逗号分隔，如果元组中只有一个元素则必须在最后增加一个逗号。
• 很多内置函数的返回值也是包含了若干元组的可迭代对象，例如enumerate()、zip()等等
• 列表和元组都属于有序序列，都支持使用双向索引访问其中的元素

• tuple()方法将其他序列转化为元组
• count()方法统计指定元素的出现次数和
• index()方法获取指定元素的索引
• len()、map()、filter()等大量内置函数和+、+=、in等运算符也都可以作用于列表和元组。

• 元组属于不可变（immutable）序列，不可以直接修改元组中元素的值，也无法为元组增加或删除元素。

• 元组没有提供append()、extend()和insert()等方法，无法向元组中添加元素；同样，元组也没有remove()和pop()方法，也不支持对元组元素进行del操作，不能从元组中删除元素，而只能使用del命令删除整个元组。
• 元组也支持切片操作，但是只能通过切片来访问元组中的元素，而不允许使用切片来修改元组中元素的值，也不支持使用切片操作来为元组增加或删除元素。

2.2 元组与列表的异同点

• Python的内部实现对元组做了大量优化，访问速度比列表更快。如果定义了一系列常量值，主要用途仅是对它们进行遍历或其他类似用途，而不需要对其元素进行任何修改，那么一般建议使用元组而不用列表。
• 元组在内部实现上不允许修改其元素值，从而使得代码更加安全，例如调用函数时使用元组传递参数可以防止在函数中修改元组，而使用列表则很难保证这一点。

3 字符串 str

4 字典 dict：反映对应关系的映射类型

4.1 字典简介

• 字典（dictionary）是包含若干“键:值”元素的无序可变序列，字典中的每个元素包含用冒号分隔开的“键（索引）”和“值（数据）”两部分，表示一种映射或对应关系，也称关联数组。定义字典时，每个元素的“键”和“值”之间用冒号分隔，不同元素之间用逗号分隔，所有的元素放在一对大括号“｛｝”中。
• 字典中元素的“键”可以是Python中任意不可变数据，例如整数、实数、复数、字符串、元组等类型等可哈希数据，但不能使用列表、集合、字典或其他可变类型作为字典的“键”。
• 另外，字典中的“键”不允许重复，而“值”是可以重复的。

4.2 字典的基本操作

4.2.1 创建字典

（1）使用赋值运算符“=”将一个字典赋值给一个变量即可创建一个字典变量。

>>> aDict = {'server': 'db', 'database': 'mysql'}

（2）也可以使用内置类dict以不同形式创建字典。

>>> x = dict() # 空字典
>>> type(x)    # 查看对象类型
<class 'dict'>

>>> x = {}     # 空字典

>>> keys = ['a', 'b', 'c', 'd']
>>> values = [1, 2, 3, 4]
# 根据已有数据创建字典
>>> dictionary = dict( zip(keys, values) )

# 对字典(无序序列)进行for遍历,相当于对键进行遍历
>>> [ k for k in dictionary ]
['c', 'b', 'd', 'a']

4.2.2 字典元素的访问

• 字典中的每个元素表示一种映射关系或对应关系，根据提供的“键”作为下标就可以访问对应的“值”，如果字典中不存在这个“键”会抛出异常。
• 字典的键具有唯一性，值可以重复。
• 按键key访问，推荐dict.get( key )方法。

>>> aDict = {'age': 39, 'name': 'Dong', 'sex': 'male'}
>>> aDict['age']     #指定的“键”存在，返回对应的“值”
39
>>> aDict['age'] = 18                #修改元素值
>>> aDict['address'] = "XI'AN"       #添加新元素

4.2.3 常用字典方法

4.2.4 例子：词频统计

#!/usr/bin/env python
# -*- coding:utf8 -*-

"""
用 Python 实现函数 count_words()，该函数输入字符串 s 和数字 n，返回 s 中 n 个出现频率最高的单词。
返回值是一个元组列表，包含出现次数最高的 n 个单词及其次数,
即 [(<单词1>, <次数1>), (<单词2>, <次数2>), ... ]，按出现次数降序排列。

您可以假设所有输入都是小写形式，并且不含标点符号或其他字符（只包含字母和单个空格）。
如果出现次数相同，则按字母顺序排列。

例如：print count_words("betty bought a bit of butter but the butter was bitter",3)

输出：[('butter', 2), ('a', 1), ('betty', 1)]

@author: 
"""

def count_words(s, n):
    """Return the n most frequently occuring words in s."""

    sList = s.split(sep = ' ')      # 拆分字符串，得到单词列表

    top = dict()        # 单词：次数 字典
    sSet = set(sList)
    for word in sSet:
        word_n = 0      # word 出现的次数
        for i in range( len(sList) ):
            if word == sList[i]:
                word_n += 1
            top[word] = word_n

    # topAll: list[tuple]
    topAll = list(top.items())          

    # 按出现次数排序。如果出现次数相同，则按字母顺序排列。
    topAll.sort( key = lambda x:( -x[1], x[0]) )

    return topAll


def test_run():
    print( count_words("cat bat mat cat bat cat", 3) )
    print( count_words("betty bought a bit of butter but the butter was bitter", 3) )
    print( count_words('london bridge is falling down falling down falling down london bridge is falling down my fair lady', 5))

if __name__ == '__main__':
    test_run()

# 输出
[('cat', 3), ('bat', 2), ('mat', 1)]
[('butter', 2), ('a', 1), ('betty', 1), ('bit', 1), ('bitter', 1), ('bought', 1), ('but', 1), ('of', 1), ('the', 1), ('was', 1)]
[('down', 4), ('falling', 4), ('bridge', 2), ('is', 2), ('london', 2), ('fair', 1), ('lady', 1), ('my', 1)]

5 集合 set

5.1 集合简介

• 是数学上的集合
• 集合（set）属于Python**无序可变序列**，使用一对大括号作为定界符，元素之间使用逗号分隔，同一个集合内的每个元素都是唯一的，元素之间不允许重复。
• 集合中只能包含数字、字符串、元组等不可变类型（或者说可哈希）的数据，而不能包含列表、字典、集合等可变类型的数据。

5.2 集合操作与运算

5.2.1 set()

• set()函数将列表、元组、字符串、range对象等其他可迭代对象转换为集合，如果原来的数据中存在重复元素，则在转换为集合的时候只保留一个；如果原序列或迭代对象中有不可哈希的值，无法转换成为集合，抛出异常。

# 把range对象转换为集合
>>> a_set = set(range(8, 14))
>>> a_set
{8, 9, 10, 11, 12, 13}

# 转换时自动去掉重复元素
>>> b_set = set( [0, 1, 2, 3, 0, 1, 2, 3, 7, 8] )   
>>> b_set
{0, 1, 2, 3, 7, 8}

#空集合（唯一方法）
>>> x = set()

5.2.2 集合元素增加与删除

• 使用集合对象的add()方法可以增加新元素，如果该元素已存在则忽略该操作，不会抛出异常；
• update()方法用于合并另外一个集合中的元素到当前集合中，并自动去除重复元素。

>>> s = {1, 2, 3}
# 添加元素，重复元素自动忽略
>>> s.add(3)                        
>>> s
{1, 2, 3}
# 更新当前字典，自动忽略重复的元素
>>> s.update({3,4})                  
>>> s
{1, 2, 3, 4}

• pop()方法用于随机删除并返回集合中的一个元素，如果集合为空则抛出异常；
• remove()方法用于删除集合中的元素，如果指定元素不存在则抛出异常；
• discard()用于从集合中删除一个特定元素，如果元素不在集合中则忽略该操作；
• clear()方法清空集合删除所有元素。

# 删除元素，不存在则忽略该操作
>>> s.discard(5)
>>> s
{1, 2, 3, 4}
# 删除元素，不存在就抛出异常
>>> s.remove(5)
KeyError: 5
# 删除并返回一个元素
>>> s.pop()
1

5.2.3 集合的运算

---

总结