python基础

#python字符串/元组/列表/字典互转
#--coding:utf-8--

##1、字典
dict = {‘name’: ‘Zara’, ‘age’: 7, ‘class’: ‘First’}

#字典转为字符串，返回：<type ‘str’> {‘age’: 7, ‘name’: ‘Zara’, ‘class’: ‘First’}
print type(str(dict)), str(dict)

#字典可以转为元组，返回：(‘age’, ‘name’, ‘class’)
print tuple(dict)
#字典可以转为元组，返回：(7, ‘Zara’, ‘First’)
print tuple(dict.values())

#字典转为列表，返回：[‘age’, ‘name’, ‘class’]

dict.items()/values/keys
#字典转为列表
print dict.values()

#字典转为series
t=Series(dict)

#2、元组
tup=(1, 2, 3, 4, 5)

#元组转为字符串，返回：(1, 2, 3, 4, 5)
print tup.str()

#元组转为列表，返回：[1, 2, 3, 4, 5]
print list(tup)

#元组不可以转为字典

#3、列表
nums=[1, 3, 5, 7, 8, 13, 20];

#列表转为字符串，返回：[1, 3, 5, 7, 8, 13, 20]
print str(nums)

#列表转为元组，返回：(1, 3, 5, 7, 8, 13, 20)
print tuple(nums)

#列表转为字典
1、现在有两个列表，list1 = [‘key1’,‘key2’,‘key3’]和list2 = [‘1’,‘2’,‘3’]，把他们转为这样的字典：{‘key1’:‘1’,‘key2’:‘2’,‘key3’:‘3’}

list1 = [‘key1’,‘key2’,‘key3’]
list2 = [‘1’,‘2’,‘3’]
dict(zip(list1,list2))

{‘key1’:‘1’,‘key2’:‘2’,‘key3’:‘3’}

2、将嵌套列表转为字典，有两种方法，
dt = {}
for (m,n) in zip(list1,list2):
dt.setdefault(m,[]).append(n)

#列表去重
list1 = [‘key1’,‘key1’,‘key3’]
list2={}.fromkeys(list1).keys()
list2=list(set(list1))
列表转为字符串
‘’.join(list)

字符串转列表
string.split(’ ')
list(‘ewrwe’)
insert/append
del/pop/remove

字典运算
令a，b为两个字典，则计算并集的最快方法为：
dict(a, **b)

计算交集最快且最简洁的方法是
dict.fromkeys(x for x in a if x in b)

#4、字符串

#字符串转为元组，返回：(1, 2, 3)
print tuple(eval("(1,2,3)"))
#字符串转为列表，返回：[1, 2, 3]
print list(eval("(1,2,3)"))
#字符串转为字典，返回：<type ‘dict’>
print type(eval("{‘name’:‘ljq’, ‘age’:24}"))

#5数组
t=[1,2,3]
#数组转为列表
t2=np.array(t)
t3=list(t2)

#6series
#基于列表/数组创建
t=Series([,],index=[,])
#基于字典创建
t=Series(dict)

#7dataframe
#创建
#基于数组创建
t=np.ones((3,5))
data=DataFrame(t)
#基于列表字典创建
t={[‘a’:=[1,2,3]}
data=DataFrame(t)
#索引
#基于字典修改索引值
data.rename(index={1:‘a’},inplace=True)

#基于三元表达式修改索引
data.index=[x if z else x for x,y,z in zip(t1,t2,t3)]
np.where(z,x,y)
#列表推导式
[x for x in a if ]
#索引运算
差diff  df2=df.reindex(index=df.index.diff(x1.index))
并union

#类型转换
#to字典
t=df.to_dict(outtype=‘dict’)
outtype的参数为‘dict’、‘list’、‘series’和‘records’。 dict返回的是dict of dict；list返回的是列表的字典；series返回的是序列的字典；records返回的是字典的列表
#to数组
t=data.values
#修改索引/列名
df.rename(columns={u’NB_pred’:‘NB_proba’}, inplace=True)
df.index.name=‘index’

#concat/append/merge/join
轴向连接concat
另一种数据合并运算concat也被称作连接（concatenation)、绑定（binding)或堆叠(stacking)
Append rows to a dataframe
pandas.merge 可根据一个或多个键将不同 DataFrame 中的行连接起来。
pandas.concat 可以沿着一条轴将多个对象堆叠到一起
#插入行
df.append(df2) DataFrame or Series/dict-like object, or list of these The data to append
pd.concat(df1,df2)

#一行转多行
df[‘Country’].str.split(’/’, expand=True).stack().reset_index(level=0).set_index(‘level_0’).rename(columns={0:‘Country’})
#多行转一行
df[[‘userID’, ‘VenueId’]].groupby([‘userID’]).aggregate(lambda x: list(x))

#动态定义变量
names = locals()

for i in xrange(1, 101):
… names[‘x%s’ % i] = i

#axis=0表示的是按照第一轴的方向操作，也就是列方向上；若是axis=1就是行方向上面
#元素级应用 dataframe applymap ；series map
#行列应用 apply

对象类型
x.class
type(x)

