在Python中运行多个函数

Question

I had a program that read in a text file and took out the necessary variables for serialization into turtle format and storing in an RDF graph. The code I had was crude and I was advised to separate it into functions. As I am new to Python, I had no idea how to do this. Below is some of the functions of the program.

I am getting confused as to when parameters should be passed into the functions and when they should be initialized with self. Here are some of my functions. If I could get an explanation as to what I am doing wrong that would be great.

#!/usr/bin/env python

from rdflib import URIRef, Graph
from StringIO import StringIO
import subprocess as sub

class Wordnet():

    def __init__(self, graph):
        self.graph = Graph()

    def process_file(self, file):
        file = open("new_2.txt", "r")
        return file

    def line_for_loop(self, file):
        for line in file:
            self.split_pointer_part()
            self.split_word_part()
            self.split_gloss_part()
            self.process_lex_filenum()
            self.process_synset_offset()
            +more functions............
            self.print_graph()

    def split_pointer_part(self, before_at, after_at, line):
        before_at, after_at = line.split('@', 1)
        return before_at, after_at

    def get_num_words(self, word_part, num_words):
        """ 1 as default, may want 0 as an invalid case """
        """ do if else statements on l3 variable """
        if word_part[3] == '0a':
            num_words = 10
        else:
            num_words = int(word_part[3])
        return num_words

    def get_pointers_list(self, pointers, after_at, num_pointers, pointerList):
        pointers = after_at.split()[0:0 +4 * num_pointers:4]
        pointerList = iter(pointers)
        return pointerList

    ............code to create triples for graph...............

    def print_graph(self):
        print graph.serialize(format='nt')

    def main():
        wordnet = Wordnet()
        my_file = wordnet.process_file()
        wordnet.line_for_loop(my_file)

if __name__ == "__main__":
    main()

Answer 1

You question is mainly a question about what object oriented programming is. I will try to explain quickly, but I recommend reading a proper tutorial on it like http://www.voidspace.org.uk/python/articles/OOP.shtml http://net.tutsplus.com/tutorials/python-tutorials/python-from-scratch-object-oriented-programming/ and/or http://www.tutorialspoint.com/python/python_classes_objects.htm

When you create a class and instantiate it (with mywordnet=WordNet(somegraph)), you can resue the mywordnet instance many times. Each variable you set on self. in WordNet, is stored in that instance. So for instance self.graph is always available if you call any method of mywordnet. If you wouldn't store it in self.graph, you would need to specify it as a parameter in each method (function) that requires it. Which would be tedious if all of these method calls require the same graph anyway.

So to look at it another way: everything you set with self. can be seen as a sort of configuration for that specific instance of Wordnet. It influences the Wordnet behaviour. You could for instance have two Wordnet instances, each instantiated with a different graph, but all other functionality the same. That way you can choose which graph to print to, depending on which Wordnet instance you use, but everything else stays the same.

I hope this helps you out a little.

Answer 2

First, I suggest you figure out the basic functional decomposition on its own - don't worry about writing a class at all.

For example,

def split_pointer_part(self, before_at, after_at, line):
    before_at, after_at = line.split('@', 1)
    return before_at, after_at

doesn't touch any instance variables (it never refers to self ), so it can just be a standalone function.

It also exhibits a peculiarity I see in your other code: you pass two arguments ( before_at , after_at ) but never use their values. If the caller doesn't already know what they are, why pass them in?

So, a free function should probably look like:

def split_pointer_part(line):
    """get tuple (before @, after @)"""
    return line.split('@', 1)

If you want to put this function in your class scope (so it doesn't pollute the top-level namespace, or just because it's a logical grouping), you still don't need to pass self if it isn't used. You can make it a static method:

@staticmethod
def split_pointer_part(line):
    """get tuple (before @, after @)"""
    return line.split('@', 1)

Answer 3

One thing that would be very helpful for you is a good visual debugger. There's a nice free one for Python called Winpdb . There are also excellent debuggers in the commercial products IntelliJ IDEA/PyCharm, Komodo IDE, WingIDE, and Visual Studio (with the Python Tools add-in). Probably a few others too.

I highly recommend setting up one of these debuggers and running your code under it. It will let you step through your code line by line and see what happens with all your variables and objects.

You may find people who tell you that real programmers don't need or shouldn't use debuggers. Don't listen to them: a good debugger is one of the very best tools to help you learn a new language or to get familiar with a piece of code.