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)  

注意此种用法