Das deutsche Python-Forum

Code: Alles auswählen

A="A"
B="B"
k=[A,B,B,B,A,B,A,B,A,B,A,B,A]                    #Beispiel-Liste
L=[]                                    #Liste in der die Punkte gesammelt werden
K=[]                                    #Liste, in der die Listen gesammelt werden
z=0
for i in k:
    if i==A and z==0:
        L.append(i)
        z=1
    
    elif i!=A:
        L.append(i)

    elif i==A and z==1:
        L.append(i)                     #Schluss-'A" wird an Liste L angehängt
        K.append(L)                     #Liste L wird in Liste K gespeichert
        L=[]                            #anschließend wird Liste L "resettet"
        L.append(i)                     #Schluss-A der vorigen Liste wird Anfangs-A der neuen Liste
        
     

print K -> [['A', 'B', 'B', 'B', 'A'], ['A', 'B', 'A'], ['A', 'B', 'A'], ['A', 'B', 'A'], ['A', 'B', 'A']]

Code: Alles auswählen

k=['A1', 'B1', 'B2', 'B3', 'A2', 'B4', 'A3', 'A4', 'B5', 'B6', 'B7', 'A5']
l=[]
for i,_ in enumerate(k):
    if k[i].startswith("A"):    # das erste auftreten von A finden
        for j,_ in enumerate(k[i+1:]):   # einen zähler danach
            if k[j+i+1].startswith("A"):   # das nächste A finden
                l.append(k[i:j+i+2])     # und die liste an l anhängen
                break
print(l)

Code: Alles auswählen

k=['A1', 'B1', 'B2', 'B3', 'A2', 'B4', 'A3', 'A4', 'B5', 'B6', 'B7', 'A5']
pos_of_a=[]
for i,_ in enumerate(k):
    if k[i].startswith("A"):
        pos_of_a.append(i)  # erzeugt liste mit allen positionen von A

pair_of_a=[]
for i,_ in enumerate(pos_of_a[:-1]):   # letztes element auslassen
    pair_of_a.append([pos[i],pos[i+1]+1])  #generiert liste mit päärchen

l=[]
for i,j in pair_of_a:
    l.append(k[i,j])

print(l)

Code: Alles auswählen

from itertools import groupby
from operator import itemgetter


def group_points(points):
    def stamp():
        i = 0
        for point in points:
            if point.startswith('A'):
                i += 1
            yield (i, point)

    result = list()
    for i, group in groupby(stamp(), itemgetter(0)):
        assert i != 0
        grouped_points = [p for _, p in group]
        if len(result) > 1:
            result.append(grouped_points[0])
            yield result
        result = grouped_points


def main():
    points = [
        'A1', 'B1', 'B2', 'B3', 'A2', 'B4', 'A3', 'A4', 'B5', 'B6', 'B7', 'A5'
    ]
    for group in group_points(points):
        print group


if __name__ == '__main__':
    main()

Code: Alles auswählen

def make_routes(points):
    result = []
    group = []
    for point in points:
        group.append(point)
        if len(group) > 1 and "A" in point:
            result.append(group)
            group = [point]
    return result

points = ['A1', 'B1', 'B2', 'B3', 'A2', 'B4', 'A3', 'A4', 'B5', 'B6', 'B7', 'A5']
make_routes(points)
>
[['A1', 'B1', 'B2', 'B3', 'A2'],
 ['A2', 'B4', 'A3'],
 ['A3', 'A4'],
 ['A4', 'B5', 'B6', 'B7', 'A5']]

Code: Alles auswählen

