පයිතන් පිටපතක් අවසන් කරන්නේ කෙසේද?

die()මුල් පිටපතෙන් පිටවන PHP හි විධානය ගැන මම දනිමි .

පයිතන්හිදී මට මෙය කළ හැක්කේ කෙසේද?

import sys
sys.exit()

sysමොඩියුලයේ ප්‍රලේඛනයෙන් විස්තර :

sys.exit([arg])

පයිතන් වලින් පිටවන්න. මෙය ක්‍රියාත්මක කරනු ලබන්නේ SystemExitව්‍යතිරේකය ඉහළ නැංවීමෙනි , එබැවින් අවසාන tryප්‍රකාශ වගන්ති මගින් නිශ්චිතව දක්වා ඇති පිරිසිදු කිරීමේ ක්‍රියාවන්ට ගරු කරනු ලබන අතර පිටවීමේ උත්සාහය බාහිර මට්ටමින් වළක්වා ගත හැකිය.

වෛකල්පික තර්ක ආර්ග් යනු පිටවීමේ තත්ත්වය (ශුන්‍යයට පෙරනිමියෙන්) ලබා දෙන පූර්ණ සංඛ්‍යාවක් හෝ වෙනත් වර්ගයක වස්තුවක් විය හැකිය. එය පූර්ණ සංඛ්‍යාවක් නම්, ශුන්‍යය “සාර්ථකව අවසන් කිරීම” ලෙස සලකනු ලබන අතර ඕනෑම අස්ථිර අගයක් “අසාමාන්‍ය ලෙස අවසන් කිරීම” ලෙස සලකනු ලබන්නේ ෂෙල් වෙඩි හා ඒ හා සමාන ය. බොහෝ පද්ධති වලට එය 0-127 පරාසයේ තිබිය යුතු අතර වෙනත් ආකාරයකින් නිර්වචනය නොකළ ප්‍රති results ල ලබා දේ. නිශ්චිත පිටවීමේ කේත සඳහා නිශ්චිත අර්ථයන් පැවරීම සඳහා සමහර පද්ධතිවල සම්මුතියක් ඇත, නමුත් මේවා සාමාන්‍යයෙන් නොදියුණු ය; යුනික්ස් වැඩසටහන් සාමාන්‍යයෙන් විධාන රේඛා සින්ටැක්ස් දෝෂ සඳහා 2 ක් සහ අනෙකුත් සියලුම දෝෂ සඳහා 1 භාවිතා කරයි. වෙනත් වර්ගයක වස්තුවක් සම්මත වුවහොත් කිසිවක් ශුන්‍යය පසු කිරීමට සමාන නොවන අතර වෙනත් ඕනෑම වස්තුවක් මුද්‍රණය කර stderrපිටවීමේ කේතය 1 ට හේතු වේ. විශේෂයෙන්, sys.exit("some error message") දෝෂයක් ඇති වූ විට වැඩසටහනකින් පිටවීමට ඉක්මන්ම ක්‍රමයකි.

සිට exit()අවසානයේ "පමනක්" ව්යතිරේකයක් මතු, එය පමණක් ප්රධාන නූල් සිට හමු වූ අවස්ථාවේ දී එම ක්රියාවලිය පිටවෙනු ඇත, සහ හැර පණිවිඩ හුවමාරු කර නැත.

පිටවීමට ඇති 'හොඳ' ක්‍රමය මෙය බව සලකන්න. @ Glyphtwistedmatrix ඔබ 'වෙහෙස මහන්සි වී පිටවීම' අවශ්ය නම්, ඔබ භාවිතා කල හැකි බව සඳහන් ය පහත os._exit(*errorcode*)එය යම් දුරකට os-විශේෂිත ඉඩ තිබුණා (එය උදාහරණයක් ලෙස, වින්ඩෝස් යටතේ errorcode ගත නොහැකි විය), සහ එය නියත බැවින් එය අඩු හිතකාමී වුවත්, ක්‍රියාවලිය මිය යාමට පෙර පරිවර්තකයාට කිසිදු පිරිසිදු කිරීමක් කිරීමට ඉඩ නොදේ.

