Tengo un código que tiene una estructura, подобный а-ля siguiente, en pseudocódigo. En el ejemplo en pseudocódigo se ха escrito class Uno y def main() para dar una idea de la estructura общий del código реальный que utilizo e intentar transmitir la idea de que habrá asignación de valores de dentro afuera de la clase y наоборот. Он decidido esta aproximación intentando plantear un ejemplo mínimo que sea а-ля vez mínimamente когерентный para el propósito de la pregunta.

from numpy import mean
x = []
nueva_x = [1,1]
class Uno: 
    mi_lista=[[1,1],[1,1],[0,1],[0,1],[0,0],[1,0]]
    for i in mi_lista:
         x.append(i)
    print(nueva_x)
def main():
    variable_1 = [1,2,3]

Es decir, declaro inicialmente una variable x que es una lista vacía y una variable nueva_x, que es una lista que contiene inicialmente una serie de valores. La Листа x va adjuntando sucesivamente las listas que hay dentro de mi_lista.

Lo que busco es:

1. que la lista x vaya adjuntando las listas de mi_lista por el mismo número de iteraciones que elementos tiene variable_1 (en el ejemplo 3).

2. una vez se hayan adjuntado en x un número de listas igual a len(variable_1), y sólo entonces, относящиеся к исчислению la медиа de los доблесть de las listas Адхунтас en x y asignarlo a nueva_x. En el ejemplo, una vez x ха adjuntado 3 listas x=[[1,1],[1,1],[0,1]], calculamos la media así media_x=mean(x, 0).

Реальный El objetivo es que cuando corra el código, el nueva_x том dentro de la clase el доблесть inicial имеет к que se cumplan las "n" primeras iteraciones (en el ejemplo 3). Desde entonces nueva_x tomará su nuevo доблесть, y así имеет к que se cumpla nuevamente el criterio del paso 1. Y así sucesivamente.

Mis intentos имеет к ahor ханьскому удару рапирой por farragosas funciones. Сенсилла Pero estoy seguro que tiene que existir una manera de ограничитель el número de listas que se adjuntan подставляет alguna función подобный a append. Una vez, hecho esto, меня gustaría сабля cómo proceder подставляет el Тему доблесть de la sustitución y asignación del nuevo a new_x, así Комо cómo formatear la lista x.

Gracias por los comentarios de antemano.

Actualización подставляют ООН código реальный (6/11/2019)

continuación vemos ООН ejemplo подставляет реальный un código más aproximado al código. Se trata de un ejemplo mínimo del código, реальный (abajo comparto el código).

Contexto:

Como puede observarse al ejecutarse el simulador, el juego (juego.jugar) Итера lo ларго de ronda en los emparejamientos. De este modo, cuando la ejecución llega al punto clave def choose, se imprime el self.sigma correspondiente al jugador (tomado de self.nombre) напоминание que está siendo simulado en ese. Комо puede observarse self.sigma доблесть довода "против" es una lista de 0 1.

Objetivo

Se desea crear una variable i que vaya adjuntando las listas self.sigma de cada "jugador" por el mismo número de iteraciones que jugadores tenemos. Существующий En el caso, 4.

Una vez se haya adjuntado en i un número de listas igual a len(jugadores), y sólo entonces, относящиеся к исчислению la медиа de los доблесть de las listas Адхунтас en i y asignarlo a nueva_i. En el ejemplo, una vez i ха adjuntado 4 listas i=[[1,1,0,0],[1,1,0,0],[0,0,1,1],[0,0,1,1]], calculamos la media así media_i=mean(i, 0).

Dado que la media de i en cada Ронда, es decir nueva_i, симулируйте сер utilizada en el futuro para hacer una serie de cálculos lo ларго de la simulación dentro de def choose, esta Листа nueva_i подросток debe asignado доблесть ООН previo cada Ронда (su доблесть iniciar será el de las medias de las sigmas iniciales asignadas en main()). su vez, en una futura versión del código, dentro de def_choose, esta nueva_i interferirá en cada Ронда подставляет el self.sigma de cada jugador, modificándolo. En resumen, se necesita que nueva_i recoja la media de self.sigmas de la предшествующая Ронда. Cada jugador tendrá su self.sigma propio, pero nueva_i será común todos los jugadores en cada Ронда. Todas estas устраивается concatenadas explican ми, intento inicial de trabajar подставляет una глобальную переменную i фаза a que nueva_i медиа la de las self.sigma de los jugadores y luego se formatee de ronda en ronda.

