Question:

How can I make two decorators in Python that would do the following.

    @makebold
    @makeitalic
    def say():
       return "Hello"

which should return

1

<b><i>Hello</i></b>

Anwser A:

    #!/usr/bin/env python
    #-*-coding=utf-8-*-

    def makeblod(func):
        def wrap():
            return "<b>" + func() + "</b>"
        return wrap

    def makeitalic(func):
        def wrap():
            return "<i>" + func() + "</i>"
        return wrap

    @makeblod
    @makeitalic
    def say():
        return "Hello"

    print say()

    # This is the exact equivalent to 
    def say():
        return "hello"
    say = makebold(makeitalic(say))

Anwser B:

    #!/usr/bin/env python
    #-*-coding=utf-8-*-

    def makehtml(tag=None):
        def wrap(func):
            def wrapped(*args, **kwargs):
                return "<%s>" % tag + func() + "</%s>" % tag
            return wrapped
        return wrap

    @makehtml("html")
    @makehtml("body")
    @makehtml("h1")
    def say():
        return "Hello"

    print say()
    print say

Anwser C:

    #!/usr/bin/env python
    #-*-coding=utf-8-*-

    from functools import wraps

    def makehtml(tag=None):
        def wrap(func):
            @wraps(func)
            def wrapped(*args, **kwargs):
                return "<%s>" % tag + func() + "</%s>" % tag
            return wrapped
        return wrap

    @makehtml("html")
    @makehtml("body")
    @makehtml("h1")
    def say():
        return "Hello"

    print say()
    print say

[stackoverflow.com top voted python questions]
[1]how can i make a chain of function decorators
[2]functools.wraps

Thanks for @Rafe Kettler, this post’s author.
I will add some extra info to this post, to help chinese pythonistas to easy understand.

Introducation

What are magic methods? They’re everything in object-oriented Python. They’re special methods that you can define to add “magic” to your classes. They’re always surrounded by double underscores (e.g. __init__ or __lt__). They’re also not as well documented as they need to be. All of the magic methods for Python appear in the same section in the Python docs, but they’re scattered about and only loosely organized. There’s hardly an example to be found in that section (and that may very well be by design, since they’re all detailed in the language reference, along with boring syntax descriptions, etc.).

So, to fix what I perceived as a flaw in Python’s documentation, I set out to provide some more plain-English, example-driven documentation for Python’s magic methods. I started out with weekly blog posts, and now that I’ve finished with those, I’ve put together this guide.

I hope you enjoy it. Use it as a tutorial, a refresher, or a reference; it’s just intended to be a user-friendly guide to Python’s magic methods.

1.Construction and Initialization (__new__, __init__, __del__)

Everyone knows the most basic magic method, __init__. It’s the way that we can define the initialization behavior of an object. However, when I call x = SomeClass(), __init__ is not the first thing to get called. Actually, it’s a method called __new__, which actually creates the instance, then passes any arguments at creation on to the initializer.

At the other end of the object’s lifespan, there’s del. Let’s take a closer look at these 3 magic methods:

1

