def calc(*num)

    def person(name, age, **kw):
        print 'name:', name, 'age:', age, 'other:', kw
    
    >>> person('Bob', 35, city='Beijing')
        name: Bob age: 35 other: {'city': 'Beijing'}

    # 用 in 和 not in 来检查某个键是否在字典中

    def func(a, b, c=0, *args, **kw):
        print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw
    # *args是可变参数，args接收的是一个tuple；
    # **kw是关键字参数，kw接收的是一个dict。

def fact_iter(num, product):
    if num == 1:
        return product
    return fact_iter(num - 1, num * product)

L = range(100)
L[:10]      # 前10个数
L[-10:]     # 后10个数
L[:10:2]    #前10个数，每两个取一个
L[::5]      #所有数，每5个取一个
L[:]        #复制一个list

d = {'a': 1, 'b': 2, 'c': 3}
for key in d            # 迭代key
for value in d.itervalues()  # 迭代value
for k, v in d.iteritems()    # 迭代key，value

# 判断是否为可迭代对象-通过collections模块的iterable类型判断
from collections import Iterable
isinstance('abc', Iterable) # str是否可迭代 true

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 还可以加上if判断
>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

# 将[]直接换成()
>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x104feab40>

# 可用next（）或for循环
>>> g.next()
0
>>> g.next()
1

#!/usr/bin/env python    ——标准注释：该注释可以让此文件直接在Unix/Linux/Mac上运行
# -*- coding: utf-8 -*-  ——标准注释：表示此文件本身使用标准UTF-8编码

' a test module '   # 模块的文档注释——任何模块代码的第一个字符串都被视为模块的文档注释

__author__ = 'Michael Liao'  # 作者名字

import sys   # 导入模块，模块argv变量用list存储了命令行所有参数
# 运行python hello.py获得的sys.argv就是['hello.py']；

# 运行python hello.py Michael获得的sys.argv就是['hello.py', 'Michael]。

def test():
    args = sys.argv
    if len(args)==1:
        print 'Hello, world!'
    elif len(args)==2:
        print 'Hello, %s!' % args[1]
    else:
        print 'Too many arguments!'

if __name__=='__main__':
    test()

def _private_1(name):
    return 'Hello, %s' % name

def _private_2(name):
    return 'Hi, %s' % name

def greeting(name):
    if len(name) > 3:
        return _private_1(name)
    else:
        return _private_2(name)
# 模块公开greeting函数，内部逻辑用private隐藏
# 外部不需要引用的函数全部定义成private，只有需要引用的函数public

# 面向过程
    # 成绩表示
std1 = { 'name': 'Michael', 'score': 98 }
std2 = { 'name': 'Bob', 'score': 81 }
    # 成绩处理
def print_score(std):
    print '%s: %s' % (std['name'], std['score'])

# 面向对象
class Student(object):  # class 类名（-大写开头） （object-继承哪个类）
    def __init__(self, name, score): # 创建实例时绑定必要属性
        self.name = name     # self：创建的实例本身
        self.score = score

    def print_score(self):
        print '%s: %s' % (self.name, self.score)

# 对象操作
bart = Student('Bart Simpson', 59)  # 类名+（） 创建实例
lisa = Student('Lisa Simpson', 87)
lisa.school = 'huagong'          # 可自由绑定属性
bart.print_score()
lisa.print_score()

# 访问限制
# 之前还能访问name，score属性，若限制保护内部变量
self.__name = name
self.__score = score
# 原因：Python解释器对外把__name变量改成了_Student__name
>>> bart._Student__name
'Bart Simpson'

# 获取方法 
# 给Student类增加get_name和get_score
class Student(object):
    ...
    def get_name(self):
        return self.__name
    
    def set_score(self, score):  # 修改
        self.__score = score

class Animal(object):
    def run(self):
        print 'Animal is running...'

class Dog(Animal):
    def run(self):
        print 'Dog is running...'

dog = Dog()
>>> dog.run()
>>> Dog is running...

# 判断一个变量是否是某个类型可以用isinstance()判断：
a = list() # a是list类型
b = Animal() # b是Animal类型

