python 数据类型

数据类型

类型判断

#类型判断
a=5
r=isinstance(a,int)
print(r)
#范围判断
r2=isinstance(a,(int,float))
print(r2)

字符串

列表

常规操作

 列表转为变量

'''
列表拆分为变量
'''
l2=[1,2,3]
a,*c=l2
print(a,c)

使用案例

删除列表中重复元素，并保持顺序不变

'''
删除列表中重复元素，并保持顺序不变
'''

def dedupe(items):
    '''
    对对可哈希类型排序
    :param items:
    :return:
    '''
    seen=set()
    for item in items:
        if item not in seen:
            yield item
            seen.add(item)

def buha(items,key=None):
    '''
    对所有类型排序
    :param items:
    :param key:
    :return:
    '''
    seen=set()
    for item in items:
        val=item if key is None else key(item)
        if val not in seen:
            yield item
            seen.add(val)
if __name__ == '__main__':
    a=[5,5,2,1,6,7,3]
    print(a)
    print(list(dedupe(a)))

    b=[{'x':2,'y':3},{'x':3,'y':3},{'x':6,'y':4},{'x':2,'y':3},{'x':5,'y':5},{'x':5,'y':3},{'x':5,'y':3},]
    key=lambda b:(b['x'],b['y'])
    print(list(buha(b,key)))

找出列表中出现次数最多的元素

'''
找出列表中出现次数最多的元素

'''
from collections import Counter
words=[1,2,33,45,657,4,56,33,22,66,33,22,22]
words_count=Counter(words)
#输出出现次数最多的前三
top_three=words_count.most_common(3)
print(words_count)
print(top_three)

创建包含1到10平方的列表（使用列表推导式）

'''
创建包含1到10平方的列表
'''
squares=[]
for x in range(1,11):
    squares.append(x**2)
print(squares)
#
squares2=[x**2 for x in range(1,11)]
print(squares2)

获取0到30，能被3整除的数平方的列表(列表推导式)

'''
获取0到30，能被3整除的数平方的列表
'''
sq=[i**2 for i in range(1,31) if i%3 is 0]
print(sq)

 切片

'''
切片
'''
items=[0,1,2,3,4,5,6]
#切片
print(items[2:4])
#取出所有
print(items[0:-1])
#通过slice切片
a=slice(2,4)
print(items[a])
#倒序
print(items[-1:0:-1])

 获取列表中所有数字

'''
获取列表中所有数字
'''

values=['1','2','3','4','-5','-','t']

def is_int(val):
    try:
        x=int(val)
        return True
    except ValueError:
        return False
#过滤并存到列表
ivals=list(filter(is_int,values))
print(ivals)

 列表求和

'''
列表求和
'''
l2=[2,3,4]
#列表内相加后再加10
s=sum(l2,10)
print(s)

 列表转字符串

s2=['RMB',50,128.88]
print(','.join(str(x) for x in s2))

 有序列表中搜索，添加元素

'''
有序列表中添加元素
'''

#二分法查找元素位置
import bisect
c=[1,2,4,6,7]
r=bisect.bisect(c,4)
print(r)
#添加元素
bisect.insort(c,5)
print(c)

元祖

元组操作

'''
元组操作
'''
tup1=(1,3,2)
tup2=(4,5,6)
#元组相加
print(tup1+tup2)
#内置操作
#长度
print(len(tup1))
#最大元素
print(max(tup1))
#最小元素
print(min(tup1))
#删除
del tup1
print(tup1)

 分解为变量

#分解为变量
a,b,c=tup1
print(a,b,c)

 元祖求和

'''
元祖求和
'''
t2=(1,2,4)
p1=sum(t2,10)
print(p1)

 元祖转字符串

#元祖转为字符串
s=('RMB',50,128.88)
#循环全部转为字符串,迭代拼接
print(','.join(str(x) for x in s))

字典

删除

dict.pop("name")
del dict["name"]

清空字典

dict.clear()     # 清空字典
del dict         # 删除字典

有序字典

'''
有序字典
'''
import collections
dic=collections.OrderedDict()
dic['k1']='v1'
dic['k2']='v2'
dic['k3']='v3'
print(dic)

 实现差集，交集

a={'x':1,'y':2,'z':3}
b={'x':11,'y':2,'w':10}

#获取共有元素的键名
print(a.keys()&b.keys())
#取差集，返回a独有的键名
print(a.keys()-b.keys())
#返回差集
print(a.items()-b.items())
#使用推导式，进行
c={key:a[key] for key in a.keys()-{'x','w'}}
print(c)

使用itemgetter进行排序

'''
使用itemgetter排序
'''
from operator import itemgetter
a=[1,2,3]
b=itemgetter(1)

print(b(a))
b=itemgetter(1,0)
print(b(a))