පයිතන් ස්ක්‍රිප්ටයක් කල්තියාම අවසන් කිරීමට සරල ක්‍රමයක් නම්, ගොඩනංවන ලද quit()ශ්‍රිතය භාවිතා කිරීමයි . කිසිදු පුස්තකාලයක් ආනයනය කිරීමේ අවශ්‍යතාවයක් නොමැති අතර එය කාර්යක්ෂම හා සරල ය.

උදාහරණයක්:

#do stuff
if this == that:
  quit()

තවත් ක්‍රමයක් නම්:

raise SystemExit

ඔබට සරලව භාවිතා කළ හැකිය exit().

බව මතක තබා ගන්න sys.exit(), exit(), quit(), සහ os._exit(0) මරා සඳහා python භාෂණ. එමනිසා, එය වෙනත් ස්ක්‍රිප්ට් එකකින් කැඳවූ ස්ක්‍රිප්ට් එකක දිස්වන්නේ නම් execfile(), එය ස්ක්‍රිප්ට් දෙකම ක්‍රියාත්මක කිරීම නවත්වයි.

මෙය වළක්වා ගැනීම සඳහා " execfile සමඟ ස්ක්‍රිප්ට් එකක් ක්‍රියාත්මක කිරීම නවත්වන්න " බලන්න .

ඔබ සාමාන්‍යයෙන් කැමති විය යුත්තේ sys.exitඑය වෙනත් කේත වලට වඩා “මිත්‍රශීලී” බැවිනි, ඇත්ත වශයෙන්ම එය කරන්නේ ව්‍යතිරේකයක් මතු කිරීම පමණි.

ඔබට වහාම ක්‍රියාවලියකින් පිටවිය යුතු බව ඔබට විශ්වාස නම්, සහ ඔබ අල්ලා ගත හැකි ව්‍යතිරේක හසුරුවන්නෙකු තුළ SystemExitසිටිය හැකි නම්, තවත් කාර්යයක් ඇත - os._exit- එය සී මට්ටමින් වහාම අවසන් වන අතර සාමාන්‍ය ඉරීම කිසිවක් සිදු නොකරයි පරිවර්තකයාගේ; උදාහරණයක් ලෙස, "atexit" මොඩියුලය සමඟ ලියාපදිංචි කර ඇති කොකු ක්‍රියාත්මක නොවේ.

මම යන්තම් multithreadded යෙදුම ලිවීමේදී බව සොයා තියෙනවා, raise SystemExitහා sys.exit()යන දෙකම එකම ධාවන නූල් මරනවා. අනෙක් අතට, os._exit()සමස්ත ක්‍රියාවලියෙන් පිටවෙයි. " පයිතන්හි නූල් ඇතුලත කැඳවූ විට sys.exit () පිටවන්නේ නැත්තේ ඇයි? "

පහත උදාහරණයේ නූල් 2 ක් ඇත. කෙනී සහ කාට්මන්. කාට්මන් සදාකල් ජීවත් විය යුතු නමුත් කෙනීව පුනරාවර්තනය ලෙස හැඳින්වෙන අතර තත්පර 3 කට පසු මිය යා යුතුය. (පුනරාවර්තන ඇමතුම් හොඳම ක්‍රමය නොවේ, නමුත් මට වෙනත් හේතු තිබුණි)

කෙනී මිය යන විට කාට්මන් මියයෑමට අපට අවශ්‍ය නම්, කෙනී සමඟ යා යුතුය os._exit, එසේ නොවුවහොත්, කෙනී පමණක් මිය යනු ඇති අතර කාට්මන් සදහටම ජීවත් වනු ඇත.

import threading
import time
import sys
import os

def kenny(num=0):
    if num > 3:
        # print("Kenny dies now...")
        # raise SystemExit #Kenny will die, but Cartman will live forever
        # sys.exit(1) #Same as above

        print("Kenny dies and also kills Cartman!")
        os._exit(1)
    while True:
        print("Kenny lives: {0}".format(num))
        time.sleep(1)
        num += 1
        kenny(num)

