Ποιος είναι ο καλύτερος τρόπος για να αναλύσει τα επιχειρήματα της γραμμής εντολών;

ψήφοι
145

Ποιο είναι το πιο εύκολο , πιο σφιχτοδεμένες και πιο ευέλικτη μέθοδο ή τη βιβλιοθήκη για την ανάλυση Python επιχειρήματα της γραμμής εντολών;

Δημοσιεύθηκε 21/08/2008 στις 13:24
πηγή χρήστη
Σε άλλες γλώσσες...                            


15 απαντήσεις

ψήφοι
14

Χρήση optparseπου έρχεται με το πρότυπο βιβλιοθήκης. Για παράδειγμα:

#!/usr/bin/env python
import optparse

def main():
  p = optparse.OptionParser()
  p.add_option('--person', '-p', default="world")
  options, arguments = p.parse_args()
  print 'Hello %s' % options.person

if __name__ == '__main__':
  main()

Πηγή: Χρησιμοποιώντας Python για να δημιουργήσει UNIX εργαλεία της γραμμής εντολών

Ωστόσο, όπως της Python 2.7 optparse έχει καταργηθεί, δείτε: Γιατί να χρησιμοποιήσετε argparse αντί optparse;

Απαντήθηκε 21/08/2008 στις 13:25
πηγή χρήστη

ψήφοι
15

Λίγο πολύ όλοι χρησιμοποιεί getopt

Εδώ είναι το παράδειγμα κώδικα για το έγγραφο:

import getopt, sys

def main():
    try:
        opts, args = getopt.getopt(sys.argv[1:], "ho:v", ["help", "output="])
    except getopt.GetoptError:
        # print help information and exit:
        usage()
        sys.exit(2)
    output = None
    verbose = False
    for o, a in opts:
        if o == "-v":
            verbose = True
        if o in ("-h", "--help"):
            usage()
            sys.exit()
        if o in ("-o", "--output"):
            output = a

Έτσι, με μια λέξη, εδώ είναι πώς λειτουργεί.

Έχετε δύο τύπους επιλογών. Όσοι είναι τα επιχειρήματα που λαμβάνει, και εκείνοι που είναι ακριβώς όπως διακόπτες.

sys.argvείναι λίγο πολύ σας char** argvστο C. Όπως και σε C παραλείψετε το πρώτο στοιχείο που είναι το όνομα του προγράμματός σας και να αναλύσει μόνο τα επιχειρήματα:sys.argv[1:]

Getopt.getopt θα αναλύσει σύμφωνα με τον κανόνα σας δώσει το επιχείρημα.

"ho:v"Εδώ περιγράφει τις σύντομες επιχειρήματα: -ONELETTER. Το :μέσο που -oδέχεται ένα όρισμα.

Τέλος ["help", "output="]περιγράφει μακριά επιχειρήματα ( --MORETHANONELETTER). Η =μετά την έξοδο σημαίνει για άλλη μια φορά ότι η έξοδος δέχεται μία επιχειρήματα.

Το αποτέλεσμα είναι μια λίστα με μερικές (επιλογή, το επιχείρημα)

Εάν μια επιλογή δεν δέχεται κανένα επιχείρημα (όπως --helpεδώ) το argμέρος είναι ένα κενό string. Στη συνέχεια, συνήθως θέλουν να βρόχο σε αυτή τη λίστα και ελέγξτε το όνομα επιλογή, όπως στο παράδειγμα.

Ελπίζω ότι αυτό σας βοήθησε.

Απαντήθηκε 21/08/2008 στις 13:26
πηγή χρήστη

ψήφοι
6

Ακριβώς σε περίπτωση που μπορεί να χρειαστεί να, αυτό μπορεί να βοηθήσει αν χρειαστεί να πάρετε τα επιχειρήματα unicode για Win32 (2K, XP κλπ):


from ctypes import *

def wmain(argc, argv):
    print argc
    for i in argv:
        print i
    return 0

def startup():
    size = c_int()
    ptr = windll.shell32.CommandLineToArgvW(windll.kernel32.GetCommandLineW(), byref(size))
    ref = c_wchar_p * size.value
    raw = ref.from_address(ptr)
    args = [arg for arg in raw]
    windll.kernel32.LocalFree(ptr)
    exit(wmain(len(args), args))
