Python Aplicado A Problemas de Gestao de

Python Aplicado a Problemas de Gestão de Recursos Humanos
1
Python Aplicado a Problemas de Gestão de
Recursos Humanos
Carlos Pedro Gonçalves
Instituto Superior de Ciências Sociais e Políticas (ISCSP)
Universidade de Lisboa
cgoncalves@iscsp.ulisboa.pt

2
Índice
1. Introdução à Linguagem Python .................................................................................. 3
1.1. Caso de Avaliação de Desempenho ................................................................... 4
2. O Python e a Gestão de Recursos Humanos .............................................................. 14
3. Exercícios de Gestão de Recursos Humanos com Python .......................................... 17
Resolução dos Exercícios ................................................................................................ 20
Exercício 1................................................................................................................... 20
Alínea a. .................................................................................................................. 20
Alínea b. .................................................................................................................. 20
Alínea c. .................................................................................................................. 21
Alínea d. .................................................................................................................. 21
Exercício 2................................................................................................................... 21
Exercício 3................................................................................................................... 23
Alínea a. .................................................................................................................. 23
Alínea b.i. ................................................................................................................ 23
Alínea b.ii. ............................................................................................................... 23
Alínea c. .................................................................................................................. 23
Exercício 4................................................................................................................... 25
Exercício 5................................................................................................................... 25
Exercício 6................................................................................................................... 26
Bibliografia...................................................................................................................... 27

3
1. Introdução à Linguagem Python
A linguagem de programação Python foi desenvolvida na década de 1980 pelo

programador holandês Guido van Rossum, fã dos Monty Python (de onde resulta o nome da
linguagem), visando:
 Desenvolver uma linguagem fácil e intuitiva tão poderosa quanto as alternativas

(nomeadamente o C++ e Java);
 De fonte aberta, tal que qualquer um possa contribuir para o seu
desenvolvimento;
 Mais próximo do discurso natural;
 Passível de suportar um tempo, mais curto, de desenvolvimento de programas,
favorecendo a componente criativa e aplicada da programação.
A linguagem Python foi adoptada pelo MIT no curso de Engenharia Eléctrica e Ciência
da Computação (http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/),
no ensino da programação1 e da Inteligência Artificial. Esta linguagem tem também sido utilizada
pela Google e pela NASA, assim como por um conjunto crescente de empresas, conforme
ilustrado no website:
https://www.python.org/about/success/#business
Embora o Python suporte diferentes paradigmas de programação, a programação

orientada a objectos, do ponto de vista de uma análise estatística dirigida à gestão, é a mais
adequada.
Um objecto corresponde a uma entidade de software, algo semelhante a um agente

artificial que possui atributos e métodos necessários à realização de determinadas tarefas
computacionais.
1
Embora as linguagens C++ e Java também sejam ensinadas.

Dependendo do tipo de objecto, estamos perante agentes inteligentes de diferentes
4
níveis cognitivos. Assim, em termos computacionais, existem elementos de Inteligência Artificial
(IA) incorporados na programação orientada a objectos.
Um objecto corresponde a uma instância de uma classe, quando definimos uma classe,
definimos os atributos de instância e os procedimentos computacionais integrados nos
chamados métodos de instância, um método de instância descreve uma unidade coerente de
computação que define o comportamento das instâncias de uma dada classe, correspondendo
a um algoritmo: sempre que o método é invocado, o algoritmo é executado pelo computador
para a instância correspondente.
No contexto da ciência da computação, um objecto é uma estrutura algoritmicamente

complexa, pois pode correr diferentes algoritmos (diferentes métodos) e possui atributos que o
caracterizam, constituindo uma entidade artificial capaz de níveis de cognição adaptativa, logo,
estamos perante entidades computacionais que residem na matriz simulada pelo computador.
Considerando o contexto da análise de dados aplicada à Gestão, às variáveis estatísticas

correspondem atributos de instância, enquanto que aos métodos correspondem procedimentos
de análise de dados e de decisões de gestão. Passamos, pois, a trabalhar um exemplo na área
da Gestão de Recursos Humanos que permite ilustrar esta correspondência, assim como permite
introduzir alguns conceitos da linguagem Python aplicada a problemas desta área de
conhecimento.
1.1. Caso de Avaliação de Desempenho
Como exemplo, considere-se um caso de uma empresa que se encontra a avaliar a

performance dos Recursos Humanos em dez unidades fabris, situadas em Portugal (6 unidades)
e Espanha (4 unidades), tendo obtido a seguinte informação sobre cada uma das unidades:
 Número total de trabalhadores;

 Peças produzidas/hora;
 Número de horas de formação;
 Número de acidentes de trabalho;
 Número de operários;
 Antiguidade máxima dos operários.

Podemos, então, definir a classe das unidades fabris tal que cada uma das dez unidades
5
fabris corresponde a uma instância particular. Os atributos de instância correspondem às
variáveis estatísticas. Embora não seja uma condição imposta pela linguagem, adoptaremos a
convenção da Oracle, tal que:
 Nomes das Classes: a primeira letra de cada palavra que compõe o nome de
uma classe é definida como maiúscula, sendo as restantes letras definidas como
minúsculas, assim, para o problema em causa temos a classe designada por
UnidadeFabril;
 Nomes dos Métodos: a primeira letra é definida como minúscula, quando um
