In diesem Tutorial erstellen wir einen Finish-to-Finish-Workflow zur kognitiven Komplexitätsanalyse mit Komplexität. Wir beginnen mit der Messung der Komplexität direkt anhand der Rohcodezeichenfolgen und skalieren dann dieselbe Analyse auf einzelne Dateien und ein gesamtes Projektverzeichnis. Unterwegs generieren wir maschinenlesbare Berichte, normalisieren sie in strukturierte DataFrames und visualisieren Komplexitätsverteilungen, um zu verstehen, wie sich die Entscheidungstiefe über Funktionen hinweg ansammelt. Indem wir kognitive Komplexität als messbares technisches Sign behandeln, zeigen wir, wie sie auf natürliche Weise in die alltägliche Python-Entwicklung und Qualitätsprüfungen integriert werden kann. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

!pip -q set up complexipy pandas matplotlib


import os
import json
import textwrap
import subprocess
from pathlib import Path


import pandas as pd
import matplotlib.pyplot as plt


from complexipy import code_complexity, file_complexity


print(" Put in complexipy and dependencies")

Wir richten die Umgebung ein, indem wir die erforderlichen Bibliotheken installieren und alle für die Analyse und Visualisierung erforderlichen Abhängigkeiten importieren. Wir stellen sicher, dass das Pocket book vollständig eigenständig ist und ohne externe Einrichtung in Google Colab ausgeführt werden kann. Es bildet das Rückgrat der Ausführung für alles, was folgt.

snippet = """
def score_orders(orders):
   complete = 0
   for o in orders:
       if o.get("legitimate"):
           if o.get("precedence"):
               if o.get("quantity", 0) > 100:
                   complete += 3
               else:
                   complete += 2
           else:
               if o.get("quantity", 0) > 100:
                   complete += 2
               else:
                   complete += 1
       else:
           complete -= 1
   return complete
"""


res = code_complexity(snippet)
print("=== Code string complexity ===")
print("Total complexity:", res.complexity)
print("Features:")
for f in res.capabilities:
   print(f" - {f.title}: {f.complexity} (strains {f.line_start}-{f.line_end})")

Wir beginnen mit der Analyse einer rohen Python-Codezeichenfolge, um die kognitive Komplexität auf Funktionsebene zu verstehen. Wir untersuchen direkt, wie verschachtelte Bedingungen und Kontrollflüsse zur Komplexität beitragen. Es hilft uns, das Kernverhalten von complexipy zu validieren, bevor wir es auf echte Dateien skalieren.

root = Path("toy_project")
src = root / "src"
exams = root / "exams"
src.mkdir(dad and mom=True, exist_ok=True)
exams.mkdir(dad and mom=True, exist_ok=True)


(src / "__init__.py").write_text("")
(exams / "__init__.py").write_text("")


(src / "easy.py").write_text(textwrap.dedent("""
def add(a, b):
   return a + b


def safe_div(a, b):
   if b == 0:
       return None
   return a / b
""").strip() + "n")


(src / "legacy_adapter.py").write_text(textwrap.dedent("""
def legacy_adapter(x, y):
   if x and y:
       if x > 0:
           if y > 0:
               return x + y
           else:
               return x - y
       else:
           if y > 0:
               return y - x
           else:
               return -(x + y)
   return 0
""").strip() + "n")


(src / "engine.py").write_text(textwrap.dedent("""
def route_event(occasion):
   variety = occasion.get("variety")
   payload = occasion.get("payload", {})
   if variety == "A":
       if payload.get("x") and payload.get("y"):
           return _handle_a(payload)
       return None
   elif variety == "B":
       if payload.get("flags"):
           return _handle_b(payload)
       else:
           return None
   elif variety == "C":
       for merchandise in payload.get("gadgets", ()):
           if merchandise.get("enabled"):
               if merchandise.get("mode") == "quick":
                   _do_fast(merchandise)
               else:
                   _do_safe(merchandise)
       return True
   else:
       return None


def _handle_a(p):
   complete = 0
   for v in p.get("vals", ()):
       if v > 10:
           complete += 2
       else:
           complete += 1
   return complete


def _handle_b(p):
   rating = 0
   for f in p.get("flags", ()):
       if f == "x":
           rating += 1
       elif f == "y":
           rating += 2
       else:
           rating -= 1
   return rating


def _do_fast(merchandise):
   return merchandise.get("id")


def _do_safe(merchandise):
   if merchandise.get("id") is None:
       return None
   return merchandise.get("id")
""").strip() + "n")