startup()
Απαντήθηκε 21/08/2008 στις 13:59
πηγή χρήστη

ψήφοι
3

Προτιμώ optparse να getopt. Είναι πολύ δηλωτική: μπορείτε να πείτε τα ονόματα των επιλογών και τα αποτελέσματα θα πρέπει να έχουν (π.χ., θέτοντας ένα boolean τομέα), και σας δίνει πίσω ένα λεξικό συμπληρωθεί σύμφωνα με τις προδιαγραφές σας.

http://docs.python.org/lib/module-optparse.html

Απαντήθηκε 21/08/2008 στις 14:22
πηγή χρήστη

ψήφοι
126

Αυτή η απάντηση υποδεικνύει optparseτο οποίο είναι κατάλληλο για τις παλαιότερες εκδόσεις Python. Για Python 2.7 και άνω, argparseαντικαθιστά optparse. Δείτε την απάντηση για περισσότερες πληροφορίες.

Όπως άλλοι άνθρωποι επεσήμανε, είστε σε καλύτερη θέση θα με optparse πάνω getopt. getopt είναι λίγο πολύ μια χαρτογράφηση ένα-προς-ένα του προτύπου getopt (3) λειτουργίες της βιβλιοθήκης C, και δεν είναι πολύ εύκολο στη χρήση.

optparse, ενώ είναι λίγο πιο φλύαρη, είναι πολύ καλύτερα δομημένη και πιο εύκολο να επεκταθεί αργότερα.

Εδώ είναι μια τυπική γραμμή για να προσθέσετε μια επιλογή για να αναλυτή σας:

parser.add_option('-q', '--query',
            action="store", dest="query",
            help="query string", default="spam")

Μιλάει λίγο πολύ για τον εαυτό της? κατά το χρόνο επεξεργασίας, θα δεχθεί -q ή --query ως επιλογές, αποθηκεύστε το επιχείρημα σε ένα χαρακτηριστικό που ονομάζεται ερώτημα και έχει μια προκαθορισμένη τιμή, αν δεν το προσδιορίζει. Είναι, επίσης, αυτο-που τεκμηριώνουν το γεγονός ότι έχετε δηλώσει το επιχείρημα βοήθεια (που θα χρησιμοποιηθούν κατά την εκτέλεση με -h / - βοήθεια) εκεί με την επιλογή.

Συνήθως αναλύσει τα επιχειρήματά σας με:

options, args = parser.parse_args()

Αυτό θα, εξ ορισμού, να αναλύσει τις τυποποιημένες επιχειρήματα περάσει στο σενάριο (sys.argv [1:])

options.query συνέχεια θα οριστεί η τιμή που πέρασε στο σενάριο.

Μπορείτε να δημιουργήσετε ένα πρόγραμμα ανάλυσης απλά κάνοντας

parser = optparse.OptionParser()

Αυτά είναι όλα τα βασικά που χρειάζεστε. Εδώ είναι ένα πλήρες σενάριο Python που δείχνει το εξής:

import optparse

parser = optparse.OptionParser()

parser.add_option('-q', '--query',
    action="store", dest="query",
    help="query string", default="spam")

options, args = parser.parse_args()

print 'Query string:', options.query

5 γραμμές του πύθωνα που σας δείχνουν τα βασικά.

Αποθηκεύστε το σε sample.py, και να το εκτελέσετε μια φορά με

python sample.py

και μία φορά με

python sample.py --query myquery

Από εκεί και πέρα, θα διαπιστώσετε ότι είναι optparse πολύ εύκολο να επεκταθεί. Σε ένα από τα έργα μου, έχω δημιουργήσει μια κατηγορία εντολών που σας επιτρέπει να υποεντολές φωλιά σε ένα δέντρο εντολή εύκολα. Χρησιμοποιεί optparse μεγάλο βαθμό στις εντολές αλυσίδα μαζί. Δεν είναι κάτι που εύκολα μπορεί να εξηγηθεί σε λίγες γραμμές, αλλά μπορείτε να περιηγηθείτε στην αποθήκη μου για την κύρια κατηγορία, καθώς και μια τάξη που και την επιλογή parser χρησιμοποιεί

Απαντήθηκε 25/08/2008 στις 20:11
πηγή χρήστη

ψήφοι
4

