Python Tips

with open(filename,'a') as filepoint:
    filepoint.write(string)

with open(filename, 'r') as fout:
    lines = fout.readlines()
for line in lines:
    print line

pixel = np.zeros((439,2), dtype=int)
s = pixel.shape[:-1]+(1,) # s (439, 1)
result = np.hstack((pixel,np.ones(s))) # result (439, 3)

pixel = np.zeros((439,2), dtype=int)
s = np.ones(439, dtype=int) 
result = np.column_stack((pixel,s))

pixel = np.zeros((439, 2), dtype = int)
s = (1,) + pixel.shape[-1:] # s (1, 2)
result = np.vstack((pixel, np.ones(s))) # result(440 * 2)

normbearing = np.linalg.norm(bearing_b3, axis=1)[:, np.newaxis]]

results = np.array([7,8,9,10])
dists = np.array([1,2,3,4])
# bitwise operation: 7 & 1 = 1
good = dists & results
# array([ True, False, False, False], dtype=bool)
matches = zip(results[good],good.nonzero()[0])
# matches is a list
# [(7, array([0]))]

ok1 = np.array([ True, False, False, False], dtype=bool)
ok2 = np.array([ True, False, True, False], dtype=bool)
ok1*ok2
# >>>array([ True, False, False, False], dtype=bool)
np.nonzero(ok1*ok2)
# >>>(array([0]),)
np.nonzero(ok1*ok2)[0]
# >>>array([0])

parser = argparse.ArgumentParser()
parser.add_argument("path", help="Provide ANS_test path for create_link <ANS_test_path>")
args = parser.parse_args()
path = args.path # path is str
# xx.py <path-name> //必须提供此参数，否则程序报错

parser.add_argument("-v","--verbosity", type=int, choices=[0,1,2], help="increase output verbosity")
args = parser.parse_args()
args.verbosity
# ××.py -v 1

parser.add_argument("-v", "--verbosity", action="count", help="increase output verbosity")
args = parser.parse_args()
# ××.py -vv --verbosity --verbosity

parser.add_argument("-v", "--verbosity", action="store_true", help="increase output verbosity")
args = parser.parse_args()
if args.verbosity:
   do something
# ××.py -v

def any(iterable):
	for element in iterable:
	    if element:
	        return True
	return False
def all(iterable):
	for element in iterable:
	    if not element:
	        return False
	return True	

str1='123456789'
str2='1.2.3.65'
str3 = 'user1 user2 user3'
list(str1) # ['1', '2', '3', '4', '5', '6', '7', '8', '9']
str2.split('.') # ['1', '2', '3', '65']
str3.split() # 移除string空格 ['user1', 'user2', 'user3']
str1.strip() # 移除空格和回车

#将list中元素组成一个string
''.join(list)

a = np.array([[1,2],[4,5],[2,3]])
# 此时才能用切片功能,a不能是list，执行下列操作：
plt.plot(a[:,0],a[:,1])

# numpy to list
numpy.ndarry.tolist

l=['a','b','c','d','e','f','g','h','i']
for i in xrange(len(l))
  for j in xrange(i+1, len(l))
    L = l[:]
    L = [v for i, v in enumerate(l) if i not in frozenset((i,j))]

size = p_unsorted[:, 2]
order = np.argsort(size)
p_sorted = p_unsorted[order, :]

def map(f, iterable)
    return [f(x) for x in iterable]

print map(lambda x , y : x ** y, [2,4,6],[3,2,1])
[8, 16, 6]
print map(None, [2,4,6],[3,2,1])
[(2, 3), (4, 2), (6, 1)]
map(int, (1,2,3))
[1, 2, 3]
map(int, '1234')
[1, 2, 3, 4]

def reduce(f, list)
product = 1
for num in list:
    product = f(product,num)
return product

# Create array from 0 to 9
np.arange(10)
# >>array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# Create a 3×3 numpy array of all True’s
np.full((3, 3), True, dtype=bool)
np.ones((3,3), dtype=bool)
# >> array([[ True,  True,  True],
# >>        [ True,  True,  True],
# >>        [ True,  True,  True]], dtype=bool)

# Extract all odd numbers from arr
arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
arr % 2 == 1
# >>array([False,  True, False,  True, False,  True, False,  True, False,True])
arr[arr % 2 == 1]
# >>array([1, 3, 5, 7, 9])

# Replace all odd numbers in arr with -1
arr[arr % 2 == 1] = -1
# >>array([ 0, -1,  2, -1,  4, -1,  6, -1,  8, -1])

# Stack arrays a and b vertically
a = np.arange(10).reshape(2,-1)
b = np.repeat(1, 10).reshape(2,-1)
np.vstack([a, b])
np.r_[a, b]
np.concatenate([a, b], axis=0)
# >> array([[0, 1, 2, 3, 4],
# >>        [5, 6, 7, 8, 9],
# >>        [1, 1, 1, 1, 1],
# >>        [1, 1, 1, 1, 1]])

# Stack the arrays a and b horizontally.
a = np.arange(10).reshape(2,-1)
b = np.repeat(1, 10).reshape(2,-1)
np.hstack([a, b])
np.c_[a, b]
np.concatenate([a, b], axis=1)
# >> array([[0, 1, 2, 3, 4, 1, 1, 1, 1, 1],
# >>        [5, 6, 7, 8, 9, 1, 1, 1, 1, 1]])

# Create the following pattern without hardcoding.
a = np.array([1,2,3])
np.r_[np.repeat(a, 3), np.tile(a, 3)]
# >> array([1, 1, 1, 2, 2, 2, 3, 3, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3])

#!/usr/bin/env python
import os

