Python review

昨天辞职了，在KDS的这一段时间确实提高了不少。趁着辞职后还有段空闲期，准备将Python数据分析这一块继续学习学习。然后把组成原理和计算机网络学习一遍，为以后的发展打下基础，然后准备继续学习C++.

Python的一个简单review

Python重要特点就是对象模型的一致性,Python解释器中的任何数值,字符串,数据结构,函数,类,模块，都是一种Python对象,每个对象都有一个与之相关的类型比如字符串和函数以及内部数据，几乎所有的Python对象都有一些附属函数,也就是方法,他们可以访问对象内部的数据，函数既可以接受位置参数,也可以接受关键字参数

在Python中对变量赋值的时候,其实是创建等号右侧对象的一个引用

a = [1,2,3]
b = a
#这样a,b都指向同一个对象
a.append(4)
print b```
赋值操作也称为绑定,将一个名称和一个对象绑定到一起
当将对象以参数的形式传入函数的时候,其实是传递了一个引用,不会发生任何复制，Python是按引用传递的

def append_element(some_list,element):
some_list.append(element)
append_element(a,5)
print b```

Python中的对象引用没有与之相关联的类型信息,变量其实就是对象在特定命名空间中的名称，对象的类型信息是保存在它自己内部的，Python可以被认为是一种强类型语言，所有对象都有一个特定的类型,隐式转换只在很明显的情况下才会发生

print type(a)
#isinstance函数来检查对象是否是某个特定类型的
print isinstance(a,list)
#可以制定元组,检查某个对象的类型是否属于元组中指定的类型
print isinstance(a,(list,int))```

Python中的对象既有属性,存储在该对象内部的其他Python对象
又有方法,与该对象有关的能够访问其内部数据的函数
getattr函数,hasattr函数和setattr函数

一般来说只关注这个对象有没有某些方法或者行为
比如实现了迭代器协议的就是可迭代的,__iter__方法
使用iter函数来判断是否可迭代

def isiterable(obj):
try:
iter(obj)
print "True"
except:
print "False"

isiterable(a)
isiterable(a[1])

检查是不是列表,如果不是列表将其转换为列表

if not isinstance(a,list) and isiterable(a):
a = list(a)```

判断两个引用是否指向同一个对象,可以使用is,或者is not

print a is b
#但是list函数会创建新列表
c = list(a)
print c
print a is c
#==表示比较两个对象是否相等,如果是列表,就是列表中每个元素相比较
c.append(6)
print a == c```

Python中,计算过程和表达式都是立即求值的
但是迭代器和生成器可以实现延迟计算,特别应用于数据密集型计算

大部分Python对象是可变的,列表,字典,数组
字符串和元组是不可变的

除后圆整运算符//,Python2中,3/2仍然是一个整数

print 3 // 2
print 3/2

复数的虚部是j表示的

print 1 + 2j```

许多Python对象可以用str函数将其转换为字符串
字符串可以被当作序列类型进行处理
在字符串的左边加上r表示按照原本的样子进行解释
None是NoneType的一个实例

from datetime import datetime,time,date
#获得datetime实例
dt = datetime(2016,8,12,20,21,32)
print dt,dt.year,dt.day,dt.month,dt.hour,dt.minute,dt.second
#获取date对象,time对象
print dt.date()
print dt.time()
#strftime将datetime对象格式化为字符串,这个是方法
print dt.strftime('%m/%d/%y %H:%M')
#字符串通过strptime函数转换为datetime对象,记得这个是函数,后面指定格式
print datetime.strptime(dt.strftime('%m/%d/%y %H:%M'),'%m/%d/%y %H:%M')
#使用replace方法将某些字段进行替换
print dt.replace(minute=0,second=0)
#两个datetime对象的差会产生一个datetime.timedelta类型
dt2 = datetime(2011,11,23,22,33)
delta = dt2 - dt
print delta,type(delta)```

if elif else
for循环用于对集合或者迭代器进行迭代

异常捕获

except ValueError:

或者异常类型组成的元组,可以捕获多个异常

except (TypeError,ValueError):

只希望不管try成功与否都能执行,finally:

在try成功时候运行,else:```

print range(10)
print range(1,10,2)
#包含前端,不包含后端
#xrange不会预先产生所有的值,而是返回一个用于逐个产生整数的迭代器
sum = 0
for i in xrange(10000):
    if i % 2 == 0:
        sum = sum + i
print sum

print 'Non-negative' if sum >= 0 else "Negative"```

要精通Python的数据结构

创建元组

tup = 4,5,6
print tup
nested_tup = (1,2,3),(5,6)
print nested_tup

通过调用tuple函数,任何序列或者迭代器都可以被转换成元组

print tuple([2,3,4])

如果对元组型变量表达式进行赋值,Python就会将等号右面的值进行拆包

a,b,c = tup
print a,b,c

嵌套元组也可以拆包

tup = 4,5,(6,7)
a,b,(c,d) = tup
print a,b,c,d

交换变量名

a,b = b,a
print a,b

元组的count方法,计算指定值的出现次数

a = (1,2,3,2,2,3,4,5)
print a.count(2)```

列表
是可变的,通过[]或者list函数定义

#append方法,insert方法将元素插入到列表指定位置
b_list = [1,2,3]
b_list.insert(0,5)
print b_list
#pop方法用于移除并返回指定索引处的元素
print b_list.pop(2)
#remove方法按值删除元素,找到第一个符合要求的值然后从列表中删除
b_list.remove(3)
print b_list
#使用in判断列表中是否有某个值
print 2 in b_list
#+合并列表
#extend方法一次性添加多个元素
b_list.extend(list((3,4,5)))
print b_list
#extend方法会比直接合并效率高很多
#排序sort,就地排序
b_list.sort()
print b_list
#sort()方法可以接受一个能够产生排序的值的函数
def bijiao(obj):
    return obj+10