Νομίζω ότι ο καλύτερος τρόπος για μεγαλύτερα έργα είναι optparse, αλλά αν ψάχνετε για έναν εύκολο τρόπο, ίσως http://werkzeug.pocoo.org/documentation/script είναι κάτι για σας.

from werkzeug import script

# actions go here
def action_foo(name=""):
    """action foo does foo"""
    pass

def action_bar(id=0, title="default title"):
    """action bar does bar"""
    pass

if __name__ == '__main__':
    script.run()

Έτσι, ουσιαστικά κάθε λειτουργία action_ * εκτίθεται στη γραμμή εντολών και ένα ωραίο μήνυμα βοήθειας δημιουργείται για δωρεάν.

python foo.py 
usage: foo.py <action> [<options>]
       foo.py --help

actions:
  bar:
    action bar does bar

    --id                          integer   0
    --title                       string    default title

  foo:
    action foo does foo

    --name                        string
Απαντήθηκε 27/08/2008 στις 18:27
πηγή χρήστη

ψήφοι
35

Ο νέος τρόπος του ισχίου είναι argparseγια αυτούς τους λόγους. argparse> optparse> getopt

ενημέρωση: Από py2.7 argparse είναι μέρος του προτύπου βιβλιοθήκης και optparse έχει καταργηθεί.

Απαντήθηκε 11/06/2009 στις 06:54
πηγή χρήστη

ψήφοι
2

consoleargs αξίζει να αναφερθεί εδώ. Είναι πολύ εύκολο στη χρήση. Τσέκαρέ το:

from consoleargs import command

@command
def main(url, name=None):
  """
  :param url: Remote URL 
  :param name: File name
  """
  print """Downloading url '%r' into file '%r'""" % (url, name)

if __name__ == '__main__':
  main()

Τώρα στην κονσόλα:

% python demo.py --help
Usage: demo.py URL [OPTIONS]

URL:    Remote URL 

Options:
    --name -n   File name

% python demo.py http://www.google.com/
Downloading url ''http://www.google.com/'' into file 'None'

% python demo.py http://www.google.com/ --name=index.html
Downloading url ''http://www.google.com/'' into file ''index.html''
Απαντήθηκε 30/06/2012 στις 04:43
πηγή χρήστη

ψήφοι
51

χρησιμοποιώντας docopt

Από το 2012 Python έχει ένα πολύ εύκολο, ισχυρό και πολύ δροσερό μονάδα για την ανάλυση επιχείρημα που ονομάζεται docopt . Λειτουργεί με την Python 2.6 έως 3.5 και δεν χρειάζεται εγκατάσταση (το αντιγράψετε μόνο). Εδώ είναι ένα παράδειγμα που λαμβάνονται από την τεκμηρίωση που είναι:

"""Naval Fate.

Usage:
  naval_fate.py ship new <name>...
  naval_fate.py ship <name> move <x> <y> [--speed=<kn>]
  naval_fate.py ship shoot <x> <y>
  naval_fate.py mine (set|remove) <x> <y> [--moored | --drifting]
  naval_fate.py (-h | --help)
  naval_fate.py --version

Options:
  -h --help     Show this screen.
  --version     Show version.
  --speed=<kn>  Speed in knots [default: 10].
  --moored      Moored (anchored) mine.
  --drifting    Drifting mine.

"""
from docopt import docopt


if __name__ == '__main__':
    arguments = docopt(__doc__, version='Naval Fate 2.0')
    print(arguments)

Έτσι, αυτό είναι αυτό: 2 γραμμές κώδικα συν εγχόρδων έγγραφο σας, η οποία είναι απαραίτητη και θα έχετε τα επιχειρήματά σας αναλύεται και διατίθεται σε αντιρρήσεις επιχειρήματά σας. Σας είπα ότι είναι δροσερό, δεν έκανα ;-)

Χρησιμοποιώντας python-φωτιά

Από το 2017 python-φωτιά έχει ένα άλλο δροσερό μονάδα που μπορεί να δώσει μια διεπαφή CLI στον κώδικά σας με κάνεις μηδέν επιχείρημα ανάλυσης. Εδώ είναι ένα απλό παράδειγμα από τα έγγραφα (αυτό το μικρό πρόγραμμα εκθέτει λειτουργία doubleμε γραμμή εντολών):

