看书笔记《python基础》__1

'''
 学习pyhon基础
 
  0xAF  十六进制  010  八进制
  pow(2,3)  2 的3 次方
  __future__  把下一版本的特性导入当前版本
\  转移 
r 标识源字符串

python 有6中建序列：列表， 元祖  字符串  Unicode字符串 buffer对象  xrange对象
通用序列操作： 索引，分片  序列相加，乘法 成员资格 长度  最小值 最大值
成员资格： 用In检查是否在序列中
[2:10:1]  1表示步长
将有字符组成的列表转化成字符串 
''.join(somelist)

  列表的修改，  list[2]=xx
  del list[2]  删除
  count 统计出现的次数 [1,2,4,3,2,1,4].count(1)
  extend(list) 
  index('value')  获得下表
  reverse  反转字符串
  排序：
  key = len
  reverse = true
  模板字符串：
    s = Template('A $thing must never $action')
    d = {}
    d['thing'] = 'selen'
    d['action'] = 'act'
    s.substitute(d)
    from string import Template
    s = Tempalte('$x .oooo')
    s.substitute(x= 'hello')
    
    字符串的格式化:
    字典：len 返回键值对的数量
        d[k]  返回值
        del d[k]  删除为k 的项
        k in d  检查是否存在键为k的项
        d.get('name')  有则返回value 无则返回none
        d.items()  转化为list
        d.iteritems() 转化为迭代器
        d.keys()  以列表返回键
        d.update(d)  更新一个字典
        d.setdefault('name',N/A)
列表推到式：
[x*x for x in range(10)]
[x*x for x in range(10) if x%3 == 0] 


callable()  判断函数是否可用

文档化函数 
    print(help())
 '''
storage = {}
me = 'Magnus Lie Hetland'
storage['first'] = [me]
storage['middle'] = [me]
storage['last'] = [me]


def init(data):
    data['first'] = {}
    data['middle'] = {}
    data['last'] = {}
def lookup(data,label,name):
    return data[label].get(name)  #获得键的值
storage = {}
init(storage)
print(storage)


def stor(data,full_name):
    names = full_name.splite() #分成列表
    print(names)
    if len(names) == 2 :names.insert(1,'')
    labels = 'first','middle','last'
    for label,name in zip(labels,names):  #返回一个可迭代对象
        people = lookup(data,label,name)  #返回label的值
        if people:
            people.append(full_name)
        else:
            data[label][name] = [full_name]

'''
收集参数：
def print_params(x,y,z=3,*pospor,**keypar):
    print(x,y,z)
    print(pospor)
    print(keypar)
print_params(1,2,3,4,5,6,foo =1,bar =2)
1,2,3
(4,5,6)
{foo: 1,bar:2}
'''

def add(x,y): return x+y
par=(1,2)
add(*par)  #参数收集的逆过程

def hello_3(greet='hello',name='world'):
    print('%s,%s'%(greet,name))
par = {'name':'selen','greet':'hello'}
hello_3(**par) #解字典


def stor(**kwargs):
    return 'once   there was a '\
        '%(job)s called %(name)s.'%kwargs

def power(x,y,*other):
    if other:
        print('recv:'.other)
    else:
        return pow(x,y)
def interval(start,stop=None,step=1):
    if stop is None:
        start, stop = 0,start
    result = []
    i=start
    while i< stop:
        result.append(i)
        i+=step

    return result

#作用域
x = 1
scope = vars() #返回一个不可修改字典
print(scope['x'])


def search(sequeue,number,lower = 0,upper = None):
    if upper is None: upper = len(sequeue)-1
    if lower == upper:
        assert number == sequeue[upper]
        return upper
    else:
        middle = (lower+upper)//2
        if number > sequeue['middle']
            return search(sequeue,number,middle=1,upper)
        else:
            return search(sequeue,number,lower,middle-1

                          )
多态  封装

__metclass__ =type 使用新式类
变量绑定一个方法。