常連

テラテイラー

回答者

ベストアンサー

拍手喝采

プロフェッサー

スピードスナイプ

先生

自己紹介

有名人

### 実現したいこと

ぱっと見では、

あり得ないだろうかも　知れない、
もしかしたら　Python開発者しか、
対処不可能かも　知れない、
挙動不振を　何とかしたい。

_
### 前提

・pythonで　配列データを、
＿スライスして　再結合する、
＿コーディングを　しました。
_

環境、

ウィンドウズ１１　　22H2
Powershell　　　　　7.3.3
python　　　　　　　3.11×64bit　Microsoft配布版
Visual Studio Code　1.76.1

＿
### 発生している問題・エラーメッセージ

※注：エラーメッセージは　ありません。

・配列データが　確率的に、
＿一部　欠損します、
＿失われたり、失われなかったり、
＿します。

・コード初見時　100％、
＿誰もが　嘘を、
＿疑うでしょう。

＿
### 該当のソースコード

```Python　iround.py(参照受けルーチン。)
import numpy as LAC

def iround(lis: list, dimensyon: int = 0, istypeint: bool = True):
     temp = (LAC.asarray(LAC.asarray((LAC.fabs((I := LAC.array(lis))) * (dimtemp := 10 **
            (0 - dimensyon + 1)) + 5) / 10, dtype=int), dtype=float) * LAC.sign(I)) / dimtemp * 10
    return LAC.asarray(temp, dtype=int) if (dimensyon > -1) and istypeint else temp
```

```Python　リスト操作。
# coding: UTF-8
# python3.11

from logging import StreamHandler, FileHandler, getLogger, DEBUG, INFO, ERROR, Formatter, WARNING, CRITICAL
import pytest
import traceback as TB
import functools as FT
import itertools as IT
import math as MT
import random as RA
import numpy as LAC  # List Array Control.
import tqdm as PGR  # Progress rate.
from iround import iround
import sys


# Backtrace define section.
ERRORformatter = Formatter(
    "  Alert I I %(levelname)s   %(message)s %(asctime)s %(filename)s")
formatter = Formatter(
    "[%(levelname)s] %(asctime)s - %(message)s (%(filename)s)")
logger = getLogger(__name__)

nomalhandler = FileHandler("DEBUG.log")
nomalhandler.setLevel(DEBUG)
nomalhandler.setFormatter(formatter)

WARNINGhandler = FileHandler("WARNING.log")
WARNINGhandler.setLevel(WARNING)
WARNINGhandler.setFormatter(formatter)

terminalhandler = StreamHandler()
terminalhandler.setLevel(ERROR)
terminalhandler.setFormatter(ERRORformatter)

logger.setLevel(DEBUG)
logger.addHandler(nomalhandler)
logger.addHandler(WARNINGhandler)
logger.addHandler(terminalhandler)


# Data definition section.
recursionlimit = sys.getrecursionlimit()
DisDataanomal = 0
E_Recursivecount = 0
Recursivemount = 3
C_Recursivecount = 0
C_Dataanomaly = 0
P_Dataanomaly = 0

# Unique random number routine.
#   Center-biased random number.
def Cran(end: int, start: int = 1, Centralization: int = 3):
    return iround([LAC.average(LAC.random.randint(start, end + 1,  Centralization))])[0]
# Combining Shuffle routine.


def list_action(action_times: int = 3, Orderlist: list = list(range(1, 55 + 1))):
    try:
        assert isinstance(Orderlist, (LAC.ndarray, list)) and not (isinstance(
            Orderlist[0], (LAC.ndarray, list)))
    except AssertionError:
        logger.debug(TB.format_exc)
    Orderlistlen = len(Orderlist)
    Spare_Orderlist = Orderlist

# Random biased on one side.
    def Eran2(end: int, start: int = 1):
        temporary1 = RA.randint(start, min(end, 4 + start) + 1)
        try:
            assert temporary1 >= start
        except AssertionError:
            logger.debug(TB.format_exc)
            logger.debug(
                f"Eran ŗ    l ُ픭   temporary1 = {temporary1}")
            return Eran2(end)
        except RecursionError:
#            E_Recursivecount += 1
            logger.warning(TB.format_exc)
            logger.warning(
                f"Eran ōċA Ăяo   񐔂 {Recursivemount} 񕪑  ₵ ܂   ")
            sys.setrecursionlimit(
                sys.getrecursionlimit() + Recursivemount)
        except MemoryError:
            logger.error(TB.format_exc)
            raise MemoryError
        return temporary1

# Overlap and integrate - routine.
    def Merements(target: list, removalside: list):
        temp1 = len(removalside)
        if temp1 < 3:
            target = removalside + target
            removalside = []
        else:
            temp2 = -Eran2(temp1)
            target = removalside[len(
                removalside) + temp2: len(removalside)] + target
            removalside = removalside[: temp2]
        return target, removalside

    for J in range(action_times):
        temp1 = Cran(len(Orderlist), Centralization=15)
        temporary1 = Orderlist[:temp1]
        temporary2 = Orderlist[temp1:]
        temporary3 = []
        while (len(temporary1) > 0) and (len(temporary2) > 0):
            temporary3, temporary1 = Merements(temporary3, temporary1)
            temporary3, temporary2 = Merements(temporary3, temporary2)
        Orderlist = temporary1 + temporary2 + temporary3
    try:
        assert Orderlistlen == len(Orderlist)
    except AssertionError:
        logger.warning(TB.format_exc)
        logger.warning(
            f"list_action Ńf [ ^ ُ픭   Orderlistlen = {len(Orderlist)}")
        Orderlist = list_action(Orderlist=Spare_Orderlist)
    except RecursionError:
        logger.warning(TB.format_exc)
        logger.warning(
            f"list_action ōċA Ăяo   񐔂 {Recursivemount} 񕪑  ₵ ܂   ")
        sys.setrecursionlimit(
            sys.getrecursionlimit() + Recursivemount)
    except MemoryError:
        logger.error(TB.format_exc)
        raise MemoryError
    return Orderlist


# Durability test routine.
def Durabilitytest(plactics: int):
    l = 0
    for j in PGR.tqdm(range(plactics)):
        l += (len(list_action()) != 55) + 0
    print(f"{l} {l / plactics * 100}%")


# main
Durabilitytest(10 ** 7)
```
### 試したこと