import fire

class Calculator(object):

  def double(self, number):
    return 2 * number

if __name__ == '__main__':
  fire.Fire(Calculator)

Από τη γραμμή εντολών, μπορείτε να εκτελέσετε:

> calculator.py double 10
20
> calculator.py double --number=15
30

Φοβερό δεν είναι;

Απαντήθηκε 04/05/2013 στις 16:51
πηγή χρήστη

ψήφοι
9

Προτιμώ Κάντε κλικ στο κουμπί . Αυτό αφαιρεί επιλογές διαχείρισης και επιτρέπει «(...) δημιουργώντας όμορφα διασυνδέσεις γραμμή εντολών με συναρμολογούμενες τρόπο με μόλις κωδικό ανάλογα με τις ανάγκες».

Εδώ είναι το παράδειγμα χρήσης:

import click

@click.command()
@click.option('--count', default=1, help='Number of greetings.')
@click.option('--name', prompt='Your name',
              help='The person to greet.')
def hello(count, name):
    """Simple program that greets NAME for a total of COUNT times."""
    for x in range(count):
        click.echo('Hello %s!' % name)

if __name__ == '__main__':
    hello()

Είναι, επίσης, αυτόματα δημιουργεί όμορφα διαμορφωμένη σελίδες βοήθειας:

$ python hello.py --help
Usage: hello.py [OPTIONS]

  Simple program that greets NAME for a total of COUNT times.

Options:
  --count INTEGER  Number of greetings.
  --name TEXT      The person to greet.
  --help           Show this message and exit.
Απαντήθηκε 21/11/2014 στις 18:00
πηγή χρήστη

ψήφοι
101

Άλλες απαντήσεις κάνουμε αναφέρουμε ότι argparseείναι ο τρόπος να πάει για νέες Python, αλλά δεν δίνουν παραδείγματα χρήσης. Για λόγους πληρότητας, εδώ είναι μια σύντομη περίληψη για το πώς να χρησιμοποιήσετε argparse:

1) Αρχικοποίηση

import argparse

# Instantiate the parser
parser = argparse.ArgumentParser(description='Optional app description')

2) Προσθέστε Επιχειρήματα

# Required positional argument
parser.add_argument('pos_arg', type=int,
                    help='A required integer positional argument')

# Optional positional argument
parser.add_argument('opt_pos_arg', type=int, nargs='?',
                    help='An optional integer positional argument')

# Optional argument
parser.add_argument('--opt_arg', type=int,
                    help='An optional integer argument')

# Switch
parser.add_argument('--switch', action='store_true',
                    help='A boolean switch')

3) Parse

args = parser.parse_args()

4) Πρόσβαση

print("Argument values:")
print(args.pos_arg)
print(args.opt_pos_arg)
print(args.opt_arg)
print(args.switch)

5) Ελέγξτε τιμές

if args.pos_arg > 10:
    parser.error("pos_arg cannot be larger than 10")

Χρήση

Σωστή χρήση:

$ ./app 1 2 --opt_arg 3 --switch

Argument values:
1
2
3
True

Εσφαλμένη επιχειρήματα:

$ ./app foo 2 --opt_arg 3 --switch
usage: convert [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]
app: error: argument pos_arg: invalid int value: 'foo'

$ ./app 11 2 --opt_arg 3
Argument values:
11
2
3
False
usage: app [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]
convert: error: pos_arg cannot be larger than 10

Πλήρης βοήθεια:

$ ./app -h

usage: app [-h] [--opt_arg OPT_ARG] [--switch] pos_arg [opt_pos_arg]

Optional app description

positional arguments:
  pos_arg            A required integer positional argument
  opt_pos_arg        An optional integer positional argument

optional arguments:
  -h, --help         show this help message and exit
  --opt_arg OPT_ARG  An optional integer argument
  --switch           A boolean switch
Απαντήθηκε 27/05/2015 στις 20:21
πηγή χρήστη

ψήφοι
0

Εδώ είναι μια μέθοδος, δεν είναι μια βιβλιοθήκη, η οποία φαίνεται να λειτουργεί για μένα.