[['A1', 'B3', 'A2'],
 ['A3', 'B4', 'A4'],
 ['A4', 'B5', 'B6', 'B7', 'A5'],
 ['A6', 'B8', 'A7'],
 ['A7', 'B9', 'B10', 'A8'],
 ['A8', 'B11', 'A9'],
 ['A9', 'B12', 'A10'],
 ['A12', 'B13', 'B14', 'A13'],
 ['A13', 'B15', 'A14'],
 ['A14', 'B16', 'B17', 'A15'],
 ['A16', 'B18', 'B19', 'B20', 'B21', 'A17'],
 ['A17', 'B22', 'B23', 'A18'],
 ['A19', 'B24', 'B25', 'A20'],
 ['A21', 'B26', 'B27', 'B28', 'B29', 'B30', 'B31', 'A22'],
 ['A22', 'B32', 'B33', 'A23'],
 ['A23', 'B34', 'A24'],
 ['A24', 'B35', 'A25'],
 ['A26', 'B36', 'A27'],
 ['A31', 'B37', 'A32'],
 ['A32', 'B38', 'A33'],
 ['A34', 'B39', 'B40', 'A35'],
 ['A35', 'B41', 'B42', 'A36'],
 ['A36', 'B43', 'B44', 'A37'],
 ['A38', 'B45', 'B46', 'B47', 'B48', 'A39'],
 ['A41', 'B49', 'B50', 'B51', 'B52', 'B53', 'B54', 'A42']]

Code: Alles auswählen

#!/usr/bin/env python3
# -*- coding: utf-8

from itertools import count, tee
from random import choice
from pprint import pprint

def pairwise(iterable):
    a, b = tee(iterable)
    next(b, None)
    return zip(a, b)

def get_points():
    cis = [['A', count(1)], ['B', count(1)]]
    yield 'A0'
    for _ in range(99):
        c, i = choice(cis)
        yield '{}{}'.format(c, next(i))
    yield 'A100'

def main():
    def get_result(points):
        def get_row(pairs=pairwise(points)):
            for x, y in pairs:
                if y.startswith('B'):
                    yield x
                elif x.startswith('B'):
                    yield x
                    yield y
                    return
        while True:
            row = list(get_row())
            if not row:
                return
            yield row
    pprint(list(get_result(get_points())))

if __name__ == '__main__':
    main()

Code: Alles auswählen

#!/usr/bin/env python3
# -*- coding: utf-8


from itertools import count, filterfalse, tee
from random import choice
from pprint import pprint


class Stream:

    def __init__(self, iterable):
        self.iterable = iter(iterable)

    def __iter__(self):
        return self

    def __next__(self):
        return next(self.iterable)

    def bind(self, mfunc):
        return mfunc(self.iterable)

    def map(self, project):
        return Stream(project(each) for each in self.iterable)

    def filter(self, pred):
        return Stream(filter(pred, self.iterable))

    def filterfalse(self, pred):
        return Stream(filterfalse(pred, self.iterable))

    def pairwise(self):
        a, b = tee(self.iterable)
        next(b, None)
        return Stream(zip(a, b))

    def split(self, pred):
        def splitter():
            acc = []
            for item in self.iterable:
                acc.append(item)
                if pred(item):
                    yield acc
                    acc = []
            if acc:
                yield acc
        return Stream(splitter())


def points():
    cis = [['A', count(1)], ['B', count(1)]]
    yield 'A0'
    for _ in range(99):
        c, i = choice(cis)
        yield '{}{}'.format(c, next(i))
    yield 'A100'


def main():
    result = list(
        Stream(points())
        .pairwise()
        .filterfalse(lambda x: x[0].startswith('A') and x[1].startswith('A'))
        .split(lambda x: x[1].startswith('A'))
        .map(lambda xs: [x[0] for x in xs] + list(xs[-1][1:]))
    )
    pprint(result)


if __name__ == '__main__':
    main()

Code: Alles auswählen

#!/usr/bin/env python3
# -*- coding: utf-8

from random import choice
from pprint import pprint

from streams import Stream, first, second, unstar

def points(n):
    return Stream.chain(
        Stream.once((0, 'A')),
        Stream.join(
            Stream.repeat('A').enumerate(start=1),
            Stream.repeat('B').enumerate(start=1),
            scheduler=choice,
        ).take(n - 1),
        Stream.once((n, 'A')),
    ).map(unstar('{1}{0}'.format))

def is_even(n):
    return n % 2 == 0

@unstar
def combine_window(left_as, bs, right_as):
    return left_as[-1:] + bs + right_as[:1]

def main():
    pprint(list(
        points(100)
        .groupby(first)
        .map(second, list)
        .window(size=3)
        .filter_by_index(is_even)
        .map(combine_window)
    ))

