Forum Pasja Informatyki - Najnowsze z tagiem kontrola-błędów

Python kontrola błędów except BaseException as e, e jest puste?

Tue, 11 Aug 2020 09:03:10 +0000

Cześć, ewidentnie coś mi umyka w tym temacie ponieważ próbuje złapać każdy błąd, Wszystkie z klasy Exception i dodatkowo KeyboardInterrupt do tego jeśli dobrze to zrozumiałem muszę użyć BaseException więc napisałem taki kod

#! /usr/bin/python3                                                                                                     
import sys                                                                                                              
from time import sleep
from reading_temp import temp_read
from mariadb_connection import connection, add_measurment, create_database, add_sensor
from tables import measurments, sensors
from pumps import  initPins, clean, pumpOn, pumpOff


def main():
    list_of_devices = '/sys/bus/w1/devices/w1_bus_master1/w1_master_slaves'
    universal_path = '/sys/bus/w1/devices/'
    try:
        initPins()
        conn = None

        while(conn == None):
            conn = connection()
        create_database(conn)

        while(True):
            current_tempratures = temp_read(list_of_devices, universal_path)
            print(current_tempratures)

            for temp, sensor in current_tempratures:
                conn.execute(f'''insert into `{sensor}`(sensor_id, temprature)
                values((select id from sensors where sensor_name = '{sensor}'), {temp})''')

                if sensor == '28-5a1993d983ff':
                    tempCWU = temp
                    maxTemp = 50.0
                    hysteresis = 2.0
                    minTemp = maxTemp - hysteresis

                    if tempCWU <= minTemp:
                        pumpOn('CWU')


                    if tempCWU >= maxTemp:
                        pumpOff('CWU')
                        print('pump off')




            sleep(30)
        clean()
    except BaseException as e:
        print(e)
        clean()

if __name__ == '__main__':
    main()

Chciałbym żeby błędy zapisywały się do pliku ale nie mogę zapisywać jeśli nie mam żadnej wiadomości z błędem, i tutaj moje pytanie co źle zrozumiałem i co muszę zrobić aby dostać moją upragnioną wiadomość. Używam BaseExcaeption żeby zapisywać ręczne wyłączenie programu.

EDIT: Tak mnie jeszcze naszło, czasami read_temp zwróci głupotę (niestety taki urok podpiętej elektroniki) czyli wartość np 12667 która nie mieści się w widełkach temperatury w bazie max 4 cyfry, czy jest możliwość złapania takiego błędu, zapisać do jakiegoś log'a i kontynuować z kodem?

Zadanie c++ wczytywanie z pliku, kontrola błędów

Mon, 16 Jul 2018 17:32:39 +0000

Witam robię zadanie z kursu programowanie na stronie cpp0x które brzmi następująco:

2. [trudne zadanie] Napisz program, który dla każdego wiersza w pliku:

wczyta liczby i wypisze ich sumę w przypadku, gdy wszystkie liczby uda się wczytać;
wypisze komunikat o błędnych danych, jeżeli wystąpi błąd podczas wczytywania liczb (komunikat ma wyświetlać numer wiersza, w którym wystąpił błąd).

Przykładowe dane:

1 2 3
3 4 a 5
3 2
5 2 2 1 3
# 3 4

Oczekiwane standardowe wyjście programu dla przykładowego zestawu danych:

6
Bledne dane w wierszu nr 2!
5
13
Bledne dane w wierszu nr 5!

Wykorzystaj poniższą funkcję do wykrywania znaku przejścia do nowej linii:

bool czyNapotkanoZnakNowegoWiersza( std::ifstream & plik )
{
    char cZnak;
    for(;; ) //nieskończona pętla
    {
        plik.clear();
        cZnak = plik.peek(); //sprawdzamy jaki kolejny znak zostanie zwrócony przez operację odczytu
        if( plik.fail() || plik.bad() )
             return false; //wystąpił błąd odczytu danych
        
        if( !isspace( cZnak ) )
             return false; //pobrany znak nie jest białym znakiem
        
        plik.get( cZnak ); //odczytujemy biały znak z pliku
        if( plik.fail() || plik.bad() )
             return false; //wystąpił błąd odczytu danych
        
        if( cZnak == '\n' )
             return true;
        
    } //for
}