Οι στόχοι εδώ είναι να είναι λιτός, κάθε επιχείρημα αναλυθεί από μια ενιαία γραμμή, τα args line up για την αναγνωσιμότητα, ο κώδικας είναι απλή και δεν εξαρτάται από τις ειδικές μονάδες (μόνο os + sys), προειδοποιεί για την απώλεια ή άγνωστο επιχειρήματα με χάρη , χρησιμοποιήστε ένα απλό για / περιοχή () βρόχο, και λειτουργεί σε Python 2.x και 3.x

Δεικνύονται τα δύο σημαίες εναλλαγής (-d, -v), και δύο τιμές ελέγχονται από επιχειρήματα (-i xxx και -o xxx).

import os,sys

def HelpAndExit():
    print("<<your help output goes here>>")
    sys.exit(1)

def Fatal(msg):
    sys.stderr.write("%s: %s\n" % (os.path.basename(sys.argv[0]), msg))
    sys.exit(1)

def NextArg(i):
    '''Return the next command line argument (if there is one)'''
    if ((i+1) >= len(sys.argv)):
        Fatal("'%s' expected an argument" % sys.argv[i])
    return(1, sys.argv[i+1])

### MAIN
if __name__=='__main__':

    verbose = 0
    debug   = 0
    infile  = "infile"
    outfile = "outfile"

    # Parse command line
    skip = 0
    for i in range(1, len(sys.argv)):
        if not skip:
            if   sys.argv[i][:2] == "-d": debug ^= 1
            elif sys.argv[i][:2] == "-v": verbose ^= 1
            elif sys.argv[i][:2] == "-i": (skip,infile)  = NextArg(i)
            elif sys.argv[i][:2] == "-o": (skip,outfile) = NextArg(i)
            elif sys.argv[i][:2] == "-h": HelpAndExit()
            elif sys.argv[i][:1] == "-":  Fatal("'%s' unknown argument" % sys.argv[i])
            else:                         Fatal("'%s' unexpected" % sys.argv[i])
        else: skip = 0

    print("%d,%d,%s,%s" % (debug,verbose,infile,outfile))

Ο στόχος της NextArg () είναι να επιστρέψει το επόμενο επιχείρημα κατά τον έλεγχο για τα δεδομένα που λείπουν, και «παραλείψετε» προσπερνάει το βρόχο όταν NextArg () χρησιμοποιείται, κρατώντας τη σημαία ανάλυσης κάτω σε ένα χιτώνια.

Απαντήθηκε 09/04/2016 στις 11:45
πηγή χρήστη

ψήφοι
2

προεπιλογές επιχείρημα Ελαφρύ γραμμής εντολών

Αν argparseείναι μεγάλη και είναι η σωστή απάντηση για πλήρως τεκμηριωμένη διακόπτες γραμμής εντολών και προηγμένα χαρακτηριστικά, μπορείτε να χρησιμοποιήσετε τη λειτουργία προεπιλογές επιχείρημα για να λαβές απλή θέσης επιχειρήματα πολύ απλά.

import sys

def get_args(name='default', first='a', second=2):
    return first, int(second)

first, second = get_args(*sys.argv)
print first, second

Το επιχείρημα «όνομα» συλλαμβάνει το όνομα του script και δεν χρησιμοποιείται. εξόδου Test μοιάζει με αυτό:

> ./test.py
a 2
> ./test.py A
A 2
> ./test.py A 20
A 20

Για απλά σενάρια όπου θέλω απλώς κάποιες προκαθορισμένες τιμές, θα βρείτε αυτό το αρκετά επαρκής. Ίσως επίσης να θέλετε να περιλαμβάνει κάποιο καταναγκασμό πληκτρολογήστε τις τιμές επιστροφής ή τις τιμές της γραμμής εντολών όλα θα είναι χορδές.

Απαντήθηκε 05/04/2017 στις 13:26
πηγή χρήστη

ψήφοι
0

Argparse κώδικα μπορεί να είναι μεγαλύτερο από το πραγματικό κώδικα της εφαρμογής!

Αυτό είναι ένα πρόβλημα που βρίσκω με τις πιο δημοφιλείς επιλογές επιχείρημα ανάλυσης είναι ότι εάν οι παράμετροι σας είναι μέτρια μόνο, ο κωδικός για να τεκμηριώσει γίνεται δυσανάλογα μεγάλο προς όφελος που παρέχουν.

Μια σχετικά νέα-έλα στη σκηνή επιχείρημα ανάλυσης (νομίζω) είναι Plac .

