Pickle Problem

[tonyr1988]

I'm a complete python n00b writing my first program (or attempting to,
anyway). I'm trying to make the transition from Java, so if you could
help me, it would be greatly appreciated. Here's the code I'm stuck on
(It's very basic):

class DemoClass:
def __init__(self):
self.title = ["Hello", "Goodbye"]

def WriteToFile(self, path = "test.txt"):
fw = file(path, "w")
pickle.dump(self.title, fw)
fw.close()

if __name__=='__main__':
x = DemoClass
x.WriteToFile

It doesn't do any file I/O at all (that I see). I hope my syntax is
alright. If I just call WriteToFile, shouldn't it perform with the
default path? It gives me no errors and pretends to execute just fine.

[Mike Kent]

On Mar 15, 11:13 am, "tonyr1988" <[e-mail]:

if __name__=='__main__':
x = DemoClass
x.WriteToFile

You meant to create a DemoClass instance object, but instead, you
obtained a reference to the class object. You want 'x = DemoClass()'
instead.
You meant to call the WriteToFile method, but instead, you obtained a
reference to the method object. You want 'x.WriteToFile()' instead.

[Marc 'BlackJack' Rintsch]

In <11**********************@d57g2000hsg.googlegroups .com>, tonyr1988
wrote:

if __name__=='__main__':
x = DemoClass
x.WriteToFile

In Python classes, functions and methods are first class objects. You
bind the `DemoClass` class object to the name `x`, you are *not* creating
an instance of `DemoClass`.

Then you access the attribute `WriteToFile` of the `DemoClass` class
object. But you don't do anything with it.

In [39]: class DemoClass(object): pass
....:

In [40]: x = DemoClass

In [41]: x
Out[41]: <class '__main__.DemoClass'>

In [42]: y = DemoClass()

In [43]: y
Out[43]: <__main__.DemoClass object at 0xb5a3fd4c>

In [44]: x()
Out[44]: <__main__.DemoClass object at 0xb5a3fc2c>

You have to call the class object and the method to see any effects.

Ciao,
Marc 'BlackJack' Rintsch

[Larry Bates]

tonyr1988 wrote:

I'm a complete python n00b writing my first program (or attempting to,
anyway). I'm trying to make the transition from Java, so if you could
help me, it would be greatly appreciated. Here's the code I'm stuck on
(It's very basic):

class DemoClass:
def __init__(self):
self.title = ["Hello", "Goodbye"]

def WriteToFile(self, path = "test.txt"):
fw = file(path, "w")
pickle.dump(self.title, fw)
fw.close()

if __name__=='__main__':
x = DemoClass
x.WriteToFile

It doesn't do any file I/O at all (that I see). I hope my syntax is
alright. If I just call WriteToFile, shouldn't it perform with the
default path? It gives me no errors and pretends to execute just fine.

Just a couple of "issues" that can be fixed as follows:

import pickle

class DemoClass:
def __init__(self):
self.title = ["Hello", "Goodbye"]

def WriteToFile(self, path):
fw = file(path, "w")
pickle.dump(self.title, fw)
fw.close()

if __name__=='__main__':
path='\\test.txt'
x = DemoClass()
x.WriteToFile(path)

Notes:

1) You have to call (follow by parenthesis) DemoClass() to get an instance.
What you got was a pointer (x) to the DemoClass not an instance of
DemoClass.

2) Same for WriteToFile()

3) Probably best to move the path to main and always pass it into
WriteToFile.

-Larry

[Jerry Hill]

On 15 Mar 2007 08:13:53 -0700, tonyr1988 <to*******@gmail.comwrote:

if __name__=='__main__':
x = DemoClass
x.WriteToFile

Here, you're binding the Class DemoClass to the name x. What you
probably meant to do is create a new instance of DemoClass, and bind
that to name x, like this:

if __name__=='__main__':
x = DemoClass()
x.WriteToFile

When I make that change, your code appears to work fine.

--
Jerry

[Gary Herron]

tonyr1988 wrote:

