Leyla Elkhamlichi's questions

Quero preencher um dataframe com valores de outra coluna. Uso uma condição para preencher os valores. A condição que quero preencher é quando o valor na coluna 'Essentieel_Optioneel' == 'essentieel', preciso preencher o valor com perc_essentieel_skill. Isso é o mesmo para quando o valor 'optioneel'.

Quando parei isso de volta, recebo um erro

conditions = [
     (df1['Essentieel_Optioneel'] <= 'essentieel'),
     (df1['Essentieel_Optioneel'] <= 'optioneel')

]

values = df1[['perc_essentieel_skill','perc_essentieel_skill']]
df1['vector'] = np.select(conditions, values)

df1

    811 'list of cases must be same length as list of conditions')
    813 # Now that the dtype is known, handle the deprecated select([], []) case
    814 if len(condlist) == 0:

ValueError: list of cases must be same length as list of conditions

Tenho a sensação de que meu dataframe é muito longo, tenho um frame de 19913 * 12 colunas.

Tenho a sensação de que preciso usar um loop for.

Tenho um dataframe onde quero contar um valor específico que ocorre em uma linha. Este código abaixo dá a resposta certa e agora quero adicionar uma nova coluna ao meu dataframe

occur = df.groupby(['Code_5elaag','Essentieel_Optioneel']).size()
occur

**Code_5elaag  Essentieel_Optioneel**
1101         essentieel               8
             optioneel                8
1102         essentieel               8
             optioneel               51
1103         essentieel               8
                                     ..
96231        optioneel                6
96232        essentieel               1
             optioneel                2
96290        essentieel               9
             optioneel               17

Quando atribuo uma nova coluna ao quadro, esta é a saída:

uniq['ess'] = df.groupby(['Code_5elaag'])['Essentieel_Optioneel'].transform(np.size)

    Code_5elaag Omschrijving_5elaag Soort_Skill Aantal_skills   ess
0   1101    Officieren landmacht    taken   16  16              15
16  1102    Officieren luchtmacht   taken   59  59              59
75  1103    Officieren marechaussee taken   16  16              16

Mas não é isso que eu quero, quero dividir a quantidade de Aantal_skills para quanto é essencial e opcional para a primeira linha, deve ser 8 essenciais e 8 opcionais

Quero ter uma função que substitua um perfil do LinkedIn que encontrei em uma string.

exemplo:

• Você pode encontrar meu LinkedIn https: www.linkedin.com/in/kim-zand-3126573/

Depois de usar a função deve ser:

• Você pode encontrar meu LinkedIn [Linkedin]

strA ='[Linkedin]'

Def linkedin(sentence):
urlReg = "^https?:\/\/?(w{3}.)? linkedin\.\/.$"
res = re.search(urlReg, sentence)
print(res)
if res != None:
    ## replace urls
    sentence= re.sub(urlReg,strA, sentence)
return (sentence)

Quando imprimo (res) ele não pega a string, acho que meu Regex não está correto

Eu tenho um script onde anonimizo dados pessoais, então quando uma string tem algumas palavras que começam com letras maiúsculas ela as substitui por outra função (ou seja, anonimizar nomes)

Quero escrever uma função onde a regex procure palavras fornecidas em uma lista. Quando uma string contém uma das palavras da lista fornecida, ela não deve ser substituída. Para dar um exemplo: Mijn naam é kim en ik heb een opleiding gevolgd aan de Universiteit van Amsterdam

Portanto, como a Universiteit van Amsterdam foi escrita em letras maiúsculas, ela será anonimizada por outra função. Quero fazer uma função extra que use Regex onde uma determinada lista com determinadas palavras será ignorada quando uma string corresponder às palavras da lista.
Tenho uma função que a substitui, mas quero que as palavras correspondentes sejam ignoradas.

Esta é a função que anonimizaNomes **