b_list.sort(key=bijiao)
#bisect模块实现了二分查找及对有序列表的插入操作
import bisect
c = [1,2,2,2,3,4,5,8]
#该函数找出应该插在列表哪里才能保证有序性
print bisect.bisect(c,6)
#insort函数将新元素插入列表中
bisect.insort(c,6)
print c```

切片

start和stop是可以省略的,默认是序列开始和结尾处

print c[:5]

负数索引从序列的末尾开始切片

stop的位置不能比start晚出现否则是空

c[-4:]表示到序列结尾处

print c[-1:-3]

如果要反序的话

print c[::-1]

或者reverse方法

c.reverse()
print c

或者reversed函数

reverse_list = []
for i in reversed(c):
reverse_list.append(i)
print reverse_list```

内置的序列函数

#enumerate()
for index,value in enumerate(c):
    print "It's index:"+str(index)
    print "It's value:"+str(value)
#sorted函数将任何序列返回为一个新的有序列表
print sorted(c)
#zip()函数将多个序列配对,产生新的元组列表
seq1 = ['one','two','three']
seq2 = ['foo','bar','baz']
for index,(a,b) in enumerate(zip(seq1,seq2)):
    print '%d:%s,%s' %(index,a,b)
#对已经压缩的序列进行解压
pitchers = [('Nolan','Ryan'),('Roger','Clemens')]
firstname,lastname = zip(*pitchers)
print firstname,lastname```

字典

d1 = {"a":'some_value','b':[1,2,3,4]}
print d1

keys和values方法分别用于获取键和值的列表,会以相同的顺序来输出键和值

for key,value in zip(d1.keys(),d1.values()):
print key,value

del删除特定的值,pop删除指定值将其返回

d1.pop('a')
print d1

使用update方法,一个字典可以被合并到另外一个字典中

d1.update({'c':"foo",'d':12})
print d1```

建立字典

key_list = range(5)
value_list = reversed(range(5))
mapping = {}
for key,value in zip(key_list,value_list):
    mapping[key] = value
print mapping
#另一种方法使用dict函数
mapping1 = dict(zip(range(5),reversed(range(5))))
print mapping1

#dict的get和pop方法可以接受一个可以返回的默认值
value = mapping1.get(6,"no key")
print value
value1 = mapping1.pop(7,"no key")
print value1

#setdefault方法
words = ["apple","bat","bar","atom"]
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)
print by_letter
#使用下面更简单的方法
by_letter1 = {}
for word in words:
    letter = word[0]
    by_letter1.setdefault(letter,[]).append(word)
print by_letter1
#另外一个使用collections模块的defaultdict的类
from collections import defaultdict
by_letter2 = defaultdict(list)
for word in words:
    by_letter2[word[0]].append(word)
print by_letter2

#键值必须是不可变的,也即是可哈希的
print hash('a')
#如果要将列表当作键,将其转换为元组
d = {}
d[tuple([1,2,3])] = 5
print d```

集合
集合是由唯一元素组成的无序集,{}或者set()

列表推导式

strings = ['a','as','asd','bat']
print [x.upper() for x in strings if len(x) > 2]

字典推导式

print {key:value for value,key in enumerate(strings)}
print dict((key,value) for value,key in enumerate(strings))

扁平化

some_tuples = [(1,2,3),(4,5,6)]
flattened = [x for tup in some_tuples for x in tup]
print flattened
print [[x for x in tup] for tup in some_tuples]```

函数
关键字参数必须位于位置参数之后,可以任何顺序指定关键字参数
虽然可以在函数中对全局变量进行赋值操作,但是那些变量必须用global关键字声明为全局

a = None
def bind_a_variable():
    global a
    a = []
#仍然是None
def bind_a_variable1():
    a = 1
bind_a_variable1()
print a

#返回多个值,可以才用字典,可以才用元组

#匿名函数
eqiv_anon = lambda x:x*2
print eqiv_anon(2)
#这种函数对象本身是没有提供名称属性的```

闭包
由其他函数动态生成并返回的函数,被返回的函数可以访问其创建者的局部命名空间的变量

def make_closure(a):
def closure():
print "I dont know "+str(a)
return closure
closure = make_closure(5)
closure()

特点就在于即使创建者已经执行完毕,闭包依然能够访问其创建者的局部命名空间```

函数的位置和关键字参数是分别被打包成元组和字典的,函数实际接受到的是一个元组args
和一个字典kwargs

部分参数应用

def add_numbers(x,y):
    return x+y
add_five = lambda y:add_numbers(5,y)
#使用functools模块的partial函数将此简化
from functools import partial
add_five1 = partial(add_numbers,5)```

生成器,一种函数
普通函数执行后会返回单个值,但是生成器每返回一个值后暂停,直到下一个值被请求时再继续
要创建一个生成器,将return换成yield就行

def squares(n=10):
for i in range(1,n+1):
yield i ** 2

直到从生成器请求元素时,它才会执行其代码

for i in squares():
print i,

生成器表达式

gen = (x**3 for x in range(10))

需要迭代才能使用

for x in gen:
print x,

生成器表达式可以用于任何接受生成器的Python函数

print list(x ** 2 for x in range(10))
print dict((i,i**2) for i in range(5))```

文件和操作系统
open函数,r,a,w,
with
seek,tell,read字符串方式返回文件数据,readlines返回行列表,write