método é composto por várias palavras têm de aparecer juntas, sem espaços,
no nome do método, a convenção é: para a primeira palavra que compõe o
nome do método as letras são minúsculas, enquanto que a primeira letra, para
cada uma das restantes palavras que compõem o nome de um método, é
definida como maiúscula (por exemplo, avaliaProdutividade ou
avaliaTrabalhadoresDaUnidade), o nome do método deverá expressar o tipo de
actividade de análise que é realizada e o interesse da mesma para a gestão da
empresa.
A mesma convenção assumida para os métodos, seguiremos para os atributos.
Em Python define-se a classe do seguinte modo:
class UnidadeFabril:
def __init__(self,local,numTrab,pecaHora,formacao,acidentes,operarios,antiguidade):
self.local = local # Localização da Unidade (Portugal ou Espanha)
self.numTrab = numTrab # Número de trabalhadores
self.pecaHora = pecaHora # Número de peças produzidas por hora
self.formacao = formacao # Número de horas de formação
self.acidentes = acidentes # Número de acidentes de trabalho
self.operarios = operarios # Número de operários
self.antiguidade = antiguidade # Antiguidade máxima dos operários
A primeira linha de código define o nome da classe, as linhas seguintes definem os

atributos de instância, os comentários são colocados após o cardinal. No código acima, cada
instância da classe “UnidadeFabril” tem como atributos de instância os seguintes:
 local: localização da unidade fabril;

 numTrab: número de trabalhadores;
 pecaHora: número de peças produzidas por hora;
 formacao: número de horas de formação;

 acidentes: número de acidentes de trabalho;
6
 operarios: número de operários;
 antiguidade: antiguidade máxima.
Somente com a definição geral da classe podemos construir o equivalente à base de

dados em código Python.
Em termos tradicionais, uma base de dados tem uma estrutura semelhante a uma
tabela, em que a cada linha corresponde um membro da população sob análise e a cada coluna
corresponde uma variável estatística. O quadro seguinte contém um exemplo desta estrutura
tradicional de base de dados, para o caso sob análise.
Nº de Peça / Nº de
Local Formação Acidentes Antiguidade
Trabalhadores hora Operários
Unidade 1 Portugal 200 20 2000 20 150 20
Unidade 7 Espanha 250 25 2000 20 160 15
Unidade 8 Espanha 250 26 1100 14 160 16
Unidade 9 Espanha 210 17 1200 10 150 17
Unidade 10 Espanha 210 14 1200 20 150 20
Em Python, a cada unidade irá corresponder uma instância, assim, temos o seguinte
processo de instanciação, conforme passamos a explicar:
Unidade1 = UnidadeFabril('Portugal',200,20,2000,20,150,20)
Unidade7 = UnidadeFabril('Espanha',250,25,2000,20,160,15)
O sinal “=” não corresponde a um sinal de “igual” matemático mas sim ao símbolo de
atribuição, cada linha de código acima dá ao computador a instrução para criar um objecto,
atribuindo-lhe, como valor, uma instância da classe UnidadeFabril com determinados valores,
assim a primeira linha de código pode ser lida do seguinte modo:

 Atribui à “Unidade1” uma instância da classe UnidadeFabril com os seguintes
7
valores para os atributos:
o local: Portugal;
o numTrab: 200;
o pecaHora: 20;
o formacao: 2000;
o acidentes: 20;
o operarios: 150;
o antiguidade: 20.
Uma interpretação análoga pode ser realizada para as restantes instâncias. Na

perspectiva imediata do utilizador, existe pouca diferença prática entre a introdução dos dados
numa tabela, ou a instanciação de objectos. Se o objectivo fosse somente a construção de uma
base de dados, ambas as alternativas seriam efectivamente equivalentes, contudo, a partir do
momento em que se criam objectos, temos entidades computacionais que registam os valores
de cada unidade fabril numa memória de trabalho, existindo uma entidade computacional por
cada unidade fabril.
Esta natureza computacional dos objectos distingue-se da natureza da tabela. A tabela

corresponde a uma estrutura de dados que são inseridos, a tabela é passiva. Os objectos têm
uma estrutura de memória e a capacidade de agir sobre esses mesmos dados. O tipo de acções
a serem programadas depende dos objectivos, com uma mesma estrutura de atributos é
possível realizar diferentes acções.
Vamos assumir, então, que a empresa pretende avaliar cada unidade fabril segundo
critérios definidos a partir de objectivos relacionados com a produtividade, a formação e os
acidentes. Podemos, então, definir três métodos de instância:
 avaliaProdutividade
 avaliaFormacao
 avaliaAcidentes
 avaliaUnidade
Assim, considerando cada objecto da classe UnidadeFabril como uma entidade

computacional que guarda na sua memória de trabalho os valores dos atributos da unidade
fabril que lhe corresponde, os métodos acima constituem procedimentos computacionais que

a entidade computacional executa a partir da sua memória de trabalho e de elementos
8
adicionais definidos como parâmetros externos (inputs do método2).
Tornando explícita a conexão com a IA, passamos a referir-nos, na descrição dos

métodos, a cada objecto/entidade computacional pela noção de agente artificial definido
enquanto agente de software que é capaz de avaliar o valor dos seus atributos e de, com base
em critérios de gestão, classificar e produzir uma síntese cognitiva avaliativa da unidade fabril
que lhe corresponde e cujas características guarda na sua memória de trabalho
(valores dos atributos).
O primeiro método avaliaProdutividade visa avaliar o nível de produtividade face a um

