Usunięcie ifa z wybranej funkcji

Cześć, mam problem z usunięciem wybranego ifa z kilku funkcji i zapisaniem zmian do nowego pliku. Wiem jak odnaleźć funkcję do poprawy, ale mam problem z ifem.
W środku ifa, są tylko wywołania funkcji.
Nagłówek if mi się usuwa ale same nawiasy wraz z kodem w środku zostają :(

Zrobiłem coś takiego

with open(ścieżka_do_zapisu, 'w') as zapis:
    write open(ścieżka_do_odczytu, 'r') as odczyt:
        for linia in odczyt
            if_funkcja = "if(nazwa_zniennej > 6)"
            if if_funkcja in linia:
                linia = ""
                if "}" in linia:
                    break
            zapis.write(linia)

Obawiam się, że Twoje pytanie jest zbyt nie precyzyjne. Nie mam pojęcia o co Ci chodzi

Cześć @Ibag! Fajnie że zadałeś pytanie na forum.

Czy próbujesz napisać program, który edytuje kod źródłowy jakiegoś języka programowania? Jeśli tak, to operacja którą próbujesz wykonać nazywa się parsowanie, i ogólnie rzecz biorąc jest to operacja która wymaga wielu kroków, większość ludzi decyduje się na skorzystanie już z gotowego parsera. Jeśli jednak chcesz spróbować swoich sił to może napisać swój własny parser, ale wymaga to wielu operacji na stringach, dużo logiki, napisania tokenizera, leksera, zbudowanie AST, etc.

Po Twoim kodzie widzę że język programowania który parsujesz ma składnię podobną do C, strzelam że może to być JavaScript, Java lub C#? Jeśli to JavaScript, to tutaj masz przykład parsera JS w pythonie: https://github.com/PiotrDabkowski/pyjsparser

Przykład:

>>> from pyjsparser import parse
>>> parse('var $ = "Hello!"')
{
"type": "Program",
"body": [
    {
        "type": "VariableDeclaration",
        "declarations": [
            {
                "type": "VariableDeclarator",
                "id": {
                    "type": "Identifier",
                    "name": "$"
                },
                "init": {
                    "type": "Literal",
                    "value": "Hello!",
                    "raw": '"Hello!"'
                }
            }
        ],
        "kind": "var"
    }
  ]
}

Gdyby chodziło o inne języki, to tutaj masz parser w pythonie do javy: https://github.com/c2nes/javalang.

Daj znać czy o to Ci chodziło, pozdrawiam

Piszę w jezyku python

Mam kilka funkcji a w nich klika pętli if. Chciałbym z wybranych funkcji usunąć całego wybranego ifa czyli if { i wszystko to co tu jest} wraz z jego nawiasami. I zapisać zmiany do nowego pliku

Ibag napisał(a):

Mam kilka funkcji a w nich klika pętli if. Chciałbym z wybranych funkcji usunąć całego wybranego ifa czyli if { i wszystko to co tu jest} wraz z jego nawiasami. I zapisać zmiany do nowego pliku

Mógłbyś pokazać treść pliku, z którego próbujesz usunąć wybranego ifa?

Gównie to wygląda w ten sposób

Funkcja(naza_funkcji)
{
    if(nazwa_zniennej_1 > 6):
    {
    wywolanie_funkcji_1()
    wywolanie_funkcji_2()
    wywolanie_funkcji_3()
    }

    if(nazwa_zniennej_2 > 7):
    {
    wywolanie_funkcji_4()
    wywolanie_funkcji_5()
    wywolanie_funkcji_6()
    }

    if(nazwa_zniennej_3 > 2):
    {
    wywolanie_funkcji_1()
    wywolanie_funkcji_4()
    wywolanie_funkcji_3()
    }
}

Muszę usunąć ifa który dot. wybranej zamiennej.

Ibag napisał(a):

Gównie to wygląda w ten sposób

[...]

Nie przypomina mi to żadnego języka programowania który znam Co to za język programowania? Jeśli to jakiś standardowy, to możliwe że istnieją gotowe narzędzia do parsowania tego.

Co do Twojego przykładu kodu, nie wiem dokładnie jakie są różnice pomiędzy tymi ifami, nazwa zmiennej, warunek, operator, ilość linijek, funkcje które są w ciele warunku, ich argumenty, jakieś dodatkowe wyrażenia, wszystko to może wpłynąć na finalny kod.

Ale jeśli cały Twój use-case widać na załączonym kodzie, to możesz to bardzo łatwo rozwiązać wyrażeniem regularnym:

• Najpierw znalazłem wyrażenie regularne, którym można "złapać" Twoją funkcje: https://regex101.com/r/qvFpaV/1
• Potem wyszukałem w google "python how to replace string with regexp", znalazłem funkcję re.sub()

I uzyskałem taki kod:

value = """
Funkcja(naza_funkcji)
{
    if(nazwa_zniennej_1 > 6):
    {
    wywolanie_funkcji_1()
    wywolanie_funkcji_2()
    wywolanie_funkcji_3()
    }

    if(nazwa_zniennej_2 > 7):
    {
    wywolanie_funkcji_4()
    wywolanie_funkcji_5()
    wywolanie_funkcji_6()
    }

    if(nazwa_zniennej_3 > 2):
    {
    wywolanie_funkcji_1()
    wywolanie_funkcji_4()
    wywolanie_funkcji_3()
    }
}
"""
import re

print(re.sub(r'if\(nazwa_zniennej_1 > 6\)[^}]+\}', '', value))

Działa to super gdy używamy stringa, który zawiera cały plik, a czy można usunąć ifa zaczytując plik linia po lini?

Ibag napisał(a):

Działa to super gdy używamy stringa, który zawiera cały plik, a czy można usunąć ifa zaczytując plik linia po lini?

A jaki efekt konkretnie chciałbyś uzyskać? Bo jeśli martwisz się wydajnością, to raczej ja bym to zostawił na później. Plik musiałby mieć miliony linijek, żeby to miało jakieś znaczenie. Wczytywanie tego po linijce najpewniej będzie wolniejsze.

W Pythonie możesz wczytać i zapisać cały plik używając:

write open(ścieżka_do_odczytu, 'r') as file:
    content = file.read()

removed = re.sub(r'if\(nazwa_zniennej_1 > 6\)[^}]+\}', '', content)

with open(ścieżka_do_zapisu, 'w') as file:
  file.write(removed)

@Ibag Dlaczego potrzebujesz to zrobić linijka po linijce? Jeśli będę wiedział jaki masz konkretnie powód, łatwiej mi będzie zaproponować dobre rozwiązanie.

Mam takie zadanie, czytanie tego pliku linia po lini używając pętli for.
Nie mogę użyć czytania całego pliku. Problem też jest że każdy if jest inny ( ma różną długość)
Twoje rozwiązanie działa naprawdę fajnie, ale muszę to czytać linia po linii.

Czy możesz mieć zagnieżdżone klamry?
Ogólnie to czytasz linia po linii, szukasz swojego otwarcia if i potem zamknięcia (klamry zamykającej).
Jeżeli możesz mieć zagnieżdżone bloki kodu to musisz je pominąć.
Wygląda to wtedy na modyfikację algorytmu https://leetcode.com/problems/valid-parentheses/ (de facto interesują cię tylko {} )

Ibag napisał(a):

Mam takie zadanie, czytanie tego pliku linia po lini używając pętli for.
Nie mogę użyć czytania całego pliku. Problem też jest że każdy if jest inny ( ma różną długość)
Twoje rozwiązanie działa naprawdę fajnie, ale muszę to czytać linia po linii.

Ktokolwiek dał Ci to zadanie, nie pokazuje Ci dobrej drogi do nauki programowania. Są faktycznie problemy które wymagają przetwarzania treści po kawałku (chunks). Głównym powodem ku temu jest wydajność, kiedy chcemy przetworzyć plik który ma 60GB, i nie da się go wczytać całego do ramu - wtedy jaknajbardziej. Ale w przypadku kiedy mamy mały rozmiar pliku, przetwarzanie tego linijka po linijce dodaje tylko dodatkową, niepotrzebną złożoność. Nie mówiąc o tym, że jest to całkowicie zbędne, bo program napisany który wczytuje plik w całości, oraz program który robi to linijka po linijce, po samym tylko działaniu programu, nie da się ich rozróżnić. Ja na Twoim miejscu powiedziałbym "zlecającemu", że to zadanie nie ma sensu. Są też inne zadania, które mogą nauczyć przetwarzania w pętlach, dobrym przykładem byłyby struktury drzewiaste, grafy, listy, może jakaś gra jak sudoku, lub szachy, w nich przetwarzanie czegoś w pętli z zapamiętaniem stanu byłoby bardzo wartościowe. Ale takie sekwencyjne dane jak treści pliku, które w gruncie rzeczy są listą znaków, nie ma to żadnego sensu.

Teraz, kiedy patrzę na treść którą dodałeś w poście: Usunięcie ifa z wybranej funkcji, faktycznie wygląda jakby ktoś go napisał z myślą o tym, żeby zmusić kogoś do napisania parsera linijka po linijce - świadczą o tym klamry { oraz } specjalnie zostawione w osobnych linijkach. W większości języków, te klamry zapewne były w tej samej linijce co kod.

Moja analiza tego zadania jest więc taka:

• Ktoś chciał nauczyć ludzi obsługi pętli lub ewentualnie parsera
• Sam nie umiał tego zbyt dobrze zrobić, więc napisał kod który parsuje taki kod linijka po linijce
• Zauważył że trudniej będzie parsować klamry, dlatego w przykładzie wsadził je do osobnych linii
• Potem zadał zadanie: "usuń linijkę parsując plik po kolei"

Co moim zdaniem jest zupełnie odwrócone. Nie robi się czegoś takiego że krytykuje się rozwiązanie, bo "nie tak miałeś to zrobić tylko inaczej". Chyba że ktoś na prawdę chciał się porwać na pisanie parsera, co jest karkołomnym zadaniem, z powodów o których mówiłem już wcześniej.

Ale jeśli koniecznie ma to być tak zrobione, bez specjalnego sensu, to do Twojego kodu należy dodać zmienną, która "pamięta" czy zachować następną linijkę czy nie:

preserve = True # załóż, żeby początkowo linijki były zapisane
with open(ścieżka_do_zapisu, 'w') as zapis:
  with open(ścieżka_do_odczytu, 'r') as odczyt:
    for linia in odczyt:
        if "if(nazwa_zniennej_1 > 6):" in linia:  # sprawdź czy następna linijka rozpoczyna warunek
          preserve = False                        # ustaw zmienną na false
        if preserve:                              # tak długo jak zmienna jest false, następna linijka nie będzie zapisana
          zapis.write(linia)
        if "}" in linia:                          # znaleziono klamrę zamykającą
          preserve = True                         # następne linijki będą zapisane

Riddle napisał(a):

Cześć @Ibag! Fajnie że zadałeś pytanie na forum.

Daj znać czy o to Ci chodziło, pozdrawiam

Wow, dawno czegoś takiego nie widziałem tutaj na forum.

Super, dziękuję, o to chodziło, zamykam temat. Dzięki za pomoc.

Wersja w Chomiku (wymaga najnowszej wersji):

#!chomik

<create new input filestream "input.txt">;
let odczyt = <the created stream index>;

<create new output filestream "output.txt">;
let zapis = <the created stream index>;


let on lower set the mode = value code {};
let on greater set the mode = value code {};
let on equal set the mode = value code
{
    let mode = value boolean true;
};


let on false and lower reset the mode = value code {};
let on false and equal reset the mode = value code {};
let on false and greater reset the mode = value code {};
let on true and lower reset the mode = value code {};
let on true and equal reset the mode = value code { let mode = value boolean false; let the getline result = value string "/* removed */"; };
let on true and greater reset the mode = value code {};

let on false set the break flag = value code { let the break flag = value boolean true; };
let on true set the break flag = value code
{
    <compare "string" <the getline result> "    }">;
    <on <mode> and <the compare result> reset the mode>;

    <compare "string" <the getline result> "    if(nazwa_zniennej_2 > 7):">;
    <on <the compare result> set the mode>;
};

let on true print (LINE:string)=value code {};
let on false print (LINE:string)=value code
{
    let my line = value string [(LINE:string)];
    <print <my line>>;
};

let main (X:integer) = value code
{
    <getline>;
    <on <the stream is good> set the break flag>;
    <on <mode> print <the getline result>>;
};

let the getline stream index = <odczyt>;
let the print target stream index = <zapis>;
let the break flag = value boolean false;
let mode = value boolean false;

<main (X:integer)>;

Future is now old mans

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline

torch.random.manual_seed(0)

model = AutoModelForCausalLM.from_pretrained(
    "microsoft/Phi-3-mini-4k-instruct",
    device_map="auto",
    attn_implementation="eager",
    torch_dtype="auto",
    trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained("microsoft/Phi-3-mini-4k-instruct")

messages = [
    {"role": "user", "content": """Delete if statement where if(nazwa_zniennej_1 > 6): in code given below:
Funkcja(naza_funkcji)
{
    if(nazwa_zniennej_1 > 6):
    {
    wywolanie_funkcji_1()
    wywolanie_funkcji_2()
    wywolanie_funkcji_3()
    }

    if(nazwa_zniennej_2 > 7):
    {
    wywolanie_funkcji_4()
    wywolanie_funkcji_5()
    wywolanie_funkcji_6()
    }

    if(nazwa_zniennej_3 > 2):
    {
    wywolanie_funkcji_1()
    wywolanie_funkcji_4()
    wywolanie_funkcji_3()
    }
}"""},
]

pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
)

generation_args = {
    "max_new_tokens": 100,
    "return_full_text": False,
    "temperature": 0.6,
    "do_sample": True,
}

output = pipe(messages, **generation_args)
print(output[0]['generated_text'])