Python语言精要 （利用Python 进行数据分析附录部分）

Python语言精要 （利用Python 进行数据分析附录部分）


exit(), ctrl+D  退出
缩进，不是大括号
万物皆对象： Python解释器中的任何数值、字符串、数据机构、函数、类、模块都对象，每个对象都有与之关联的类型（比如字符串或函数）
对变量赋值， 其实是创建等号右侧对象的一个引用 如a=1,2,3,4; b=a, 此时b和a指向同一个地址， 可用b=a[:]进行复制，这时指向另外的地址
将对象以参数的形式传入函数时，其实传入的是一个引用，不是复制，因此内部的修改会影响对象
Python 可以认为是一种强类型语言，素有对象都有一个特定的类型，隐式转换只有在很明显的情况下发生，a=5, isinstance(a,int)
Python 中的对象既有属性 attribute又有方法， method 可以通过objlattirbute_name 访问， 如a='foo' a.<tab>, getattr(a,'split')
不关心对象类型，关心对象是否具有行为。 比如： iterator行为， 


def isterable(obj):
   try:
      iter(obj)
      return True
   except TypeError
      return False
我们可以isiterable('a string') 


导入 import
form some_module import f, g,PI


result=g(5,PI)


要判断两个对象是否指向同一对象，用 is or is not 
Python 是一种非常严格的语言， 几乎在任何时候，计算过程和表达式都是立即求值的， 如a=b=c=20, d=a+b*c 是先计算b*c再加a
迭代器和生成器是延迟计算的
s='python'
list(s)
['p', 'y', 't', 'h', 'o', 'n']
可以使用str（a) 将数字转化为字符串， bool, int和float 也可进行类型转换
None 是 Python的空值类型， None还可是函数可选参数的一种常见默认值
from datetime import datetime, date, time
 dt=datetime(2011,10,29,20,30,21)
 dt.day
 29


dt.strftime('%m/%d/%Y %H:%M')
datetime.strptime('20091031','%Y%m%d')
dt.replace(minute=0,second=0)
datetime.datetime(2011,10,29,20,0)
两个datetime 对象会产生一个datetime.timedelta类型的对象
sequence=[1,2,0,4,6,5,2,1]
total_until_5=0
for value in sequence:
    if value==5:
    break 
    total_until_5+=value
break关键词用于使for循环完全退出，continue关键词用于使for循环提前进入下一次迭代
pass是Python中的空操作语句， 它可以备用在那些没有任何功能的代码块中， 由于Python是根据空白符划分代码块的， 因此它的存在很是有必要的。
异常处理
f=open(path,'w')
try:
   write_to_file(f)
except:
   print 'Failed'
else:
   Print 'Succeeded'
finally:
   f.close()


类型检查：
def attempt_float(x):
    try:
       return float(x)
    except (TypeError, ValueError):
       return x
