2017 年 – 第 6 頁

推銷員之死

2017 年 10 月 29 日
Quote

他們覺得我怎麼樣，我才不在乎吶！多少年他們取笑爸爸，你知道為甚麼？因為我們和這個瘋人院似的城市合不來！我們應該在空曠的原野攪拌洋灰，或者―或者做木匠。木匠是可以隨便吹口哨的！

多麼偉大的女性阿！上帝造了她之後，就把模子給毀了。

你跟他談話的時候，要是他桌上有甚麼東西掉在地上—比如說一個包兒或甚麼的—你可別把它撿起來。

我總是跟垃圾場泡上了！我剛付清汽車的分期付款，那架車快就要壽終正寢了。這個電冰箱好像鬼上身的瘋子一樣，橡膠帶剛換上就給咬斷了。他們是算準時間的，他們把機器算定時間，等你付清最後一期的錢，機器也就玩兒完了。

八十四歲的年紀，他不用走出房間，就可以靠這樣吃飯。我看在眼裡才恍然大悟，原來推銷員是個再好不過的行業。一個人到了八十四歲的年紀還能夠跑二三十個碼頭，拿起電話來就有那麼許多人記得他，喜歡他，幫他的忙。還有甚麼比這個更美的事嗎？你知道嗎？他死的時候──說起來，他死也死得像推銷員──他死的時候，有好幾百個推銷員和買主去送葬。一連幾個月有火車上有很多人為著他傷心。那時候講人品，講尊敬，講交情，講知恩必報。現在，甚麼都是死牌死板的，再也沒有講交情講人品的餘地了。你明白我的意思嗎？他們都不認識我了。

你不能像吃橘子一樣就把橘皮扔了的──人可不是水果阿！

這個世界只有你能賣錢的東西才是你的。可笑的是：你是個推銷員，可是連這個道理你都不懂。

這是豬狗不如的日子。我後悔世界大戰的時候，他們沒把我拉到軍隊裡去，到現在不見得就不活著了。

他只對我看了一眼───我就恍然大悟：我這一輩子整個而是多麼大一個謊，笑死人的謊！

在那座大廈半中間，我站住了，我瞧見───天空。我看見了世界上我心愛的東西。工作，吃的東西，和坐著抽菸的閒工夫，我望著那隻墨水筆，自己跟自己說：我他媽的偷這個東西幹嘛阿？為甚麼我要把自己變成一個我不願意做的人？為甚麼我要在一個辦公室裏做大傻瓜，苦苦哀求得讓人家瞧不起？實際上我所要的就在外邊兒等我，只要我開口說：我知道我是老幾！

Python Beyond the Basics

2017 年 10 月 27 日2019 年 8 月 23 日
Python

Entities

class: blueprint for an instance
instance: a constructed object of the class
type: indicates the class/instance belongs to
attribute: value of any object
method: a callable attribute defined in the class

Instance Methods

instance methods are variables define in the class
when call through the instance, the instance is automatically passed as first argument (named self) to the method, e.g. below:
because of this automatic passing of the instance, instance method are known as “bound” methods, i.e. bound to the instance upon which it is called

class Car(object):

def break(): # note not passing 'self' here

pass

car = Car()

car.break()

# TypeError: break() takes no arguments(1 given)

Encapsulation

breaking encapsulation: setting the object value without using the setter method

class Integer(object):

def set_value(self, val):

try:

val = int(val)

except ValueError:

return

self.val = val

enforce encapsulation:

class Integer(object):

def __init__(self, val):

try:

val = int(val)

except ValueError:

val = 0

self.val = val

Python Class Variable v.s. Instance Attribute

Set class variable and instance attribute the same name to show the difference and look up order:

class SomeClass(object):

val = 'this is a class variable'

instance = SomeClass()

print(instance.val) # this is a class variable

instance.val = 'this is a instance variable'

print(instance.val) # this is a instance variable

del instance.val

print(instance.val) # this is a class variable<span id="mce_marker" data-mce-type="bookmark" data-mce-fragment="1"></span>

The attribute look up order: when request an attribute to an instance, it looks for that attribute in the instance first then in the class.

Access class variable in instance:

class SomeClass(object):

val = 0

def __init__(self):

SomeClass.val += 1

Polymorphism

Different classes has same interface (i.e., method name), we can say that this group of related classes implement the same action
Being able to work with different types to call methods without checking it’s possible and handle errors using exception handling is called DOCK TYPING
Checking the type ahead of time is generally considered un-pythonic

An example from stackoverflow:

class Person(object):

def pay_bill():

raise NotImplementedError

class Millionare(Person):

def pay_bill():

print "Here you go! Keep the change!"

class GradStudent(Person):

def pay_bill():

print "Can I owe you ten bucks or do the dishes?"

or an built in len method as an interface implemented by list and set object:

l = [1, 2, 3]

s = (1, 2, 3)

l.__len__()

/*3*/

s.__len__()

/*3*/

Inheriting the Constructor

__init__ can be inherited
if a class doesn’t have an __init__ constructor, Python will check its parent class, as soon as it finds one, Python calls it and stops looking
we can use the super() function to call method in the parents class, or we may want to initialize in the parent class

