Saeed's questions

Eu tenho um liste um dictionaryassim:

mydict = {
    'some-id-string1': {'name': 'Saeed1', 'phone': '+989307333730', 'id': 'abc'},
    'some-id-string2': {'name': 'Saeed2', 'phone': '+989307333731', 'id': 'def'},
    'some-id-string3': {'name': 'Saeed3', 'phone': '+989307333732', 'id': 'ghi'},
    'some-id-string4': {'name': 'Saeed3', 'phone': '+989307333733', 'id': 'jkl'},
    'some-id-string5': {'name': 'Saeed3', 'phone': '+989307333730', 'id': 'abc'},
    'some-id-string6': {'name': 'Saeed3', 'phone': '+989307333730', 'id': 'abc'},
    'some-id-string7': {'name': 'Saeed3', 'phone': '+989307333731', 'id': 'def'},

}
mylist = [
    {'id': 'abc', 'name': 'some_name1'},
    {'id': 'def', 'name': 'some_name2'},
    {'id': 'ghi', 'name': 'some_name3'},
]

Vou verificar se o idvalor de mydictcorresponde myliste adicionar o nameof mylista mydict. Se isso não existir lá, terei duas saídas (porque não tenho certeza atualmente de manter qual delas, então terei as duas para decidir depois):

Saída esperada 1 se nameexistir e adicionar NOT_FOUNDpara aqueles que não tiverem correspondente name:

newmydict1 = {
    'some-id-string1': {'name': 'Saeed1', 'phone': '+989307333730', 'id': 'abc', 'id_name': 'some_name1'},
    'some-id-string2': {'name': 'Saeed2', 'phone': '+989307333731', 'id': 'def', 'id_name': 'some_name2'},
    'some-id-string3': {'name': 'Saeed3', 'phone': '+989307333732', 'id': 'ghi', 'id_name': 'some_name3'},
    'some-id-string4': {'name': 'Saeed3', 'phone': '+989307333733', 'id': 'jkl', 'id_name': 'NOT_FOUND'},
    'some-id-string5': {'name': 'Saeed3', 'phone': '+989307333730', 'id': 'abc', 'id_name': 'some_name1'},
    'some-id-string6': {'name': 'Saeed3', 'phone': '+989307333730', 'id': 'abc', 'id_name': 'some_name1'},
    'some-id-string7': {'name': 'Saeed3', 'phone': '+989307333731', 'id': 'def', 'id_name': 'some_name2'},
}

Saída esperada 2 se nameexistir e para criar uma nova lista para aqueles que não possuem correspondente name:

newmydict2 {
    'some-id-string1': {'name': 'Saeed1', 'phone': '+989307333730', 'id': 'abc', 'id_name': 'some_name1'},
    'some-id-string2': {'name': 'Saeed2', 'phone': '+989307333731', 'id': 'def', 'id_name': 'some_name2'},
    'some-id-string3': {'name': 'Saeed3', 'phone': '+989307333732', 'id': 'ghi', 'id_name': 'some_name3'},
    'some-id-string5': {'name': 'Saeed3', 'phone': '+989307333730', 'id': 'abc', 'id_name': 'some_name1'},
    'some-id-string6': {'name': 'Saeed3', 'phone': '+989307333730', 'id': 'abc', 'id_name': 'some_name1'},
    'some-id-string7': {'name': 'Saeed3', 'phone': '+989307333731', 'id': 'def', 'id_name': 'some_name2'},
}
newmydict3 = {
    'some-id-string4': {'name': 'Saeed3', 'phone': '+989307333733', 'id': 'jkl'},
}

Não tenho certeza do que fazer e o que escrever, porque o keyde mydict(quero dizer some-id-string) não existe em mylist, e também alguns membros do mydict['id']têm mais de uma ocorrência.

tentei

new = [{
    'string_id': d, 
    'id': l['id'], 
    'id_name': l['name'], 
    'phone': mydict[d]['phone'], 
    'name': mydict[d]['name']
    } for l in mylist for d in mydict if mydict[d]['id'] == l['id']
]

Este é um dicionário que eu tenho:

mydict = {
    4: {'K', 'H'},
    2: {'Y', 'X', 'Q', 'U'},
    8: {'A', 'T', 'S'},
}

Parece que há algumas maneiras de classificar um dicionário que tentei, mas não funcionaram:

sorted([(value,key) for (key,value) in mydict.items()])

Mas vou classificar usando a len()função com base em quantos valores cada um tem.

Esta é a len()saída atual:

for x in mydict: print(x, mydict[x], len(mydict[x]))

Como posso classificar o dicionário conforme o esperado?

