• In Python 3, there are two types that represent sequences of characters: bytes and str. Instances of bytes contain raw 8-bit values. Instances of str contain Unicode characters.
• In Python 2, there are two types that represent sequences of characters: str and unicode. In contrast to Python 3, instances of str contain raw 8-bit values. Instances of unicode contain Unicode characters.
• To convert Unicode characters to binary data, you must use the encode method. To convert binary data to Unicode characters, you must use the decode method.
• When you’re writing Python programs, it’s important to do encoding and decoding of Unicode at the furthest boundary of your interfaces. The core of your program should use Unicode character types (str in Python 3, unicode in Python 2) and should not assume anything about character encodings.

• Slicing lets you access a subset of a sequence’s items with minimal effort. The simplest uses for slicing are the built-in types list, str, and bytes.
• Python has special syntax for the stride of a slice in the form somelist[start:end:stride].

enumerate wraps any iterator with a lazy generator.

for i, flavor in enumerate(flavor_list):
print(‘%d: %s’ % (i + 1, flavor))
>>>
1: vanilla
2: chocolate
3: pecan
4: strawberry

There are two problems with the zip built-in.

• The first issue is that in Python 2 zip is not a generator; it will fully exhaust the supplied iterators and return a list of all the tuples it creates. This could potentially use a lot of memory and cause your program to crash. If you want to zip very large iterators in Python 2, you should use izip from the itertools built-in module.
• The second issue is that zip behaves strangely if the input iterators are of different lengths.

• The pickle built-in module is only useful for serializing and deserializing objects between trusted programs.
• The pickle module may break down when used for more than trivial use cases.
• Use the copyreg built-in module with pickle to add missing attribute values, allow versioning of classes, and provide stable import paths.

converting time between UTC and local clocks.

# UTC to local
from time import localtime, strftime
now = 1407694710
local_tuple = localtime(now)
time_format = ‘%Y-%m-%d %H:%M:%S’
time_str = strftime(time_format, local_tuple)
print(time_str)
# local to UTC
time_tuple = strptime(time_str, time_format)
utc_now = mktime(time_tuple)
print(utc_now)

# take present time in UTC and convert it to local time.
from datetime import datetime, timezone
now = datetime(2014, 8, 10, 18, 18, 30)
now_utc = now.replace(tzinfo=timezone.utc)
now_local = now_utc.astimezone()
print(now_local)
>>>
2014-08-10 11:18:30-07:00

Standard dictionaries are unordered. That means a dict with the same keys and values can result in different orders of iteration. This behavior is a surprising byproduct of the way the dictionary’s fast hash table is implemented. The OrderedDict class from the collections module is a special type of dictionary that keeps track of the order in which its keys were inserted. Iterating the keys of an OrderedDict has predictable behavior. This can vastly simplify testing and debugging by making all code deterministic.

One problem with dictionaries is that you can’t assume any keys are already present. If you wish to increment a counter stored in a dictionary when that counter key is not existed in the dictionary before, you have to assign a default value to that key.

stats = {}
key = 'my_counter'
if key not in stats:
stats[key] = 0
stats[key] += 1

# Using defaultdict doesn't have such problem.
from collections import defaultdict
stats = defaultdict(int)
stats['my_counter'] += 1

Write docstrings for every function, class, and module.

--main.py
--mypackage
    |-- __init__.py
    |-- mypackage/models.py
    |-- mypackage/utils.py

# main.py
from mypackage import utils

• By default, pip installs new packages in a global location. That

causes all Python programs on your system to be affected by these installed modules. If one package requires newer version of another package, which could cause conflict version dependency issue. pip3 show flask pip3 show Sphinx

• use the pip freeze command to save all

of your explicit package dependencies into a file.

pip freeze > requirements.txt
pip install -r requirements.txt

# utils.py
def to_str(data):
    if isinstance(data, str):
        return data
    elif isinstance(data, bytes):
        return data.decode(‘utf-8’)
    else:
        raise TypeError('Must supply str or bytes,''found: %r' % data)

# utils_test.py
from unittest import TestCase, main
from utils import to_str
class UtilsTestCase(TestCase):
    @classmethod
    def setUpClass(cls):
        cls.dates = pd.date_range('20160101', periods = 5)
        cls.dataDf = pd.DataFrame({'date': cls.dates,
            'count': np.array([3, 7, 4, 66, 9])})

    def test_to_str_bytes(self):
        self.assertEqual('hello', to_str(b'hello'))

    def test_to_str_str(self):
        self.assertEqual('hello', to_str('hello'))

    def test_to_str_bad(self):
        self.assertRaises(TypeError, to_str, object())


if __name__ == '__main__':
    main()

The TestCase class provides helper methods for making assertions in your tests, such as assertEqual for verifying equality, assertTrue for verifying Boolean expressions, and assertRaises for verifying that exceptions are raised when appropriate (see help(TestCase) for more). You can define your own helper methods in TestCase subclasses to make your tests more readable; just ensure that your method names don’t begin with the word test.

1. 如何查看python程序的运行效率：

The dynamic nature of Python causes surprising behaviors in its runtime performance. Operations you might assume are slow are actually very fast (string manipulation, generators). Language features you might assume are fast are actually very slow (attribute access, function calls). The true source of slowdowns in a Python program can be obscure. The best approach is to ignore your intuition and directly measure the performance of a program before you try to optimize it. Python provides a built-in profiler for determining which parts of a program are responsible for its execution time. This lets you focus your optimization efforts on the biggest sources of trouble and ignore parts of the program that don’t impact speed. STEPS: 1). install snakeviz using pip from cmd.

pip install snakeviz

2). profile the test python file using below command.

$ python -m cProfile -o profile.stats test.py
# test.py
from random import randint
max_size = 10**4
data = [randint(0, max_size) for _ in range(max_size)]
test = lambda: insertion_sort(data)

3). check the efficiency result from profile.stats file.

$ snakeviz profile.stats