valor definido pela empresa como objectivo de produtividade para a unidade fabril. Assim,
considerando o número de peças produzidas por hora pela unidade fabril e o objectivo de peças
definido pela empresa, o agente artificial divide os resultados obtidos pelo objectivo
correspondente e, face ao resultado dessa divisão, classifica a unidade.
O processamento cognitivo pode ser expresso em termos de uma árvore de decisão,

conforme ilustrado abaixo.
Comunica:
Divisão inferior a 1 'não atingiu o objectivo de Devolve resultado do rácio
produtividade'
Comunica:
Divide peça/hora por
Divisão igual a 1 'atingiu o objectivo de Devolve resultado do rácio
objectivo
produtividade'
Comunica:
Divisão superior a 1 'superou o objectivo de Devolve resultado do rácio
produtividade'
A acção do agente artificial pode ser analisada seguindo a árvore. No primeiro nó da

árvore (nó de raiz) o agente realiza uma divisão do resultado de produtividade pelo objectivo,
quando este rácio é inferior a 1, isso significa que o resultado foi inferior ao objectivo, pelo que
2
Os inputs de um método, para problemas de gestão, geralmente correspondem a variáveis
estratégicas que estão sob o controlo da empresa, podendo ser alteradas pela gestão da empresa (a
definição de um objectivo quantitativo pela gestão da empresa constui um exemplo).

o agente comunica que a unidade fabril que lhe corresponde não atingiu o objectivo de
9
produtividade.
Quando o rácio é igual a 1, o resultado obtido coincide com o objectivo, logo, o agente
comunica que a unidade que lhe corresponde atingiu o objectivo de produtividade.
Finalmente, quando o rácio é superior a 1, o agente comunica que o objectivo de

produtividade foi superado.
Em qualquer das alternativas, o agente devolve o resultado do rácio, podendo esse valor
ser utilizado pelo agente para efeitos de cálculo futuro, como iremos ver mais adiante.
Em linguagem Python, o método é escrito do seguinte modo:
def avaliaProdutividade(self,objectivo):
avaliacao = self.pecaHora / objectivo
if avaliacao < 1:
print(self.nome, 'não atingiu o objectivo de produtividade')
elif avaliacao == 1:
print(self.nome, 'atingiu o objectivo de produtividade')
else:
print(self.nome, 'superou o objectivo de produtividade')
return avaliacao
A primeira linha de código define o nome do método (def avaliaProdutividade)

enquanto método de instância (self) que recebe como input o valor do objectivo de
produtividade definido pela empresa (este elemento terá de ser fornecido ao agente artificial).
As restantes linhas de código (após os dois pontos) correspondem ao corpo do método.
No primeiro passo, o agente recupera o conteúdo da sua memória de trabalho referente

ao número de peças produzidas por hora (atributo pecaHora) e divide esse conteúdo pelo
objectivo a ser atingido, atribuindo-o a uma variável local designada por avaliacao. As variáveis
locais permitem, em termos de IA, simular o funcionamento de memória de trabalho
temporária.
Após ter o conteúdo da variável avaliacao, estamos no primeiro nó da árvore. O passo

seguinte, no processamento cognitivo, conduz o agente a uma dinâmica condicional:
 Se o conteúdo da variável avaliacao for inferior a 1 (if avaliacao < 1:), então, imprime
na consola do Python o conteúdo do atributo nome (o nome da unidade fabril)
seguido da mensagem não atingiu o objectivo de produtividade (print(self.nome,
'não atingiu o objectivo de produtividade'));

 Se o conteúdo da variável avaliacao for igual a 1 (elif avaliacao == 1:), então, imprime