Powyższej funkcji nie wolno modyfikować.

Napisałem następujący kod:

#include <iostream>
#include <fstream>
#include <string>

using namespace std;

bool czyNapotkanoZnakNowegoWiersza(ifstream & plik )
{
    char cZnak;
    for(;; ) //nieskończona pętla
    {
        plik.clear();
        cZnak = plik.peek(); //sprawdzamy jaki kolejny znak zostanie zwrócony przez operację odczytu
        if( plik.fail() || plik.bad() )
             return false; //wystąpił błąd odczytu danych

        if( !isspace( cZnak ) )
             return false; //pobrany znak nie jest białym znakiem

        plik.get( cZnak ); //odczytujemy biały znak z pliku
        if( plik.fail() || plik.bad() )
             return false; //wystąpił błąd odczytu danych

        if( cZnak == '\n' )
             return true;

    } //for
}

bool wczytajplik(string nazwapliku)
{
 ifstream file;
 file.open(nazwapliku.c_str() );
 if(!file.good() )
 {
     cout<<"Nie udalo sie odczytac pliku";
     return false;
 }
 int wiersz=1;
 int number;
 int suma=0;
 string linia;
    while(!file.eof() )
    {
    file>>number;
    if(file.fail() )
    {
      suma=0;
      cout<<"Bledne dane w wierszu: "<<wiersz<<endl;
      file.clear();
      std::getline( file, linia );
      wiersz++;

    }
    else
    {
        suma+=number;
        if(czyNapotkanoZnakNowegoWiersza(file));
        {
        wiersz++;
        cout<<suma<<" ";
        suma=0;
        }
    }

    }
    file.close();
    return true;

}

int main()
{
    if(wczytajplik("dane.txt") )
        cout<<"Plik odczytano";
    return 0;
}

Jednak w oknie konsoli wyświetla mi się:

1 2 3 3 4 Bledne dane w wierszu: 6
3 2 5 2 2 1 3 Bledne dane w wierszu: 14
Bledne dane w wierszu: 15
Plik odczytano
Process returned 0 (0x0) execution time : 0.016 s
Press any key to continue.

Co może być nie tak w kodzie?

C++ kontrola błędów wejścia, pętla ?

Tue, 29 Aug 2017 09:12:16 +0000

Witam wszystkich!

Zacząłem jakiś czas temu robić kurs C++ Pana Mirosława, obecnie zrobiłem 6 odcinek.

https://www.youtube.com/watch?v=ib7LXBNfZ7g

Chodzi mi dokładnie o moment w którym mowa o pętli która będzie pozwalała podać jeszcze raz poprawne wartości(jeśli użytkownik poda złe). W filmiku 17;08. W kodzie z odcinka program kończy się po wpisaniu błędnych danych.

Postanowiłem zmierzyć się z tym problemem, lecz opornie mi to szło, jednak przeszukując internet natrafiłem na takie rozwiązanie...

Przerobiłem kod odcinka w taki sposób:

   cout << "Podaj numer miesiaca: ";
   while(!(cin >> nr_miesiaca))
    {
        cout << "Blad! Podaj poprawny numer miesiaca: ";
        cin.clear();
        cin.ignore(9999, '\n' );
    }

Teraz działa to tak, że po wpisaniu np liczby, program prosi jeszcze raz o podanie właściwych danych, aż do skutku( tak właśnie chciałem).

TO jest kod z odcinka:

#include <iostream>
#include <cstdlib>
 
using namespace std;
int nr_miesiaca;
 
int main()
{
    //cout << "Podaj numer miesiaca: ";
 
    //if (!(cin >> nr_miesiaca))
    //{
    //    cerr<<"To nie jest liczba!";
    //    exit(0);
    //}
 
    switch(nr_miesiaca)
    {
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:
            cout<<"Ten miesiac ma 31 dni!";
        break;
 
        case 4:
        case 6:
        case 9:
        case 11:
            cout<<"Ten miesiac ma 30 dni!";
        break;
 
        case 2:
            {
                int rok;
                cout<<"Podaj rok: ";
                cin >> rok;
 
if (((rok%4 == 0) && (rok%100 != 0)) || (rok%400 == 0))
    cout<<"Ten miesiac ma 29 dni!";
else cout<<"Ten miesiac ma 28 dni!";
 
            }
        break;
 
        default: cout<<"Niepoprawny numer miesiaca!";
 
    }
 
    return 0;
}