(exams / "test_engine.py").write_text(textwrap.dedent("""
from src.engine import route_event


def test_route_event_smoke():
   assert route_event({"variety": "A", "payload": {"x": 1, "y": 2, "vals": (1, 20)}}) == 3
""").strip() + "n")


print(f" Created venture at: {root.resolve()}")

Wir erstellen programmgesteuert ein kleines, aber realistisches Python-Projekt mit mehreren Modulen und Testdateien. Wir integrieren bewusst unterschiedliche Kontrollflussmuster, um sinnvolle Unterschiede in der Komplexität zu schaffen. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

engine_path = src / "engine.py"
file_res = file_complexity(str(engine_path))


print("n=== File complexity (Python API) ===")
print("Path:", file_res.path)
print("File complexity:", file_res.complexity)
for f in file_res.capabilities:
   print(f" - {f.title}: {f.complexity} (strains {f.line_start}-{f.line_end})")


MAX_ALLOWED = 8


def run_complexipy_cli(project_dir: Path, max_allowed: int = 8):
   cmd = (
       "complexipy",
       ".",
       "--max-complexity-allowed", str(max_allowed),
       "--output-json",
       "--output-csv",
   )
   proc = subprocess.run(cmd, cwd=str(project_dir), capture_output=True, textual content=True)


   preferred_csv = project_dir / "complexipy.csv"
   preferred_json = project_dir / "complexipy.json"


   csv_candidates = ()
   json_candidates = ()


   if preferred_csv.exists():
       csv_candidates.append(preferred_csv)
   if preferred_json.exists():
       json_candidates.append(preferred_json)


   csv_candidates += listing(project_dir.glob("*.csv")) + listing(project_dir.glob("**/*.csv"))
   json_candidates += listing(project_dir.glob("*.json")) + listing(project_dir.glob("**/*.json"))


   def uniq(paths):
       seen = set()
       out = ()
       for p in paths:
           p = p.resolve()
           if p not in seen and p.is_file():
               seen.add(p)
               out.append(p)
       return out


   csv_candidates = uniq(csv_candidates)
   json_candidates = uniq(json_candidates)


   def pick_best(paths):
       if not paths:
           return None
       paths = sorted(paths, key=lambda p: p.stat().st_mtime, reverse=True)
       return paths(0)


   return proc.returncode, pick_best(csv_candidates), pick_best(json_candidates)


rc, csv_report, json_report = run_complexipy_cli(root, MAX_ALLOWED)

Wir analysieren eine echte Quelldatei mithilfe der Python-API und führen dann die komplexe CLI für das gesamte Projekt aus. Wir führen die CLI aus dem richtigen Arbeitsverzeichnis aus, um zuverlässig Berichte zu erstellen. Dieser Schritt verbindet die lokale API-Nutzung mit statischen Analyse-Workflows im Produktionsstil.

df = None


if csv_report and csv_report.exists():
   df = pd.read_csv(csv_report)
elif json_report and json_report.exists():
   knowledge = json.masses(json_report.read_text())
   if isinstance(knowledge, listing):
       df = pd.DataFrame(knowledge)
   elif isinstance(knowledge, dict):
       if "information" in knowledge and isinstance(knowledge("information"), listing):
           df = pd.DataFrame(knowledge("information"))
       elif "outcomes" in knowledge and isinstance(knowledge("outcomes"), listing):
           df = pd.DataFrame(knowledge("outcomes"))
       else:
           df = pd.json_normalize(knowledge)


if df is None:
   elevate RuntimeError("No report produced")


def explode_functions_table(df_in):
   if "capabilities" in df_in.columns:
       tmp = df_in.explode("capabilities", ignore_index=True)
       if tmp("capabilities").notna().any() and isinstance(tmp("capabilities").dropna().iloc(0), dict):
           fn = pd.json_normalize(tmp("capabilities"))
           base = tmp.drop(columns=("capabilities"))
           return pd.concat((base.reset_index(drop=True), fn.reset_index(drop=True)), axis=1)
       return tmp
   return df_in


fn_df = explode_functions_table(df)


col_map = {}
for c in fn_df.columns:
   lc = c.decrease()
   if lc in ("path", "file", "filename", "module"):
       col_map(c) = "path"
   if ("perform" in lc and "title" in lc) or lc in ("perform", "func", "function_name"):
       col_map(c) = "perform"
   if lc == "title" and "perform" not in fn_df.columns:
       col_map(c) = "perform"
   if "complexity" in lc and "allowed" not in lc and "max" not in lc:
       col_map(c) = "complexity"
   if lc in ("line_start", "linestart", "start_line", "startline"):
       col_map(c) = "line_start"
   if lc in ("line_end", "lineend", "end_line", "endline"):
       col_map(c) = "line_end"