def anonymizeNames(sentence):
    '''
        :param sentence: the input sentence
        :return: the sentence without names
    '''

    ##define x
    x = ""

    ##Check naam: indication
    names0Reg = "[Aa]chternaam:|[Vv]oornaam:|[Nn]aam:|[Nn]amen:"
    res = re.search(names0Reg, sentence)
    if res != None:
        ##Achternaam:, voornaam: or naam: or namen: occurs; next Standardize
        sentence = re.sub('[Nn]amen:', 'naam:', sentence)
        sentence = re.sub('[Aa]chternaam:', 'naam:', sentence)
        sentence = re.sub('[Vv]oornaam:', 'naam:', sentence)
        sentence = re.sub('Naam:', 'naam:', sentence)

        ##Extract names
        names00Reg = "naam: [A-Za-z]+"
        x = re.findall(names00Reg, sentence)
        for y in x:
            ##remove naam:\s
            y = re.sub('naam: ', '', y)
            ##Check for tussenvoegsels
            if y in tussenVList:
                ##Add next word
                regTest = y + " " + "[A-Za-z]+"
                x2 = re.search(regTest, sentence)
                if x2 != None:
                    ##Name found
                    y = x2.group()
                    ##replace
                   sentence = re.sub(y, strz, sentence)

    ##Always check sentences for names 1
    names1Reg = "[Ii]k [Bb]en ([A-Z]{1}[a-z ]{2,})+[\\.\\,]*"
    res = re.search(names1Reg, sentence)
    if res != None:
        ##adjust result
        x = re.sub('[Ii]k [Bb]en ', '', res.group())
        x = re.sub('[\\,\\.]', '', x)
        ##use NLP to only keep names
        

    ##Always check sentences for names 2
    names2Reg = "[Mm]ijn [Nn]aam is ([A-Z]{1}[a-z\s-]{2,})+[\\.\\,]*"
    res = re.search(names2Reg, sentence)
    if res != None:
        ##adjust result
        x = re.sub('[Mm]ijn [Nn]aam is ', '', res.group())
        x = re.sub('[\\,\\.]', '', x)
        ##use NLP to only keep names
        

    ##Check for single letter followed by dot and series of letters
    if x == "":
        regNameLet = "^[A-Z]{1}\\.[A-Za-z]{2,}|\s[A-Z]{1}\\.[A-Za-z]{2,}"
        res = re.search(regNameLet, sentence)
        if res != None:
            ##replace word in sentence, first at start
            sentence = re.sub('^[A-Z]{1}\\.[A-Za-z]{2,}', strz, sentence)
            ##next in sentence with additional space
            strY = " " + strz
            sentence = re.sub('\s[A-Z]{1}\\.[A-Za-z]{2,}', strz, sentence)

    ##Check for occurence of two subsequent uppercase words (might be a name)
    if x == "":
        res = re.findall("[A-Z]{1}[a-z]{2,}\s[A-Z]{1}[a-z]{2,}", sentence)
        if res != []:
            for y in res:
                if len(y) > 1:
                    ##replace name with strX
                    sentence = re.sub(y, strz, sentence)

    ##Always recheck remaining sentence with NLP to make sure all personal info is removed
    sentence = pureNLP2(sentence)  ##pureNLP2 tries to include entity checks

    return (sentence)

Esta é a minha função para encontrar nomes de universidades e com esta função não quero substituí-los

school ['Hogenschool Amsterdam', 'Universiteit van Amsterdam']
strX='xxx'

def school (sentence):
   for schoolname in school:
     res = re.findall(schoolname,sentence)
     if res !=[]:
        for y in res:
            if len(y) >1:
               sentence = replaceNice(sentence, strX, y)
      return(sentence)
print(school('Mijn naam is Kim en ik volg een opleiding aan de Universiteit van Amsterdam'))

saída :Mijn naam xxx en ik volg een opleiding aan de xxx xxx

A saída que eu quero é: Mijn naam is Kim en ik volg een opleiding aan de Universiteit van Amsterdam

Acho que tenho um começo. Mas quando quero terminar a frase variável fico um pouco preso, porque aqui quero dizer se a string tem palavras correspondentes da lista Escola não a substitua, apenas imprima de volta.

Quero calcular a porcentagem de quanto cada tipo de habilidade está presente para cada ocupação. Eu fiz uma ocupação de nós diferentes e Soft_skills eles têm um relacionamento [r:MAPS_TO] o relacionamento tem dois tipos de propriedade ('essentieel', 'optioneel') e b (esse tipo de peso essentieel = 1,0 e optioneel = 0,5)

veja abaixo um exemplo do arquivo que estou usando

fiz uma consulta onde posso calcular qual é a soma de cada ocupação veja abaixo minha consulta:

match (b:BOC_beroep)-[r:MAPS_TO]-(s:Soft_Skill)                                                     
return b.beroepstitel as beroep,                             
sum(toFloat(r.b)) as sum order by sum desc                         
limit 10

esta é a minha saída

sei que quero atingir qual é a porcentagem do tipo de habilidade que meu cálculo será

Dokter have in total 4 skills en the percentage of each skill is 
2/4 * 100 = 50% essentieel 
1/4 * 100 = 25% optioneel 

i was trying to make a new calculation with this query:

  MATCH (b:BOC_beroep)-[r:MAPS_TO]->(s:Soft_skill)
  WITH SUM(toFloat(r.b)) As total
  MATCH (b:BOC_beroep)-[r:MAPS_TO]->(s:Soft_Skill)
  RETURN b.beroepstitel  AS beroep, 
  (toFloat(total/(r.b)))*100 AS percent
  order by percent desc

Minha saída é Não é possível dividir 'Long' por 'string' Não entendo o erro

fui inspirado por esta pergunta e resposta Aqui está um link embutido para stackoverflow .