__new__(cls, [...)

1

python metaclass and __new__

1

__init__(self, [...)

1

__del__(self)

Putting it all together, here’s an example of __init__ and __del__ in action:

    from os.path import join

    class FileObject:
        '''Wrapper for file objects to make sure the file gets closed on deletion.'''

        def __init__(self, filepath='~', filename='sample.txt'):
            # open a file filename in filepath in read and write mode
            self.file = open(join(filepath, filename), 'r+')

        def __del__(self):
            self.file.close()
            del self.file

2. Making Operators Work on Custom Classes

One of the biggest advantages of using Python’s magic methods is that they provide a simple way to make objects behave like built-in types. That means you can avoid ugly, counter-intuitive, and nonstandard ways of performing basic operators. In some languages, it’s common to do something like this:

    if instance.equals(other_instance):
        # do something

You could certainly do this in Python, too, but this adds confusion and is unnecessarily verbose. Different libraries might use different names for the same operations, making the client do way more work than necessary. With the power of magic methods, however, we can define one method (__eq__, in this case), and say what we mean instead:

    if instance == other_instance:
        #do something

That’s part of the power of magic methods. The vast majority of them allow us to define meaning for operators so that we can use them on our own classes just like they were built in types.

Comparison magic methods

Python has a whole slew of magic methods designed to implement intuitive comparisons between objects using operators, not awkward method calls. They also provide a way to override the default Python behavior for comparisons of objects (by reference). Here’s the list of those methods and what they do:

1

__cmp__(self, other)

1

__eq__(self, other)

1

__ne__(self, other)

1

__lt__(self, other)

1

__gt__(self, other)

1

__le__(self, other)

1

__ge__(self, other)

For an example, consider a class to model a word. We might want to compare words lexicographically (by the alphabet), which is the default comparison behavior for strings, but we also might want to do it based on some other criterion, like length or number of syllables. In this example, we’ll compare by length. Here’s an implementation:

    class Word(str):
        '''Class for words, defining comparison based on word length.'''

        def __new__(cls, word):
            # Note that we have to use __new__. This is because str is an immutable
            # type, so we have to initialize it early (at creation)
            if ' ' in word:
                print "Value contains spaces. Truncating to first space."
                word = word[:word.index(' ')] # Word is now all chars before first space
            return str.__new__(cls, word)

        def __gt__(self, other):
            return len(self) > len(other)
        def __lt__(self, other):
            return len(self) < len(other)
        def __ge__(self, other):
            return len(self) >= len(other)
        def __le__(self, other):
            return len(self) <= len(other)

Now, we can create two Words (by using Word(‘foo’) and Word(‘bar’)) and compare them based on length. Note, however, that we didn’t define __eq__ and __ne__. This is because this would lead to some weird behavior ( notably that Word(‘foo’) == Word(‘bar’) would evaluate to true). It wouldn’t make sense to test for equality based on length, so we fall back on str’s implementation of equality.

Now would be a good time to note that you don’t have to define every comparison magic method to get rich comparisons. The standard library has kindly provided us with a class decorator in the module functools that will define all rich comparison methods if you only define __eq__ and one other (e.g. __gt__, __lt__, etc.) This feature is only available in Python 2.7, but when you get a chance it saves a great deal of time and effort. You can use it by placing @total_ordering above your class definition.

Numeric magic methods

Just like you can create ways for instances of your class to be compared with comparison operators, you can define behavior for numeric operators. Buckle your seat belts, folks, there’s a lot of these. For organization’s sake, I’ve split the numeric magic methods into 5 categories:

1. unary operators
2. normal arithmetic operators
3. reflected arithmetic operators (more on this later)
4. augmented assignment
5. and type conversions

1.Unary operators and functions

Unary operators and functions only have one operand, e.g. negation, absolute value, etc.

1

__pos__(self)

1

__neg__(self)

1

__abs__(self)

1

__invert__(self)

1

__round__(self, n)

1

__floor__(self)

1

__ceil__(self)

1

__trunc__(self)

2.Normal arithmetic operators

Now, we cover the typical binary operators (and a function or two): +, -, * and the like. These are, for the most part, pretty self-explanatory.

1

__add__(self, other)

1

__sub__(self, other)

1

__mul__(self, other)

1

__floordiv__(self, other)

1

__div__(self, other)

1

__truediv__(self, other)

1

__mod__(self, other)

1

__divmod__(self, other)

1

__pow__

1

__lshift__(self, other)

1

__rshift__(self, other)

1

__and__(self, other)

1

__or__(self, other)

1

__xor__(self, other)

3.Reflected arithmetic operators

You know how I said I would get to reflected arithmetic in a bit? Some of you might think it’s some big, scary, foreign concept. It’s actually quite simple. Here’s an example:

1

some_object + other

1

other + some_object

1

__radd__(self, other)

1

__rsub__(self, other)

1

__rmul__(self, other)

1

__rfloordiv__(self, other)

1

__rdiv__(self, other)

1

__rtruediv__(self, other)

1

__rmod__(self, other)

1

__rdivmod__(self, other)

1

__rpow__

1

__rlshift__(self, other)

1

__rrshift__(self, other)

1

__rand__(self, other)

1

__ror__(self, other)

1

__rxor__(self, other)

4.Augmented assignment

Python also has a wide variety of magic methods to allow custom behavior to be defined for augmented assignment. You’re probably already familiar with augmented assignment, it combines “normal” operators with assignment. If you still don’t know what I’m talking about, here’s an example:

    x = 5
    x += 1 # in other words x = x + 1

Each of these methods should return the value that the variable on the left hand side should be assigned to ( for instance, for a += b, __iadd__ might return a + b, which would be assigned to a). Here’s the list:

1

__iadd__(self, other)

1

__isub__(self, other)

1

__imul__(self, other)

1

__ifloordiv__(self, other)

1

__idiv__(self, other)

1

__itruediv__(self, other)

1

__imod_(self, other)

1

__ipow__

1

__ilshift__(self, other)

1

__irshift__(self, other)

1

__iand__(self, other)

1

__ior__(self, other)

1

__ixor__(self, other)

5.Type conversion magic methods

Python also has an array of magic methods designed to implement behavior for built in type conversion functions like float(). Here they are:

1

__int__(self)

1

__long__(self)

1

__float__(self)

1

__complex__(self)

1

__oct__(self)

1

__hex__(self)

1

__index__(self)

1

__trunc__(self)

1

__coerce__(self, other)

3.Representing your Classes

It’s often useful to have a string representation of a class. In Python, there’s a few methods that you can implement in your class definition to customize how built in functions that return representations of your class behave.

1

__str__(self)

1

__repr__(self)

1

__unicode__(self)

1

__format__(self, formatstr)

1

__hash__(self)

1

__nonzero__(self)

1

__dir__(self)

1

__sizeof__(self)

We’re pretty much done with the boring (and example-free) part of the magic methods guide. Now that we’ve covered some of the more basic magic methods, it’s time to move to more advanced material.

4.Controlling Attribute Access

Many people coming to Python from other languages complain that it lacks true encapsulation for classes (e.g. no way to define private attributes and then have public getter and setters). This couldn’t be farther than the truth:it just happens that Python accomplishes a great deal of encapsulation through “magic”, instead of explicit modifiers for methods or fields.

Take a look:

1

__getattr__(self, name)

1

__setattr__(self, name, value)

1

__delattr__

1

__getattribute__(self, name)

You can easily cause a problem in your definitions of any of the methods controlling attribute access. Consider this example:

    def __setattr__(self, name, value):
        self.name = value
        # since every time an attribute is assigned, __setattr__() is called, this
        # is recursion.
        # so this really means self.__setattr__('name', value). Since the method
        # keeps calling itself, the recursion goes on forever causing a crash

    def __setattr__(self, name, value):
        self.__dict__[name] = value # assigning to the dict of names in the class
        # define custom behavior here

Again, Python’s magic methods are incredibly powerful, and with great power comes great responsibility. It’s important to know the proper way to use magic methods so you don’t break any code.

So, what have we learned about custom attribute access in Python? It’s not to be used lightly. In fact, it tends to be excessively powerful and counter-intuitive. But the reason why it exists is to scratch a certain itch: Python doesn’t seek to make bad things impossible, but just to make them difficult. Freedom is paramount, so you can really do whatever you want.

Here’s an example of some of the special attribute access methods in action (note that we use super because not all classes have an attribute dict):

    class AccessCounter(object):
        '''A class that contains a value and implements an access counter.
        The counter increments each time the value is changed.'''

        def __init__(self, val):
            super(AccessCounter, self).__setattr__('counter', 0)
            super(AccessCounter, self).__setattr__('value', val)

        def __setattr__(self, name, value):
            if name == 'value':
                super(AccessCounter, self).__setattr__('counter', self.counter + 1)
            # Make this unconditional.
            # If you want to prevent other attributes to be set, raise AttributeError(name)
            super(AccessCounter, self).__setattr__(name, value)

        def __delattr__(self, name):
            if name == 'value':
                super(AccessCounter, self).__setattr__('counter', self.counter + 1)
            super(AccessCounter, self).__delattr__(name)]

5.Making Custom Sequences

There’s a number of ways to get your Python classes to act like built in sequences (dict, tuple, list, string, etc.). These are by far my favorite magic methods in Python because of the absurd degree of control they give you and the way that they magically make a whole array of global functions work beautifully on instances of your class. But before we get down to the good stuff, a quick word on requirements.

Requirements

Now that we’re talking about creating your own sequences in Python, it’s time to talk about protocols. Protocols are somewhat similar to interfaces in other languages in that they give you a set of methods you must define. However, in Python protocols are totally informal and require no explicit declarations to implement. Rather, they’re more like guidelines.

Why are we talking about protocols now? Because implementing custom container types in Python involves using some of these protocols. First, there’s the protocol for defining immutable containers: to make an immutable container, you need only define __len__ and __getitem__ ( more on these later). The mutable container protocol requires everything that immutable containers require plus __setitem__ and __delitem__. Lastly, if you want your object to be iterable, you’ll have to define __iter__, which returns an iterator. That iterator must conform to an iterator protocol, which requires iterators to have methods called __iter__(returning itself) and next.

The magic behind containers

Without any more wait, here are the magic methods that containers use:

1

__len__(self)

1

__getitem__(self, key)

1

__setitem__(self, key, value)

1

__delitem__(self, key)

1

__iter__(self)

1

__reversed__(self)

1

__contains__(self, item)

1

__missing__(self, key)

An example

For our example, let’s look at a list that implements some functional constructs that you might be used to from other languages (Haskell, for example).

    class FunctionalList:
        '''A class wrapping a list with some extra functional magic, like head,
        tail, init, last, drop, and take.'''

        def __init__(self, values=None):
            if values is None:
                self.values = []
            else:
                self.values = values

        def __len__(self):
            return len(self.values)

        def __getitem__(self, key):
            # if key is of invalid type or value, the list values will raise the error
            return self.values[key]

        def __setitem__(self, key, value):
            self.values[key] = value

        def __delitem__(self, key):
            del self.values[key]

        def __iter__(self):
            return iter(self.values)

        def __reversed__(self):
            return FunctionalList(reversed(self.values))

        def append(self, value):
            self.values.append(value)
        def head(self):
            # get the first element
            return self.values[0]
        def tail(self):
            # get all elements after the first
            return self.values[1:]
        def init(self):
            # get elements up to the last
            return self.values[:-1]
        def last(self):
            # get last element
            return self.values[-1]
        def drop(self, n):
            # get all elements except first n
            return self.values[n:]
        def take(self, n):
            # get first n elements
            return self.values[:n]

There you have it, a (marginally) useful example of how to implement your own sequence. Of course, there are more useful applications of custom sequences, but quite a few of them are already implemented in the standard library ( batteries included, right?), like Counter, OrderedDict, and NamedTuple.

6.Reflection

You can also control how reflection using the built in functions isinstance() and issubclass() behaves by defining magic methods. The magic methods are:

1

__instancecheck__(self, instance)

1

__subclasscheck__(self, subclass)

The use case for these magic methods might seem small, and that may very well be true. I won’t spend too much more time on reflection magic methods because they aren’t very important, but they reflect something important about object-oriented programming in Python and Python in general: there is almost always an easy way to do something, even if it’s rarely necessary. These magic methods might not seem useful, but if you ever need them you’ll be glad that they’re there (and that you read this guide!).

7.Callable Objects (__call__)

As you may already know, in Python, functions are first-class objects. This means that they can be passed to functions and methods just as if they were objects of any other kind. This is an incredibly powerful feature.

A special magic method in Python allows instances of your classes to behave as if they were functions, so that you can “call” them, pass them to functions that take functions as arguments, and so on. This is another powerful convenience feature that makes programming in Python that much sweeter.

1

__call__(self, [args...])

__call__ can be particularly useful in classes whose instances that need to often change state. “Calling” the instance can be an intuitive and elegant way to change the object’s state. An example might be a class representing an entity’s position on a plane:

    class Entity:
        '''Class to represent an entity. Callable to update the entity's position.'''

        def __init__(self, size, x, y):
            self.x, self.y = x, y
            self.size = size

        def __call__(self, x, y):
            '''Change the position of the entity.'''
            self.x, self.y = x, y

        # snip...

8.Context Managers (with)

In Python 2.5, a new keyword was introduced in Python along with a new method for code reuse, the with statement. The concept of context managers was hardly new in Python (it was implemented before as a part of the library), but not until PEP 343 was accepted did it achieve status as a first class language construct. You may have seen with statements before:

1
2
with open('foo.txt') as bar:
    # perform some action with bar

Context managers allow setup and cleanup actions to be taken for objects when their creation is wrapped with a with statement. The behavior of the context manager is determined by two magic methods:

1

__enter__(self)

1

__exit__(self, exception_type, exception_value, traceback)

__enter__ and __exit__ can be useful for specific classes that have well-defined and common behavior for setup and cleanup. You can also use these methods to create generic context managers that wrap other objects. Here’s an example:

    class Closer:
        '''A context manager to automatically close an object with a close method
        in a with statement.'''

        def __init__(self, obj):
            self.obj = obj

        def __enter__(self):
            return self.obj # bound to target

        def __exit__(self, exception_type, exception_val, trace):
            try:
               self.obj.close()
            except AttributeError: # obj isn't closable
               print 'Not closable.'
               return True # exception handled successfully

Here’s an example of Closer in action, using an FTP connection to demonstrate it (a closable socket):

    >>> from magicmethods import Closer
    >>> from ftplib import FTP
    >>> with Closer(FTP('ftp.somesite.com')) as conn:
    ...     conn.dir()
    ...
    # output omitted for brevity
    >>> conn.dir()
    # long AttributeError message, can't use a connection that's closed
    >>> with Closer(int(5)) as i:
    ...     i += 1
    ...
    Not closable.
    >>> i
    6

See how our wrapper gracefully handled both proper and improper uses? That’s the power of context managers and magic methods. Note that the Python standard library includes a module contextlib that contains a context manager, contextlib.closing(), that does approximately the same thing (without any handling of the case where an object does not have a close() method).

9.Abstract Base Classes

See python doc/abc

10.Building Descriptor Objects (__get__)

Descriptors are classes which, when accessed through either getting, setting, or deleting, can also alter other objects. Descriptors aren’t meant to stand alone; rather, they’re meant to be held by an owner class. Descriptors can be useful when building object-oriented databases or classes that have attributes whose values are dependent on each other. Descriptors are particularly useful when representing attributes in several different units of measurement or representing computed attributes (like distance from the origin in a class to represent a point on a grid).

To be a descriptor, a class must have at least one of __get__, __set__, and __delete__ implemented. Let’s take a look at those magic methods:

1

__get__(self, instance, owner)

1

__set__(self, instance, value)

1

__delete__(self, instance)

Now, an example of a useful application of descriptors: unit conversions.

    class Meter(object):
        '''Descriptor for a meter.'''

        def __init__(self, value=0.0):
            self.value = float(value)
        def __get__(self, instance, owner):
            return self.value
        def __set__(self, instance, value):
            self.value = float(value)


    class Foot(object):
        '''Descriptor for a foot.'''

        def __get__(self, instance, owner):
            return instance.meter * 3.2808
        def __set__(self, instance, value):
            instance.meter = float(value) / 3.2808


    class Distance(object):
        '''Class to represent distance holding two descriptors for feet and
        meters.'''
        meter = Meter()
        foot = Foot()

11.Copying (__copy__, __deepcopy__)

Sometimes, particularly when dealing with mutable objects, you want to be able to copy an object and make changes without affecting what you copied from. This is where Python’s copy comes into play. However (fortunately), Python modules are not sentient, so we don’t have to worry about a Linux-based robot uprising, but we do have to tell Python how to efficiently copy things.

1

__copy__(self)

1

__deepcopy__(self, memodict={})

What are some use cases for these magic methods? As always, in any case where you need more fine-grained control than what the default behavior gives you. For instance, if you are attempting to copy an object that stores a cache as a dictionary (which might be large), it might not make sense to copy the cache as well – if the cache can be shared in memory between instances, then it should be.

12.Pickling Your Objects

If you spend time with other Pythonistas, chances are you’ve at least heard of pickling. Pickling is a serialization process for Python data structures, and can be incredibly useful when you need to store an object and retrieve it later ( usually for caching). It’s also a major source of worries and confusion.

Pickling is so important that it doesn’t just have its own module (pickle), but its own protocol and the magic methods to go with it. But first, a brief word on how to pickle existing types(feel free to skip it if you already know).

Pickling: A Quick Soak in the Brine

Let’s dive into pickling. Say you have a dictionary that you want to store and retrieve later. You couldwrite it’s contents to a file, carefully making sure that you write correct syntax, then retrieve it using either exec() or processing the file input. But this is precarious at best: if you store important data in plain text, it could be corrupted or changed in any number of ways to make your program crash or worse run malicious code on your computer. Instead, we’re going to pickle it:

    import pickle

    data = {'foo': [1, 2, 3],
            'bar': ('Hello', 'world!'),
            'baz': True}
    jar = open('data.pkl', 'wb')
    pickle.dump(data, jar) # write the pickled data to the file jar
    jar.close()

Now, a few hours later, we want it back. All we have to do is unpickle it:

    import pickle

    pkl_file = open('data.pkl', 'rb') # connect to the pickled data
    data = pickle.load(pkl_file) # load it into a variable
    print data
    pkl_file.close()

What happens? Exactly what you expect. It’s just like we had data all along.

Now, for a word of caution: pickling is not perfect. Pickle files are easily corrupted on accident and on purpose. Pickling may be more secure than using flat text files, but it still can be used to run malicious code. It’s also incompatible across versions of Python, so don’t expect to distribute pickled objects and expect people to be able to open them. However, it can also be a powerful tool for caching and other common serialization tasks. Pickling your own Objects

Pickling isn’t just for built-in types. It’s for any class that follows the pickle protocol. The pickle protocol has four optional methods for Python objects to customize how they act ( it’s a bit different for C extensions, but that’s not in our scope):

1

__getinitargs__(self)

1

__getnewargs__(self)

1

__getstate__(self)

1

__setstate__(self, state)

1

__reduce__(self)

1

__reduce_ex__(self)

An Example

Our example is a Slate, which remembers what its values have been and when those values were written to it. However, this particular slate goes blank each time it is pickled: the current value will not be saved.

    import time

    class Slate:
        '''Class to store a string and a changelog, and forget its value when
        pickled.'''

        def __init__(self, value):
            self.value = value
            self.last_change = time.asctime()
            self.history = {}

        def change(self, new_value):
            # Change the value. Commit last value to history
            self.history[self.last_change] = self.value
            self.value = new_value
            self.last_change = time.asctime()

        def print_changes(self):
            print 'Changelog for Slate object:'
            for k, v in self.history.items():
                print '%s\t %s' % (k, v)

        def __getstate__(self):
            # Deliberately do not return self.value or self.last_change.
            # We want to have a "blank slate" when we unpickle.
            return self.history

        def __setstate__(self, state):
            # Make self.history = state and last_change and value undefined
            self.history = state
            self.value, self.last_change = None, None

Conclusion

The goal of this guide is to bring something to anyone that reads it, regardless of their experience with Python or object-oriented programming. If you’re just getting started with Python, you’ve gained valuable knowledge of the basics of writing feature-rich, elegant, and easy-to-use classes. If you’re an intermediate Python programmer, you’ve probably picked up some slick new concepts and strategies and some good ways to reduce the amount of code written by you and clients. If you’re an expert Pythonista, you’ve been refreshed on some of the stuff you might have forgotten about and maybe picked up a few new tricks along the way. Whatever your experience level, I hope that this trip through Python’s special methods has been truly magical (I couldn’t resist the final pun).

[参考资料]
[1]A guide to python’s magic methods
[2]python metaclass

exception

    "你好".encode("utf8")
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    UnicodeDecodeError: 'ascii' codec can't decode byte 0xe4 in
    position 0: ordinal not in range(128)

1	"你好".encode('utf-8')

encode converts a unicode object to a string object. But here you have invoked it on a string object (because you don’t have the u).
So python has to convert the string to a unicode object first. So it does the equivalent of

1	"你好".decode().encode('utf-8')

But the decode fails because the string isn’t valid ascii. That’s why you get a complaint about not being able to decode.

“你好” 的编码有外部文本环境决定 例如 # -*- coding: utf-8 -*- 则 编码为’utf8’,而此时系统编码为默认的ascii, </br> 所以第一步 utf8–>ascii 编码肯定会错误的。。

ASCII

1

man ascii

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
For convenience, let us give more compact tables in hex and decimal.

      2 3 4 5 6 7       30 40 50 60 70 80 90 100 110 120
    -------------      ---------------------------------
   0:   0 @ P ` p     0:    (  2  <  F  P  Z  d   n   x
   1: ! 1 A Q a q     1:    )  3  =  G  Q  [  e   o   y
   2: " 2 B R b r     2:    *  4  >  H  R  \  f   p   z
   3: # 3 C S c s     3: !  +  5  ?  I  S  ]  g   q   {
   4: $ 4 D T d t     4: "  ,  6  @  J  T  ^  h   r   |
   5: % 5 E U e u     5: #  -  7  A  K  U  _  i   s   }
   6: & 6 F V f v     6: $  .  8  B  L  V  `  j   t   ~
   7: ´ 7 G W g w     7: %  /  9  C  M  W  a  k   u  DEL
   8: ( 8 H X h x     8: &  0  :  D  N  X  b  l   v
   9: ) 9 I Y i y     9: ´  1  ;  E  O  Y  c  m   w
   A: * : J Z j z
   B: + ; K [ k {
   C: , < L \ l |
   D: - = M ] m }
   E: . > N ^ n ~
   F: / ? O _ o DEL

UNICODE

参考

字符编码简介
中文编码问题
字符集和字符编码
python里的string和unicode

1.段落

使用一个或多个空行分隔内容段来生成段落 <p>
段内换行需要手动添加<br />

this is first paragraph, fuck great firewall
fuck great firewall

this is second paragraph

this is third paragraph

2.标题

标题（h1~h6）格式为使用相应个数的“#”作前缀，比如以下代码表示：

this is a level-1 header

this is a level-2 header

this is a level-3 header

this is a level-4 header

this is a level-5 header

this is a level-6 header

####### this is a level-7 header (support max # length is 6)

3.引用

使用“>”作为段落前缀来标识引用文字段落。这其实是 email 中标记引用文字的标准方式：

引用的内容

这个记号直接借鉴的邮件标准,可以嵌套引用内容

4.列表

使用“*”“+”“-”来表示无序列表；使用数字加“.”表示有序列表。如：

• first
• second
• third

• first
• second
• third

• first
• second
• third

1. first
2. second
3. third

5.转义段落

使用 4 个以上 空格或 1 个以上 的 tab 来标记代码段落，它们将被 <pre> 和 <code> 包裹，这意味着代码段内的字体会是 monospace 家族的，并且特殊符号不会被转义。

    //this is a monospace paragraph
    <script type="text/javascript">
    $(document).ready(function(){
        console.log("hello world!");
    });
    </script>

6.图片和链接

使用www.google.com来标记普通链接。

1
使用[www.google.com](https://www.google.com "mouse over title")来标记普通链接。

使用 来标记图片。
引号内的 title 文字是可选的，链接也可以使用相对路径。

1
使用 ![img](http://img.hb.aicdn.com/189331a13a653f1b69e266ece9214e9f7aaf969612cc-8XQ4H6_sq75 "mouse over title") 来标记图片。

7. 强调字体

使用 * 或 _ 包裹文本产生 strong 效果：

你是什么意思，我想上人人网。

*你是什么意思，我想上人人网。*

你是什么意思，我想上人人网。

_你是什么意思，我想上人人网。_

你是什么意思，我想上人人网。

__你是什么意思，我想上人人网。__

你是什么意思，我想上人人网。

**你是什么意思，我想上人人网。**

8.CODE

this is inline code.

1

javascript:$(this).html("clicked.");

this is inline code. `javascript:$(this).html(“clicked.”);`

this is code block

    import sys
    import os
    import unittest

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