if __name__ == '__main__':
    main()

Code: Alles auswählen

[['A1', 'B1', 'A2'],
 ['A2', 'B2', 'B3', 'A3'],
 ['A6', 'B4', 'B5', 'A7'],
 ['A8', 'B6', 'B7', 'A9'],
 ['A10', 'B8', 'A11'],
 ['A12', 'B9', 'B10', 'A13'],
 ['A14', 'B11', 'B12', 'B13', 'A15'],
 ['A15', 'B14', 'B15', 'A16'],
 ['A18', 'B16', 'B17', 'A19'],
 ['A19', 'B18', 'A20'],
 ['A20', 'B19', 'B20', 'A21'],
 ['A21', 'B21', 'B22', 'B23', 'B24', 'B25', 'A22'],
 ['A23', 'B26', 'B27', 'A24'],
 ['A26', 'B28', 'B29', 'B30', 'B31', 'A27'],
 ['A29', 'B32', 'A30'],
 ['A30', 'B33', 'B34', 'A31'],
 ['A31', 'B35', 'B36', 'B37', 'A32'],
 ['A32', 'B38', 'A33'],
 ['A35', 'B39', 'A36'],
 ['A37', 'B40', 'A38'],
 ['A38', 'B41', 'B42', 'A39'],
 ['A40', 'B43', 'A41'],
 ['A41', 'B44', 'B45', 'A42'],
 ['A42', 'B46', 'B47', 'B48', 'A43'],
 ['A43', 'B49', 'A44'],
 ['A44', 'B50', 'A45'],
 ['A45', 'B51', 'B52', 'A46'],
 ['A46', 'B53', 'A100']]

Code: Alles auswählen

#!/usr/bin/env python3
# -*- coding: utf-8

from streams import Stream

def computation(a, b, c):
    return a + b * c

def main():
    s1 = Stream.count()
    s2 = Stream.count().map(lambda n: 10 ** n)
    s3 = Stream.repeat(5)
    print(computation(1, 2, 3))
    print(list(computation(s1, s2, s3).take(10)))

if __name__ == '__main__':
    main()

Code: Alles auswählen

7
[5, 51, 502, 5003, 50004, 500005, 5000006, 50000007, 500000008, 5000000009]

Code: Alles auswählen

left_as[-1:] + bs + right_as[:1]

Code: Alles auswählen

a b c d e f g ...
a b c
  b c d
    c d e
      d e f
        e f g
          ...

Code: Alles auswählen

for left_as, bs, right_as in islice(windows, 0, None, 2):
    ...

Code: Alles auswählen

windows = zip(
    *(islice(each, i, None) for i, each in enumerate(tee(groups, 3)))
)

Code: Alles auswählen

groups = (
    list(group) for key, group in groupby(points, itemgetter(0))
)

Code: Alles auswählen

from itertools import groupby, islice, tee
from operator import itemgetter

def make_rows(points):
    groups = (
        list(group) for key, group in groupby(points, itemgetter(0))
    )
    windows = zip(
        *(islice(each, i, None) for i, each in enumerate(tee(groups, 3)))
    )
    for left_as, bs, right_as in islice(windows, 0, None, 2):
        yield left_as[-1:] + bs + right_as[:1]

Code: Alles auswählen

def main():
    from pprint import pprint
    pprint(list(make_rows(make_points(100))))

if __name__ == '__main__':
    main()

Code: Alles auswählen

from streams import Stream
from combinators import first, unstar

@unstar
def combine_window(left_as, bs, right_as):
    return left_as[-1:] + bs + right_as[:1]

def make_rows(points):
    return (
        points
        .groupby(first)
        .window(size=3)
        .slice(step=2)
        .map(combine_window)
    )

Code: Alles auswählen

import random

def points(n):
    return Stream.chain(
        Stream.once((0, 'A')),
        Stream.join(
            Stream.repeat('A').enumerate(start=1),
            Stream.repeat('B').enumerate(start=1),
            scheduler=random.choice,
        ).take(n - 1),
        Stream.once((n, 'A')),
    ).map(unstar('{1}{0}'.format))