A saída esperada seria:

mydict = {
    2: {'Y', 'X', 'Q', 'U'},
    8: {'A', 'T', 'S'},
    4: {'K', 'H'},
}

Tenho uma lista de assuntos de e-mail que foram enviados hoje (eu conecto ao meu servidor IMAP e busco todos os e-mails):

sent_subjects = [
    'subject1 backup up completed', 'subject2-2 backup failed', 'subject4 backup partial complete', 'email3 done', 'ak47 failed', 'mp5 is good', 'm4 is good'
]

Tenho um jsonarquivo e quase todos os scripts que tenho e envio por e-mail, eles têm entrada lá:

emails = [
    {'subject': 'mp3 is good', 'date': '2020-02-02'},
    {'subject': 'mp5 is good', 'date': '2020-02-02'},
    {'subject': 'm4 is good', 'date': '2020-02-02'}
]

E eu crio subjectsassim:

subjects = [x['subject'] for x in emails]

Estes são todos os assuntos que devem ser enviados (alguns deles não foram enviados):

static_subjects = [
    'subject1', 'subject2-2', 'subject4', 'email3', 'ak47', 'subject10', 'email11', 'final destination'
    ]
subjects += static_subjects
subjects.sort()

Eu sei que posso fazer isso, mas isso não retorna a saída esperada:

final = list(set(subjects) - set(sent_subjects))

Porque alguns assuntos subject1não subject4têm assunto estático e podem mudar com base em algumas condições (esses assuntos não são meus e eu não envio e-mails com esses assuntos. Eu apenas os recebo).

Então, preciso verificar se algum assunto subjectsnão está em sent_subjects, para que eu possa rastrear quais e-mails não recebi, para ver se há algum problema.

Neste caso, não recebi esses assuntos e a saída deveria tê-los:

mp3 is good
subject10
email11
final destination

A outra coisa que sei é que usar if ==não funciona, porque email11por exemplo é como subject1e subject2-2que tem dois ou mais assuntos (se falha ou sucesso).

Você poderia me ajudar com isso?

Eu tenho essas listas:

list1 = [
    {'itemid': '264', 'name': 'Interface Gi1/17(Port1:TP TPIA-CL03-017-G15-14): Bits sent', 'some_other_keys': 'some_more_values'},
    {'itemid': '215', 'name': 'Interface Te1/50("Port1:CL-PO-G22-23"): Bits received', 'some_other_keys': 'some_more_values'},
    {'itemid': '425', 'name': 'Interface Gi1/46(no description): Bits sent', 'some_other_keys': 'some_more_values'},
    {'itemid': '521', 'name': 'Interface Te1/50("Port1:CL-PO-G22-23"): Bits sent', 'some_other_keys': 'some_more_values'},
    {'itemid': '310', 'name': 'Interface Gi1/46(no description): Bits received', 'some_other_keys': 'some_more_values'},
    {'itemid': '123', 'name': 'Interface Gi1/17(Port1:TP TPIA-CL03-017-G15-14): Bits received', 'some_other_keys': 'some_more_values'},
]
list2 = [
    {'itemid': '264', 'clock': '1724146566', 'value': '6246880', 'ns': '120003316'},
    {'itemid': '264', 'clock': '1724146746', 'value': '6134912', 'ns': '113448784'},
    {'itemid': '215', 'clock': '1724144406', 'value': '5786832', 'ns': '157177073'},
    {'itemid': '215', 'clock': '1724144766', 'value': '5968784', 'ns': '760851309'},
    {'itemid': '425', 'clock': '1724148366', 'value': '6590424', 'ns': '403316048'},
    {'itemid': '425', 'clock': '1724148726', 'value': '6549984', 'ns': '484278803'},
    {'itemid': '521', 'clock': '1724148906', 'value': '6346488', 'ns': '306999249'},
    {'itemid': '521', 'clock': '1724147106', 'value': '6139008', 'ns': '459391602'},
    {'itemid': '310', 'clock': '1724147286', 'value': '6000208', 'ns': '826776455'},
    {'itemid': '310', 'clock': '1724147466', 'value': '6784960', 'ns': '152620809'},
    {'itemid': '123', 'clock': '1724147826', 'value': '6865272', 'ns': '70247389'},
    {'itemid': '123', 'clock': '1724148186', 'value': '6544328', 'ns': '610791670'},
]

Agora vou fazer isso:

Primeiro, armazene a soma e a média de cada um itemidcom list2base em value(por exemplo, para itemid264, some todos os seus valores e depois divida pela função len()):

Segundo, encontre cada dois itemids no list1e veja se seus nomes correspondem:

Terceiro, divida os valores que têm receivedpor sent.

Eu adiciono todos os valores iguais itemidassim:

from collections import defaultdict
new_list = defaultdict(list)
for entry in list2:
    if int(entry['value']) > 0:
        new_list[int(entry['itemid'])].append(int(entry['value']))

# >>> new_list
# defaultdict(<class 'list'>, {264: [6246880, 6134912], 215: [5786832, 5968784], 425: [6590424, 6549984], 521: [6346488, 6139008], 310: [6000208, 6784960], 123: [6865272, 6544328]})

Agora devo descobrir se o id 264 name( name.split(': Bits')[0]de fato) list1corresponde a qual id e então dividir .endswith('Bits received') / .endswith('Bits sent').

Vamos supor isso:

O nome do id 264 é Interface Gi1/17(Port1:TP TPIA-CL03-017-G15-14) e outro id com este nome é 123. Agora dividimos a soma de todos os valores com id 123 (porque é received) pela soma de todos os valores tendo id 264 (porque é sent).

Deveria ser assim:

    [
        {'name': 'Interface Gi1/17(Port1:TP TPIA-CL03-017-G15-14)', 'received': 13409600, 'sent': 12381792, 'ratio': 1.0830096322083265} # ( (6865272 + 6544328) / (6246880 + 6134912) )
    ]

Com este código, posso somar e calcular a média de cada um itemid(mas não é isso que vou fazer):

import datetime
for x in new_list:
    print(f"Item ID: {x}, Ratio: {float(str(sum(new_list[x]) / len(new_list[x]) / 1000 / 1000)[:3])}")

Saída atual:

Item ID: 264, Ratio: 6.1
Item ID: 215, Ratio: 5.8
Item ID: 425, Ratio: 6.5
Item ID: 521, Ratio: 6.2
Item ID: 310, Ratio: 6.3
Item ID: 123, Ratio: 6.7

Resultado totalmente esperado:

output = [
    {'name': 'Interface Gi1/17(Port1:TP TPIA-CL03-017-G15-14)', 'received': 13409600, 'sent': 12381792, 'ratio': 1.0830096322083265}, # ( (6865272 + 6544328) / (6246880 + 6134912) )
    {'name': 'Interface Te1/50("Port1:CL-PO-G22-23")', 'received': 11755616, 'sent': 12485496, 'ratio': 0.941541769746272}, # ( (5786832 + 5968784) / (6346488 + 6139008) )
    {'name': 'Interface Gi1/46(no description)', 'received': 12785168, 'sent': 13140408, 'ratio': 0.9729658318067446}, # ( (6000208 + 6784960) / (6590424 + 6549984) )
]

Você poderia me ajudar como alcançá-lo?

Este é o meu código:

from collections import defaultdict

ip_port_device = [

    {'ip': '192.168.1.140', 'port_number': 4, 'device_name': 'device1'},
    {'ip': '192.168.1.128', 'port_number': 8, 'device_name': 'device1'},
    {'ip': '192.168.1.56', 'port_number': 14, 'device_name': 'device1'},
    {'ip': '192.168.1.61', 'port_number': 4, 'device_name': 'device1'},
    {'ip': '192.168.1.78', 'port_number': 8, 'device_name': 'device1'},
    {'ip': '192.168.1.13', 'port_number': 16, 'device_name': 'device1'},

    {'ip': '192.168.2.140', 'port_number': 4, 'device_name': 'device2'},
    {'ip': '192.168.2.128', 'port_number': 8, 'device_name': 'device2'},
    {'ip': '192.168.2.56', 'port_number': 14, 'device_name': 'device2'},
    {'ip': '192.168.2.61', 'port_number': 4, 'device_name': 'device2'},
    {'ip': '192.168.2.78', 'port_number': 8, 'device_name': 'device2'},
    {'ip': '192.168.2.13', 'port_number': 16, 'device_name': 'device2'},

    {'ip': '192.168.3.140', 'port_number': 4, 'device_name': 'device3'},
    {'ip': '192.168.3.128', 'port_number': 8, 'device_name': 'device3'},
    {'ip': '192.168.3.56', 'port_number': 14, 'device_name': 'device3'},
    {'ip': '192.168.3.61', 'port_number': 4, 'device_name': 'device3'},
    {'ip': '192.168.3.78', 'port_number': 8, 'device_name': 'device3'},
    {'ip': '192.168.3.13', 'port_number': 16, 'device_name': 'device3'},

]