fn_df = fn_df.rename(columns=col_map)

Wir laden die generierten Komplexitätsberichte in Pandas und normalisieren sie in eine Tabelle auf Funktionsebene. Wir verarbeiten mehrere mögliche Berichtsschemata, um den Workflow stabil zu halten. Diese strukturierte Darstellung ermöglicht es uns, mit Commonplace-Datenanalysetools über die Komplexität nachzudenken.

if "complexity" in fn_df.columns:
   fn_df("complexity") = pd.to_numeric(fn_df("complexity"), errors="coerce")
   plt.determine()
   fn_df("complexity").dropna().plot(variety="hist", bins=20)
   plt.title("Cognitive Complexity Distribution (capabilities)")
   plt.xlabel("complexity")
   plt.ylabel("depend")
   plt.present()


def refactor_hints(complexity):
   if complexity >= 20:
       return (
           "Break up into smaller pure capabilities",
           "Exchange deep nesting with guard clauses",
           "Extract complicated boolean predicates"
       )
   if complexity >= 12:
       return (
           "Extract inside logic into helpers",
           "Flatten conditionals",
           "Use dispatch tables"
       )
   if complexity >= 8:
       return (
           "Cut back nesting",
           "Early returns"
       )
   return ("Acceptable complexity")


if "complexity" in fn_df.columns and "perform" in fn_df.columns:
   for _, r in fn_df.sort_values("complexity", ascending=False).head(8).iterrows():
       cx = float(r("complexity")) if pd.notna(r("complexity")) else None
       if cx is None:
           proceed
       print(r("perform"), cx, refactor_hints(cx))


print(" Tutorial full.")

Wir visualisieren die Verteilung der kognitiven Komplexität und leiten Refactoring-Anleitungen aus numerischen Schwellenwerten ab. Wir übersetzen abstrakte Komplexitätswerte in konkrete technische Maßnahmen. Es schließt den Kreis, indem es die Messung direkt mit Entscheidungen zur Wartbarkeit verknüpft.

Abschließend stellten wir eine praktische, reproduzierbare Pipeline zur Prüfung der kognitiven Komplexität in Python-Projekten mithilfe von complexipy vor. Wir haben gezeigt, wie wir von der Advert-hoc-Inspektion zu datengesteuerten Überlegungen zur Codestruktur übergehen, risikoreiche Funktionen identifizieren und umsetzbare Refactoring-Anleitungen auf der Grundlage quantifizierter Schwellenwerte bereitstellen können. Der Workflow ermöglicht es uns, frühzeitig über die Wartbarkeit nachzudenken, Komplexitätsbudgets konsequent durchzusetzen und Codebasen mit Klarheit und Zuversicht zu entwickeln, anstatt uns ausschließlich auf die Instinct zu verlassen.

---

Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

[ad_2]

Ich habe neulich mit jemandem über eine umstrittene Behauptung in der Wissenschaft gesprochen, etwas, das anscheinend niemand, einschließlich der Forscher, die die ursprüngliche Behauptung veröffentlicht haben, jemals reproduziert hat. An diesem besonderen Beispiel waren weder Brian Wansink noch Dan Ariely beteiligt, noch battle das der Fall Glücksgolfball Studie, die von der Affiliation for Psychological Science gefördert wurde, lange nachdem sie entlarvt worden battle (nicht, dass eine Entlarvung nötig gewesen wäre, wenn man bedenkt, wie lächerlich die Studie überhaupt battle); Tatsächlich hatte es überhaupt nichts mit Psychologie zu tun, aber es hatte insofern einen ähnlichen Geschmack, als das Fehlen jeglichen Versuchs, es zu reproduzieren, bei meinem Korrespondenten ein Gefühl des Misstrauens auslöste: ob es nun Betrug ist oder sich die Wege verzweigen oder Clarkes Gesetz oder was auch immer, da hatte er das Gefühl, dass etwas Verdächtiges vor sich ging. Anders ausgedrückt: Ja, Ehrlichkeit und Transparenz sind es nicht genugund es ist für gute Leute möglich, schlechte Wissenschaft zu betreiben, wenn sie Regeln befolgen, die keinen Sinn ergeben, aber in diesem Fall schien es, dass es im System eine gewisse Unehrlichkeit und Intransparenz gab.

Hier ist meine Frage.

Aus demselben Grund, aus dem diese Probleme meinem Korrespondenten klar waren, sollten sie auch anderen klar sein. Wie bleibt das additionally über Wasser?

