python keys模块_Python常用模块

最新推荐文章于 2023-05-05 07:33:50 发布

weixin_39915721

最新推荐文章于 2023-05-05 07:33:50 发布

阅读量1k

点赞数

文章标签： python keys模块

本文链接：https://blog.csdn.net/weixin_39915721/article/details/111746316

版权

一、os模块

os模块是与操作系统交互的一个接口，使用该模块必须先导入该模块。

importos

#操作文件和目录

os.getcwd()#获取当前脚本运行的工作目录路径，'C:\\Users\\Administrator\\代码测试'

os.chdir('C:\\Users\\Administrator\\代码测试') #改变当前脚本的工作目录路径

os.curdir #获取当前工作目录，'.'

os.pardir #返回当前目录的父目录，'..'

os.mkdir("test1") #创建单级目录

os.rmdir("test1") #删除单级空目录，若目录不为空则无法删除，则会报错

os.makedirs('tes2/test3') #生成多层递归目录

os.removedirs('tes2/test3') #若最里面一层目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.listdir('tes2') #获取指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印，['test3']

os.remove('test/1.txt') #删除一个文件

os.rename("test","newtest") #重命名文件/目录

os.stat('tes2/test3') #获取文件/目录信息，os.stat_result(st_mode=16895, st_ino=4785074604532972,

st_dev=3189517348, st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1570541912,

st_mtime=1570541912, st_ctime=1570541912)

#操作文件或者目录路径，使用os.path模块

os.path.abspath('test3') #返回给定的文件或目录的绝对路径输出：'C:\\Users\\Administrator\\代码测试\\test3'

os.path.split('tes2/text3/1.txt') #将path分割成目录和文件名二元组返回输出('tes2/text3', '1.txt')os.path.dirname('tes2/text3/1.txt') #返回path的目录。其实就是os.path.split(path)的第一个元素，输出'tes2/text3'

os.path.basename('tes2/test3/1.txt') #返回path最后的文件名。如果path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素，输出'1.txt'

os.path.join('tes2','test3','test.txt') # 将多个路径组合后返回，输出'tes2\\test3\\test.txt'

os.path.exists('test.txt') #文件存在返回True，否则返回False，注意是文件而非目录

os.path.isdir('tes2') #用来判断给定的path是否是一个目录，如果是目录代表的是最外层的目录

os.path.isfile('test.txt') #用来判断给定的path是否是一个文件输出：True

os.path.getsize('tes2/test3/1.txt') #返回path所指向的文件或者目录的大小

os.path.getatime('tes2/test3/1.txt') #返回path所指向的文件或者目录的最后访问时间，输出1570588470.5294871

os.path.getmtime('tes2/test3/1.txt') #返回path所指向的文件或者目录的最后修改时间输出1570588470.5294871

#os模块的属性

os.name #输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

os.sep # 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

os.linesep #输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"

os.pathsep # 输出用于分割文件路径的字符串 win下为;,Linux下为:

二、sys模块

sys模块是与python解释器交互的一个接口，使用该模块必须先导入该模块。

1、sys.argv 获取当前正在执行的命令行参数的参数列表(list)

#输出

['c:\\users\\administrator\\envs\\automatic\\lib\\site-packages\\ipykernel_launcher.py','-f','C:\\Users\\Administrator\\AppData\\Roaming\\jupyter\\runtime\\kernel-6c1095fc-19fa-4e5e-872b-192b7fcd1c55.json']

sys.argv[]是一个程序获取外部参数的桥梁。sys.argv[0]表示代码本身的文件路径。

2、sys.modules.keys() 返回所有已经导入的模块列表

dict_keys(['traitlets.config.application',

'jupyter_client.blocking.channels',

'IPython.utils.terminal',

'errno',

'jupyter_client.localinterfaces',

'ipywidgets.widgets.valuewidget',

'math',

'datetime',

'IPython.core.magics.basic',

'asyncio.windows_utils',

'IPython.core.completer',

'jupyter_client.connect',

'IPython.core.logger',

'jupyter_client.jsonutil',

'_functools',

'tornado.gen',

'encodings.latin_1',

'uuid',

...

]}

3、sys.path path是一个目录列表，供Python从中查找第三方扩展模块。

['c:\\users\\administrator\\envs\\automatic\\scripts\\python35.zip','c:\\users\\administrator\\envs\\automatic\\DLLs','c:\\users\\administrator\\envs\\automatic\\lib','c:\\users\\administrator\\envs\\automatic\\scripts','e:\\python\\python3.5.2\\progress\\Lib','e:\\python\\python3.5.2\\progress\\DLLs','c:\\users\\administrator\\envs\\automatic','','c:\\users\\administrator\\envs\\automatic\\lib\\site-packages','c:\\users\\administrator\\envs\\automatic\\lib\\site-packages\\pip-19.0.3-py3.5.egg','c:\\users\\administrator\\envs\\automatic\\lib\\site-packages\\win32','c:\\users\\administrator\\envs\\automatic\\lib\\site-packages\\win32\\lib','c:\\users\\administrator\\envs\\automatic\\lib\\site-packages\\Pythonwin','c:\\users\\administrator\\envs\\automatic\\lib\\site-packages\\IPython\\extensions','C:\\Users\\Administrator\\.ipython']