def cartman():
    i = 0
    while True:
        print("Cartman lives: {0}".format(i))
        i += 1
        time.sleep(1)

if __name__ == '__main__':
    daemon_kenny = threading.Thread(name='kenny', target=kenny)
    daemon_cartman = threading.Thread(name='cartman', target=cartman)
    daemon_kenny.setDaemon(True)
    daemon_cartman.setDaemon(True)

    daemon_kenny.start()
    daemon_cartman.start()
    daemon_kenny.join()
    daemon_cartman.join()

from sys import exit
exit()

පරාමිතියක් ලෙස ඔබට පිටවීමේ කේතයක් සම්මත කළ හැකිය, එය මෙහෙයුම් පද්ධතියට නැවත ලබා දෙනු ඇත. පෙරනිමිය 0 වේ.

මම සම්පුර්ණ නවකයෙක් නමුත් නිසැකවම මෙය වඩා පිරිසිදු හා පාලනය කළ හැකිය

def main():
    try:
        Answer = 1/0
        print  Answer
    except:
        print 'Program terminated'
        return
    print 'You wont see this'

if __name__ == '__main__': 
    main()

...

වැඩසටහන අවසන් විය

වඩා

import sys
def main():
    try:
        Answer = 1/0
        print  Answer
    except:
        print 'Program terminated'
        sys.exit()
    print 'You wont see this'

if __name__ == '__main__': 
    main()

...

වැඩසටහන අවසන් කරන ලද ලුහුබැඳීම (අවසන් වරට ඇමතුම අවසන්): ගොනුව "Z: \ නාමාවලිය \ testdieprogram.py", 12 වන පේළිය, ප්‍රධාන () ගොනුව "Z: \ නාමාවලිය \ testdieprogram.py", 8 වන පේළිය, ප්‍රධාන sys.exit ( ) SystemExit

සංස්කරණය කරන්න

කාරණය වන්නේ "මම නැවතුණා !!!!" යන්නට වඩා වැඩසටහන සුමට හා සාමකාමීව අවසන් වීමයි.

පයිතන් 3.5 හි, ස්ක්‍රිප්ට් නැවැත්වීමට සහ මගේ පරිශීලකයින්ට දෝෂ පණිවිඩයක් මුද්‍රණය කිරීම සඳහා ගොඩනගා ඇති දේ හැරුණු විට මොඩියුල (උදා: sys, Biopy) භාවිතා නොකර සමාන කේතයක් ඇතුළත් කිරීමට මම උත්සාහ කළෙමි. මෙන්න මගේ උදාහරණය:

## My example:
if "ATG" in my_DNA: 
    ## <Do something & proceed...>
else: 
    print("Start codon is missing! Check your DNA sequence!")
    exit() ## as most folks said above

පසුකාලීනව, දෝෂයක් විසි කිරීම වඩාත් සංක්ෂිප්ත බව මට පෙනී ගියේය:

## My example revised:
if "ATG" in my_DNA: 
    ## <Do something & proceed...>
else: 
    raise ValueError("Start codon is missing! Check your DNA sequence!")

මගේ ශත දෙක.

පයිතන් 3.8.1, වින්ඩෝස් 10, 64-බිට්.

sys.exit() මා වෙනුවෙන් කෙලින්ම ක්‍රියා නොකරයි.

මට ඊළඟ ලූප කිහිපයක් තිබේ.

පළමුව මම බූලියන් විචල්‍යයක් ප්‍රකාශ කරමි immediateExit.

එබැවින්, වැඩසටහන් කේතයේ ආරම්භයේ දී මම ලියන්නේ:

immediateExit = False

ඉන්පසුව, වඩාත් අභ්‍යන්තර (කැදැලි) ලූප් ව්‍යතිරේකයෙන් පටන් ගෙන මම ලියන්නේ:

            immediateExit = True
            sys.exit('CSV file corrupted 0.')

ඉන්පසුව මම පිටත ලූපය වහාම ඉදිරියට ගෙන යන අතර කේතය මඟින් වෙනත් දෙයක් ක්‍රියාත්මක කිරීමට පෙර මම මෙසේ ලියමි.

    if immediateExit:
        sys.exit('CSV file corrupted 1.')