ip_per_node = [

    {'node_name': 'server9.example.com', 'ip_address': '192.168.1.140'},
    {'node_name': 'server19.example.com', 'ip_address': '192.168.1.128'},
    {'node_name': 'server11.example.com', 'ip_address': '192.168.2.140'},
    {'node_name': 'server21.example.com', 'ip_address': '192.168.2.128'},
    {'node_name': 'server17.example.com', 'ip_address': '192.168.3.140'},
    {'node_name': 'server6.example.com', 'ip_address': '192.168.3.128'},

]

ips_and_ports_in_switch = []
for compute in ip_per_node:
    for port in ip_port_device:
        if compute['ip_address'] == port['ip']:
            port = port['port_number']
            for new_port in ip_port_device:
                if port == new_port['port_number']:
                    ips_and_ports_in_switch.append({
                        'port_number': new_port['port_number'],
                        'ip_address': new_port['ip'],
                        'node_name': compute['node_name'],
                        'device_name': new_port['device_name']
                        })

concatenated = defaultdict(list)
for entry in ips_and_ports_in_switch:
    concatenated[(entry['device_name'], entry['port_number'], entry['node_name'])].append(entry['ip_address'])

A lógica é:

se ip_per_node['ip_address']corresponder ip_port_device['ip'], então em ip_port_devicefind todos os ips terão o mesmo número de porta.

Em seguida, salve assim (resultado esperado):

node server9.example.com, port 4, device device1, ips ['192.168.1.140', '192.168.1.61']
node server19.example.com, port 8, device device1, ips ['192.168.1.128', '192.168.1.78']
node server11.example.com, port 4, device device2, ips ['192.168.2.140', '192.168.2.61']
node server21.example.com, port 8, device device2, ips ['192.168.2.128', '192.168.2.78']
node server17.example.com, port 4, device device3, ips ['192.168.3.140', '192.168.3.61']
node server6.example.com, port 8, device device3, ips ['192.168.3.128', '192.168.3.78']

Meu código atual não funciona como esperado. Ele salva uma porta várias vezes para todos os nós.

Tentei adicionar menos dados, mas necessários, para a amostra.

Este é o meu código:

import os
import sys
my_path = 'C:/Users/S.Fazlollahzadeh/Desktop/shell-scripts/test only/excel'
os.chdir(my_path)
sys.path.append(my_path)
from openpyxl import Workbook

names = ['name1', 'name2', 'name3', 'name4']
wb = Workbook()
ws = wb.active

for name in names:
        ws.title = name
        wb.create_sheet(name)

wb.save("sample.xlsx")
quit()

Os nomes das folhas são:

name4
name11
name21
name31
name41

Embora devesse ser:

name1
name2
name3
name4

O que estou fazendo de errado?

Em primeiro lugar, sinto muito se a pergunta for muito longa. Tentei incluir o mínimo de dados, mas pude acrescentar.

Estas são as listas que tenho:

products_income = [
    {'client_group': 'A', 'count': 2, 'product': 'A', 'monthly_income': 370},
    {'client_group': 'B', 'count': 1, 'product': 'B', 'monthly_income': 215},
    {'client_group': 'C', 'count': 3, 'product': 'C', 'monthly_income': 495},
    {'client_group': 'A', 'count': 2, 'product': 'D', 'monthly_income': 304},
    {'client_group': 'B', 'count': 1, 'product': 'E', 'monthly_income': 110},
    {'client_group': 'B', 'count': 2, 'product': 'F', 'monthly_income': 560},
    {'client_group': 'A', 'count': 1, 'product': 'G', 'monthly_income': 196},
    ]

client_package = [
    {'client_group': 'A', 'total_income': 870},
    {'client_group': 'B', 'total_income': 885},
    {'client_group': 'C', 'total_income': 495}
]

client_group_user_counts = {
    'A': ['user1', 'user2', 'user3', 'user4', 'user5'], # 5 users
    'B': ['user21', 'user22', 'user23', 'user24'], # 4 users
    'C': ['user41', 'user42', 'user43'], # 3 users
}

Esta é a saída da minha loja, e esta é a saída esperada para serem gravados diferentes arquivos chamados por ' client_group.txt':

A.txt:

group A has 2 product A, monthly income is 370.
group A has 2 product D, monthly income is 304.
group A has 1 product G, monthly income is 196.

group A total income is 870.

group A has total 5 users, and this is its users:
user1
user2
user3
user4
user5

B.txt:

group B has 1 product B, monthly income is 215.
group B has 1 product E, monthly income is 110.
group B has 2 product F, monthly income is 560.

group B total income is 885.

group B has total 4 users, and this is its users

user21
user22
user23
user24

C.txt:

group C has 3 product C, monthly income is 495.