class Animal(object):

def __init__(self, name):

self.name = name

class Dog(Animal):

def __init__(self, name):

super(Dog, self).__init__(name)

'''

if the name of Animal class change in the future

or rearrange the class hierarchy that Dog class

inherite from another class and we want to call

that constructor instead

'''

Depth-First Order

Multiple inheritance

class A(object):

def run(self):

print('run in A')

class B(A):

pass

class C(object):

def run(self):

print('run in C')

class D(B, C):

pass

D.mro()

'''

the order is : [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.C'>, <class 'object'>]

'''

After Python 2.3, add a role for diamond shape ambiguous inheritance

(Make C inherit A in this example)

class A(object):

def run(self):

print('run in A')

class B(A):

pass

class C(A):

def run(self):

print('run in C')

class D(B, C):

pass

D.mro()

'''

if the same class appears in a method resolution order, the earlier occurrences are removed

from [__main__.D, __main__.B, __main__.A, __main__.C, __main__.A, object]

to [__main__.D, __main__.B, __main__.C, __main__.A, object]

'''

Abstract Class

An abstract class is not designed to and can’t not construct instances, but subclassed by regular classes
An interface / methods that defined in abstract class must be implement by its subclass
The python abc module enables the creation of abstract class

import abc

class GetterSetter(object):

__metaclass__ = abc.ABCMeta

@m.abstractmethod

def set_val(self, input):

return

@m.abstractmethod

def get_val(self):

return

class MyGetterSetter(GetterSetter):

def set_val(self, input):

self.val = input

def get_val(self):

return self.val<span id="mce_marker" data-mce-type="bookmark" data-mce-fragment="1"></span>

Composition

Inheritance could be brittle (a change may require changes elsewhere)
Decoupled code could work independently or interactively
classes interactions will work with an interface
Not checking types: polymorphic and Pythonic

import StringIO

class FileWriter(object):

def __init__(self, file):

self.file = file

def write(self, text):

# no type checking here as long as the interface stay the same

self.file.write(text)

f = open('text.txt', 'w')

w1 = FileWriter(f)

w1.write('writing into a file object...')

w1.close

sio = String.StringIO()

w2 = FileWriter(sio)

w2.write('writing into a string io object...')

Here is an example for inheritance and composition working together:

from myappengine import webfunc, run_app

# inheritance: create class inherit from specific class

class MainPage(webfunc.RequestHandler):

def get(self):

self.response.out.write('Here is the MainPage')

class FAQPage(webfunc.RequestHandler):

def get(self):

self.response.out.write('Here is the FAQ Page')

# composition: pass class to specific app engine function as an interface

app = webfunc.WSGIApplication(

[('/', MainPage),

('/faq', FAQPage)]

)

def main():

run_app(app)

Magic Functions

In [1]: class Dog(object):

def __init__(self, color, age, name):

if not isinstance(age, int): raise ValueError

self.color = color

self.age = age

self.name = name

def __eq__(self, other_dog):

return self.name == other_dog.name and self.color == other_dog.color

def __lt__(self, other_dog):

return self.age < other_dog.age

def __gt__(self, other_dog):

return self.age > other_dog.age

mike = Dog('black', 1, 'Mike')

jack = Dog('white', 4, 'Jack')

michael = Dog('black', 10, 'Mike')

In [2]: mike < jack

Out[1]: True

In [3]: mike == michael

Out[2]: True

Attribute Encapsulation

@property should not encapsulate expensive operations, because attribute setting looks cheap
@property only controls attributes that are expected

class Me(object):

def __init__(self, var):

self._var = var

# encapsulate _var attribute to var

@property

def var(self)

return self._var

@var.setter

def var(self, var):

self._var = var

@var.deleter

def var(self)

self._var = None

In [1]: me = Me(1)

In [2]: me.var

Out[2]: 1

In [3]: me.var = 2

In [4]: del me.var

“with” in Python

class MyClass(object):

def __enter__(self):

print('We have entered "with"')

return self

# Use "with" to capture errors

def __exit__(self, type value, traceback):

print('We have leaved "with"')

print('error type: {0}'.format(type))

def do(self):

print('Do something...')

In [1]: with MyClass() as c:

c.do()

Out[1]: We have entered "with"

Do something...

We have leaved "with"

In [2]: with MyClass() as c:

c.do()

5/0

Out[2]: error type: <type 'exceptions.ZeroDivisionError'>

Custom Exception

class MyError(Exception):

def __init__(self, **kwargs):

self.msg = kwargs.get('msg')

def __str__(self):

if self.msg:

return 'Here\'s MyError Message: %s' % self.msg

else:

return 'Here\'s MyError'

In [1]: raise MyError(msg='Huston, we have a problem.')

Out[1]: ---------------------------------------------------------------------------

MyError Traceback (most recent call last)

<ipython-input-6-de465e9d3c17> in <module>()

9 return 'Here\'s MyError'

---> 11 raise MyError(msg='Huston, we have a problem.')

MyError: Here's MyError Message: Huston, we have a problem.