[从头学python] 第05节 字符串模块string

本节目标：

(1) 学习标准库ctypes, functools, gettext, io, keyword, itertools, logging, mmap, re, string模块



实现步骤：

对c语言中的类型进行操作

from ctypes import *
>>> dir()
['ARRAY', 'ArgumentError', 'Array', 'BigEndianStructure', 'CDLL', 'CFUNCTYPE', 'DEFAULT_MODE', 'DllCanUnloadNow', 'DllGetClassObject', 'FormatError', 'GetLastError',
'HRESULT', 'LibraryLoader', 'LittleEndianStructure', 'OleDLL', 'POINTER', 'PYFUNCTYPE',
'PyDLL', 'RTLD_GLOBAL', 'RTLD_LOCAL', 'SetPointerType', 'Structure', 'Union', 'WINFUNCTYPE'
, 'WinDLL', 'WinError', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', 'addressof', 'alignment', 'byref', 'c_bool', 'c_buffer', 'c_byte', 'c_char', 'c_char_p',
'c_double', 'c_float', 'c_int', 'c_int16', 'c_int32', 'c_int64', 'c_int8', 'c_long',
'c_longdouble', 'c_longlong', 'c_short', 'c_size_t', 'c_ssize_t', 'c_ubyte', 'c_uint',
'c_uint16', 'c_uint32', 'c_uint64', 'c_uint8', 'c_ulong', 'c_ulonglong', 'c_ushort',
'c_void_p', 'c_voidp', 'c_wchar', 'c_wchar_p', 'cast', 'cdll', 'create_string_buffer',
'create_unicode_buffer', 'get_errno', 'get_last_error', 'memmove', 'memset', 'oledll',
'pointer', 'py_object', 'pydll', 'pythonapi', 'resize', 'set_errno', 'set_last_error',
'sizeof', 'string_at', 'windll', 'wstring_at']

>>> help(ctypes)
Help on package ctypes:

NAME
ctypes - create and manipulate C data types in Python

PACKAGE CONTENTS
_endian
macholib (package)
test (package)
util
wintypes

CLASSES
_ctypes._SimpleCData(_ctypes._CData)
HRESULT
c_bool
c_byte
c_char
c_char_p
c_double
c_float
c_long
c_longlong
c_short
c_ubyte
c_ulong
c_ulonglong
c_ushort
c_void_p
c_wchar
c_wchar_p
py_object
builtins.Exception(builtins.BaseException)
ArgumentError
builtins.object
CDLL
OleDLL
PyDLL
WinDLL
LibraryLoader

包装后的函数工具functools

>>> import functools
>>> dir(functools)
['RLock', 'WRAPPER_ASSIGNMENTS', 'WRAPPER_UPDATES', '_CacheInfo', '_HashedSeq', '__all__',
'__builtins__', '__cached__', '__doc__', '__file__', '__initializing__', '__loader__',
'__name__', '__package__', '_make_key', 'cmp_to_key', 'lru_cache', 'namedtuple', 'partial',
'reduce', 'total_ordering', 'update_wrapper', 'wraps']

>>> help(functools)
Help on module functools:

NAME
functools - functools.py - Tools for working with functions and callable objects

CLASSES
builtins.object
partial

>>> functools.reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])
15

国际化的取文字串

>>> import gettext
>>> dir(gettext)
['Catalog', 'ENOENT', 'GNUTranslations', 'NullTranslations', '__all__', '__builtins__',
'__cached__', '__doc__', '__file__', '__initializing__', '__loader__', '__name__',
'__package__', '_current_domain', '_default_localedir', '_expand_lang', '_localecodesets',
'_localedirs', '_translations', 'bind_textdomain_codeset', 'bindtextdomain', 'c2py', 'copy',
'dgettext', 'dngettext', 'find', 'gettext', 'install', 'io', 'ldgettext', 'ldngettext',
'lgettext', 'lngettext', 'locale', 'ngettext', 'os', 're', 'struct', 'sys', 'textdomain',
'translation']