>>> isinstance(a, list)
True
>>> isinstance(b, Animal)
True

>>> type(123)
<type 'int'>
>>> type('str')
<type 'str'>
>>> type(None)
<type 'NoneType'>
# 函数或类
>>> type(abs)
<type 'builtin_function_or_method'>
>>> type(a)
<class '__main__.Animal'>

# types模块
>>> import types
>>> type('abc')==types.StringType
True
>>> type([])==types.ListType
True
>>> type(str)==types.TypeType  # 所有类型本身的类型就是TypeType
True

h = Husky()

>>> isinstance(h, Husky) # 父类也可以
True

# 基本类型也可以
>>> isinstance('a', str)
True
# 判断是否属于一种
>>> isinstance('a', (str, unicode))
True

dir('abc')

>>> class MyObject(object):
	     def __init__(self):
         self.x = 9
	     def power(self):
	         return self.x * self.x

>>> obj = MyObject()
紧接着，可以测试该对象的属性：

>>> hasattr(obj, 'x') # 有属性'x'吗？
True
>>> obj.x
9
>>> hasattr(obj, 'y') # 有属性'y'吗？
False
>>> setattr(obj, 'y', 19) # 设置一个属性'y'
>>> hasattr(obj, 'y') # 有属性'y'吗？
True
>>> getattr(obj, 'y') # 获取属性'y'  
19
>>> obj.y # 获取属性'y'
19
# 若不存在，返回默认值
>>> getattr(obj, 'z', 404)
404

class Student(object):
  __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称

s = Student() # 创建新的实例
s.score = 99 # 绑定属性'score'
# 由于'score'没有被放到__slots__中，所以不能绑定score属性，试图绑定score将得到AttributeError的错误。

class Student(object):
  def get_score(self):
    return self._score

  def set_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.set_score(60) # ok!
>>> s.get_score()
60

# 转化为可直接调用的属性
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

class Dog(Mammal, Runnable):
  pass

# mixin
# python自带功能库

try:
  print 'try...'
  r = 10 / 0
  print 'result:', r
except ZeroDivisionError, e:
  print 'except:', e
else: 
  print 'no error!'
finally:
  print 'finally...'
print 'END'

# 结果
try...
except: integer division or modulo by zero
finally...
END

  # err.py
  def foo(s):
      n = int(s)
      assert n != 0, 'n is zero!'
      return 10 / n

  def main():
      foo('0')

  # 若断言失败
  $ python err.py
  Traceback (most recent call last):
    ...
  AssertionError: n is zero!

  # 关闭断言
  $ python -O err.py

# open()函数，传入文件名和标示符
f = open('/Users/michael/test.txt', 'r')
# read()方法一次读取文件的全部内容，把内容读到内存，用一个str对象表示
f.read()   # 'Hello, world!'

# close()方法关闭文件(以防占用操作系统的资源)
f.close()

# IOError，一旦出错，后面的f.close()不会调用
# 为了保证无论是否出错都能正确地关闭文件，使用try ... finally
try:
    f = open('/path/to/file', 'r')
    print f.read()
finally:
    if f:
        f.close()

# with语句： 自动调用close
with open('/path/to/file', 'r') as f:
    print f.read()

read()      # 一次性读取文件的全部内容
readline()  # 每次读取一行内容
readlines() # 一次读取所有内容并按行返回list

# file-like object
# 像open()函数返回的这种有个read()方法的对象，在Python中统称为file-like Object
# 二进制文件（图片、视频等等）
f = open('/Users/michael/test.jpg', 'rb')
f.read()

f = open('/Users/michael/test.txt', 'w')
f.write('Hello, world!')
f.close()

# 写文件时，操作系统往往不会立刻把数据写入磁盘，而是放到内存缓存起来，空闲的时候再慢慢写入。只有调用close()方法时，操作系统才保证把没有写入的数据全部写入磁盘
# with 保险方法
with open('/Users/michael/test.txt', 'w') as f:
    f.write('Hello, world!')