Python实操摘要

写入文件时换行
q:with open 
a:
f.write(k[0])
f.write("\n")

更新空词典
dd = {}
dd.setdefault('a',1)
将一个大的列表按照索引个数分成若干个小列表
names=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
n = 3  # 将列表每3个组成一个小列表，
for i in range(0, len(names), n):
    name = names[i:i + n]
    print(name)
解析：仔细看
al = ['a', 1, 'b', 2, 'c', 3]

for i in range(0,len(al),n):
    print(i)
    
0
2
4
for i in range(0,len(al),n):
    print(al[i])
    
a
b
c
for i in range(0,len(al),n):
    print(al[i+1])
    
1
2
3
for i in range(0,len(al),n):
    print(al[i:i+1])
    
['a']
['b']
['c']

al[0:0+2]
['a', 1]
al[2:2+2]
['b', 2]
al[4:5+2]
['c', 3]
拆分成一个大的列表
print([names[i:i + n] for i in range(0, len(names), n)])
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]]
清除列表中的所有的空元素
ex1
aa = [1, 2, 3, '', '']
bb = [i for i in aa if i != ""]
print(bb)
ex2
while "" in aa:
    aa.remove("")

生产词典数据,需要再列表里面追加一个字典
{
    "commands": [
        {
            "move": {
                "index": "laojian",
                "shard": 0,
                "from_node": "10.185.17.107",
                "to_node": "tihuan"
            }
        }
    ]
}

统计for循环次数,适用于未知数量的列表
n=0
aa = [1,2,4]
for i in aa:
    print(i)
    n +=1
print(n)    

判断列表中所有元素是否相同
1、采用count统计索引数量和总量对比
aa =[1,2,3] or aa = ["a","b","c"]
bb = [1,1,1] or bb = ["a","a","a"]
aa =[1,2,3]
aa.count(aa[0]) == len(aa)
False
aa.clear()
aa = ["a","b","c"]
aa.count(aa[0]) == len(aa)
False

bb = [1,1,1]
bb = ["a","a","a"]
bb.count(bb[0]) == len(bb)
True
bb = [1,1,1]
bb.count(bb[0]) == len(bb)
True
bb.clear()
bb = ["a","a","a"]
bb.count(bb[0]) == len(bb)
2、使用集合
aa
['a', 'b', 'c']
bb
['a', 'a', 'a']
len(set(aa)) == 1
False
len(set(bb)) == 1
True
3、all函数 列表推导
aa = [1,1,1]
all(item==aa[0] for item in aa)
True

bb = ['a', 'a', 'a']
all(item==bb[0] for item in bb)
True

统计列表中重复元素的个数
1、
aa = [1,1,1,2,2]
myset = set(aa)
for i in myset:
    print(i,aa.count(i))
1 3
2 2
2、统计列表元素重复出现次数
List=[1,2,2,2,4,4,4,4]
a = {}
for i in List:
    if List.count(i)>1:
        a[i] = List.count(i)
print (a)
{2: 3, 4: 4}


 列表取第一个最后一个元素
 a
[1, 2, 3]
a[::len(a)-1]
[1, 3]    

倒排列表
a[::-1]
[3, 2, 1]
查找两个字典相同值
a = {
    'x' : 1,
    'y' : 2,
    'z' : 3
}

b = {
    'w' : 10,
    'x' : 11,
    'y' : 2
}
# Find keys in common
a.keys() & b.keys() # { 'x', 'y' }
# Find keys in a that are not in b
a.keys() - b.keys() # { 'z' }
# Find (key,value) pairs in common
a.items() & b.items() # { ('y', 2) }
以现有字典构造一个排除几个指定键的新字典。 下面利用字典推导来实现这样的需求：
# Make a new dictionary with certain keys removed
c = {key:a[key] for key in a.keys() - {'z', 'w'}}
# c is {'x': 1, 'y': 2}

A和B是两个字典，Key值存在相同的值，当两个字典的key值相同的时候，如何将dic1对应的values取出来作为新的字典values，dic2对应的values取出来作为新字典的key
A = {"name": "姓名", "age": "年龄", "gender": "性别"}
B = {"name": "小明", "age": 18, "gender": "男"}

# 方法一:
sub = {A[x]: B[x] for x in B if x in A}
print(sub)
{'姓名': '小明', '年龄': 18, '性别': '男'}

# 方法二:
for key, value in A.items():
    for k in B.keys():
        if key == k:
            # 需要转dict不然会报错
            # AttributeError: 'str' object has no attribute 'keys'
            B = eval(str(B).replace(k, value))
print(B)
{'姓名': '小明', '年龄': 18, '性别': '男'}

# 方法三：
# 遍历其中一个字典的Key，然后替换
for key in B.keys():
    A[key] = B[key]
print(B)
{'姓名': '小明', '年龄': 18, '性别': '男'}
通过某个字段将记录分组
特性，key相同，value不同
{'issue_sample-2022.09.11': '10.182.15.223'}
{'issue_sample-2022.09.11': '10.75.30.168'}
{'topic_guandian_checking_processor_transfer-2022.09.14': '10.182.15.223'}
{'topic_guandian_checking_processor_transfer-2022.09.14': '10.75.30.168'}

eg:
    rows = [
    {'address': '5412 N CLARK', 'date': '07/01/2012'},
    {'address': '5148 N CLARK', 'date': '07/04/2012'},
    {'address': '5800 E 58TH', 'date': '07/02/2012'},
    {'address': '2122 N CLARK', 'date': '07/03/2012'},
    {'address': '5645 N RAVENSWOOD', 'date': '07/02/2012'},
    {'address': '1060 W ADDISON', 'date': '07/02/2012'},
    {'address': '4801 N BROADWAY', 'date': '07/01/2012'},
    {'address': '1039 W GRANVILLE', 'date': '07/04/2012'},
]
from operator import itemgetter
from itertools import groupby
# Sort by the desired field first
rows.sort(key=itemgetter('date'))
# Iterate in groups
for date, items in groupby(rows, key=itemgetter('date')):
    print(date)
    for i in items:
        print(' ', i)
        