>>> help(gettext)
Help on module gettext:

NAME
gettext - Internationalization and localization support.

DESCRIPTION
This module provides internationalization (I18N) and localization (L10N)
support for your Python programs by providing an interface to the GNU gettext
message catalog library.

I18N refers to the operation by which a program is made aware of multiple
languages.  L10N refers to the adaptation of your program, once
internationalized, to the local language and cultural habits.

CLASSES
builtins.object
NullTranslations
GNUTranslations

流式输入输出的io

>>> import io
>>> dir(io)
['BlockingIOError', 'BufferedIOBase', 'BufferedRWPair', 'BufferedRandom', 'BufferedReader',
'BufferedWriter', 'BytesIO', 'DEFAULT_BUFFER_SIZE', 'FileIO', 'IOBase',
'IncrementalNewlineDecoder', 'OpenWrapper', 'RawIOBase', 'SEEK_CUR', 'SEEK_END', 'SEEK_SET',
'StringIO', 'TextIOBase', 'TextIOWrapper', 'UnsupportedOperation', '__all__', '__author__',
'__builtins__', '__cached__', '__doc__', '__file__', '__initializing__', '__loader__',
'__name__', '__package__', '_io', 'abc', 'open']

>>> help(io)
Help on module io:

NAME
io

DESCRIPTION
The io module provides the Python interfaces to stream handling. The
builtin open function is defined in this module.

At the top of the I/O hierarchy is the abstract base class IOBase. It
defines the basic interface to a stream. Note, however, that there is no
separation between reading and writing to streams; implementations are
allowed to raise an IOError if they do not support a given operation.

Extending IOBase is RawIOBase which deals simply with the reading and
writing of raw bytes to a stream. FileIO subclasses RawIOBase to provide
an interface to OS files.

BufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its
subclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer
streams that are readable, writable, and both respectively.
BufferedRandom provides a buffered interface to random access
streams. BytesIO is a simple stream of in-memory bytes.

Another IOBase subclass, TextIOBase, deals with the encoding and decoding
of streams into text. TextIOWrapper, which extends it, is a buffered text
interface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO
is a in-memory stream for text.

Argument names are not part of the specification, and only the arguments
of open() are intended to be used as keyword arguments.

data:

DEFAULT_BUFFER_SIZE

An int containing the default buffer size used by the module's buffered
I/O classes. open() uses the file's blksize (as obtained by os.stat) if
possible.

CLASSES
_io._BufferedIOBase(_io._IOBase)
_io.BufferedRWPair
_io.BufferedRandom
_io.BufferedReader
_io.BufferedWriter
_io.BytesIO
BufferedIOBase(_io._BufferedIOBase, IOBase)
_io._IOBase(builtins.object)
IOBase
BufferedIOBase(_io._BufferedIOBase, IOBase)
RawIOBase(_io._RawIOBase, IOBase)
TextIOBase(_io._TextIOBase, IOBase)
_io._RawIOBase(_io._IOBase)
_io.FileIO
RawIOBase(_io._RawIOBase, IOBase)
_io._TextIOBase(_io._IOBase)
_io.StringIO
_io.TextIOWrapper
TextIOBase(_io._TextIOBase, IOBase)
builtins.OSError(builtins.Exception)
builtins.BlockingIOError
UnsupportedOperation(builtins.ValueError, builtins.OSError)
builtins.ValueError(builtins.Exception)
UnsupportedOperation(builtins.ValueError, builtins.OSError)

>>> dir(io.BufferedWriter)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__',
'__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__'
, '__init__', '__iter__', '__le__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__',
'__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_dealloc_warn',
'close', 'closed', 'detach', 'fileno', 'flush', 'isatty', 'mode', 'name', 'raw', 'read',
'read1', 'readable', 'readinto', 'readline', 'readlines', 'seek', 'seekable', 'tell',
'truncate', 'writable', 'write', 'writelines']