group C total income is 495.

group C has total 3 users, and this is its users:
user41
user42
user43

Este é o meu código atual e ainda não alcancei a saída esperada (na verdade, atualmente não sei como escrever em arquivos separados neste caso, além do outro problema do meu código):

# I added this function, because I had error in the last line of next code block inside the `f-string`, so I thought that could be a workaround for this
def to_join():
    return '\n'.join(client_group_user_counts[user])

for product in products_income:
    for client in client_package:
        for user in client_group_user_counts:
            if product['client_group'] == client['client_group'] == user:
                print(f"""group {product['client_group']} has {product['count']} product {product['product']}, monthly income is {product['monthly_income']}.
total income is {client['total_income']}.
group {product['client_group']} has total {len(client_group_user_counts[user])} users, and this is its users:
{to_join()}
""")

Esta é a saída atual:

group A has 2 product A, monthly income is 370.
group A total income is 870.
group A has total 5 users, and this is its users:
user1
user2
user3
user4
user5

group B has 1 product B, monthly income is 215.
group B total income is 885.
group B has total 4 users, and this is its users:
user21
user22
user23
user24

group C has 3 product C, monthly income is 495.
group C total income is 495.
group C has total 3 users, and this is its users:
user41
user42
user43

group A has 2 product D, monthly income is 304.
group A total income is 870.
group A has total 5 users, and this is its users:
user1
user2
user3
user4
user5

group B has 1 product E, monthly income is 110.
group B total income is 885.
group B has total 4 users, and this is its users:
user21
user22
user23
user24

group B has 2 product F, monthly income is 560.
group B total income is 885.
group B has total 4 users, and this is its users:
user21
user22
user23
user24

group A has 1 product G, monthly income is 196.
group A total income is 870.
group A has total 5 users, and this is its users:
user1
user2
user3
user4
user5

Este é o meu código python:

import secrets
from time import sleep

ids = [{'id': number} for number in range(1, 5+1)]

rand1 = secrets.choice(ids)
rand2 = secrets.choice(ids)
rand3 = secrets.choice(ids)

n = 0
while rand1['id'] == rand2['id'] == rand3['id']:
        n += 1
        print('Before')
        print(rand1['id'], rand2['id'], rand3['id'])
        sleep(1)
        rand1 = secrets.choice(ids)
        rand2 = secrets.choice(ids)
        rand3 = secrets.choice(ids)
        print('After')
        print(rand1['id'], rand2['id'], rand3['id'])

Eu vou chegar nisso:

faça o loop while e escolha um id aleatório até que nenhum dos rand1['id'], rand2['id'] e rand3['id'] sejam iguais.

Mesmo que dois deles sejam iguais, faça outro loop for.

Neste exemplo , mostra botões como este:

Number1ToChoose Number2ToChoose Number3ToChoose Number4ToChoose Number5ToChoose

Enquanto vou ver isso:

Number1ToChoose
Number2ToChoose
Number3ToChoose
Number4ToChoose
Number5ToChoose

Não encontrei uma maneira de fazer isso até agora.

Este é o arquivo json:

[
  {"name": "Saeed"},
  {"name": "Joseph"},
  {"name": "Mary"},
  {"name": "Peter"}
]

Vou iterar sobre ele e adicionar uma nova chave chamada idpara cada uma, e seu valor é único.

Este é o meu loop for atual, mas incrementa apenas o primeiro item:

import json

with open('db.json', 'r') as file:
    data = json.load(file)

data.sort(key=lambda x: x['name'])
for i in range(1, len(data) + 1):
    for d in data:
        d['id'] = i
        break

Saída atual:

for i in data:
{'name': 'Joseph', 'id': 4}
{'name': 'Mary'}
{'name': 'Peter'}
{'name': 'Saeed'}

A saída esperada é:

{'name': 'Joseph', 'id': 1}
{'name': 'Mary', 'id': 2}
{'name': 'Peter', 'id': 3}
{'name': 'Saeed', 'id': 4}

Este é o meu texto:

    set $domain_name some-not-important-name.com;

Eu quero chegar a isso:

    set $domain_name test.com;

Isto é o que eu tentei até agora:

DOMAIN_NAME=test.com
awk '{ sub(/ set $domain_name(.*)/, " set $domain_name $DOMAIN_NAME;") }1' file

resultado atual:

    set $domain_name some-not-important-name.com

Atualização 1

A razão pela qual adicionei vários whitespacesé que a linha pertence à nginxconfiguração e possui vários espaços.

Como há ambos charsete setem meu arquivo e eles não são o primeiro caractere da linha, devo substituir setpor espaço antes.