Zamienilem te wykomentowane linie, na ten kod który wkleiłem wyżej. Dla pewności zamieszcze całośc, poniżej POPRAWNY KOD(dzialajacy jak chcialem):

#include <iostream>
#include <cstdlib>

using namespace std;

int nr_miesiaca;

int main()
{
    cout << "Podaj numer miesiaca: ";
   while(!(cin >> nr_miesiaca))
    {
        cout << "Blad! Podaj poprawny numer miesiaca: ";
        cin.clear();
        cin.ignore(9999, '\n' );
    }

    switch(nr_miesiaca)
    {
    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12:
        cout << "Ten miesiac ma 31 dni!";
    break;

    case 4:
    case 6:
    case 9:
    case 11:
        cout << "Ten miesiac ma 30 dni!";
    break;

    case 2:
        {
            int rok;
            cout << "Podaj rok: ";
             if(!(cin >> rok))
            {
                cerr << "To nie jest liczba!";
                exit(0);
            }

            if(((rok % 4 == 0) && (rok % 100 != 0)) || (rok % 400 == 0))
                cout << "Ten miesiac na 29 dni!";
            else
                cout << "Ten miesiac ma 28 dni!";
        }

    break;

    default: cout << "Niepoprawny numer miesiaca" << endl;
    }


    return 0;
}

Czy jest to poprawny sposób? Dodam, że jestem początkujący i z c++ narazie wiem tyle ile z odcinków Pana Mirosława, a tam nie było narazie pojęcia cin.ignore. Czytałem w internecie lecz nie mogę tego zrozumieć. Może mi to ktoś łopatologicznie wyjaśnić? Czy jest to dobry sposób? Na jakiej zasadzie działa to całe cin.clear i cin.ignore ?? Proszę o pomoc, mam nadzieje, że napisałem w miarę jasno. Pozdrawiam

[SWIFT]Obsługa błędów w prostym kalkulatorze

Tue, 07 Mar 2017 19:01:58 +0000

Witam :) Pisałem wcześniej, ale nikt nie odpowiedział: https://forum.pasja-informatyki.pl/232719/swift-obsluga-bledow-mnozenie-i-dzielenie-przed-dodawaniem-i-odejmowaniem?show=232719#q232719

Zmieniłem kod na tyle, że myślę, że lepiej będzie jak nowe pytanie zadam. Gdyby nie jeden błąd to pewnie bym nie napisał, ale nie rozumiem skąd on wynika:

Błąd: Expected declaration. Jak rozwinę to mi pisze: In declaration of 'Parser'. Znajduje się on przy wywoływaniu funkcji na samym dole.

Uczę się z książki i mam dodać odejmowanie (zrobiłem bardzo szybko), mnożenie i dzielenie (połowicznie bo nie uwzględnia pierwszeństwa co próbuję zrobić) i dodanie index-u do komunikatu błędu(tak średnio wiem co mam zrobić).

Ktoś pomoże mi zrozumieć co źle robię? Najlepiej też z tym indexem jakby mi ktoś pomógł


enum Token {
    //rodzaje tokenów
    case Number(Int)
    case Plus
    case Minus
    case Division
    case Multiplication
    case OpeningBracket
    case ClosingBracket
}

//analizator leksykalny - budowa
class Lexer {
    //String.CharacterView ma właściwości startIndex i endIndex
    let input: String.CharacterView
    var position: String.CharacterView.Index
    
    enum theError: Error {                        //zgłasza błąd
        case IncorrectCharacter(Character)
    }
    
    init(input: String) {
        self.input = input.characters             //inicjalizujemy właściwośc wraz z danymi wejściowymi,ma wartość wskazującą początek tych danych wejściowych
        self.position = self.input.startIndex
    }
    
    //może być wywołana zawsze
    func peek() -> Character? {                  //spradzenie kolejnego znaku w danych wejściowych. Wskazuje analizatorowi, że zostały przetworzone wszystkie dane wejściowe
        guard position < input.endIndex else {
            return nil
        }
        return input[position]
    }
    