>>> help(io.BufferedWriter)
Help on class BufferedWriter in module io:

class BufferedWriter(_BufferedIOBase)
|  A buffer for a writeable sequential RawIO object.
|
|  The constructor creates a BufferedWriter for the given writeable raw
|  stream. If the buffer_size is not given, it defaults to
|  DEFAULT_BUFFER_SIZE.
|
|  Method resolution order:
|      BufferedWriter
|      _BufferedIOBase
|      _IOBase
|      builtins.object

迭代工具itertools

>>> import itertools
>>> dir(itertools)
['__doc__', '__loader__', '__name__', '__package__', '_grouper', '_tee', '_tee_dataobject',
'accumulate', 'chain', 'combinations', 'combinations_with_replacement', 'compress', 'count',
'cycle', 'dropwhile', 'filterfalse', 'groupby', 'islice', 'permutations', 'product',
'repeat', 'starmap', 'takewhile', 'tee', 'zip_longest']

>>> help(itertools)
Help on built-in module itertools:

NAME
itertools - Functional tools for creating and using iterators.

DESCRIPTION
Infinite iterators:
count(start=0, step=1) --> start, start+step, start+2*step, ...
cycle(p) --> p0, p1, ... plast, p0, p1, ...
repeat(elem [,n]) --> elem, elem, elem, ... endlessly or up to n times