4、sys.exit(0) 调用sys,exit(n)可以中途退出程序，sys.exit(0)表示正常退出，n不为0时，会引发SystemExit异常，从而在主程序中可以捕获该异常。

importsystry:

sys.exit(1)exceptSystemExit as e:print(e) #1

5、sys.version 获取python解释程序的版本信息

>>> importsys>>>sys.version'3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:18:55) [MSC v.1900 64 bit (AMD64)]'

6、sys.platform 返回操作系统平台名称

>>> importsys>>>sys.platform'win32'

>>>

7、sys.stdin, sys.stdout, sys.stderr 标准输入，标准输出，错误输出

标准输入：一般为键盘输入，stdin对象为解释器提供输入字符流，一般使用raw_input()和input()函数

importsysprint("Please input message:")

name=sys.stdin.readline()print(name)#输出

"""Please input message:

hello

hello"""

标准输出：一般为屏幕。stdout对象接收到print语句产生的输出

importsys

sys.stdout.write("hello")

sys.stdout.flush()"""输出：

hello"""

调用python中的print函数，事实上是调用了 sys.stdout.write() ，比如print('hello')，等价于sys.stdout.write(‘hello\n’)，print 将内容打印到了控制台，并且追加了一个换行符。

三、json & pickle模块

上述两个模块都是序列化模块，什么是序列化呢？把对象(变量)从内存中变成可存储或传输的过程称之为序列化。反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

系列化后就可以将数据写入磁盘进行持久化存储。

(一)json模块

r"""JSON (JavaScript Object Notation) is a subset of

JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data

interchange format.

:mod:`json` exposes an API familiar to users of the standard library

:mod:`marshal` and :mod:`pickle` modules. It is derived from a

version of the externally maintained simplejson library.

Encoding basic Python object hierarchies::

>>> import json

>>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])

'["foo", {"bar": ["baz", null, 1.0, 2]}]'

>>> print(json.dumps("\"foo\bar"))

"\"foo\bar"

>>> print(json.dumps('\u1234'))

"\u1234"

>>> print(json.dumps('\\'))

"\\"

>>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True))

{"a": 0, "b": 0, "c": 0}

>>> from io import StringIO

>>> io = StringIO()

>>> json.dump(['streaming API'], io)

>>> io.getvalue()

'["streaming API"]'

Compact encoding::

>>> import json

>>> from collections import OrderedDict

>>> mydict = OrderedDict([('4', 5), ('6', 7)])

>>> json.dumps([1,2,3,mydict], separators=(',', ':'))

'[1,2,3,{"4":5,"6":7}]'

Pretty printing::

>>> import json

>>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4))

{

"4": 5,

"6": 7

}

Decoding JSON::

>>> import json

>>> obj = ['foo', {'bar': ['baz', None, 1.0, 2]}]

>>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj

True

>>> json.loads('"\\"foo\\bar"') == '"foo\x08ar'

True

>>> from io import StringIO

>>> io = StringIO('["streaming API"]')

>>> json.load(io)[0] == 'streaming API'

True

Specializing JSON object decoding::

>>> import json

>>> def as_complex(dct):

... if '__complex__' in dct:

... return complex(dct['real'], dct['imag'])

... return dct

...

>>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',

... object_hook=as_complex)

(1+2j)

>>> from decimal import Decimal

>>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1')

True

Specializing JSON object encoding::

>>> import json

>>> def encode_complex(obj):

... if isinstance(obj, complex):

... return [obj.real, obj.imag]

... raise TypeError(repr(o) + " is not JSON serializable")

...

>>> json.dumps(2 + 1j, default=encode_complex)

'[2.0, 1.0]'

>>> json.JSONEncoder(default=encode_complex).encode(2 + 1j)

'[2.0, 1.0]'

>>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j))

'[2.0, 1.0]'

Using json.tool from the shell to validate and pretty-print::

$ echo '{"json":"obj"}' | python -m json.tool

{

"json": "obj"

}

$ echo '{ 1.2:3.4}' | python -m json.tool

Expecting property name enclosed in double quotes: line 1 column 3 (char 2)"""

__version__ = '2.0.9'

__all__ =['dump', 'dumps', 'load', 'loads','JSONDecoder', 'JSONDecodeError', 'JSONEncoder',

]__author__ = 'Bob Ippolito '

from .decoder importJSONDecoder, JSONDecodeErrorfrom .encoder importJSONEncoder

_default_encoder=JSONEncoder(

skipkeys=False,

ensure_ascii=True,

check_circular=True,

allow_nan=True,

indent=None,

separators=None,

default=None,

)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).