    //IMPLEMENTACJA ALGORYTMU ANALIZATORA
    
    //można wywołać tylko wtedy, gdy aktualne położenie nie jest końcem danych wejściowych
    func advance() {                                                //przejście do kolejnego znaku
        assert(position < input.endIndex, "You can not go beyond the data input") //gdy false - wpadnięcie w pułapkę i wyświetlenie komunikatu
        position = input.index(after: position)
    }
    func getNumber () -> Int {              //wyodrębnia liczby całkowite z danych wejściowych
        var value = 0
        
        while let nextCharacter = peek() {
            switch nextCharacter {
            case "0"..."9":
                let digitValue = Int(String(nextCharacter))!
                value = 10*value + digitValue
                advance()
            default:
                return value
            }
        }
        return value
    }
    func lex() throws -> [Token] { //throws, czyli funkcja/metoda może wygenerować błąd
        var tokens = [Token]()      //tablica z tokenami
        
        while let nextCharacter = peek() {   //przetworzenie wszystkich danych wejściowych
            switch nextCharacter {
             case "(":
                tokens.append(.OpeningBracket)
                advance()
                
            case ")":
                tokens.append(.ClosingBracket)
            case "0"..."9":
                let value = getNumber()
                tokens.append(.Number(value))
                
            case "*":
                tokens.append(.Multiplication)
                advance()
                
            case "/":
                tokens.append(.Multiplication)
                advance()
                
            case "+":
                tokens.append(.Plus)
                advance()
                
            case "-":
                tokens.append(.Minus)
                advance()
                
            case " ":
                advance()
                
            default:
                throw theError.IncorrectCharacter(nextCharacter)   //throws  zatrzymuje funkcje i przekazuje błąd do komponentu wywołąjącego dany błąd zgodnego z protokołem Error
            }
        }
        return tokens
    }
}

class Parser {
    let tokens: [Token]
    var position = 0
    
    enum theError: Error {
        case unexpectedEndOfOutput
        case incorrectToken(Token)
    }
    
    init(tokens: [Token]) {
        self.tokens = tokens
    }
    
    func getNextToken() -> Token? {                     //peek() i advance() w jedną
        guard position < tokens.count else {
            return nil
        }
        let token = tokens[position]
        position += 1
        return token
    }
    
    func getNumber() throws -> Int {
        guard let token = getNextToken() else {
            throw theError.unexpectedEndOfOutput
        }
        switch token {
        case .Number(let value):
            return value
        case .Division:
            throw theError.incorrectToken(token)
        case .Multiplication:
            throw theError.incorrectToken(token)
        case .Plus:
            throw theError.incorrectToken(token)
        case .Minus:
            throw theError.incorrectToken(token)
        case .OpeningBracket:
            throw theError.incorrectToken(token)
        case .ClosingBracket:
            throw theError.incorrectToken(token)
        }
    }
    
    func parse() throws -> Int {
        var value = try getNumber()
        
        while let token = getNextToken() {
            switch token {
            case .OpeningBracket:
                try getBrackets()
            
            case .ClosingBracket:
                try getNumber()
                
            case .Multiplication:
                let nextNumber = try getNumber()
                value *= nextNumber
                
            case .Division:
                let nextNumber = try getNumber()
                value / nextNumber
                
            case .Plus:
                let nextNumber = try getNumber()
                value += nextNumber
                
            case .Minus:
                let nextNumber = try getNumber()
                value -= nextNumber
                
            case .Number:
                throw theError.incorrectToken(token)
            }
        }
        return value
    }
    