සංකීර්ණත්වය මත පදනම්ව, සමහර විට ඉහත ප්‍රකාශය කොටස් ආදිය හැර නැවත නැවතත් කළ යුතුය.

    if immediateExit:
        sys.exit('CSV file corrupted 1.5.')

අභිරුචි පණිවිඩය මගේ පුද්ගලික නිදොස්කරණය සඳහා වන අතර, සංඛ්‍යා එකම අරමුණක් සඳහා වන බැවින් - පිටපත සැබවින්ම පිටවන්නේ කොතැනදැයි බැලීමට.

'CSV file corrupted 1.5.'

මගේ විශේෂිත අවස්ථාවෙහිදී, මම CSV ගොනුවක් සැකසෙමින් සිටිමි, එය මෘදුකාංගය ස්පර්ශ කිරීමට මා කැමති නැත, මෘදුකාංගය දූෂිත බව අනාවරණය වුවහොත්. එබැවින් මට සිදුවිය හැකි දූෂණය හඳුනාගත් වහාම මුළු පයිතන් පිටපතෙන් පිටවීම ඉතා වැදගත් වේ.

ක්‍රමානුකූලව sys.exit-ing අනුගමනය කිරීමෙන් මම එය කිරීමට සමත් වෙමි.

සම්පූර්ණ කේතය: (අභ්‍යන්තර කාර්යයන් සඳහා හිමිකාර කේතය බැවින් සමහර වෙනස්කම් අවශ්‍ය විය):

immediateExit = False
start_date = '1994.01.01'
end_date = '1994.01.04'
resumedDate = end_date


end_date_in_working_days = False
while not end_date_in_working_days:
    try:
        end_day_position = working_days.index(end_date)

        end_date_in_working_days = True
    except ValueError: # try statement from end_date in workdays check
        print(current_date_and_time())
        end_date = input('>> {} is not in the list of working days. Change the date (YYYY.MM.DD): '.format(end_date))
        print('New end date: ', end_date, '\n')
        continue


    csv_filename = 'test.csv'
    csv_headers = 'date,rate,brand\n' # not real headers, this is just for example
    try:
        with open(csv_filename, 'r') as file:
            print('***\nOld file {} found. Resuming the file by re-processing the last date lines.\nThey shall be deleted and re-processed.\n***\n'.format(csv_filename))
            last_line = file.readlines()[-1]
            start_date = last_line.split(',')[0] # assigning the start date to be the last like date.
            resumedDate = start_date

            if last_line == csv_headers:
                pass
            elif start_date not in working_days:
                print('***\n\n{} file might be corrupted. Erase or edit the file to continue.\n***'.format(csv_filename))
                immediateExit = True
                sys.exit('CSV file corrupted 0.')
            else:
                start_date = last_line.split(',')[0] # assigning the start date to be the last like date.
                print('\nLast date:', start_date)
                file.seek(0) # setting the cursor at the beginnning of the file
                lines = file.readlines() # reading the file contents into a list
                count = 0 # nr. of lines with last date
                for line in lines: #cycling through the lines of the file
                    if line.split(',')[0] == start_date: # cycle for counting the lines with last date in it.
                        count = count + 1
        if immediateExit:
            sys.exit('CSV file corrupted 1.')
        for iter in range(count): # removing the lines with last date
            lines.pop()
        print('\n{} lines removed from date: {} in {} file'.format(count, start_date, csv_filename))



        if immediateExit:
            sys.exit('CSV file corrupted 1.2.')
        with open(csv_filename, 'w') as file:
            print('\nFile', csv_filename, 'open for writing')
            file.writelines(lines)

            print('\nRemoving', count, 'lines from', csv_filename)

        fileExists = True

    except:
        if immediateExit:
            sys.exit('CSV file corrupted 1.5.')
        with open(csv_filename, 'w') as file:
            file.write(csv_headers)
            fileExists = False
    if immediateExit:
        sys.exit('CSV file corrupted 2.')