#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 集合操作符号