    func getBrackets() throws {
        var value = try getNumber()
        
        while let token = getNextToken() {
            switch token {
            case .Plus:
                let nextNumber = try getNumber()
                value += nextNumber
            case .Minus:
                let nextNumber = try getNumber()
                value -= nextNumber
            }
        }
    
}

func evaluate(input: String) {
    print("Calculation: \(input)")
    
    let lexer = Lexer(input: input)
    do {
        //wprowadza nowy zasięg, jeżeli jakieś wywołanie try spowoduje zgłoszenie błędu nastąpi wykonanie odpowiedniego bloku catch
        let tokens = try lexer.lex()
        print("Data output lexical analyzer: \(tokens)")
        
        let parser = Parser(tokens: tokens)
        let result = try parser.parse()
        print("Output parser: \(result)")
    }
    catch Lexer.theError.IncorrectCharacter(let character) {                        //zgłoszona wartość błędu jest przypisywana stłej error
        print("Data output contains invalid character: \(character)")
    }
    catch Parser.theError.unexpectedEndOfOutput {
        print("Unexpected end of data output during processing.")
    }
    catch Parser.theError.incorrectToken(let token) {
        print("Incorrect token during processing: \(token)")
    }
    catch {
        print("Following an unexpected error: \(error).")
    }
}

evaluate(input: "10 + 5 + 3")
evaluate(input: "10 + + 3")
evaluate(input: "10 - 5 + 3")
evaluate(input: "(10 * 3) - (3 * 5)")

[Swift] Obsługa błędów - mnożenie i dzielenie przed dodawaniem i odejmowaniem

Sun, 05 Mar 2017 16:41:20 +0000

Witam,

niestety znowu proszę o pomoc. Uczę się z książki i mam dwa zadania, których do końca nie potrafię zrobić. Zgodnie z tematem, skończyłem czytać zadania o obsłudze błędów. Pierwsze zadanie poszło bardzo szybko (trzeba było dodać odejmowanie). Drugie zadanie jest o dodaniu informacji o tym w jakim indexie wystąpił błąd. W trzecim zadaniu mam dodać mnożenie i dzielenie. To mi się udało ale jest nieprawidłowy wynik. Kiedy próbuję, aby mnożenie i dzielenie miało wyższy priorytet od dodawania i odejmowania to wyskakuje mi, że * jest nieprawidłowym tokenem podczas przetwarzania. Próbowałem zastosować nawiasy, ale nie pykło. W tym momencie chciałem użyć wskazówki w zadaniu o rekurencyjnych analizatorach składni, ale nie mogę jakoś znaleźć nic co by mi pomogło.

Pewnie kod jest zbyt rozbudowany, ale teraz priorytetem jest, aby najpierw zrozumieć co i jak należy zrobić, aby wszystko działało tak jak należy :)

enum Token {
    case Number(Int)
    case Plus
    case Minus
    case Division
    case Multiplication
}

class Lexer {
    let input: String.CharacterView
    var position: String.CharacterView.Index
    
    enum theError: Error {
        case IncorrectCharacter(Character)
    }
    
    init(input: String) {
        self.input = input.characters
        self.position = self.input.startIndex
    }
    func peek() -> Character? {
        guard position < input.endIndex else {
            return nil
        }
        return input[position]
    }
    func advance() {
        assert(position < input.endIndex, "You can not go beyond the data input")
        position = input.index(after: position)
    }
    func getNumber () -> Int {
        var value = 0
        
        while let nextCharacter = peek() {
            switch nextCharacter {
            case "0"..."9":
                let digitValue = Int(String(nextCharacter))!
                value = 10*value + digitValue
                advance()
            default:
                return value
            }
        }
        return value
    }
    func lex() throws -> [Token] {
        var tokens = [Token]()
        
        while let nextCharacter = peek() {
            switch nextCharacter {
            case "0"..."9":
                let value = getNumber()
                tokens.append(.Number(value))
            case "*":
                tokens.append(.Multiplication)
                switch nextCharacter {
                case "+":
                    tokens.append(.Plus)
                    advance()
                case "-":
                    tokens.append(.Minus)
                    advance()
                default:
                    advance()
                }
                advance()
            case "/":
                switch nextCharacter {
                case "+":
                    tokens.append(.Plus)
                    advance()
                case "-":
                    tokens.append(.Minus)
                    advance()
                default:
                    advance()
                }
                advance()
            case "+":
                tokens.append(.Plus)
                advance()
            case "-":
                tokens.append(.Minus)
                advance()
            case " ":
                advance()
            default:
                throw theError.IncorrectCharacter(nextCharacter)
            }
        }
        return tokens
    }
}

class Parser {
    let tokens: [Token]
    var position = 0
    
    enum theError: Error {
        case unexpectedEndOfOutput
        case incorrectToken(Token)
    }
    
