Das deutsche Python-Forum

Code: Alles auswählen

import re
...
numrex = re.compile(r'\d+')

def main_sort( rrange, args):
    """

    """
    for arg in args[::-1]:
        try:
            global field
            global flags
            field, flags = int(arg[0]), arg[1]
            if not flags:
                flags = 'n'
            rrange.sort(key=naturalkey, reverse=('r' in flags ) )
        except Exception as ll:
            print '%s'%ll
    return rrange

def naturalkey( key):
    key = key[field]
    if isinstance(key, unicode):
        if not 's' in flags:
            key = key.lower()
        if 'n' in flags: # http://code.activestate.com/recipes/285264-natural-string-sorting/#c7
            return numrex.sub(lambda m:'%03d%d' %(len(m.group()), m.group()), key)
        return key
    else:
        if 't' in flags:
            return ('zzzzzzz', key)
        return key

Code: Alles auswählen

...
rrange.sort(key=lamda k : k[field].lower() if blah else ...., reverse=('r' in flags ) )
...

Code: Alles auswählen

import re
from functools import partial

def main_sort( rrange, args):
    """

    """
    for arg in args[::-1]:
        try:

            field, flags = int(arg[0]), arg[1]
            if not flags:
                flags = 'n' 
            rrange.sort(key=partial(naturalkey,field, flags), reverse=('r' in flags ) )
        except Exception as error:
            return '%s'% error
    return rrange

def naturalkey(field, flags, key):
    key = key[field]
    if isinstance(key, unicode):
        if not 's' in flags:
            key = key.lower()
        if 'n' in flags: 
            return numrex.sub(lambda m:'%03d%s' %(len(m.group()), m.group()), key)
        return key
    else:
        if 't' in flags: # t : for Textfirst
            return ('zzzzzzz', key)
        return key

Code: Alles auswählen

import re
from functools import partial
from operator import methodcaller


NUMBER_RE = re.compile(r'\d+')


def make_key_func(index, flags):
    
    def key_func(item):
        key = item[index]
        if isinstance(key, unicode):
            for function in functions:
                key = function(key)
            return (0, key)
        else:
            return (number_sort_key, key)
    
    number_sort_key = -1 if 't' in flags else 1
    functions = list()
    if 's' not in flags:
        functions.append(methodcaller('lower'))
    if 'n' in flags:
        functions.append(
            partial(
                NUMBER_RE.sub, lambda m: '%03d%d' % (len(m.group()), m.group())
            )
        )
    return key_func


def main_sort(items, sort_specs):
    for index, flags in reversed(sort_specs):
        items.sort(key=make_key_func(index, flags or 'n'), reverse='r' in flags)

Code: Alles auswählen

import unohelper
import locale
import re
from functools import partial
from operator import methodcaller
from com.capylibre.sortaddin import XSortArray


# SortArray Calc Add-in implementation.

NUMBER_RE = re.compile(r'[1-9]\d*')

class NaturalSort( unohelper.Base, XSortArray ):
    def __init__( self, ctx ):
        self.ctx = ctx
        locale.setlocale(locale.LC_ALL, "")



    def sortieren(self, inRange, fieldspecs , HasHeaders=False , ByRows=False):
        """
        Functionname : SORTIEREN
        Arguments:
        InRange : The Range to Sort
        fieldspecs: List of 2 Columns, with Fieldnumber left ,and any
                Combination of Flags s, r, t, n on the Right Side
        HasHeaders: if True skip First Row/Column as header
        ByRows : if True sorts left to Right, otherwise Top to Bottom
        """
        inRange = list(inRange)
        out = []
        if ByRows:
            inRange = zip(*inRange)
        if HasHeaders:
            out.append(inRange[0])
            inRange = inRange[1:]


        sortrange = main_sort(inRange,fieldspecs)
        out.extend(sortrange)

        if ByRows:
            return tuple(zip(*out))

        return tuple(out)




def make_key_func(index, flags):

    def key_func(item):
        key = item[index]
        if isinstance(key, unicode):
            for function in functions:
                key = function(key)
            return (0, key)
        else:
            return (number_sort_key, key)

    number_sort_key = -1 if 't' in flags else 1
    functions = list()
    if 's' not in flags:
        functions.append(methodcaller('lower'))
    if 'n' in flags:
        functions.append(
            partial(
                NUMBER_RE.sub, lambda m: '%03d%s' % (len(m.group()), m.group())
            )
        )
    functions.append(methodcaller('encode','utf8'))
    functions.append(locale.strxfrm)

    return key_func


def main_sort(items, sort_specs):
    for index, flags in reversed(sort_specs):
        index = int(index)
        items.sort(key=make_key_func(index, flags or 'n'), reverse='r' in flags)
    return items



def createInstance( ctx ):
    return NaturalSort( ctx )

g_ImplementationHelper = unohelper.ImplementationHelper()
g_ImplementationHelper.addImplementation(
    createInstance,"com.capylibre.sortaddin.python.NaturalSort",("com.sun.star.sheet.AddIn",),)