Iterators terminating on the shortest input sequence:
accumulate(p[, func]) --> p0, p0+p1, p0+p1+p2
chain(p, q, ...) --> p0, p1, ... plast, q0, q1, ...
chain.from_iterable([p, q, ...]) --> p0, p1, ... plast, q0, q1, ...
compress(data, selectors) --> (d[0] if s[0]), (d[1] if s[1]), ...
dropwhile(pred, seq) --> seq
, seq[n+1], starting when pred fails
groupby(iterable[, keyfunc]) --> sub-iterators grouped by value of keyfunc(v)
filterfalse(pred, seq) --> elements of seq where pred(elem) is False
islice(seq, [start,] stop [, step]) --> elements from
seq[start:stop:step]
starmap(fun, seq) --> fun(*seq[0]), fun(*seq[1]), ...
tee(it, n=2) --> (it1, it2 , ... itn) splits one iterator into n
takewhile(pred, seq) --> seq[0], seq[1], until pred fails
zip_longest(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ...

Combinatoric generators:
product(p, q, ... [repeat=1]) --> cartesian product
permutations(p[, r])
combinations(p, r)
combinations_with_replacement(p, r)

CLASSES
builtins.object
accumulate
chain
combinations
combinations_with_replacement
compress
count
cycle
dropwhile
filterfalse
groupby
islice
permutations
product
repeat
starmap
takewhile
zip_longest

关銉词keyword模块

>>> import keyword
>>> dir(keyword)
['__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__initializing__',
'__loader__', '__name__', '__package__', 'iskeyword', 'kwlist', 'main']

>>> help(keyword)
Help on module keyword:

NAME
keyword - Keywords (from "graminit.c")

DESCRIPTION
This file is automatically generated; please don't muck it up!

To update the symbols in this file, 'cd' to the top directory of
the python source tree after building the interpreter and run:

./python Lib/keyword.py

日志工具logging

>>> import logging
>>> dir(logging)
['BASIC_FORMAT', 'BufferingFormatter', 'CRITICAL', 'DEBUG', 'ERROR', 'FATAL', 'FileHandler',
'Filter', 'Filterer', 'Formatter', 'Handler', 'INFO', 'LogRecord', 'Logger', 'LoggerAdapter',
'Manager', 'NOTSET', 'NullHandler', 'PercentStyle', 'PlaceHolder', 'RootLogger',
'StrFormatStyle', 'StreamHandler', 'StringTemplateStyle', 'Template', 'WARN', 'WARNING',
'_STYLES', '_StderrHandler', '__all__', '__author__', '__builtins__', '__cached__',
'__date__', '__doc__', '__file__', '__initializing__', '__loader__', '__name__',
'__package__', '__path__', '__status__', '__version__', '_acquireLock', '_addHandlerRef',
'_checkLevel', '_defaultFormatter', '_defaultLastResort', '_handlerList', '_handlers',
'_levelNames', '_lock', '_logRecordFactory', '_loggerClass', '_releaseLock',
'_removeHandlerRef', '_showwarning', '_srcfile', '_startTime', '_warnings_showwarning',
'addLevelName', 'atexit', 'basicConfig', 'captureWarnings', 'critical', 'currentframe',
'debug', 'disable', 'error', 'exception', 'fatal', 'getLevelName', 'getLogRecordFactory',
'getLogger', 'getLoggerClass', 'info', 'io', 'lastResort', 'log', 'logMultiprocessing',
'logProcesses', 'logThreads', 'makeLogRecord', 'os', 'raiseExceptions', 'root',
'setLogRecordFactory', 'setLoggerClass', 'shutdown', 'sys', 'threading', 'time',
'traceback', 'warn', 'warning', 'warnings', 'weakref']

>>> help(logging)
Help on package logging:

NAME
logging

DESCRIPTION
Logging package for Python. Based on PEP 282 and comments thereto in
comp.lang.python.

Copyright (C) 2001-2013 Vinay Sajip. All Rights Reserved.

To use, simply 'import logging' and log away!

PACKAGE CONTENTS
config
handlers

CLASSES
builtins.object
BufferingFormatter
Filter
Formatter
LogRecord
LoggerAdapter
Filterer(builtins.object)
Handler
NullHandler
StreamHandler
FileHandler
Logger

>>> logging.warn('not good')
WARNING:root:not good

内存映射mmap

>>> import mmap
>>> dir(mmap)
['ACCESS_COPY', 'ACCESS_READ', 'ACCESS_WRITE', 'ALLOCATIONGRANULARITY', 'PAGESIZE',
'__doc__', '__loader__', '__name__', '__package__', 'error', 'mmap']

>>> help(mmap)
Help on built-in module mmap:

NAME
mmap

CLASSES
builtins.object
mmap

class mmap(builtins.object)
|  Windows: mmap(fileno, length[, tagname[, access[, offset]]])
|
|  Maps length bytes from the file specified by the file handle fileno,
|  and returns a mmap object.  If length is larger than the current size
|  of the file, the file is extended to contain length bytes.  If length
|  is 0, the maximum length of the map is the current size of the file,
|  except that if the file is empty Windows raises an exception (you cannot
|  create an empty mapping on Windows).

正则表达式re模块

>>> import re
>>> dir(re)
['A', 'ASCII', 'DEBUG', 'DOTALL', 'I', 'IGNORECASE', 'L', 'LOCALE', 'M', 'MULTILINE', 'S',
'Scanner', 'T', 'TEMPLATE', 'U', 'UNICODE', 'VERBOSE', 'X', '_MAXCACHE', '__all__',
'__builtins__', '__cached__', '__doc__', '__file__', '__initializing__', '__loader__',
'__name__', '__package__', '__version__', '_alphanum_bytes', '_alphanum_str', '_cache',
'_cache_repl', '_compile', '_compile_repl', '_expand', '_pattern_type', '_pickle', '_subx',
'compile', 'copyreg', 'error', 'escape', 'findall', 'finditer', 'functools', 'match',
'purge', 'search', 'split', 'sre_compile', 'sre_parse', 'sub', 'subn', 'sys', 'template']

>>> help(re)
Help on module re:

NAME
re - Support for regular expressions (RE).

DESCRIPTION
This module provides regular expression matching operations similar to
those found in Perl.  It supports both 8-bit and Unicode strings; both
the pattern and the strings being processed can contain null bytes and
characters outside the US ASCII range.

Regular expressions can contain both special and ordinary characters.
Most ordinary characters, like "A", "a", or "0", are the simplest
regular expressions; they simply match themselves.  You can
concatenate ordinary characters, so last matches the string 'last'.

The special characters are:
"."      Matches any character except a newline.
"^"      Matches the start of the string.
"$"      Matches the end of the string or just before the newline at
the end of the string.
"*"      Matches 0 or more (greedy) repetitions of the preceding RE.
Greedy means that it will match as many repetitions as possible.
"+"      Matches 1 or more (greedy) repetitions of the preceding RE.
"?"      Matches 0 or 1 (greedy) of the preceding RE.
*?,+?,?? Non-greedy versions of the previous three special characters.
{m,n}    Matches from m to n repetitions of the preceding RE.
{m,n}?   Non-greedy version of the above.
"\\"     Either escapes special characters or signals a special sequence.
[]       Indicates a set of characters.
A "^" as the first character indicates a complementing set.
"|"      A|B, creates an RE that will match either A or B.
(...)    Matches the RE inside the parentheses.
The contents can be retrieved or matched later in the string.
(?aiLmsux) Set the A, I, L, M, S, U, or X flag for the RE (see below).
(?:...)  Non-grouping version of regular parentheses.
(?P<name>...) The substring matched by the group is accessible by name.
(?P=name)     Matches the text matched earlier by the group named name.
(?#...)  A comment; ignored.
(?=...)  Matches if ... matches next, but doesn't consume the string.
(?!...)  Matches if ... doesn't match next.
(?<=...) Matches if preceded by ... (must be fixed length).
(?<!...) Matches if not preceded by ... (must be fixed length).
(?(id/name)yes|no) Matches yes pattern if the group with id/name matched,
the (optional) no pattern otherwise.

The special sequences consist of "\\" and a character from the list
below.  If the ordinary character is not on the list, then the
resulting RE will match the second character.
\number  Matches the contents of the group of the same number.
\A       Matches only at the start of the string.
\Z       Matches only at the end of the string.
\b       Matches the empty string, but only at the start or end of a word.
\B       Matches the empty string, but not at the start or end of a word.
\d       Matches any decimal digit; equivalent to the set [0-9] in
bytes patterns or string patterns with the ASCII flag.
In string patterns without the ASCII flag, it will match the whole
range of Unicode digits.
\D       Matches any non-digit character; equivalent to [^\d].
\s       Matches any whitespace character; equivalent to [ \t\n\r\f\v] in
bytes patterns or string patterns with the ASCII flag.
In string patterns without the ASCII flag, it will match the whole
range of Unicode whitespace characters.
\S       Matches any non-whitespace character; equivalent to [^\s].
\w       Matches any alphanumeric character; equivalent to [a-zA-Z0-9_]
in bytes patterns or string patterns with the ASCII flag.
In string patterns without the ASCII flag, it will match the
range of Unicode alphanumeric characters (letters plus digits
plus underscore).
With LOCALE, it will match the set [0-9_] plus characters defined
as letters for the current locale.
\W       Matches the complement of \w.
\\       Matches a literal backslash.

字符串string模块

>>> import string
>>> dir(string)
['ChainMap', 'Formatter', 'Template', '_TemplateMetaclass', '__builtins__', '__cached__',
'__doc__', '__file__', '__initializing__', '__loader__', '__name__', '__package__', '_re',
'_string', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits',
'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace']

>>> help(string)
Help on module string:

NAME
string - A collection of string constants.

DESCRIPTION
Public module variables:

whitespace -- a string containing all ASCII whitespace
ascii_lowercase -- a string containing all ASCII lowercase letters
ascii_uppercase -- a string containing all ASCII uppercase letters
ascii_letters -- a string containing all ASCII letters
digits -- a string containing all ASCII decimal digits
hexdigits -- a string containing all ASCII hexadecimal digits
octdigits -- a string containing all ASCII octal digits
punctuation -- a string containing all ASCII punctuation characters
printable -- a string containing all ASCII characters considered printable

CLASSES
builtins.object
Formatter
Template

本节就到这里