print("Path at terminal when executing this file")
# 运行python脚步的路径
print(os.getcwd() + "\n")

print("This file path, relative to os.getcwd()")
print(__file__ + "\n")

print("This file full path (following symlinks)")
full_path = os.path.realpath(__file__)
# python real path
print(full_path + "\n")

print("This file directory and name")
path, filename = os.path.split(full_path)
print(path + ' --> ' + filename + "\n")

print("This file directory only")
print(os.path.dirname(full_path))

def add_end(L=[]):
    L.append('END')
    return L

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)
person('Bob', 35, city='Beijing')
person('Adam', 45, gender='M', job='Engineer')

def person(name, age, *, city, job):
    print(name, age, city, job)

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

L[:3]
L[-2:]
L[:] #复制一个list

for i, value in enumerate(['A', 'B', 'C']):
    print(i, value)
for x, y in [(1, 1), (2, 4), (3, 9)]:
    print(x, y)

[x * x for x in range(1, 11)]
[m + n for m in 'ABC' for n in 'XYZ']
[s.lower() for s in L]

L = [x * x for x in range(10)]
g = (x * x for x in range(10))
next(g)

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

# >>> o = odd()
# >>> next(o)
# step 1
# 1
# >>> next(o)
# step 2
# 3
# >>> next(o)
# step 3
# 5
# >>> next(o)
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# StopIteration

import functools
def log(func):
  @functools.wraps(func)
  def wrapper(*args, **kw):
    print('call %s():' % func.__name__)
    return func(*args, **kw)
  return wrapper

@log
def now():
    print('2015-3-25')

call now();
2015-3-25

import functools
def log(text): # text is "I " here
  def decorator(func): # param is now
    @functools.wraps(func)
    def wrapper(*args, **kw): #now param
      print('%s cal %s' %(text, func.__name__))
      return func(*args, **kw) #let now() to run
    return wrapper
  return decorator
@log("I ")
def now():
  print('2015-3-25')

int('1234', base = 10) # return 1234
int2 = functools.partial(int, base = 2)
int2('101') #return 5

class Student(object):
    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

class Animal(object):
    def run(self):
        print('Animal is running...')
# inherit from Animal
class Cat(Animal):
    def run(self):
        print('Cat is running...')
    def eat(self):
        print('Cat eats fish.')
class Dog(Animal):
    def run(self):
        print('Dog is running...')
    def eat(self):
        print('Dog eats meat')

def run_twice(animal):
    animal.run()

class Timer(object):
    def run(self):
        print('Start...')

def readImage(fp):
    if hasattr(fp, 'read'):
        return readData(fp)
    return None

class Student(object):

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value
>>> s = Student()
>>> s.score = 60 # OK，实际转化为s.set_score(60)
>>> s.score # OK，实际转化为s.get_score()
60
>>> s.score = 9999
Traceback (most recent call last):
...
ValueError: score must between 0 ~ 100!

def main():
    '''
    Creating empty Dictionary
    '''
    # Creating an empty dict using empty brackets
    wordFrequency = {}
    # Creating an empty dict using dict()
    wordFrequency = dict()
    print(wordFrequency)
    
    '''
    Creating Dictionaries with literals
    '''                                  
    wordFrequency = {
        "Hello" : 7,
        "hi" : 10,
        "there" : 45,
        "at" : 23,
        "this" : 77
        }
    print(wordFrequency)
 
    '''
    Creating Dictionaries by passing parametrs in dict constructor
    '''
    wordFrequency = dict(Hello =  7, 
                         hi    = 10,
                         there  = 45,
                         at    = 23,
                         this  = 77
                         )
    print(wordFrequency)
    
    '''
    Creating Dictionaries by a list of tuples
    '''
    # List of tuples    
    listofTuples = [("Hello" , 7), ("hi" , 10), ("there" , 45),("at" , 23),("this" , 77)]
    # Creating and initializing a dict by tuple
    wordFrequency = dict(listofTuples)        
    print(wordFrequency)    

    '''
    Creating Dictionary by a list of keys and initialzing all with same value
    '''    
    listofStrings = ["Hello", "hi", "there", "at", "this"]
    # create and Initialize a dictionary by this list elements as keys and with same value 0
    wordFrequency = dict.fromkeys(listofStrings,0 )
    print(wordFrequency)
 
    '''
    Creating a Dictionary by a two lists
    '''         
    # List of strings
    listofStrings = ["Hello", "hi", "there", "at", "this"]
    # List of ints
    listofInts = [7, 10, 45, 23, 77]
    # Merge the two lists to create a dictionary
    wordFrequency = dict( zip(listofStrings,listofInts ))
    print(wordFrequency)
 
if __name__ == "__main__":
    main()

## return a list and l[0] is key and l[1] is value
l = max(stat.items(), key=operator.itemgetter(1))
## dict remove a pair: stat.pop(key, default)
stat.pop(l[0])

# first method:
courses = sorted(courses, key=lambda sl: (-sl[0],sl[1]))
# second method:
li.sort(key=itemgetter(1))
li.sort(key=itemgetter(0), reverse = True)

class Solution(object):    
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        solutions = []
        self._get_subset(nums, 0, [], solutions)
        return solutions

    @staticmethod
    def _get_subset(nums, curr, path, solutions):
        if curr>= len(nums):
            # path[:] is a copy of path
            # solutions.push_back(path[:])
            # pass by reference: element of solution changes with path changing
            solutions.append(path)
            return
        path.append(nums[curr])
        Solution._get_subset(nums, curr+1, path, solutions)
        path.pop()
        Solution._get_subset(nums, curr+1, path, solutions)