py13 json picle configparser模塊

json和pickle

JSON(JavaScript Object Notation, JS 對象標記) 是一種輕量級的數據交換格式。JSON的數據格式其實就是python裏面的字典格式，裏面能夠包含方括號括起來的數組，也就是python裏面的列表。

在python中，有專門處理json格式的模塊—— json 和 picle模塊

Json   模塊提供了四個方法： dumps、dump、loads、load

pickle 模塊也提供了四個功能：dumps、dump、loads、load

json vs pickle:

JSON:

優勢：跨語言、體積小

缺點：只能支持int\str\list\tuple\dict

Pickle:

優勢：專爲python設計，支持python全部的數據類型

缺點：只能在python中使用，存儲數據佔空間大

一. dumps 和 dump:

 dumps和dump序列化方法

       dumps只完成了序列化爲str，

       dump必須傳文件描述符，將序列化的str保存到文件中

查看源碼：

def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
        allow_nan=True, cls=None, indent=None, separators=None,
        default=None, sort_keys=False, **kw):
    # Serialize ``obj`` to a JSON formatted ``str``.
    # 序列號 「obj」 數據類型 轉換爲 JSON格式的字符串 

def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
        allow_nan=True, cls=None, indent=None, separators=None,
        default=None, sort_keys=False, **kw):
    """Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
    ``.write()``-supporting file-like object).
     我理解爲兩個動做，一個動做是將」obj「轉換爲JSON格式的字符串，還有一個動做是將字符串寫入到文件中，也就是說文件描述符fp是必需要的參數 """

示例代碼：

>>> import json
>>> json.dumps([])    # dumps能夠格式化全部的基本數據類型爲字符串
'[]'
>>> json.dumps(1)    # 數字
'1'
>>> json.dumps('1')   # 字符串
'"1"'
>>> dict = {"name":"Tom", "age":23}  
>>> json.dumps(dict)     # 字典
'{"name": "Tom", "age": 23}'

a = {"name":"Tom", "age":23}
with open("test.json", "w", encoding='utf-8') as f:
    # indent 超級好用，格式化保存字典，默認爲None，小於0爲零個空格
    f.write(json.dumps(a, indent=4))
    # json.dump(a,f,indent=4)   # 和上面的效果同樣

保存的文件效果：

二. loads 和 load 

loads和load  反序列化方法

       loads 只完成了反序列化，

       load 只接收文件描述符，完成了讀取文件和反序列化

 查看源碼：

def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
    """Deserialize ``s`` (a ``str`` instance containing a JSON document) to a Python object.
       將包含str類型的JSON文檔反序列化爲一個python對象"""

def load(fp, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):
    """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a JSON document) to a Python object.
        將一個包含JSON格式數據的可讀文件飯序列化爲一個python對象"""

實例：

>>> json.loads('{"name":"Tom", "age":23}')
{'age': 23, 'name': 'Tom'}

import json
with open("test.json", "r", encoding='utf-8') as f:
    aa = json.loads(f.read())
    f.seek(0)
    bb = json.load(f)    # 與 json.loads(f.read())
print(aa)
print(bb)

# 輸出：
{'name': 'Tom', 'age': 23}
{'name': 'Tom', 'age': 23}

三. json 和 pickle 模塊

 json模塊和pickle模塊都有  dumps、dump、loads、load四種方法，並且用法同樣。

不用的是json模塊序列化出來的是通用格式，其它編程語言都認識，就是普通的字符串，

而picle模塊序列化出來的只有python能夠認識，其餘編程語言不認識的，表現爲亂碼

不過picle能夠序列化函數，可是其餘文件想用該函數，在該文件中須要有該文件的定義（定義和參數必須相同，內容能夠不一樣）

注意，pickle,dump接收的文件須要是字節類型

import pickle
data = {'k1':123,'k2':'Hello'}

# pickle.dumps 將數據經過特殊的形式轉換位只有python語言認識的字符串
p_str = pickle.dumps(data)
print(p_str)

#pickle.dump 將數據經過特殊的形式轉換位只有python語言認識的字符串，並寫入文件
with open('D:/result.pk','wb',encoding='utf8') as fp:
    pickle.dump(data,fp)

四. python對象（obj） 與json對象的對應關係

    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

 五. 總結

 1. json序列化方法：

          dumps：無文件操做            dump：序列化+寫入文件

  2. json反序列化方法：

          loads：無文件操做              load： 讀文件+反序列化

  3. json模塊序列化的數據 更通用

      picle模塊序列化的數據 僅python可用，但功能強大，能夠序列號函數

  4. json模塊能夠序列化和反序列化的  數據類型 見  python對象（obj） 與json對象的對應關係表

  5. 格式化寫入文件利用  indent = 4 

 