I'm a complete python n00b writing my first program (or attempting to,
anyway). I'm trying to make the transition from Java, so if you could
help me, it would be greatly appreciated. Here's the code I'm stuck on
(It's very basic):

class DemoClass:
def __init__(self):
self.title = ["Hello", "Goodbye"]

def WriteToFile(self, path = "test.txt"):
fw = file(path, "w")
pickle.dump(self.title, fw)
fw.close()

if __name__=='__main__':
x = DemoClass
x.WriteToFile

It doesn't do any file I/O at all (that I see). I hope my syntax is
alright. If I just call WriteToFile, shouldn't it perform with the
default path? It gives me no errors and pretends to execute just fine.

Several people have pointed out the problem, but when you get that
fixed, I see another bit of trouble. The pickle format is a binary
format (be default), but you don't open the file in binary mode. On
Unix the distinction is (wisely) irrelevant, but on Windows you should
open the file with a mode of "wb" not just "w".

[=?UTF-8?B?U8O2bm1leiBLYXJ0YWw=?=]

Hi,

You should write your last two lines as ...

x = DemoClass()
x.WriteToFile()

Don't miss paranthesis again... :)

Maybe there are still some mistakes too. Does dump method writes list's
elements?

Sönmez

tonyr1988 wrote:

I'm a complete python n00b writing my first program (or attempting to,
anyway). I'm trying to make the transition from Java, so if you could
help me, it would be greatly appreciated. Here's the code I'm stuck on
(It's very basic):

class DemoClass:
def __init__(self):
self.title = ["Hello", "Goodbye"]

def WriteToFile(self, path = "test.txt"):
fw = file(path, "w")
pickle.dump(self.title, fw)
fw.close()

if __name__=='__main__':
x = DemoClass
x.WriteToFile

It doesn't do any file I/O at all (that I see). I hope my syntax is
alright. If I just call WriteToFile, shouldn't it perform with the
default path? It gives me no errors and pretends to execute just fine.

[tonyr1988]

On Mar 15, 10:38 am, Gary Herron <[e-mail]:

tonyr1988 wrote:

I'm a complete python n00b writing my first program (or attempting to,
anyway). I'm trying to make the transition from Java, so if you could
help me, it would be greatly appreciated. Here's the code I'm stuck on
(It's very basic):

class DemoClass:
def __init__(self):
self.title = ["Hello", "Goodbye"]

def WriteToFile(self, path = "test.txt"):
fw = file(path, "w")
pickle.dump(self.title, fw)
fw.close()

if __name__=='__main__':
x = DemoClass
x.WriteToFile

It doesn't do any file I/O at all (that I see). I hope my syntax is
alright. If I just call WriteToFile, shouldn't it perform with the
default path? It gives me no errors and pretends to execute just fine.

Several people have pointed out the problem, but when you get that
fixed, I see another bit of trouble. The pickle format is a binary
format (be default), but you don't open the file in binary mode. On
Unix the distinction is (wisely) irrelevant, but on Windows you should
open the file with a mode of "wb" not just "w".

Thanks guys for all the help. Sure enough, it was the parenthesis.
Most of my problems seem to be from under-simplifying (using
semicolons, brackets, etc) or, rarely, over-simplifying (forgetting
parenthesis). The biggest thing that was messing me up was the
mandatory "self" input. For some reason I was thinking that, if I had
parenthesis, I would have to define it. Fixing that works perfectly.

Also, about the binary format for opening files. The program that I'm
working on now is completely Linux-based - it's impossible for it to
work on any other OS. Should I still open with "wb" or not? Either
way, thanks for that tip!

One more (completely irrelevant) question. I don't quite understand
the double-underscore functions / methods / etc, such as __name__,
__main__, __init__. Is there a reason for the double-underscore? Does
it make anything special?

Again, thanks for the help...I'm probably going to ask a lot more of
it before too long. :)

[Alex Martelli]

Gary Herron <gh*****@islandtraining.comwrote:
...

fixed, I see another bit of trouble. The pickle format is a binary
format (be default), but you don't open the file in binary mode. On

Alas, wish it were:-(.

Unfortunately, snipping the right snippet from help(pickle) ...:

"""
| The optional protocol argument tells the pickler to use the
| given protocol; supported protocols are 0, 1, 2. The
default
| protocol is 0, to be backwards compatible. (Protocol 0 is
the
| only protocol that can be written to a file opened in text
| mode and read back successfully. When using a protocol
higher
| than 0, make sure the file is opened in binary mode, both
when
| pickling and unpickling.)
|
| Protocol 1 is more efficient than protocol 0; protocol 2 is
| more efficient than protocol 1.
"""

So, by default, you're using the most inefficient protocol... but, you
can write it out to a file opened in text mode and read it back.
Alex

[7stud]

I'm trying to make the transition from Java

The biggest thing that was messing me up was the
mandatory "self" input. For some reason I was thinking
that, if I had parenthesis, I would have to define it.

I think things are pretty similar in Java. Java does the same thing
except 'self' is invisible in Java, and in Java 'self' is called
'this'. For instance, in Java you can write:

int num;

void setNum(int num)
{
this->num = num
}

Where did 'this' come from? In Java, methods are passed the invisible
'this' argument, which you can then access inside the method. It
looks like Python just "uncloaks" Java's 'this'.