Python数据类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
函数 描述
int(x [,base])
将x转换为一个整数
long(x [,base] )
将x转换为一个长整数
float(x)
将x转换到一个浮点数
complex(real [,imag])
创建一个复数
str(x)
将对象 x 转换为字符串
repr(x)
将对象 x 转换为表达式字符串
eval(str)
用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)
将序列 s 转换为一个元组
list(s)
将序列 s 转换为一个列表
set(s)
转换为可变集合
dict(d)
创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)
转换为不可变集合
chr(x)
将一个整数转换为一个字符
unichr(x)
将一个整数转换为Unicode字符
ord(x)
将一个字符转换为它的整数值
hex(x)
将一个整数转换为一个十六进制字符串
oct(x)
将一个整数转换为一个八进制字符串

#多层索引
切片
df.xs(‘BB’,level=0,axis=0)
df.loc[(slice(None),‘Math’),(slice(None),‘II’)]

获取索引值
data.index.get_level_values(‘scene’)
zip(*data.index.values)[0]

索引到列
data.reset_index([‘scene’,‘amt_mean’],inplace=True)
列转为索引
df = df.set_index(‘row’)

创建多层索引
index = pd.MultiIndex.from_tuples([item.split(’_’) for item in df.index])
df.index = index
切片后替换之
data[‘kx_score’].where(~data.cust_id.isin©,-99)

#PANDAS apply,applymap和map的应用:
apply 用在dataframe上，用于对row或者column进行计算, applymap 用于dataframe上，是元素级别的操作，map 用于series上，是元素级别的操作。

传入参数
data.apply(axis=1,b=‘b’)#无计算，**kwds传参
data[‘cate’].apply(Sum,args=(‘b’,)) #无计算，args传参,注意必须是序列
data.apply(lambda x:x+‘b’ if x>0 else x-‘b’)#有计算，采用匿名函数
my_series.apply(your_function, args=(2,3,4), extra_kw=1)

Python中的apply，filter和map函数
apply函数：
apply(func [, args [, kwargs ]]) 函数用于当函数参数已经存在于一个元组或字典中时，间接地调用函数。args是一个包含将要提供给函数的按位置传递的参数的元组。如果省略了args，任何参数都不会被传递，kwargs是一个包含关键字参数的字典。
apply()的返回值就是func()的返回值，apply()的元素参数是有序的，元素的顺序必须和func()形式参数的顺序一致

下面给几个例子来详细的说下:
1、假设是执行没有带参数的方法

def say():
print ‘say in’

apply(say)

输出的结果是’say in’

2、函数只带元组的参数。

def say(a, b):
print a, b

apply(say,(“hello”, “老王python”))

输出的结果是hello,老王python

3、函数带关键字参数。

def say(a=1,b=2):
print a,b

def haha(**kw):
#say(kw)
apply(say,(),kw)

print haha(a=‘a’,b=‘b’)

输出的结果是:a,b

map()可以对多个序列的每个元素都执行相同的操作，并组成列表返回，声明如下：
map(func, sequence[, sequence,…]) -> list
4.1 参数func是自定义的函数，实现对序列每个元素的操作
4.2 参数sequence为待处理的序列，可以有多个序列
4.3 map()的返回值是对序列元素处理后的列表

a = [1, 2, 3, 4, 5]

def foo(x):

return 3 * x

map(foo, a) #[3, 6, 9, 12, 15]

filter()可以对某个序列做过滤处理，对自定义函数的参数返回的结果是否为“真”来过滤，并一次性返回处理结果。
声明如下：
filter(func or None, sequence) -> list, tuple, or string
2.1 参数func是自定义的过滤函数，在函数func(item)中定义过滤的规则。如果func为None，则过滤项都为真，返回所有的序列元素。
2.2 参数sequence为待处理的序列
2.3 filter()的返回值是由func()的返回值组成的序列，返回的类型与参数sequence的类型相同
2.4 filter()的过滤函数func()的参数不能为空
filter函数以一个函数和序列作为参数，它返回该序列的子集，其中子集的成员能满足函数的条件。
如果filter以None作为第一个参数，它将过滤掉序列中所有假值

pandas.merge 可根据一个或多个键将不同 DataFrame 中的行连接起来。
pandas.concat 可以沿着一条轴将多个对象堆叠到一起
实例方法 combine_first 可以用一个对象中的值填充另一个对象中对应位置的缺失值

timedelta64

x = np.timedelta64(2069211000000000, ‘ns’)
days = x.astype(‘timedelta64[D]’)
days / np.timedelta64(1, ‘D/s’) or days.item().days/total_seconds()

st[‘difftime’]=st.gmt_occur_x-st.gmt_occur_y

st[‘difftime’].map(lambda x:x.astype(‘timedelta64[D]’))/np.timedelta64(1, ‘m’) #D/ns/m/M/Y
st[‘difftime’].map(lambda x:x.astype(‘timedelta64[D]’).item().days)

st[‘difftime’]=(st.gmt_occur_x-st.gmt_occur_y).apply(lambda x: x/np.timedelta64(1,‘s’))

组合
list(itertools.combinations(g, 2))

conda install seaborn
pip instll seaborn

try:
    t=data['流入资金（万元）'].astype('double')
except ValueError,e:
    print "Error:",e

集合运算
集合的交集、合集（并集）、差集，了解集合set的这些非常好用的功能前，要先了解一些集合操作符号
python 集合操作符号