Ich weiß es nicht, aber hier ist eine Theorie. Es hilft, einen Kern von Betrug oder Bösgläubigkeit zu haben – einige Forscher im Inneren, die das Gefühl haben, die Antwort bereits zu kennen und bereit sind, alles zu tun, um diese Antwort aus den Daten herauszuholen. Aber dann brauchen Sie eine Gruppe um sich herum, die motiviert ist, den Ball in der Luft zu halten, und zwar aus einer Mischung aus Verwirrung, Wunschdenken, Fehlinterpretationsbeweisen und politischer oder wissenschaftlicher Ideologie.

Ich denke, dass meine Sichtweise sich geringfügig von unserem üblichen Modell wissenschaftlicher Fehler und wissenschaftlichen Fortschritts unterscheidet.

Nach dem üblichen Modell entwickeln Forscher Ideen und entwerfen Experimente, um sie zu testen, und Forscher sammeln Daten, aus denen sie neue Dinge lernen und so neue Theorien und neue Experimente anregen. Auch bei diesem üblichen Modell gibt es manchmal (oft!) Fehler: Schlechte Theorien werden getestet und manchmal scheinbar bestätigt, falsche Schlussfolgerungen werden aus Daten gezogen und schließlich werden schlechte Ideen verworfen oder modifiziert, um sie mit der Realität in Einklang zu bringen, wie sie durch Folgestudien, direkte und indirekte Replikationen, neue Theorien usw. dargestellt wird. Das ist die selbstkorrigierende Natur der Wissenschaft.

Eine Sache, die ich in der Vergangenheit betont habe, ist, dass sich „Wissenschaft“ nur deshalb selbst korrigiert, weil einzelne Wissenschaftler die Arbeit übernehmen, frühere Theorien und empirische Behauptungen zu überprüfen, Theorien zu überarbeiten und im Allgemeinen die Aufzeichnungen zu korrigieren. Es ähnelt der Artwork und Weise, wie die Kontrollen und Gegenkontrollen unserer Regierung auf tatsächlichen Regierungsbeamten beruhen, die die Kontrolle und den Ausgleich durchführen. Das System besteht aus Menschen; nichts ist automatisch.

Aber mein Standpunkt in diesem Beitrag ist etwas anders. Hier geht es mir nicht so sehr darum, wie Fehler untersucht und behoben werden, sondern vielmehr darum, wie sie sich verbreiten. Und was ich sagen möchte ist, dass ich denke, dass dies ziemlich absichtlich geschieht.

Ich meine das nicht unbedingt auf eine unheimliche Artwork und Weise, nämlich die Vorstellung, dass schlaue Forscher ihre Netzwerkfähigkeiten nutzen, um schlechte Arbeit in die Literatur einzubringen – auch wenn ich denke, dass dies ständig vorkommt –, sondern allgemeiner gesagt, dass es viel aktiver Anstrengung bedarf, um diese schlechten Ideen in verkörperter Kognition, Evolutionspsychologie, unterschwelligen Effekten usw. fortzuführen und in der wissenschaftlichen Literatur fortzuführen. Ebenso wie das Ungeheuer von Loch Ness, UFOs als Außerirdische im Weltraum und verschiedene politische Verschwörungstheorien eine ständige Aktualisierung erfordern, um in den Nachrichten zu bleiben. Ja, die Menschen haben alle möglichen dummen Überzeugungen – ein Drittel der Amerikaner gibt an, an Geister zu glauben! –, aber passiver Glaube reicht nicht aus. Intestine vernetzte Menschen müssen sie aktiv fördern, sonst geraten sie in den Hintergrund des kollektiven Bewusstseins.

Zusammenfassend denke ich, dass man, damit schlechte Wissenschaft bestehen und fortbestehen kann, (1) einen Kern ethisch oder methodisch beeinträchtigter Menschen braucht, die bereit sind, Daten zu fabrizieren oder irreführende Beweise zu liefern, und (2) eine größere Gruppe von Menschen, die, aus welchen Gründen auch immer, bereit sind, ihre natürliche Skepsis aufzugeben, um diese Ideen zu fördern.

Dies gibt auch Aufschluss darüber, warum es so schwierig sein kann, den Datensatz zu korrigieren (wie die Grafik oben in diesem Beitrag zeigt). Bei diesen schlechten Ideen handelt es sich nicht nur um Fehler, die leider in der Literatur verbreitet wurden; Es sind Fehler oder Betrügereien oder Fehler, die so schlimm sind, dass sie genauso intestine sind wie die Betrügereien, die es dann gibt geschoben in die Literatur und gepflegt dort durch die Bemühungen lokal mächtiger Eliten, wie zum Beispiel als Freakonomics dies förderte unzählig Studie zum Verhältnis von Schönheit und Geschlecht und zum Klimawandel Denier.