rows=[
    {'fname':'AAA','lname':'zhang','uid':1001},
    {'fname':'CCC','lname':'zhou','uid':1002},
    {'fname':'DDD','lname':'wu','uid':1004},
    {'fname':'BBB','lname':'li','uid':1003},
]
#按照fname排序
rows_by_fname=sorted(rows,key=itemgetter('fname'))
print(rows_by_fname)

rows_by_uid=sorted(rows,key=itemgetter('uid'))
print(rows_by_uid)
#按照lname和fname排序
rows_by_lfname=sorted(rows,key=itemgetter('lname','fname'))
print(rows_by_lfname)
#按照fname排序(使用匿名函数)
rows_by_fname=sorted(rows,key=lambda r:r['fname'])
print(rows_by_fname)
#通过fname和lname组成的集合进行排序
rows_by_lfname=sorted(rows,key=lambda r:(r['fname'],r['lname']))
print(rows_by_lfname)
#最小用户uid
rows_min_uid=min(rows,key=itemgetter('uid'))
print(rows_min_uid)
#最大用户uid
rows_max_uid=max(rows,key=itemgetter('uid'))
print(rows_max_uid)

字典推导式应用

'''
字典推导式应用

'''
#简单读取
mcase={'a':10,'b':34,'A':7,'z':3}
for i in mcase:
    print("{%s:%s}"%(i,mcase[i]))

mcase_frequency={
    k.lower():mcase.get(k.lower(),0)  +mcase.get(k.upper(),0)#第三步：拼接字典，大小写键明对应的键值相加
    for k in mcase.keys()#第一步：循环键名
    if k.lower() in ['a','b']#第二步：满足条件保留
}
print(mcase_frequency)

#字典中key和val对换
mcase1={'a':10,'b':34}
mcase1_frequency={v:k   for k,v in mcase1.items() }
print(mcase1_frequency)

#从字典中提取子集
prices={'asp.net':49.9,'python':69.9,'java':59.9,'c':45.9,'php':79.9}
#读取价格大于50的
p1={key:val  for key,val in prices.items() if val>50}
print(p1)
#选取子集
tech_names={'python','java','c'}
p2={key:val for key,val in prices.items() if key in tech_names}
print(p2)

p3=dict((key,val) for key,val in prices.items() if val>50)#使用推导式要比这种快两倍以上
p4=dict((key,val) for key,val in prices.items() if key in tech_names)#使用推导式要比这种快两倍以上

排序

'''
字典排序
'''

price={'小米':899,'华为':1999,'三星':3999,'谷歌':4999,'酷派':599,'iphone':5000}
#取出价格最低
min_price=min(zip(price.values(),price.keys()))
print(min_price)
#取出价格最高
max_price=max(zip(price.values(),price.keys()))
print(max_price)
#排序
price_sorted=sorted(zip(price.values(),price.keys()))
print(price_sorted)
price_and_names=zip(price.values(),price.keys())
print(price_and_names)

print(min(price))
print(max(price))
print(max(price,key=lambda k:price[k]))

 使用groupby分组

'''

使用groupby分组
'''
#对数据进行分组
from itertools import groupby
from operator import itemgetter
things=[('2012-05-21',11),('2012-05-21',3),('2012-05-22',10),('2012-05-22',4),('2012-05-22',22),('2012-05-22',33)]
#可迭代对象，分组条件
for key,items in groupby(things,itemgetter(0)):#按照元祖序列中第一个元素进行分组
    print(key)
    #items为分组后的内容，可迭代对象
    for subitem in items:
        print(subitem)
    print('-'*20)

#分组复杂数据
rows=[
    {'address':'5412 N CLARK','data':'07/01/2018'},
    {'address':'5414 N CLARK','data':'07/03/2018'},
    {'address':'5422 N CLARK','data':'07/01/2018'},
    {'address':'5222 N CLARK','data':'07/03/2018'},
    {'address':'5224 N CLARK','data':'07/02/2018'}
]
#按照data分组
from operator import itemgetter
from itertools import groupby
rows.sort(key=itemgetter('data'))
for data,items in groupby(rows,key=itemgetter('data')):
    print(data)
    for i in items:
        print(' ',i)


from collections import defaultdict
rows_by_date=defaultdict(list)

for row in rows:
    rows_by_date[row['data']].append(row)
print(rows_by_date)
from collections import defaultdict
#使用defaultdict,
d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)
d['b'].append(4)
print(d)
d = defaultdict(set)
d['a'].add(1)
d['a'].add(2)
d['b'].add(4)
print(d)

将多个映射合并为单个映射

'''
将多个映射合并为单个映射
'''
a={'x':1,'z':3}
b={'y':2,'z':4}
from collections import ChainMap
#字典合并，若是健名重复，使用第一个
c=ChainMap(a,b)
print(c)
print(c['x'])#from a
print(c['y'])#from b
print(c['z'])# from a
print(len(c))

print(list(c.keys()))
print(list(c.values()))
#对合并后的修改将影响原来的
c['z']=10
c['w']=40

del c['x']
print(a)

集合

后期补充。。。