from __future__ import division
from random import random
from bisect import bisect
from collections import deque, Counter

i=[]
nueva_i=[]    

def choice(opciones, probs):
    probAcumuladas = list()
    aux = 0
    for p in probs:
        aux += p
        probAcumuladas.append(aux)
    r = random() * probAcumuladas[-1]
    op = bisect(probAcumuladas, r)
    return opciones[op]

class Jugador:
    def __init__(self, nombre, senales, sigma, b, x, m, menLen):
        self.nombre = nombre
        self.senales = senales
        self.mem_mostradas = {senal: 0 for senal in senales}
        self.men_observadas = {senal: 0 for senal in senales}
        self.__mem_mostradas = deque(maxlen=menLen)
        self.__men_observadas = deque(maxlen=menLen)
        self.sigma = sigma[:]  
        self.b = b
        self.x = x
        self.m = m

    def memoriza(self, mostrada, observada):
        self.__mem_mostradas.append(mostrada)
        self.__men_observadas.append(observada)
        mostradas = Counter(self.__mem_mostradas)
        observadas = Counter(self.__men_observadas)
        self.mem_mostradas = { signal: mostradas.get(signal, 0) for signal in self.senales }
        self.mem_observadas = { signal: observadas.get(signal, 0) for signal in self.senales }

    def __str__(self):
        return "Jugador_{}".format(self.nombre)

    def with_b(self, muestra, observa, r, idx):
        if not (muestra == observa == 0):
            result = (
                ((0.98) * (1.0 - self.b) * (1.0 - self.x) * muestra / r)
                + ((0.98) * (1.0 - self.b) * (self.x) * observa / r)
                + ((0.98) * self.b * self.sigma[idx])
                + ((self.m / 8))
            )
        else:
            result = (
                ((0.98) * (1.0 - 0) * (1.0 - self.x) * muestra / r)
                + ((0.98) * (1.0 - 0) * (self.x) * observa / r)
                + ((0.98) * 0 * self.sigma[idx])
                + ((self.m / 8))
            )
        return result

    def choose(self, r):
        probs = [
            self.with_b(
                self.mem_mostradas[op], self.men_observadas[op], r, indx
            )
            for indx, op in enumerate(self.senales)
        ]
        elecc = choice(self.senales, probs)

        #Aquí es donde se necesitará llamar a self.sigma y nueva_i
        print(self.sigma)
        print(nueva_i)

        return elecc

class Partida:
    def __init__(self, jugadores, emparejamientos, senales, sigmas, b, x, m, menLen):
        self.emparejamientos = emparejamientos
        self.senales = senales
        self.jugadores = {
            nombre: Jugador(nombre, senales, sigmas[nombre], b, x, m, menLen)
            for nombre in jugadores
        }
        self.memoria = list()
        self.entropy = float()

    def generar_senales(self):
        yield dict(zip(self.jugadores, self.senales))
        r = 1
        while True:
            eleccs = {}
            for jugador in self.jugadores.values():
                eleccs[jugador.nombre] = jugador.choose(r)
            r += 1
            yield eleccs

    def jugar(self):
        gen_sens = self.generar_senales()
        for ronda in self.emparejamientos:
            senales = next(gen_sens)
            self.memoria.append(senales)
            for jugador1, jugador2 in ronda:
                self.jugadores[jugador1].memoriza(observada=senales[jugador2], mostrada=senales[jugador1])
                self.jugadores[jugador2].memoriza(observada=senales[jugador1], mostrada=senales[jugador2])

def main():
    jugadores = [1, 2, 3, 4]
    senales = ["S1", "S2", "S3", "S4"]
    emparejamientos = [[(1, 2), (3, 4)], [(1, 3), (2, 4)], [(1, 4), (2, 3)]]

    patron = 1

    menLen=3

    s1 = [1, 0, 0, 0]
    s2 = [0, 0, 0, 1]
    sigmas = {1: s1, 2: s1, 3: s2, 4: s2}

    muestras = [{"b": 0.0, "x": 0.5, "m": 0.02}]

    muestras = [d for d in muestras for _ in range(1)]

    simulaciones = 1

    for sim in range(simulaciones):
        for mu in range(len(muestras)):
            juego = Partida(
                jugadores,
                emparejamientos,
                senales,
                sigmas,
                muestras[mu]["b"],
                muestras[mu]["x"],
                muestras[mu]["m"],
                menLen
            )
            juego.jugar()

if __name__ == "__main__":
    main()