現在，筋電センサを用いて動作推定するプログラムを作っているのですが，個人学習する際に得られるデータをトーレーニングデータの書式（csv)と同じようにcsvに出力したいと考えています．使用している筋電センサは8電極あり，8行1列の行列値でデータが取得できます．

例 deque([160067619223897, [-12, 13, 2, 4, 1, 4, 0, 0])のような形式で表示されます．

一方で，トレーニングデータはcsvファイルの1つのセルに1；2；3；4；（省略）63；64；のように64行1列で；で区切られている書式になっています．つまり，８要素のdequeを８個繋げてかつ；で各数字を区切る必要があります．データは貯めておいて連結して8個毎に区切って出力し、次の8個を連結して出力できるようにしたいです。前回，ご回答いただいたコードで実行したところ，8個のデータを連結して，出力できました．ありがとうございます．
**しかし，最初の64個分のデータは出力されたのですが，さらに次の64個のデータも出力したいです．つまり，8要素のデータを8個繋げて64要素のデータの出力を繰り返し行いたいです．大変，恐縮ですが，ご教示頂けないでしょうか？**

どなたか，このようなcsvへの出力の仕方をご存知の方おりませんでしょうか？おりましたら，ぜひご教示ください．以下にデータを取得するコードを記載いたします．gesture列に関しては付与です。  
また，下記のコードを実装すると毎回8個ずつデータがプリントされます．1つめの大きなデータはデータの番号ですdeque([], maxlen=8)  
以下に実行された時のテキストエディタは以下のようになります．（一部記載）

```

    deque([], maxlen=8) paired XDirection.toward_elbow deque([], maxlen=8)
    deque([(1601359906744595, [2, 3, 2, -13, -3, 5, 1, 11]), (1601359906744595, 
    [-2, -5, -7, 2, -9, -2, 0, 2])], maxlen=8) deque([(1601359906800668, [-2, -4, 
    -3, -9, 7, -10, -2, -24]), (1601359906800668, [-1, -1, 1, -27, -108, -18, -4, 
    -8]), (1601359906824581, [1, 3, 4, 25, 35, 14, 2, -2]), (1601359906824581, 
    [-2, -1, -9, -31, -95, -27, -6, 3]), (1601359906826582, [3, 3, 16, 55, 83, 
    31, 6, 9]), (1601359906826582, [-8, 0, -7, -26, -20, -11, -4, -40]), 
    (1601359906838606, [-1, -4, -10, -42, -97, -29, -8, -12]), (1601359906838606, 
    [5, 5, 12, 61, 126, 25, 9, 29])], maxlen=8)
    deque([(1601359906919984, [-2, -6, -8, 43, 8, -1, -3, -6]),(1601359906919984, 
     [0, -2, 1, -1, 3, -2, -3, 1]), (1601359906936890, [-1, -1, 4, -23, -27, -2, 
     1, 0]), (1601359906936890, [-3, -8, -10, -12, 6, -1, -1, -4]), 
     (1601359906951941, [1, 4, 4, 24, 3, 1, -2, -5]
    
```

また，使用しているトレーニングデータは以下のリンクのものを参考にしています．dataディレクトリの中のtrain_data_set.csvです．この形式で出力したいです．  
<https://github.com/exelban/myo-armband-nn>

```

    from collections import deque
    from threading import Lock
    import myo
    import pandas as pd
    import csv
    import numpy as np
    class MyListener(myo.DeviceListener):
    """
    classe en écoute d'un myo
    """
    def __init__(self, queue_size=8):
        self.lock = Lock()  # verrouille le thread pour lecture des donnees
        # création de listes optimisées pour seulement ajouter des éléments
        self.emg_data_queue = deque(maxlen=queue_size)
        self.orientation_data_queue = deque(maxlen=queue_size)
        self.acceleration_data_queue = deque(maxlen=queue_size)
        self.gyroscope_data_queue = deque(maxlen=queue_size)
        self.rssi_data_queue = deque(maxlen=100)
        # initialisation d'attribut
        self.pose = myo.Pose.rest  # pose quelconque
        self.connected = False  # non connecté
        self.battery_level = 100  # niveau de batterie maximal
        self.emg_enabled = False  # on acquiert pas les EMG
        self.locked = False  # myo non vérouillé
        self.rssi = None  # aucune valeur de force du signal bluetooth
        self.emg = None  # données null des emg
        self.device_name = None  # pas de nom du myo
        self.device = None
        self.myo_firmware = None
        self.arm = None
        self.x_direction = None
        self.sync = None
    
    def on_paired(self, event):
        """
        méthode appelée si le myo est appareillé
        """
        if __name__ == '__main__':
            print('paired')
        else:
            pass
    
    def on_unpaired(self, event):
        """
        méthode appelée si le myo n'est plus appareillé
        """
        if __name__ == '__main__':
            print('unpaired')
        else:
            pass
    
    def on_connected(self, event):
        """
        méthode appelé si le myo est connecté
        """
        self.device = event.device  # sauvegarde de l'instance au myo arm
        event.device.unlock()  # demande de desappareiller
        event.device.lock()  # demande d'appareiller (génère des vibrations)
        event.device.stream_emg(True)  # lance l'acquisition des emg
        self.connected = True  # mise à jour du flag de connection du myo
        self.device_name = event.device_name  # on récupère le petit nom du myo
        # on récupère également le numéro du firmware (non exploité dans l'UI)
        self.myo_firmware = '.'.join(map(str, event.firmware_version[:-1]))
    
    def on_disconnected(self, event):
        """
        méthode appelée si le myo est déconnecté
        """
        self.connected = False  # flag mis à jour
    
    def on_arm_synced(self, event):
        """
        méthode appelé si un bras est synchronisé
        pas vraiment compris !!!
        """
        self.sync = True
        self.arm = event.arm  # informe de la latéralité du bras détecté
        # informe de l'orientation du bracelet
        # (vers le poignet ou vers le coude)
        self.x_direction = event.x_direction
        if __name__ == '__main__':
            print(self.x_direction)
        else:
            pass
    
    def on_arm_unsynced(self, event):
        """
        méthode appelée si le bras est désynchronisé
        pas vraiment compris !!!
        """
        self.sync = False
        if __name__ == '__main__':
            print(f'arm unsynced : {event.arm}')
        else:
            pass
    
    def on_unlocked(self, event):
        """
        méthode appelée si le myo est dévérouillé
        """
        self.locked = False  # flag mis à jour
    
    def on_locked(self, event):
        """
        méthode appelée si le myo est vérouillé
        """
        self.locked = True  # flag mis à jour
    
    def on_pose(self, event):
        """
        méthode appelée dès qu'une pose gestuelle est reconnue
    
            a) Spread
            b) Fist
            c) Wave in
            d) Wave out
            e) Double Tap
            f) Rest
        """
        self.pose = event.pose  # attribut mis à jour
    
    def on_orientation(self, event):
        """
        méthode appelée pour récupérer
    
            a) orientation
            b) gyroscope
            c) accéléromètre
            d) associé à un timestamp
        """
        with self.lock:
            self.orientation_data_queue.append((event.timestamp,
                                                event.orientation))
            self.gyroscope_data_queue.append((event.timestamp,
                                              event.gyroscope))
            self.acceleration_data_queue.append((event.timestamp,
                                                 event.acceleration))
    
    def on_rssi(self, event):
        """
        méthode appelée suite à la réponse d'une requête "request_rssi()"
        """
        with self.lock:
            # mise à jour de la liste
            self.rssi_data_queue.append(-event.rssi)
    
    def on_battery_level(self, event):
        """
        méthode appelée dès que le niveau de batterie évolue
        """
        self.battery_level = event.battery_level  # mise à jour de l'attribut
    
    def on_emg(self, event):
        """
        méthode appelée pour réceptionner les données EMG
        avec son timestamp
        """
        with self.lock:
            self.emg_data_queue.append((event.timestamp,
                                        event.emg))
    
    def on_warmup_completed(self, event):
        """
        méthode appelée quand le myo arm est "chaud"
    
        c'est à partir de ce moment que les données sont les plus stables
        mais ça reste à vérifier
    
        pas vraiment pris en compte dans ce code (à faire évoluer)
        """
        event.device.stream_emg(True)  # lancement de l'acquisition EMG
        self.emg_enabled = True  # mise à jour du flag
    
    def get_emg_data(self):
        """
        méthode pour récupérer les données EMGs
        """
        with self.lock:
            return list(self.emg_data_queue)
    
    def get_orientation_data(self):
        """
        méthode pour récupérer les données d'orientation
        """
        with self.lock:
            return list(self.orientation_data_queue)
    
    def get_gyroscope_data(self):
        """
        méthode pour récupérer les données du gyroscope
        """
        with self.lock:
            return list(self.gyroscope_data_queue)
    
    def get_accelerometor_data(self):
        """
        méthode pour récupérer les données de l'accéléromètre
        """
        with self.lock:
            return list(self.acceleration_data_queue)
    
    
    if __name__ == '__main__':
    # permet de tester sans interface graphique
    #import os
    from time import sleep
    myo.init(bin_path=r'C:\Users\ユーザー名\Desktop\myo-sdk-win-0.9.0\bin')
    HUB = myo.Hub()
    LISTENER = MyListener()
    with HUB.run_in_background(LISTENER.on_event):
        while True:
            print(LISTENER.emg_data_queue)
            np.savetxt("data.csv", LISTENER.emg_data_queue, fmt="%r", delimiter=",")
    
```

sleep(0.1)deque([], maxlen=8)

**また，ご教示頂いたコードで実装してみました．  
以下に変更した部分を記載いたします．**

```

    if __name__ == '__main__':
    from time import sleep
    myo.init(bin_path=r'C:\Users\ユーザー名\Desktop\myo-sdk-win-0.9.0\bin')
    HUB = myo.Hub()
    LISTENER = MyListener()
    emg64 = []
    with HUB.run_in_background(LISTENER.on_event):
        while True:
            print(LISTENER.emg_data_queue)
            emg64 = [';'.join(map(str, sum([e[1] for e in 
                     LISTENER.emg_data_queue], []))) + ';']
            np.savetxt("data.csv", emg64, fmt= "%s", delimiter=",")
    
            sleep(0.1)
    
```

以前，教えて頂きまして，以下のコードのように変更しました．8個貯まる要素を8個連結する作業を繰り返し行いたいです．エクセルに連続して，64個のデータを主力していきたいです．上記で示しましたtrain_data_set.csvのように．ご教示の程，よろしくお願い申し上げます．
CC BY-SA 4.0
2020-09-21T08:36:08.310
70584
2020-12-09T11:00:45.243
2020-11-04T11:00:36.177
41671
41671
question
python pandas numpy csv
得られたデータ(deque)を書式に合わせてcsvに出力したいです．
質問記事の加筆修正に対応して改訂：

`LISTENER.emg_data_queue`が0～8個の`deque`データであり、それをバッファリングして8個貯まる毎に1つのデータとして連結して出力するには、以下のようにして出来るはずです。

```

    with HUB.run_in_background(LISTENER.on_event):
        emg_buffer = []
        while True:
            print(LISTENER.emg_data_queue)
            if LISTENER.emg_data_queue:
                emg_buffer.extend([e[1] for e in LISTENER.emg_data_queue])
                LISTENER.emg_data_queue.clear()
            
            if len(emg_buffer) >= 8:
                emg64 = [';'.join(map(str, sum(emg_buffer[:8], []))) + ';']
                np.savetxt("data.csv", emg64, fmt="%s", delimiter=",")
                emg_buffer = emg_buffer[8:] if len(emg_buffer) > 8 else []
            
            sleep(0.1)
    
```
CC BY-SA 4.0
2020-09-22T12:09:59.897
70605
2020-09-30T14:13:54.680
2020-09-30T14:13:54.680
26370
26370
70584
answer