    init(tokens: [Token]) {
        self.tokens = tokens
    }
    
    func getNextToken() -> Token? {
        guard position < tokens.count else {
            return nil
        }
        let token = tokens[position]
        position += 1
        return token
    }
    
    func getNumber() throws -> Int {
        guard let token = getNextToken() else {
            throw theError.unexpectedEndOfOutput
        }
        switch token {
        case .Number(let value):
            return value
        case .Division:
            throw theError.incorrectToken(token)
        case .Multiplication:
            throw theError.incorrectToken(token)
        case .Plus:
            throw theError.incorrectToken(token)
        case .Minus:
            throw theError.incorrectToken(token)
        }
    }
    func parse() throws -> Int {
        var value = try getNumber()
        
        while let token = getNextToken() {
            switch token {
            case .Multiplication:
                let nextNumber = try getNumber()
                value *= nextNumber
                switch token {
                case .Plus:
                    let nextNumber = try getNumber()
                    value += nextNumber
                case .Minus:
                    let nextNumber = try getNumber()
                    value -= nextNumber
                default:
                    throw theError.incorrectToken(token)
                }
            case .Division:
                let nextNumber = try getNumber()
                value / nextNumber
                switch token {
                case .Plus:
                    let nextNumber = try getNumber()
                    value += nextNumber
                case .Minus:
                    let nextNumber = try getNumber()
                    value -= nextNumber
                default:
                    throw theError.incorrectToken(token)
                }
            case .Plus:
                let nextNumber = try getNumber()
                value += nextNumber
            case .Minus:
                let nextNumber = try getNumber()
                value -= nextNumber
            case .Number:
                throw theError.incorrectToken(token)
            }
        }
        return value
    }
}
func evaluate(input: String) {
    print("Calculation: \(input)")
    
    let lexer = Lexer(input: input)
    do {
        let tokens = try lexer.lex()
        print("Data output lexical analyzer: \(tokens)")
        
        let parser = Parser(tokens: tokens)
        let result = try parser.parse()
        print("Output parser: \(result)")
    }
    catch Lexer.theError.IncorrectCharacter(let character) {
        print("Data output contains invalid character: \(character)")
    }
    catch Parser.theError.unexpectedEndOfOutput {
        print("Unexpected end of data output during processing.")
    }
    catch Parser.theError.incorrectToken(let token) {
        print("Incorrect token during processing: \(token)")
    }
    catch {
        print("Following an unexpected error: \(error).")
    }
}


evaluate(input: "10 + 5 + 3")
evaluate(input: "10 + + 3")
evaluate(input: "10 - 5 + 3")
evaluate(input: "10 * 3 - 3 * 5")

Kontrola błędów (switch)

Wed, 25 Jan 2017 11:38:02 +0000

Witam, jeżeli zajmiemy się instrukcją switch, zrobimy do niej jakieś opcje, np. case 1: case 2: to wprowadzając jakiś ciąg znaków program się wysypie. Opcja default nie jest wystarczająca w tym wypadku. Jak można zabezpieczyć program przed takimi błędami?

Całkowita kontrola błędów wejścia.

Sat, 18 Jun 2016 13:47:37 +0000

Witam, ostatnio natrafiłem na potrzebe obsłużenia kompletnej kontroli błędów wejścia, konkretnie chodzi o to, żeby do zmiennej móc zapisać tylko to co do niej należy, a każdy inny przypadek wyrzucać.

Czyli od podstawowych faktów takich jak to, że do inta nie można zapisać literki, do takich, żeby wywalało nawet jak po części wpiszemy dobrze, czyli np :123abca, albo 1.55.

Funkcje takie jak cin.fail(), albo cin.good() działają tylko w tych podstawowych problemach, znajdę coś, co poradzi sobie z tym w całości?

Oczywiście wpadłem na pomysł, żeby zapisać wszystko do stringa i tam już na tym operować, a potem za pomocą atoi np. zapisać to do zmiennej, ale mimo to wydaje mi się, że to nie jest najprostsze i najoptymalniejsze rozwiązanie.

Znajdę gdzieś funkcje, która będzie dokonywała takiej selekcji z najwyższą surowością?