Python "Get Specific field in csv file "

https://stackoverflow.com/questions/5757743/how-can-i-get-a-specific-field-of-a-csv-file

Python Property

@Property
https://www.programiz.com/python-programming/property


__STR__ & __REPR__
http://mrlyc.blogspot.hk/2014/04/pythonreprstr.html

Python 函式、模組、類別與套件

https://openhome.cc/Gossip/CodeData/PythonTutorial/NumericStringPy3.html

Import vs from

Import X :

• imports the module X, and creates a reference to that module in the current namespace. Then you need to define completed module path to access a particular attribute or method from inside the module. 
• For example: X.name or X.attribute

From X import * :

• * imports the module X, and creates references to all public objects defined by that module in the current namespace (that is, everything that doesn’t have a name starting with “_”) or what ever the name you mentioned. Or in other words, after you’ve run this statement, you can simply use a plain name to refer to things defined in module X. But X itself is not defined, so X.name doesn’t work. And if name was already defined, it is replaced by the new version. And if name in X is changed to point to some other object, your module won’t notice.* This makes all names from the module available in the local namespace.

Now let’s see when we do import X.Y:

>>> import sys

>>> import os.path

Check sys.modules with name os and os.path:

>>> sys.modules['os']

<module 'os' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>

>>> sys.modules['os.path']

<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>

Check globals() and locals() namespace dict with name os and os.path:

 >>> globals()['os']

<module 'os' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>

>>> locals()['os']

<module 'os' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>

>>> globals()['os.path']

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

KeyError: 'os.path'

>>>

From the above example we found that only os is inserted in the local and global namespace. So, we should be able to use:

>>> os

 <module 'os' from

  '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>

 >>> os.path

 <module 'posixpath' from

 '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>

 >>>

But not path

>>> path

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

NameError: name 'path' is not defined

>>>

Once you delete the os from locals() namespace, you won't be able to access os as well as os.path even though they exist in sys.modules:

>>> del locals()['os']

>>> os

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

NameError: name 'os' is not defined

>>> os.path

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

NameError: name 'os' is not defined

>>>

Now let's come to from :

** from :**

>>> import sys

>>> from os import path

Check sys.modules with name os and os.path:

>>> sys.modules['os']

<module 'os' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/os.pyc'>

>>> sys.modules['os.path']

<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>

Oh, we found that in sys.modules we found as same as we did before by using import name

OK, let's check how it looks like in locals() and globals() namespace dict:

>>> globals()['path']

<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>

>>> locals()['path']

<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>

>>> globals()['os']

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

KeyError: 'os'

>>>

You can access by using name path not by os.path:

>>> path

<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>

>>> os.path

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

NameError: name 'os' is not defined

>>>

Let's delete 'path' from locals():

>>> del locals()['path']

>>> path

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

NameError: name 'path' is not defined

>>>

One final example using an alias:

>>> from os import path as HELL_BOY

>>> locals()['HELL_BOY']

<module 'posixpath' from '/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>

>>> globals()['HELL_BOY']

<module 'posixpath' from /System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/posixpath.pyc'>

And no path defined:

>>> globals()['path']

Traceback (most recent call last):

 File "<stdin>", line 1, in <module>

KeyError: 'path'

>>>

https://stackoverflow.com/a/21547583

Python csv.writerow寫入多隔一行

用writerow 寫入時，每row 資料之間會多隔一行的情況。

原因是，在Windows系統下會幫每一行結尾多加一個看不見的"進位符號"，然而這個動作writerow本身就會幫我們做，所以等於重複按Enter兩次。避免這種狀況一般常見的解決方法是以binary的方式開啟檔案：

f = open("xxx.csv","wb")
c = csv.writer(f)

然而這種方法在Python 3 下會產生錯誤：


ValueError: binary mode doesn't take a newline argument

在python 3的解決方法是，在後面多加一個參數

f = open('xxx.csv', 'w', newline='')

If newline='' is not specified, newlines embedded inside quoted fields will not be interpreted correctly, and on platforms that use \r\n linendings on write an extra \r will be added. It should always be safe to specify newline='', since the csv module does its own (universal) newline handling.


http://pykynix.blogspot.hk/2013/01/csvwriterow.html

Python With statement

As most other things in Python, the with statement is actually very simple, once you understand the problem it’s trying to solve. Consider this piece of code:

    set things up
    try:
        do something
    finally:
        tear things down

Here, “set things up” could be opening a file, or acquiring some sort of external resource, and “tear things down” would then be closing the file, or releasing or removing the resource. The try-finally construct guarantees that the “tear things down” part is always executed, even if the code that does the work doesn’t finish.

If you do this a lot, it would be quite convenient if you could put the “set things up” and “tear things down” code in a library function, to make it easy to reuse. You can of course do something like

    def controlled_execution(callback):
        set things up
        try:
            callback(thing)
        finally:
            tear things down

    def my_function(thing):
        do something

    controlled_execution(my_function)

But that’s a bit verbose, especially if you need to modify local variables. Another approach is to use a one-shot generator, and use the for-in statement to “wrap” the code:

    def controlled_execution():
        set things up
        try:
            yield thing
        finally:
            tear things down

    for thing in controlled_execution():
        do something with thing

But yield isn’t even allowed inside a try-finally in 2.4 and earlier. And while that could be fixed (and it has been fixed in 2.5), it’s still a bit weird to use a loop construct when you know that you only want to execute something once.

So after contemplating a number of alternatives, GvR and the python-dev team finally came up with a generalization of the latter, using an object instead of a generator to control the behaviour of an external piece of code:

    class controlled_execution:
        def __enter__(self):
            set things up
            return thing
        def __exit__(self, type, value, traceback):
            tear things down

    with controlled_execution() as thing:
         some code

Now, when the “with” statement is executed, Python evaluates the expression, calls the __enter__ method on the resulting value (which is called a “context guard”), and assigns whatever __enter__ returns to the variable given by as. Python will then execute the code body, and no matter what happens in that code, call the guard object’s __exit__ method.

As an extra bonus, the __exit__ method can look at the exception, if any, and suppress it or act on it as necessary. To suppress the exception, just return a true value. For example, the following __exit__ method swallows any TypeError, but lets all other exceptions through:

    def __exit__(self, type, value, traceback):
        return isinstance(value, TypeError)

In Python 2.5, the file object has been equipped with __enter__ and __exit__ methods; the former simply returns the file object itself, and the latter closes the file:

    >>> f = open("x.txt")
    >>> f
    <open file 'x.txt', mode 'r' at 0x00AE82F0>
    >>> f.__enter__()
    <open file 'x.txt', mode 'r' at 0x00AE82F0>
    >>> f.read(1)
    'X'
    >>> f.__exit__(None, None, None)
    >>> f.read(1)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: I/O operation on closed file

so to open a file, process its contents, and make sure to close it, you can simply do:

with open("x.txt") as f:
    data = f.read()
    do something with data

http://effbot.org/zone/python-with-statement.htm

send e-mail via python

http://naelshiab.com/tutorial-send-email-python/