10
na consola do Python o conteúdo do atributo nome (o nome da unidade fabril)
seguido da mensagem atingiu o objectivo de produtividade (print(self.nome, 'atingiu
o objectivo de produtividade'));
 Se o conteúdo da variável avaliacao for superior a 1 (else:), então, imprime na
consola do Python o conteúdo do atributo nome (o nome da unidade fabril) seguido
da mensagem superou o objectivo de produtividade (print(self.nome, 'superou o
objectivo de produtividade')).
A estrutura condicional tem uma correspondência com os ramos da árvore de decisão.

O agente necessita de avaliar em que ramo se encontra para saber que acções deverá
implementar. Os ramos da condicional são expressos em código, em termos de uma estrutura
de alternativas, se houvessem apenas duas alternativas teríamos a seguinte estrutura elementar
geral:
 Se (“if”) a condição se verifica então realiza as operações X;

 De outro modo (“else”) realiza as operações Y.
A estrutura condicional SE (if) – DE OUTRO MODO (else), é tal que o agente realiza um
determinado conjunto de acções se uma dada condição se verifica, de outro modo (isto é, nos
restantes casos em que a condição não se verifica) realiza outro conjunto de acções.
As computações realizadas pelo agente dependem da condição se verificar ou não. Para

esta estrutura mais elementar teríamos uma árvore com dois ramos.
No caso acima, a estrutura é mais complexa, pois existem três ramos, o primeiro está
marcado com a expressão if (SE), o segundo ramo (segunda alternativa) está marcado com a
expressão elif que significa else if (DE OUTRO MODO, SE). Deste modo, quando a primeira
condição não se verifica, se a segunda se verifica, então, o agente realiza as acções
correspondentes à segunda condição.
O terceiro ramo é marcado com else, esgotando todas as alternativas, no sentido em

que ou a divisão é inferior a 1, ou igual a 1 ou superior a 1, logo, esgotadas as primeiras duas
alternativas o que resta (else) é o caso em que o resultado é superior a 1 (caso em que a unidade
fabril supera o seu objectivo de produtividade).
A última linha do método corresponde à instrução return avaliacao, esta instrução

permite trabalhar o método como uma função que, para além de executar as instruções
analisadas acima, devolve o valor calculado da avaliação, valor que é registado na variável local

avaliacao, o que permite incorporar o método no cálculo posterior da avaliação final da unidade
11
fabril.
O método seguinte avaliaFormacao envolve também uma comparação entre um

resultado obtido e um objectivo, contudo o resultado obtido é calculado primeiro em termos de
um rácio, ou seja, estamos a trabalhar um exemplo em que a empresa definiu, para cada
unidade fabril, um objectivo em termos de horas de formação por operário3 (assim, as horas de
formação que estão a ser consideradas na avaliação, são as horas de formação dos operários).
O método seguinte inclui o cálculo do rácio horas de formação por operário e a avaliação
face ao objectivo.
def avaliaFormacao(self,objectivo):
racio = self.formacao / self.operarios
avaliacao = racio / objectivo
if avaliacao < 1:
print(self.nome, 'horas de formação por trabalhador inferiores ao objectivo')
print(self.nome, 'horas de formação por trabalhador iguais ao objectivo')
else:
print(self.nome, 'horas de formação por trabalhador superiores ao objectivo')
return avaliacao
Deixamos, como exercício, a tarefa de analisar o método, incluindo a construção da

árvore de decisão e a correspondência entre a árvore e o programa escrito em linguagem
Python. O método seguinte converte mais um critério de avaliação implementado pela empresa
numa estrutura algorítmica, neste caso, a empresa define um objectivo em termos de número
de acidentes por operário, o que significa que é necessário calcular o rácio do número de
acidentes pelo número de operários e dividir esse rácio pelo valor definido pela empresa como
objectivo.
def avaliaAcidentes(self,objectivo):
racio = self.acidentes / self.operarios
avaliacao = racio / objectivo
if avaliacao < 1:
print(self.nome, 'superou o objectivo de acidentes por operário')
print(self.nome, 'atingiu o objectivo de acidentes por operário')
else:
print(self.nome, 'não atingiu o objectivo de acidentes por operário')
return 1 / avaliacao
3
Outros objectivos de formação podem ser trabalhados, implicando a alteração ou mesmo
introdução de novos métodos para as instâncias da classe UnidadeFabril.

12
Embora com uma base análoga aos restantes métodos analisados até ao momento,
existem algumas diferenças neste método, no que se refere à relação entre o rácio e o objectivo,
pois quanto menor o rácio melhor a performance, ao contrário do que acontecia no caso do
método anterior.
Assim, se o valor da avaliação for inferior a 1, isso significa que o rácio de acidentes por
operário é inferior ao objectivo definido pela empresa o que implica uma boa performance, logo,
considera-se que a unidade fabril superou o objectivo em termos de número de acidentes por
operário. Se o valor da avaliação for igual a 1, então, a unidade fabril atingiu o objectivo.
Contudo, se o valor da avaliação for superior a 1, isso significa que a unidade fabril tem mais
acidentes por operário do que o objectivo definido pela empresa, o que significa uma má
performance em termos de acidentes, logo, considera-se, neste caso, que a empresa não atingiu
o objectivo em termos de acidentes por operário.
Dado que a avaliação segue no sentido inverso dos restantes elementos sob avaliação,
ou seja, quanto maior o valor pior é a performance da unidade fabril, a instrução “return”
devolve o valor inverso da avaliação, será esse o valor a ser utilizado na ponderação final da
avaliação da unidade fabril.
O último método define o processo final de avaliação da unidade fabril:
def avaliaUnidade(self,objectivos,pesos):
prod = self.avaliaProdutividade(objectivos[0])
form = self.avaliaFormacao(objectivos[1])
acid = self.avaliaAcidentes(objectivos[2])
avaliacao = pesos[0] * prod + pesos[1] * form + pesos[2] * acid
print('Valor Final:', avaliacao,'\n')
O método avaliaUnidade recebe como inputs uma lista de objectivos e uma lista de
pesos associados a cada dimensão sob avaliação. O método executa a avaliação da
produtividade e guarda o valor devolvido por esta avaliação numa variável local “prod”, o
mesmo é feito para a avaliação da formação (guardada na variável “form”) e dos acidentes
(guardada na variável “acid”), a avaliação final resulta de uma média ponderada de cada uma
das avaliações em que cada avaliação é multiplicada pelo peso respectivo, o método imprime,
então, o resultado final da avaliação da unidade e muda de linha deixando um espaço (comando
newline: '\n').

O método trabalha com um tipo de objecto primitivo em Python designado por lista.
13
Uma lista é representada, na linguagem Python, como uma sequência de valores separada por
vírgulas e delimitada por parêntesis rectos. Assim, por exemplo, uma lista dos nomes João,
Maria e José, seria representada em Python como [João,Maria,José]. Se atribuirmos esta lista a
uma variável chamada “amigos”, podemos escrever:
amigos = [João,Maria,José]
Para acedermos a um elemento particular da lista basta escrever “amigos[j]”, em que j

é o índice correspondente ao elemento na posição j da lista, assim, por exemplo amigos[0]
corresponde a João, amigos[1] a Maria e amigos[2] a José. A contagem de elementos começa
em 0 (origem) e segue a sequência, tal que o terceiro elemento ocupa a posição 2, o segundo a
posição 1 e o primeiro a posição 0.
No caso do método avaliaUnidade, existem duas listas que são fornecidas ao agente
artificial, uma lista de objectivos, em termos de valores definidos como objectivos a serem
cumpridos pelas unidades fabris, e uma lista de pesos, que corresponde ao valor atribuído pela
empresa a cada dimensão de avaliação. A lista de objectivos é utilizada na fase de avaliação de
cada dimensão enquanto que a lista de pesos é utilizada na avaliação final da unidade fabril.
Utilizando estes elementos, cada agente tem a estrutura cognitiva necessária para
avaliar cada unidade, assim que tenha os valores correspondentes. Considere-se, então, que a
empresa definiu os seguintes objectivos para as unidades fabris:
 10 peças/hora produzidas;
 20 horas de formação por operário;
 No máximo 5 acidentes por cada 100 operários (rácio de 0.05).
Então, a lista de objectivos é definida em Python como objectivos = [10,20,0.05].

Assumindo que a empresa definiu os pesos seguintes para cada dimensão sob avaliação:
 0.35: para a dimensão de produtividade;

 0.35: para a dimensão de formação;
 0.3: para dimensão de acidentes.
A lista de pesos é, então, dada por pesos = [0.35,0.35,0.3], o código final em linguagem
Python é apresentado no website http://pythonfiddle.com/avaliacao-de-desempenho/.
Executando o código, verifica-se que as unidades 1, 3, 7 e 8 apresentam um resultado final
superior a 1, ou seja, a classificação média é positiva. Contudo, nenhuma destas quatro unidades

cumpriu os objectivos de formação e de acidentes por operário, o que ocorre também com as
14
restantes unidades fabris.
Assim, a empresa deverá rever as causas do não cumprimento destes objectivos, e,

nomeadamente, no que se refere aos acidentes de trabalho, procurar implementar, em todas
as unidades fabris, medidas no sentido da diminuição do número de acidentes por operário.
Importa também reforçar o sistema de comunicação interno dos objectivos e sistema de
avaliação de desempenho das unidades fabris.
2. O Python e a Gestão de Recursos Humanos
No exemplo fornecido na secção anterior, vimos um caso particular de implementação

da linguagem Python a um problema de avaliação de desempenho. O exemplo visou ilustrar as
diferenças entre uma análise de dados aplicada a uma base de dados tradicional, e uma análise
estatística que incorpora um sistema de análise de gestão, logo, uma ferramenta feita à medida
do problema de gestão. A programação orientada a objectos permite realizar esta transição de
uma análise de dados tradicional, para uma análise de dados suportada por sistemas inteligentes
artificiais que exibem respostas adaptativas em função do problema sob análise e, logo,
construir soluções específicas para a Gestão de Recursos Humanos (GRH), ou para a Gestão em
geral.
A GRH é, deste modo, suportada por métodos de trabalho dos dados dirigidos a uma
resposta feita à medida. Desde que as condições do problema se mantenham inalteradas, as
mesmas classes e os mesmos métodos podem ser implementados, trata-se de um problema de
generalidade algorítmica.
Os algoritmos dirigidos à gestão exigem o estabelecimento de uma ponte directa entre

a estatística e a gestão, no sentido de uma estruturação do problema na perspectiva da gestão
e uma estruturação dos algoritmos em função do problema, de modo a que a máquina possa
melhor adaptar-se às necessidades do gestor.
Se outros critérios de avaliação tivessem sido definidos pela empresa, o programa a ser
escrito teria sido distinto. Assim, existe a possibilidade de construir “fatos à medida” do gestor,
em que o sistema artificial analisa os dados e sintetiza a informação que é mais útil ao gestor na
sua actividade. O “discurso” da máquina pode inclusive ser adaptado ao discurso do gestor,

estabelecendo, o programa informático, a ponte entre o nível de discurso computacional
15
estatístico e o nível de discurso de gestão.
Por seu turno, é possível também desenvolver sistemas multiproblema, isto é, sistemas
que são capazes de resolver diferentes problemas de gestão e, sem modificação de código,
suportar o gestor no seu trabalho. O sistema artificial a ser desenvolvido depende do tipo de
problema de gestão a ser trabalhado.
No caso de GRH, é possível desenvolver quer sistemas integrados de suporte à gestão,

quer aplicativos dirigidos ao trabalho do gestor. A diferença nas tecnologias actuais, e no Python
em particular, reside no facto de que podemos torná-las móveis, isto é: podemos desenvolver
ferramentas que podem acompanhar o gestor para qualquer lugar, utilizando os seus
dispositivos móveis. O modelo de computação distribuída, em particular o aumento da
capacidade e da gama de aplicações para dispositivos móveis, abre a oportunidade de
desenvolvimento de ferramentas de analytics inteligentes que acompanham o gestor para
qualquer lugar, apoiando-o na sua actividade.
Em termos de programação, o exemplo trabalhado no presente artigo, apesar de ser

elementar ao nível da programação, permite ilustrar um ponto central, a saber: cabe ao decisor
humano indicar à máquina o que deve valorizar e como, cabe à máquina realizar a dimensão
algorítmica do processo de tomada de decisão humana, suportando esse processo em termos
de velocidade de processamento e trabalho dos dados.
Assim, tudo aquilo que, na Gestão Empresarial (e das organizações em geral), pode ser
convertido em algoritmo poderá ser resolvido por uma máquina, por seu turno, tudo aquilo que
na gestão possa ser resolvido por uma máquina, mais eficientemente e eficazmente do que por
um humano, tenderá a ser resolvido por uma máquina (devido à própria acção humana de
desenhar tecnologias que substituam a componente humana nessa tarefa). Note-se que a
máquina não substitui, neste caso, o gestor, mas, sim, apoia-o no processo de tomada de
decisão, realizando parte da tarefa do gestor, tornando a tarefa mais fácil, logo, mais rápida.
Importa relevar, contudo, que a máquina poderá nem sempre substituir com mais
eficiência o ser humano numa dada actividade, principalmente se a actividade a ser realizada
pela máquina for algoritmicamente complexa (conceito de complexidade algorítmica), neste
caso, a capacidade humana para capturar totalidades poderá conduzir a uma solução mais
eficiente dado que pode ir para além do algoritmo, não sendo confinada a segui-lo.

Se alguma vez uma máquina for capaz de intuir soluções de modo não-algorítmico,
16
então, poderá também ultrapassar a barreira dos limites à computação, trata-se, contudo, de
uma estrutura tecnológica distinta da que temos presentemente, embora, em termos de Ciência
da Computação, não possamos rejeitar esta possibilidade, isto é, não podemos afirmar ser
impossível construir tecnologia não-algorítmica (ou com níveis de actividade não-algorítmicos).
É conhecida a capacidade da computação quântica em quebrar barreiras de

complexidade que a computação clássica não é capaz de quebrar, por seu turno, a biotecnologia,
incluindo a biónica, poderá vir a construir híbridos tecno-orgânicos que, caso se tornem
sustentáveis, isto é, caso a componente “tecno” seja aceite/integrada e compatibilizada com o
processamento orgânico, poderão possivelmente ultrapassar limites algorítmicos.
Regressando ao problema anteriormente analisado, e tendo em atenção as

funcionalidades que se pretende para a ferramenta, é possível construir diferentes programas
que respondam eficazmente às funcionalidades requeridas, em particular, diferentes
paradigmas de programação poderiam ser aplicados para a resolução do mesmo problema.
Em termos de eficácia, a programação orientada a objectos apresenta duas vantagens.

A primeira vantagem reside no facto de obrigar o programador a estruturar o problema de
gestão, em termos de unidades computacionais e tarefas elementares incorporadas nos
métodos decorrentes de escolhas estratégicas da própria empresa e que condicionam a
estrutura do próprio algoritmo, de tal modo que cada método corresponde a uma estrutura
algorítmica coerente de resposta ao problema da empresa. Assim, um problema pode ser
dividido em partes coerentes e abordado em termos de uma dinâmica entre inputs fornecidos
pelo utilizador e computações realizadas pelas instâncias de uma dada classe que trabalham
esses mesmos inputs e/ou os valores dos atributos para dar uma resposta adequada ao
problema, à luz dos critérios e processos definidos pela empresa, o que nos conduz à segunda
vantagem, a saber: a correspondência com a IA.
A segunda vantagem da programação orientada a objectos reside no facto de trabalhar

com o computador enquanto ambiente tecnológico que permite simular uma matriz artificial
onde residem entidades computacionais: os objectos, instâncias de uma dada classe. Os
objectos, conforme vimos na secção anterior, podem ser abordados enquanto agentes
inteligentes, deste modo, o programa de computador não tem uma forma de um algoritmo
único mas, sim, de algoritmos incorporados num modelo de cognição do agente. O agente é
capaz de trabalhar dados exteriores (fornecidos pelo utilizador) e os conteúdos da sua memória

de trabalho permanente (os registos dos valores nos atributos de instância), assim como é
17
possível introduzir memória de trabalho temporária (as variáveis locais).
Deste modo, o programa é abordado a partir de uma dinâmica cognitiva, o que suporta
um trabalho mais eficaz no sentido em que uma dinâmica cognitiva humana algoritmizável
pode, por paralelismo, ser programada na máquina.
3. Exercícios de Gestão de Recursos Humanos com Python

1. Uma empresa comercial decidiu atribuir prémios de produtividade aos vendedores
cujas vendas se situem acima da média, esses prémios são proporcionais ao valor das
vendas realizadas pelo vendedor. Com base nesta informação, responda às seguintes
questões:
a. Defina a classe apropriada para o caso (nome da classe e atributos).
b. Defina um método de instância que expresse, em código Python, o sistema de
prémios definido pela empresa.
c. Construa a árvore de decisão para o método de instância da alínea anterior.
d. Implemente o código para a base de dados de vendedores representada na
tabela abaixo.
Código Vendedor Vendas (milhares de

Euros)
V01 Ambrósio Severino Pais 500
V02 Ana Leopolda Leopardo 650
V03 Ana Reis Corrais 320
V04 Blimunda Refrescada Sais 450
V05 Dário Vidigais do Finigal 350
V06 Eduarda Susana Cimeira 300
V07 Helena Correia Zifulmática 360
V08 João Sumido Santeiro 470
V09 Jorge Santos Reis Tomar 420
V10 Jorge Pais dos Reis 430
2. Modifique o código da questão anterior de tal modo que os prémios sejam

proporcionais às vendas até um valor máximo e construa a árvore de decisão
correspondente ao código modificado.

18
3. Uma empresa definiu um sistema de controlo de acidentes de trabalho que emite um
aviso de excesso de acidentes se o número anual de acidentes ultrapassar um limite
definido como número máximo aceitável pela empresa. Com base nesta informação,
responda às seguintes questões:
a. Defina a classe apropriada para o caso (nome da classe e atributos).
b. Defina um método de instância que expresse, em código Python, o sistema de
controlo definido pela empresa, para os seguintes dois casos:
i. A empresa apenas pretende que o sistema forneça o alerta sem
apresentar qual o número de acidentes.
ii. A empresa pretende que o número de acidentes seja fornecido pelo
sistema em qualquer circunstância.
c. Expresse o método de instância para o código das alíneas b.i. e b.ii. em árvore
de decisão, e analise as diferenças em termos de Gestão de Recursos Humanos.
4. Modifique a árvore da questão anterior para o caso em que a empresa pretende que o
sinal de alerta tenha o seguinte código de cores:
a. Alerta Amarelo: se o número de acidentes com nível de gravidade elevada se
situar entre 25% (inclusive) e 50% (exclusive) do número total de acidentes;
b. Alerta Laranja: se o número de acidentes com nível de gravidade elevada se
situar entre 50% (inclusive) e 75% (exclusive) do número total de acidentes;
c. Alerta Vermelho: se o número de acidentes com nível de gravidade elevada for
superior ou igual a 75% do número total de acidentes.
5. Construa o código para a árvore da questão anterior.
6. A tabela seguinte contém dados de produtividade média para dez sucursais de uma
empresa, no ano de 2014, construa um programa em Python que classifique as sucursais
em função do objectivo de produtividade média (comum às 10 sucursais), tal que se
houverem sucursais que tenham atingido ou superado o objectivo de produtividade,
aquela que tiver a produtividade mais elevada recebe um prémio de produtividade e
execute o código para as 10 sucursais. Considere, na resolução, um objectivo de
produtividade média de 225 Euros/hora.

Sucursais Produtividade
19
Média
(Euros/h)
Sucursal 1 230
Sucursal 2 150
Sucursal 3 260
Sucursal 4 220
Sucursal 5 120
Sucursal 6 110
Sucursal 7 225
Sucursal 8 250
Sucursal 9 270
Sucursal 10 220

Resolução dos Exercícios4
20
Exercício 1.
Alínea a.
Dado que se pretende avaliar os vendedores, o nome da classe é definido como
“Vendedores”, o atributo sob avaliação é o atributo “vendas”, para além desse atributo,
introduzimos também os atributos código do vendedor e nome, de onde resulta a seguinte
definição de classe:
Alínea b.
Conforme definido pela empresa, temos uma estrutura condicional, assim:
 Se um dado vendedor tiver vendas acima da média, então este recebe um

prémio que é proporcional às vendas que realizou (proporção é um elemento
a ser definido pela empresa).
Temos, assim, o seguinte código em Python, com a definição da classe (alínea anterior)
e do método de instância:
O método recebe como inputs a média das vendas realizadas por cada vendedor e a
proporção definida pela empresa e avalia a condicional tal que: se as vendas de um vendedor
forem superiores à média, então, atribui um prémio decorrente da multiplicação da proporção
4
Na resolução dos exercícios utilizamos, por uma questão de efeito comparativo, a versão 2 do
Python.

definida pela empresa pelas vendas realizadas por esse vendedor e imprime a informação de
21
que o vendedor deverá receber o prémio.
Alínea c.
Vendas > Média 
Calcula prémio
Comunica: codigo
nome recebe
prémio de <valor
do prémio> euros
Alínea d.
A resolução encontra-se disponível no website:
https://sites.google.com/site/mqgestao/programas-em-python/caso-vendedores
Esta resolução pode ser executada online no website:
http://pythonfiddle.com/vendedores
Exercício 2.
Temos, agora, de definir uma segunda condicional, tal que, se o prémio exceder o
prémio máximo definido pela empresa (novo input do método), então, atribui-se o prémio
máximo ao vendedor, caso contrário o vendedor recebe o prémio proporcional às suas vendas.

22
.
Vendas > Média 
Calcula prémio
Valor do prémio > Valor do prémio ≤

Prémio Máximo Prémio Máximo
Comunica: codigo Comunica: codigo

nome recebe prémio nome recebe prémio
de <valor do prémio de <valor do prémio>
máximo> euros euros

Exercício 3.
23
Alínea a.
Dado que se pretende avaliar o número total anual de acidentes de trabalho, o nome
da classe é definido como “Acidentes”, definida com um único atributo o número de
acidentes, assim, escrevemos:
Alínea b.i.
Face ao critério definido pela empresa, o seguinte código em Python, com a definição
da classe (alínea anterior) e do método de instância, fornece uma solução para o problema:
Alínea b.ii.
Dado que a empresa pretende que o número de acidentes seja fornecido pelo sistema
em qualquer circustância o código tem de ser modificado para:
Alínea c.
Para o caso da alínea b.ii. a árvore é dada por:

24
.
Número de

Acidentes > Limite
Comunica: Alerta:
Excesso de
Acidentes de
Trabalho!
Para a alínea b.ii. a árvore é dada por:
Comunica: Número
de acidentes de
trabalho: <número>
Número de

Acidentes > Limite
Comunica: Alerta:
Excesso de
Acidentes de
Trabalho!
No primeiro caso, a empresa não está a considerar como relevante um número de

acidentes abaixo do limite. No segundo caso, a empresa considera como relevante a informação
acerca do número de acidentes quer esse número exceda o limite ou não. Assim, o segundo caso
reflecte uma opção estratégica por um maior controlo do número de acidentes.

Exercício 4.
25
Comunica: Número
de acidentes de
trabalho:
<número>
Número de

Acidentes > Limite
Comunica: Alerta:
Excesso de
Acidentes de
Trabalho!
Calcula
percentagem de
acidentes com
gravidade elevada
25% ≤
50 ≤ Percentagem < Percentagem ≥
Percentagem <
75% 75%
50%
Comunica: "Alerta Comunica: "Alerta Comunica: "Alerta

Amarelo!" Laranja! Vermelho!"
Exercício 5.

Exercício 6.
26
O programa, em Python é dado pelo código seguinte:
O resultado final do programa é, para estes dados, a impressão da informação na

consola do Python:
Sucursal 9 recebe o prémio de produtividade

Bibliografia
27
 Borny, T. 2015, Interview: Neil Jacobstein Discusses Future of Jobs, Universal
Basic Income and the Ethical Dangers of AI,
http://singularityhub.com/2015/03/23/future-of-work-interview-with-neil-
jacobstein/.
 Cassel, L. and Gauld, A. 2015, Python® Projects, Wrox.
 Downey, Allen B. 2012, Think Python, O'Reilly Media. Introdução ao Python
disponível no formato Wiki: http://en.wikibooks.org/wiki/Think_Python.
 Goertzel, B. 2014, Ten Years to the Singularity, If We Really Really Try…and
other Essays on AGI and its Implications, humanity+ Press.
 Gonçalves, 2014, Singularidade Tecnológica e a Terceira Revolução Industrial,
https://www.academia.edu/9763186/Singularidade_Tecnol%C3%B3gica_e_a_
Terceira_Revolu%C3%A7%C3%A3o_Industrial.

Python Aplicado A Problemas de Gestao de

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Python Aplicado A Problemas de Gestao de

Загружено:

Авторское право:

Доступные форматы

Python Aplicado a Problemas de Gestão de Recursos Humanos

Carlos Pedro Gonçalves

Instituto Superior de Ciências Sociais e Políticas (ISCSP)

Carlos Pedro Gonçalves

1.1. Caso de Avaliação de Desempenho ................................................................... 4

2. O Python e a Gestão de Recursos Humanos .............................................................. 14

3. Exercícios de Gestão de Recursos Humanos com Python .......................................... 17

Resolução dos Exercícios ................................................................................................ 20

Alínea b.i. ................................................................................................................ 23

Alínea b.ii. ............................................................................................................... 23

Carlos Pedro Gonçalves

A linguagem de programação Python foi desenvolvida na década de 1980 pelo

 Desenvolver uma linguagem fácil e intuitiva tão poderosa quanto as alternativas

Embora o Python suporte diferentes paradigmas de programação, a programação

Um objecto corresponde a uma entidade de software, algo semelhante a um agente

Carlos Pedro Gonçalves

Dependendo do tipo de objecto, estamos perante agentes inteligentes de diferentes

No contexto da ciência da computação, um objecto é uma estrutura algoritmicamente

Considerando o contexto da análise de dados aplicada à Gestão, às variáveis estatísticas

1.1. Caso de Avaliação de Desempenho

Como exemplo, considere-se um caso de uma empresa que se encontra a avaliar a

 Número total de trabalhadores;

Carlos Pedro Gonçalves

A mesma convenção assumida para os métodos, seguiremos para os atributos.

Em Python define-se a classe do seguinte modo:

A primeira linha de código define o nome da classe, as linhas seguintes definem os

 local: localização da unidade fabril;

Carlos Pedro Gonçalves

 acidentes: número de acidentes de trabalho;

Somente com a definição geral da classe podemos construir o equivalente à base de

Carlos Pedro Gonçalves

 Atribui à “Unidade1” uma instância da classe UnidadeFabril com os seguintes

Uma interpretação análoga pode ser realizada para as restantes instâncias. Na

Esta natureza computacional dos objectos distingue-se da natureza da tabela. A tabela

Assim, considerando cada objecto da classe UnidadeFabril como uma entidade

Carlos Pedro Gonçalves

a entidade computacional executa a partir da sua memória de trabalho e de elementos

Tornando explícita a conexão com a IA, passamos a referir-nos, na descrição dos

O primeiro método avaliaProdutividade visa avaliar o nível de produtividade face a um

O processamento cognitivo pode ser expresso em termos de uma árvore de decisão,

A acção do agente artificial pode ser analisada seguindo a árvore. No primeiro nó da

Carlos Pedro Gonçalves

Finalmente, quando o rácio é superior a 1, o agente comunica que o objectivo de

Em linguagem Python, o método é escrito do seguinte modo:

A primeira linha de código define o nome do método (def avaliaProdutividade)

No primeiro passo, o agente recupera o conteúdo da sua memória de trabalho referente

Após ter o conteúdo da variável avaliacao, estamos no primeiro nó da árvore. O passo

Carlos Pedro Gonçalves

A estrutura condicional tem uma correspondência com os ramos da árvore de decisão.

 Se (“if”) a condição se verifica então realiza as operações X;

As computações realizadas pelo agente dependem da condição se verificar ou não. Para

O terceiro ramo é marcado com else, esgotando todas as alternativas, no sentido em

A última linha do método corresponde à instrução return avaliacao, esta instrução

Carlos Pedro Gonçalves

O método seguinte avaliaFormacao envolve também uma comparação entre um

Deixamos, como exercício, a tarefa de analisar o método, incluindo a construção da

Carlos Pedro Gonçalves

O último método define o processo final de avaliação da unidade fabril:

Carlos Pedro Gonçalves

Para acedermos a um elemento particular da lista basta escrever “amigos[j]”, em que j

Então, a lista de objectivos é definida em Python como objectivos = [10,20,0.05].

 0.35: para a dimensão de produtividade;

Carlos Pedro Gonçalves