Κάνει κάποια αναγνωρισμένη συμβιβασμούς με argparse, αλλά χρησιμοποιεί την τεκμηρίωση inline και αναδιπλώνεται απλώς γύρω από main()τη λειτουργία λειτουργία τύπου:

def main(excel_file_path: "Path to input training file.",
     excel_sheet_name:"Name of the excel sheet containing training data including columns 'Label' and 'Description'.",
     existing_model_path: "Path to an existing model to refine."=None,
     batch_size_start: "The smallest size of any minibatch."=10.,
     batch_size_stop:  "The largest size of any minibatch."=250.,
     batch_size_step:  "The step for increase in minibatch size."=1.002,
     batch_test_steps: "Flag.  If True, show minibatch steps."=False):
"Train a Spacy (http://spacy.io/) text classification model with gold document and label data until the model nears convergence (LOSS < 0.5)."

    pass # Implementation code goes here!

if __name__ == '__main__':
    import plac; plac.call(main)
Απαντήθηκε 05/07/2018 στις 06:17
πηγή χρήστη

ψήφοι
0

Θα επεκταθεί η προσέγγιση Erco να καταστεί δυνατή η απαιτούμενη θέσης επιχειρήματα και για τις προαιρετικές επιχειρήματα. Αυτά θα πρέπει να προηγείται της -d, -v κλπ επιχειρήματα.

Θέσεως και προαιρετικά ορίσματα μπορούν να ανακτηθούν με PosArg (i) και OPTARG (i, προεπιλογή) αντίστοιχα. Όταν ένα προαιρετικό όρισμα βρίσκεται η θέση έναρξης της έρευνας για τις επιλογές (π.χ. -i) μετακινείται 1 μπροστά για να μην προκαλεί μια «απροσδόκητη» μοιραία.

import os,sys


def HelpAndExit():
    print("<<your help output goes here>>")
    sys.exit(1)

def Fatal(msg):
    sys.stderr.write("%s: %s\n" % (os.path.basename(sys.argv[0]), msg))
    sys.exit(1)

def NextArg(i):
    '''Return the next command line argument (if there is one)'''
    if ((i+1) >= len(sys.argv)):
        Fatal("'%s' expected an argument" % sys.argv[i])
    return(1, sys.argv[i+1])

def PosArg(i):
    '''Return positional argument'''
    if i >= len(sys.argv):
        Fatal("'%s' expected an argument" % sys.argv[i])
    return sys.argv[i]

def OptArg(i, default):
    '''Return optional argument (if there is one)'''
    if i >= len(sys.argv):
        Fatal("'%s' expected an argument" % sys.argv[i])
    if sys.argv[i][:1] != '-':
        return True, sys.argv[i]
    else:
        return False, default


### MAIN
if __name__=='__main__':

    verbose = 0
    debug   = 0
    infile  = "infile"
    outfile = "outfile"
    options_start = 3

    # --- Parse two positional parameters ---
    n1 = int(PosArg(1))
    n2 = int(PosArg(2))

    # --- Parse an optional parameters ---
    present, a3 = OptArg(3,50)
    n3 = int(a3)
    options_start += int(present)

    # --- Parse rest of command line ---
    skip = 0
    for i in range(options_start, len(sys.argv)):
        if not skip:
            if   sys.argv[i][:2] == "-d": debug ^= 1
            elif sys.argv[i][:2] == "-v": verbose ^= 1
            elif sys.argv[i][:2] == "-i": (skip,infile)  = NextArg(i)
            elif sys.argv[i][:2] == "-o": (skip,outfile) = NextArg(i)
            elif sys.argv[i][:2] == "-h": HelpAndExit()
            elif sys.argv[i][:1] == "-":  Fatal("'%s' unknown argument" % sys.argv[i])
            else:                         Fatal("'%s' unexpected" % sys.argv[i])
        else: skip = 0

    print("Number 1 = %d" % n1)
    print("Number 2 = %d" % n2)
    print("Number 3 = %d" % n3)
    print("Debug    = %d" % debug)
    print("verbose  = %d" % verbose)
    print("infile   = %s" % infile)
    print("outfile  = %s" % outfile) 
Απαντήθηκε 24/07/2018 στις 11:32
πηγή χρήστη

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more