データ欠損異常が、

以下の　範囲で、
集中して　発生している事を、
突き止めました。
```　Python
    def Merements(target: list, removalside: list):
        temp1 = len(removalside)
        if temp1 < 3:
            target = removalside + target
            removalside = []
        else:
            temp2 = -Eran2(temp1)
            target = removalside[len(
                removalside) + temp2: len(removalside)] + target
            removalside = removalside[: temp2]
        return target, removalside

    for J in range(action_times):
        temp1 = Cran(len(Orderlist), Centralization=15)
        temporary1 = Orderlist[:temp1]
        temporary2 = Orderlist[temp1:]
        temporary3 = []
        while (len(temporary1) > 0) and (len(temporary2) > 0):
            temporary3, temporary1 = Merements(temporary3, temporary1)
            temporary3, temporary2 = Merements(temporary3, temporary2)
        Orderlist = temporary1 + temporary2 + temporary3
```

しかし、

Merementsルーチン内で、
異常は　発生しませんでした。
＿

詰り、

以下の　範囲内で、
データ欠損異常が　発生しているものと、
思われます。
```　Python
    for J in range(action_times):
        temp1 = Cran(len(Orderlist), Centralization=15)
        temporary1 = Orderlist[:temp1]
        temporary2 = Orderlist[temp1:]
        temporary3 = []
        while (len(temporary1) > 0) and (len(temporary2) > 0):
          処理、
        Orderlist = temporary1 + temporary2 + temporary3
```
＿

流石に、

此は　初任者では、
どうこうできる　レベルを、
超えてそうな　気が、
しています、

ご教示を　お願いします。
＿

### 補足情報

実行すると、

大量の　Warningを、
ファイルに　吐き出し始めます、
お気をつけを。

### 追記
なんだか、

酷い　虚実な、
誹り、誹謗中傷、悪態を、
つけられてますので、

どっちが　聞く、
耳を　持たないのか、
どっちが　迷惑行為を、
仕掛けているのか、

検証Coding提示によって、
明らかにしたいと　思います。
_
是非、

お手元で　検証を、
頂き、
原因究明に　お役立て、
頂ければ　幸いです。

_
尚、

当然ですが　当該環境では、
ok以外の　結果は、
詰まり　データ欠損は、
存在しませんでした。

_
Merementsルーチンは、

無問題である旨、
示したにも　関わらず、
他者の　仕業を、
軽軽しく　踏みにじり、

_
おまけに、

冒涜の限りを、
尽くす　姿勢には、
誰であろうと　看過できない、
事でしょう。

_
Merements検証ルーチン。
```Python3.11．1
j = 0
k = 0
Eran2 = lambda X: j
def test(func):
    pass
    def wrap(*args, **kwargs):
        a = [1, 2, 3, 4, 5, 6, 7]
        master = []
        global k, j
        for i in a:
            master.append(a)
            applicable = master
            for j in range(-1, -7, -1):
                temp1, temp2 = func([], applicable)
                k += 0 if len(master) == len(temp1) + len(temp2) else 1
        return
    return wrap

@test
def Merements(target: list, removalside: list):
    temp1 = len(removalside)
    if temp1 < 3:
        target = removalside + target
        removalside = []
    else:
        temp2 = -1 * Eran2(temp1)
        target = removalside[len(removalside) +
                             temp2: len(removalside)] + target
        removalside = removalside[: temp2]
    return target, removalside

print(str(k) if Merements([], []) else "ok")
```