from keyword import iskeyword as _iskeyword

import sys as _sys

import logging

logging.basicConfig(level=logging.INFO, filename="logging.txt", filemode="w+", \

                    format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')

logger = logging.getLogger(__name__)

_class_template = """\

from builtins import property as _property, tuple as _tuple

from operator import itemgetter as _itemgetter

from collections import OrderedDict

class {typename}(tuple):

    '{typename}({arg_list})'

    __slots__ = ()

    _fields = {field_names!r}

    def __new__(_cls, {arg_list}):

        'Create new instance of {typename}({arg_list})'

        return _tuple.__new__(_cls, ({arg_list}))

    @classmethod

    def _make(cls, iterable, new=tuple.__new__, len=len):

        'Make a new {typename} object from a sequence or iterable'

        result = new(cls, iterable)

        if len(result) != {num_fields:d}:

            raise TypeError('Expected {num_fields:d} arguments, got %d' % len(result))

        return result

    def _replace(_self, **kwds):

        'Return a new {typename} object replacing specified fields with new values'

        result = _self._make(map(kwds.pop, {field_names!r}, _self))

        if kwds:

            raise ValueError('Got unexpected field names: %r' % list(kwds))

        return result

    def __repr__(self):

        'Return a nicely formatted representation string'

        return self.__class__.__name__ + '({repr_fmt})' % self

    def _asdict(self):

        'Return a new OrderedDict which maps field names to their values.'

        return OrderedDict(zip(self._fields, self))

    def __getnewargs__(self):

        'Return self as a plain tuple.  Used by copy and pickle.'

        return tuple(self)

{field_defs}

"""

_repr_template = '{name}=%r'

_field_template = '''\

    {name} = _property(_itemgetter({index:d}), doc='Alias for field number {index:d}')

'''

def namedtuple(typename, field_names, *, verbose=False, rename=False, module=None):

    """Returns a new subclass of tuple with named fields.

    >>> Point = namedtuple('Point', ['x', 'y'])

    >>> Point.__doc__                   # docstring for the new class

    'Point(x, y)'

    >>> p = Point(11, y=22)             # instantiate with positional args or keywords

    >>> p[0] + p[1]                     # indexable like a plain tuple

    33

    >>> x, y = p                        # unpack like a regular tuple

    >>> x, y

    (11, 22)

    >>> p.x + p.y                       # fields also accessible by name

    33

    >>> d = p._asdict()                 # convert to a dictionary

    >>> d['x']

    11

    >>> Point(**d)                      # convert from a dictionary

    Point(x=11, y=22)

    >>> p._replace(x=100)               # _replace() is like str.replace() but targets named fields

    Point(x=100, y=22)

    """

    # Validate the field names.  At the user's option, either generate an error

    # message or automatically replace the field name with a valid name.

    if isinstance(field_names, str):

        field_names = field_names.replace(',', ' ').split()

    field_names = list(map(str, field_names))

    typename = str(typename)

    logging.info("%s:   %s" %(typename, field_names))

    if rename:

        seen = set()

        for index, name in enumerate(field_names):

            if (not name.isidentifier()

                or _iskeyword(name)

                or name.startswith('_')

                or name in seen):

                field_names[index] = '_%d' % index

            seen.add(name)

    for name in [typename] + field_names:

        logging.info(name)

        if type(name) is not str:

            raise TypeError('Type names and field names must be strings')

        #判断是否为标识符，标识符必须以字母或者“_”开头

        #标识符用于作为变量，函数名、类名、方法名等

        if not name.isidentifier():

            raise ValueError('Type names and field names must be valid '

                             'identifiers: %r' % name)

        #判断是否为关键字，关键字为python内部已经使用了的标识符

        if _iskeyword(name):

            raise ValueError('Type names and field names cannot be a '

                             'keyword: %r' % name)

    seen = set()

    for name in field_names:

        if name.startswith('_') and not rename:

            raise ValueError('Field names cannot start with an underscore: '

                             '%r' % name)

        if name in seen:

            raise ValueError('Encountered duplicate field name: %r' % name)

        seen.add(name)

    # Fill-in the class template

    class_definition = _class_template.format(

        typename = typename,

        field_names = tuple(field_names),

        num_fields = len(field_names),

        arg_list = repr(tuple(field_names)).replace("'", "")[1:-1],

        repr_fmt = ', '.join(_repr_template.format(name=name)

                             for name in field_names),

        field_defs = '\n'.join(_field_template.format(index=index, name=name)

                               for index, name in enumerate(field_names))

    )

    logging.info(class_definition)

    # Execute the template string in a temporary namespace and support

    # tracing utilities by setting a value for frame.f_globals['__name__']

    namespace = dict(__name__='namedtuple_%s' % typename)

    exec(class_definition, namespace)

    result = namespace[typename]

    result._source = class_definition

    if verbose:

        print(result._source)

    # For pickling to work, the __module__ variable needs to be set to the frame

    # where the named tuple is created.  Bypass this step in environments where

    # sys._getframe is not defined (Jython for example) or sys._getframe is not

    # defined for arguments greater than 0 (IronPython), or where the user has

    # specified a particular module.

    if module is None:

        try:

            module = _sys._getframe(1).f_globals.get('__name__', '__main__')

        except (AttributeError, ValueError):

            pass

    if module is not None:

        result.__module__ = module

    return result

#coding=utf-8

from builtins import property as _property, tuple as _tuple

from operator import itemgetter as _itemgetter

from collections import OrderedDict

import logging

logging.basicConfig(level=logging.INFO, filename="logging.txt", filemode="w+", \

                    format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')

logger = logging.getLogger(__name__)

class person(tuple):

    'person(name, age, sex)'

    __slots__ = ()

    _fields = ('name', 'age', 'sex')

    def __new__(_cls, name, age, sex):

        'Create new instance of person(name, age, sex)'

        logger.info("__new__")

        return _tuple.__new__(_cls, (name, age, sex))

    @classmethod

    def _make(cls, iterable, new=tuple.__new__, len=len):

        'Make a new person object from a sequence or iterable'

        result = new(cls, iterable)

        if len(result) != 3:

            raise TypeError('Expected 3 arguments, got %d' % len(result))

        return result

    def _replace(_self, **kwds):

        'Return a new person object replacing specified fields with new values'

        #需要深刻理解该代码的精髓

        logger.info(type(_self))

        for item in _self:

            logger.info(item)

        str = '''

            how to replace dict_keyvalue

            li = map({"age":99}.pop, ('name', 'age', 'sex'), ("zhanglin", "11", "man"))

        '''

        logger.info(str)

        result = _self._make(map(kwds.pop, ('name', 'age', 'sex'), _self))

        if kwds:

            raise ValueError('Got unexpected field names: %r' % list(kwds))

        return result

    def __repr__(self):

        'Return a nicely formatted representation string'

        return self.__class__.__name__ + '(name=%r, age=%r, sex=%r)' % self

    def _asdict(self):

        'Return a new OrderedDict which maps field names to their values.'

        return OrderedDict(zip(self._fields, self)) #打包为元组列表

    def __getnewargs__(self):

        'Return self as a plain tuple.  Used by copy and pickle.'

        return tuple(self)

    name = _property(_itemgetter(0), doc='Alias for field number 0')

    age = _property(_itemgetter(1), doc='Alias for field number 1')

    sex = _property(_itemgetter(2), doc='Alias for field number 2')

if __name__ == "__main__":

    p1 = person("zhanglin", "", "man")

    logger.info("{0}:{1}".format("p1", p1))

    #_replace验证

    p2 = p1._replace(name ="zhangsan", age=99)

    logger.info(p2)

    logger.info("{0}:{1}".format("p2", p2))
    

2018-03-21 15:10:46,197 - __main__ - INFO - __new__

2018-03-21 15:10:46,197 - __main__ - INFO - p1:person(name='zhanglin', age='', sex='man')

2018-03-21 15:10:46,197 - __main__ - INFO - <class '__main__.person'>

2018-03-21 15:10:46,197 - __main__ - INFO - zhanglin

2018-03-21 15:10:46,197 - __main__ - INFO - 30

2018-03-21 15:10:46,197 - __main__ - INFO - man

2018-03-21 15:10:46,197 - __main__ - INFO -

            how to replace dict_keyvalue

            li = map({"age":99}.pop, ('name', 'age', 'sex'), ("zhanglin", "", "man"))

2018-03-21 15:10:46,197 - __main__ - INFO - person(name='zhangsan', age=99, sex='man')

2018-03-21 15:10:46,197 - __main__ - INFO - p2:person(name='zhangsan', age=99, sex='man')

#coding=utf-8

import logging

logging.basicConfig(level=logging.INFO, filename="logging.txt", filemode="w+",\

                    format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')

logger = logging.getLogger(__name__)                    

_class_template = \

'''

class {typename}(tuple):

    __slots__ = ()

    _fields = {field_names!r}

    def __new__(cls, *args, **dwargs):

        return super().__new__(cls, *args, **dwargs)

'''

def defineclass(typename, field_names):

    logging.info(field_names)

    class_definition = _class_template.format(typename=typename,field_names=field_names,\

            #方法1

            arg_list = ','.join(name for name in field_names),\

            self_format = "".join("\t\tself.{name}={name}\n".format(name=name) for name in field_names))

            #方法2

            #arg_list = ', '.join('{name}'.format(name=name) for name in field_names))

             #方法3

            #arg_list = repr(tuple(field_names)).replace("'", "")[1:-1])

    logging.info(class_definition)

    namespace = dict(__name__='defineclass_%s' % typename)

    logging.info("namespce:{}".format(namespace))

    exec(class_definition, namespace)

    result = namespace[typename]

    logging.info("typename:{0}--result:{1}".format(typename, namespace[typename]))

    result._source = class_definition

    return result

if __name__ == "__main__":

    person = defineclass("person", ("name", "age", "sex"))

    print (type(person))

    p = person(("zhanglin", "", "man"))

    print (p)

    print (p[0])

2018-03-22 00:05:50,705 - root - INFO - ('name', 'age', 'sex')

2018-03-22 00:05:50,705 - root - INFO -

class person(tuple):

    __slots__ = ()

    _fields = ('name', 'age', 'sex')

    def __new__(cls, *args, **dwargs):

        return super().__new__(cls, *args, **dwargs)

2018-03-22 00:05:50,705 - root - INFO - namespce:{'__name__': 'defineclass_person'}

2018-03-22 00:05:50,705 - root - INFO - typename:person--result:<class 'defineclass_person.person'>