Abrufen diese Geschichte vom Psychologen Greg Francis, der von seinen Schwierigkeiten erzählt, sich gegen dieses schreckliche „Glücksgolfball“-Papier zu wehren:

Im Jahr 2012 habe ich bei Psychological Sciences einen Kommentar zu Damish et al. eingereicht. (2010), als mir klar wurde, dass die Ergebnisse „zu intestine um wahr zu sein“ schienen. Der Herausgeber lehnte den Kommentar ab und stützte sich dabei auf das Suggestions eines „sehr distanzierten Professors für experimentelles Design und statistische Methoden“, der (unter anderem) schrieb: „Es würde mich überhaupt nicht überraschen, wenn eine Publikationsverzerrung im Spiel wäre. Wenn ich eine Studie über Aberglauben durchgeführt hätte und die Ergebnisse null wären, würde ich sie wahrscheinlich nicht zur Veröffentlichung einreichen.“

Damals battle mir das noch nicht aufgefallen, aber später wurde mir klar, dass die in Experiment 4 von Damish et al. Papier besteht einen GRIM-Take a look at nicht. Der Maßstab für die Leistung ist die Anzahl der korrekt identifizierten Wörter, daher muss die Summe der Punktzahlen aller Teilnehmer jeder Bedingung ein ganzzahliger Wert sein. Damish et al. Geben Sie nicht ihre Stichprobengröße für jede der beiden Bedingungen an, sondern nur die Gesamtstichprobengröße (n1+n2=29). Der gemeldete Mittelwert für Teilnehmer mit Glücksbringer (M1=45,84) und der Mittelwert für Teilnehmer ohne Glücksbringer (M2=30,56) können nicht gleichzeitig durch eine Kombination von n1 und n2 Stichprobengrößen ermittelt werden, die zusammen eine Gesamtstichprobengröße von 29 ergeben. Wenn beispielsweise n1=14, dann wäre die Summe der Bewertungen n1*M1=641,76, was vermutlich auf 642 aufgerundet wird (muss). eine ganze Zahl sein, da es sich um die Anzahl korrekt identifizierter Wörter handelt). Aber 642/14=45,857, was nicht mit den gemeldeten 45,84 übereinstimmt. Auch das Abrunden hilft nicht, denn 641/14 = 45,785, was nicht dem gemeldeten Mittelwert entspricht. Es gibt keine Möglichkeit, M1=45,84 von n1=14 Teilnehmern zu erhalten. Für andere Kombinationen von n1 und n2 können Sie eines der Mittel verwenden, um einen Sinn zu ergeben, jedoch niemals beide gleichzeitig.

Additionally, ja, die Arbeit an diesem albernen Thema wird in die Zeitschriften gedrängt und abweichende Meinungen werden zurückgewiesen. Diese Artwork von Verhalten steht im Einklang mit einer Lakatos‘schen Sicht auf wissenschaftliche Forschungsprogramme, daher sind wir uns, die über die Soziologie der Wissenschaft nachdenken, in gewisser Weise dessen bewusst. Ich denke jedoch, dass wir leicht in die naive Ansicht verfallen, dass schlechte Ideen nur Fehler sind, die eine Weile bestehen bleiben, bis sie schließlich durch fehlgeschlagene Replikationen widerlegt werden. Tatsächlich werden große Anstrengungen unternommen, um den Established order aufrechtzuerhalten, zu denen auch Angriffe der Regierung gehören Redaktionen von wissenschaftlichen Zeitschriften; die wiederholte Verwendung von PNAS, Ted, NPR usw. zur Förderung schlechter Arbeit; Unterdrückung abweichender Meinungen (wie es Greg Francis widerfahren ist, wie oben beschrieben); und Förderung von Fehlinformationen durch große akademische Institutionen. Nach vielen Jahren hörte Harvard endlich auf, diesen Betrug zu fördern Jesu Frau Manuskript, aber meines Wissens haben sie ihr Manuskript nie zurückgezogen lächerliche Behauptung dass die Replikationsrate in der Psychologie „statistisch nicht von 100 % zu unterscheiden ist“.

Auch hier gibt es für jedes dieser Dinge den ethisch oder methodisch korrupten Kern und dann die größere Gruppe von Influencern, die Dinge bewerben, obwohl sie es besser wissen sollten, vermutlich aus dem Gefühl heraus, dass die schlechte Arbeit die richtige Richtung hat und es daher verdient, vor Kritik geschützt zu werden.

[ad_2]