configparser模塊

ConfigParser模塊在python3中修改成configparser.這個模塊定義了一個ConfigParser類，該類的做用是使用配置文件生效，配置文件的格式和windows的INI文件的格式相同

該模塊的做用 就是使用模塊中的RawConfigParser()、ConfigParser()、 SafeConfigParser()這三個方法（三者擇其一），建立一個對象使用對象的方法對指定的配置文件作增刪改查 操做。

詳見http://www.javashuo.com/article/p-argondam-c.html

讀取配置文件

-read(filename) 直接讀取ini文件內容
-sections() 獲得全部的section，並以列表的形式返回
-options(section) 獲得該section的全部option(key)
-items(section) 獲得該section的全部鍵值對
-get(section,option) 獲得section中option的值(value)，返回爲string類型
-getint(section,option) 獲得section中option的值，返回爲int類型
 

寫入配置文件

-add_section(section) 添加一個新的section
-set( section, option, value) 對section中的option進行設置，option和value必須都是字符串
  須要調用write將內容寫入配置文件。

咱們來看一個很是基本的配置文件，以下所示：

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes

[bitbucket.org]
User = hg

[topsecret.server.com]
Port = 50022
ForwardX11 = no

本質上，該文件由部分組成，每一個部分包含帶值的鍵(鍵值對都必須是字符串)。 configparser類能夠讀寫這些文件。咱們首先以編程方式建立上述配置文件。

import configparser
config = configparser.ConfigParser()
config['DEFAULT'] = {'ServerAliveInterval': '45',
                     'Compression': 'yes',
                     'CompressionLevel': '9'}
config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Port'] = '50022'     # mutates the parser
topsecret['ForwardX11'] = 'no'  # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
    config.write(configfile)

如您所見，咱們能夠將配置解析器視爲字典。稍後概述差別，但行爲很是接近您對字典的指望。

還能夠如此寫帶參數的配置文件

config = ConfigParser.RawConfigParser()
config.set('Section1', 'baz', 'fun')
config.set('Section1', 'bar', 'Python')
config.set('Section1', 'foo', '%(bar)s is %(baz)s!')

如今咱們已經建立並保存了一個配置文件，下面是相似於字典的取值操做

>>> import configparser # 導入模塊
>>> config = configparser.ConfigParser()  #實例化(生成對象)
>>> config.sections()  #調用sections方法
[]
>>> config.read('example.ini')  # 讀配置文件(注意文件路徑)
['example.ini']
>>> config.sections() #調用sections方法(默認不會讀取default)
['bitbucket.org', 'topsecret.server.com']
>>> 'bitbucket.org' in config #判斷元素是否在sections列表內
True
>>> 'bytebong.com' in config
False
>>> config['bitbucket.org']['User'] # 經過字典的形式取值
'hg'
>>> config['DEFAULT']['Compression']
'yes'
>>> topsecret = config['topsecret.server.com']
>>> topsecret['ForwardX11']
'no'
>>> topsecret['Port']
'50022'
>>> for key in config['bitbucket.org']: print(key) # for循環 bitbucket.org 字典的key
...
user
compressionlevel
serveraliveinterval
compression
forwardx11
>>> config['bitbucket.org']['ForwardX11']
'yes'

其餘增刪改查操做

[group1] 
k1 = v1
k2:v2
k3 = 123

[group2]
k1 = v1
##########


import configparser

config = configparser.ConfigParser()
config.read('i.cfg')

# ########## 讀 ##########
secs = config.sections()
print(secs)
options = config.options('group2') # 獲取指定section的keys
print(options)

item_list = config.items('group2') # 獲取指定 section 的 keys & values ,key value 以元組的形式
print(item_list)

val = config.get('group1','k1') # 獲取指定的key 的value
print(val)

val = config.getint('group1','k3')
print(val)
# ########## 改寫 ##########
sec = config.remove_section('group1') # 刪除section 並返回狀態(true, false)
print(sec)
config.write(open('i.cfg', "w")) # 對應的刪除操做要寫入文件纔會生效

sec = config.has_section('wupeiqi')
print(sec)

sec = config.add_section('wupeiqi')
print(sec)
config.write(open('i.cfg', "w")) #


config.set('group2','k1','11111')
config.write(open('i.cfg', "w"))

config.remove_option('group2','age')
config.write(open('i.cfg', "w"))

#############
['group1', 'group2']
['k1']
[('k1', 'v1')]
v1
123
True
False
None

使用add_section時，若是有了要建立的section，則會報錯