If ``skipkeys`` is true then ``dict`` keys that are not basic types

(``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped

instead of raising a ``TypeError``.

If ``ensure_ascii`` is false, then the strings written to ``fp`` can

contain non-ASCII characters if they appear in strings contained in

``obj``. Otherwise, all such characters are escaped in JSON strings.

If ``check_circular`` is false, then the circular reference check

for container types will be skipped and a circular reference will

result in an ``OverflowError`` (or worse).

If ``allow_nan`` is false, then it will be a ``ValueError`` to

serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)

in strict compliance of the JSON specification, instead of using the

JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).

If ``indent`` is a non-negative integer, then JSON array elements and

object members will be pretty-printed with that indent level. An indent

level of 0 will only insert newlines. ``None`` is the most compact

representation.

If specified, ``separators`` should be an ``(item_separator, key_separator)``

tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and

``(',', ': ')`` otherwise. To get the most compact JSON representation,

you should specify ``(',', ':')`` to eliminate whitespace.

``default(obj)`` is a function that should return a serializable version

of obj or raise TypeError. The default simply raises TypeError.

If *sort_keys* is ``True`` (default: ``False``), then the output of

dictionaries will be sorted by key.

To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the

``.default()`` method to serialize additional types), specify it with

the ``cls`` kwarg; otherwise ``JSONEncoder`` is used."""

#cached encoder

if (not skipkeys and ensure_ascii andcheck_circularand allow_nan andclsis None and indent is None and separators is None anddefaultis None and not sort_keys and notkw):

iterable=_default_encoder.iterencode(obj)else:if cls isNone:

cls=JSONEncoder

iterable= cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,

check_circular=check_circular, allow_nan=allow_nan, indent=indent,

separators=separators,

default=default, sort_keys=sort_keys, **kw).iterencode(obj)#could accelerate with writelines in some versions of Python, at

#a debuggability cost

for chunk initerable:

fp.write(chunk)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``.

If ``skipkeys`` is true then ``dict`` keys that are not basic types

(``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped

instead of raising a ``TypeError``.

If ``ensure_ascii`` is false, then the return value can contain non-ASCII

characters if they appear in strings contained in ``obj``. Otherwise, all

such characters are escaped in JSON strings.

If ``check_circular`` is false, then the circular reference check

for container types will be skipped and a circular reference will

result in an ``OverflowError`` (or worse).

If ``allow_nan`` is false, then it will be a ``ValueError`` to

serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in

strict compliance of the JSON specification, instead of using the

JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).

If ``indent`` is a non-negative integer, then JSON array elements and

object members will be pretty-printed with that indent level. An indent

level of 0 will only insert newlines. ``None`` is the most compact

representation.

If specified, ``separators`` should be an ``(item_separator, key_separator)``

tuple. The default is ``(', ', ': ')`` if *indent* is ``None`` and

``(',', ': ')`` otherwise. To get the most compact JSON representation,

you should specify ``(',', ':')`` to eliminate whitespace.

``default(obj)`` is a function that should return a serializable version

of obj or raise TypeError. The default simply raises TypeError.

If *sort_keys* is ``True`` (default: ``False``), then the output of

dictionaries will be sorted by key.

To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the

``.default()`` method to serialize additional types), specify it with

the ``cls`` kwarg; otherwise ``JSONEncoder`` is used."""

#cached encoder

if (not skipkeys and ensure_ascii andcheck_circularand allow_nan andclsis None and indent is None and separators is None anddefaultis None and not sort_keys and notkw):return_default_encoder.encode(obj)if cls isNone:

cls=JSONEncoderreturncls(

skipkeys=skipkeys, ensure_ascii=ensure_ascii,

check_circular=check_circular, allow_nan=allow_nan, indent=indent,

separators=separators, default=default, sort_keys=sort_keys,**kw).encode(obj)

_default_decoder= JSONDecoder(object_hook=None, object_pairs_hook=None)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.

``object_hook`` is an optional function that will be called with the

result of any object literal decode (a ``dict``). The return value of

``object_hook`` will be used instead of the ``dict``. This feature

can be used to implement custom decoders (e.g. JSON-RPC class hinting).

``object_pairs_hook`` is an optional function that will be called with the

result of any object literal decoded with an ordered list of pairs. The

return value of ``object_pairs_hook`` will be used instead of the ``dict``.

This feature can be used to implement custom decoders that rely on the

order that the key and value pairs are decoded (for example,

collections.OrderedDict will remember the order of insertion). If

``object_hook`` is also defined, the ``object_pairs_hook`` takes priority.

To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``

kwarg; otherwise ``JSONDecoder`` is used."""

returnloads(fp.read(),

cls=cls, object_hook=object_hook,

parse_float=parse_float, parse_int=parse_int,

parse_constant=parse_constant, object_pairs_hook=object_pairs_hook, **kw)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.