07/01/2012
  {'address': '5412 N CLARK', 'date': '07/01/2012'}
  {'address': '4801 N BROADWAY', 'date': '07/01/2012'}
07/02/2012
  {'address': '5800 E 58TH', 'date': '07/02/2012'}
  {'address': '5645 N RAVENSWOOD', 'date': '07/02/2012'}
  {'address': '1060 W ADDISON', 'date': '07/02/2012'}
07/03/2012
  {'address': '2122 N CLARK', 'date': '07/03/2012'}
07/04/2012
  {'address': '5148 N CLARK', 'date': '07/04/2012'}
  {'address': '1039 W GRANVILLE', 'date': '07/04/2012'}

合并两个字典相同key,value不同
aa =  {'topic-req-2022.09.08': '10.182.15.223'}
bb = {'topic-req-2022.09.08': '10.182.15.224'}
aa
{'topic-req-2022.09.08': '10.182.15.223'}
bb
{'topic-req-2022.09.08': '10.182.15.224'}
aa.keys() & bb.keys()  取字典中相同的key
{'topic-req-2022.09.08'}
{key: aa[key] +' ' +bb[key] for key in aa}
{'topic-req-2022.09.08': '10.182.15.223 10.182.15.224'}

dict1 = {'key1' : 1,'key2' : 2,'key3' : 7}
dict2 = {'key1' : 3,'key2' : 9,'key4' : 10}
#dict4用来存储合并后的字典
dict4 = {}
#求出俩个字典不相同的key集合，下面是做的集合的运算，不清楚的百度一下
not_common_keys = (dict1.keys() | dict2.keys()) - (dict1.keys() & dict2.keys())
print(not_common_keys)
print('------------分割线-----------')
#**表示传入键值对
def main(**dict3):
    for key in dict3.keys():
        if key in not_common_keys:
            dict4[key] = dict3[key]
        else:
            dict4.setdefault(key, []).append(dict3[key])
main(**dict1)
main(**dict2)
print(dict4)


字典upate，将b字典的值更新到a字典里面，如果key相同则更新value,否则追加进去,改变词典接口，词典更新后他不更新
from collections import ChainMap 类只是在内部创建了一个容纳这些字典的列表 并重新定义了一些常见的字典操作来遍历这个列表，词典更新链表后的词典也更新

合并多个词典或映射
ChainMap 接受多个字典并将它们在逻辑上变为一个字典,实际是合并到一起，同大部分词典同等的操作方式
from collections import ChainMap
a = {'x': 1, 'z': 3 }
b = {'y': 2, 'z': 4 }
ChainMap(a,b)
ChainMap({'x': 1, 'z': 3}, {'y': 2, 'z': 4})
c = ChainMap(a,b)
c['x'] from a
1
c['y'] from b
2
c['z'] from a 此时重复的值，只取到一个
3
len(c)
3
c.keys()
KeysView(ChainMap({'x': 1, 'z': 3}, {'y': 2, 'z': 4}))
list(c.keys())
['y', 'z', 'x']
list(c.values())
[2, 3, 1]
更新 删除
c['z'] = 10
c['z']
10
此时a词典值发生变化
ChainMap({'x': 1, 'z': 10}, {'y': 2, 'z': 4})
更新
c['w'] = 40
c
ChainMap({'x': 1, 'z': 10, 'w': 40}, {'y': 2, 'z': 4})


从字典中取子集--取出value大于200的 k,v
prices = {
    'ACME': 45.23,
    'AAPL': 612.78,
    'IBM': 205.55,
    'HPQ': 37.20,
    'FB': 10.75
}
for k,v in prices.items():
    if v > 200:
        print(k,v)
        
AAPL 612.78
IBM 205.55
{key: value for key,value in prices.items() if value >200}
{'AAPL': 612.78, 'IBM': 205.55}

列表中有n多字典，相同的key的字典对应的value合并到一起
现有list：
list1 = [{a: 123}, {a: 456},{b: 789}]
合并成：
list2 = [{a: [123,456]},{b: [789]}]
from collections import defaultdict
dic = {}
for _ in lst:
    for k, v in _.items():
        dic.setdefault(k, []).append(v)
print[{k:v} for k, v in dic.items()])

方法二、
lst = [('a', 1), ('b', 2)]
dic = {}
for (k,v) in lst:
    if k in dic.keys(): 如果k存在字典中
        dic[k] += [v]  则在后面追加[v] ,此时[v] 为列表
    else:
        dic[k] = [v]   否则空字典 的值设置为v
        
dic

dic
{'a': [1], 'b': [2]}
dic['a']
[1]
dic['a'] += [2]
dic
{'a': [1, 2], 'b': [2]}

列表里面元组类型的排序
data
[('a', 1), ('a', 2), ('a', 3), ('b', 4)]
d = defaultdict(list) 
d
defaultdict(<class 'list'>, {})
for k, v in data: 
    d[k.strip()].append(v)
    
d
defaultdict(<class 'list'>, {'a': [1, 2, 3], 'b': [4]})
type(d)
<class 'collections.defaultdict'>

for循环两个数字如何判断他们是否相等?
大列表嵌套列表 比较值
bl = [['10','182'],['10','182']]
bl[0] == bl[1]
True