range(10) 生成0，1，。。。10
range(0,20,2) 生成 0，2，4，6，18
对于长的范围， 建议使用xrange, 其参数和range一样，但不会预先产生值并保存到列表中，而是返回一个逐个产生正数的迭代器
元组是不可变的Python 对象序列， tup=4，5，6
nested_tup=(4,5,6),(7,8)
通过tuple, 任何序列或迭代器转换为元组
tuple([4,0,2]) -> (4,0,2)
可以使用[] 访问元组
虽然储存在元组中的对象本身是可变的， 但一旦创建完毕， 存放在各个插槽中的对象不能变了
tup=tuple(['foo',[1,2],True])
tup[2] =false //错误
tup[1].append(3) //可以
可以用+， * 延长元组  （'foo','job')*4  -> ('foo','job'.....
元组拆包  tup=(4,5,6),
a.b,c=tup


嵌套元组也能拆包
tup=4,5,(6,7）
a,b,(c,d)=tup
a,b=b,a


和元组相比，列表是变长的， 内容是可以修改的
append, insert, pop， remove 方法， 可以排序
通过 in 关键词，可以判断列表中是否还有某个值
+ 合并列表， extend 一次合并多个元素


内置的bisect模块实现了二分查找集有序数的插入操作， bisect.bisect
c=[1,2,2,2,3,4,7]
bisect.insort(c,6)
c -> [1,2,2,2,3,4,6,7]
切片操作， [-2:] 从倒数开始
seq[::2] 2 代表步长
seq[::-1] 实现了列表或元组的反序
enumerate 序列迭代函数， 可以逐个返回序列的（i，value） 元组
some_list=['foo','bar','james']
mapping=dict((v,i) for i,v in enumerate(some_list))
mapping
{'bar': 1, 'foo': 0, 'james': 2}


sorted 可以将任何序列返回为一个新序列


sorted([7,1,2,5,3,4,6])
[1,2,3,4,5,6,7]


sorted('horse race')
[' ','a','c','e','e','h'...
常常将sorted和set结合起来使用已得到一个又序列中唯一元素组成的有序列表
 sorted(set('this is my'))
 [' ', 'h', 'i', 'm', 's', 't', 'y']
用zip进行配对
for i, (a, b) in enumerate(zip(seq1,seq2)):
      print('%d:%s,%s' % (i, a,b))
对于已有的配对，zip可以解对， 如下， 注意*的用法
 pitchers=[('Nolan','Ryan'),('Roger','Clemens'),('Schilling','Curt')]
 first_names, last_names=zip(*pitchers)
  first_names
  ('Nolan', 'Roger', 'Schilling')
 last_names
 ('Ryan', 'Clemens', 'Curt')
* 的用法相当于
zip(seq[0],seq[1],,,,seq[len(seq)-1])
reversed 用于反序


字段del， pop返回删除值
keys和values方法风别用于获取键和值的列表
dl.key(), d1.values()  python 3 返回的是迭代器


mapping={}
for key, value in zip(key_list, value_list):
      mapping[key]=value


mapping=dict(zip(range(5), reversed(range(5))))


dict的get和pop方法可以接受一个可供返回的默认值
value=some_dict.get(key,default_value)


words=['apple','bat','bar','atom','book']


 by_letter={}


  for word in words:
    ...:     letter=word[0]
    ...:     if letter not in by_letter:
    ...:         by_letter[letter]=[word]
    ...:     else:
    ...:         by_letter[letter].append(word)
    ...:


  by_letter
  {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}


字典的setdefault方法能达到如上目的
by_letter.setdefault(letter,[]).append(word)


内置的collections 的defaultdict实现
from collections import defaultdict
by_letter=deaultdict(list)
for word in words:
by_letter[word[0]].append(word)
字段的键必须是不可变对象， 可哈希行， 通过hash判断师傅可哈希
hash('string')
结合是有唯一元素组成的无序集， 用set或大括号构建， 支持各种运算
 set([2,3,4,5,5,5,])
 {2, 3, 4, 5}
列表，结合及字典的推导式
loc_mapping={val:index for index, val in enumerate(string)} 注意enumerate字典推导式的使用
loc_mapping=dict((val,index) for idx, val in enumerate(string))


嵌套列表推导式
 result=[name for namess in in all_data for name in names if name.count'e'>=2] 注意name和names的层次关系
虽然可以对全区变量进行赋值操作， 但是那些变量必须用global关键词声明成才可行， 区部变量在函数退出时销毁
注意理解 可以， 说明是可以的， 但是在函数内部用global声明更好
函数返回多个值： 如下两种
def f():
   a=5
   b=6
   c=7
   return a, b, c


a,b,c=f()
另外
def f():
    a=5
    b=6
    c=7
    return {'a':a,'b':b,'c':c}
函数也是对象， 如下
def remove_punctuation(value):
   return re.sub('[!#?]','',value)
 
clean _ops=[str.strip, remove_punctuation, str.title]   函数放在列表中


def clean_string(strings, ops):
   return =[]
   for value in string;


      for function in ops:
          value=function(value)
      result.append(value)
    return result
这里把函数装入列表，然后使用的时候直接， clean_strings(states, clean_ops)


lambda 表达式
 strings=['foo','card','bar','aaaa','abab']
 strings.sort(key=lambda x:len(set(list(x))))
 strings 
['aaaa', 'foo', 'abab', 'bar', 'card']
闭包：
闭包和标准函数的区别在于创建者已经执行完毕， 仍能继续访问其创建者的局部命名空间
函数参数传递


  def say_hello_then_call_f(f,*args,**kwargs):
    ...:     print 'args is',args
    ...:     print 'kwargs is',kwargs


 say_hello_then_call_f(12,1,2,3,3,3,21,g=5.)
args is (1, 2, 3, 3, 3, 21)
kwargs is {'g': 5.0}


柯里化：部分参数化
def add_numbers(x,y):
    ...:     return x+y
add_five=lambda y:add_numbers(5,y)
生成器：
通过一种迭代器协议的方式实现的， 大部分能接受列表之类的对象的方法也都可以接受任何迭代对象，比如min,max, sum等内置方法及list, tuple等构造器类型
一般的函数执行后会返回单个值，而生成器以延迟的方式返回一个序列值，
def squares(n=10):
         for i in xrange(1,n+1):
            print 'Generating squares from 1 to %d' % (n**2)
            yield i**2
调用该生成器时，没有任何代码执行
gen=squares()
知道从生成器请求元素时，才开始执行代码
for x in gen:
   print x,
注意此时请求到末尾了，一轮结束了，在此请求的话没有数据了
生成器表达式：创建方式为 把列表推导式两段的方括号改为圆括号
gen=(x**2 for x in xrange(100))


和下面的是等价的
def _make_gen():
    for x in xrange(100):
       yield x**2


gen=_make_gen()


生成器表达式可用于任何接受生成器的python函数
sum(x**2 for x in xrange(100))
itertools 内置了许多生成器算法， 如groupby 可以接受任何序列和一个函数，可根据函数的返回值对序列中的连续元素进行分组
open('tmp.txe').readlines()
with open('tmp.txt'，'w') as handle:
   handle.writelines(x for x in open(path) if len(x)>0)  


注意此种用法