 |
|
|
 Planilha de Dimensionamento de Tubulações
Hidráulicas Água Fria e Água Quente CompletaNossa planilha automática de dimensionamento de tubulações de água fria e quente é uma ferramenta desenvolvida para auxiliar engenheiros e projetistas no cálculo rápido e preciso das redes hidráulicas de edificaçoes. Por meio da inserçao de dados como vazao, diâmetro da tubulaçao, comprimento da rede, material do tubo e coeficientes hidráulicos, a planilha realiza automaticamente os cálculos necessários para verificar velocidade da água, perda de carga e dimensionamento adequado das tubulaçoes. |
||
Você está aqui: Cards de Python |
||
|
||
 Link para compartilhar na Internet ou com seus amigos: |
||
Ruby ::: Dicas & Truques ::: Programação Orientada a Objetos |
Como acessar variáveis de instâncias para leitura em Ruby sem a necessidade de métodos acessores usando a função attr_readerQuantidade de visualizações: 7379 vezes |
|
Por padrão, variáveis de instância em Ruby só podem ser acessadas usando métodos acessores, ou seja, uma variável de instância @nome deve ser lida usando um método obter_nome. É possível dispensar o uso de métodos acessores empregando o método attr_reader nos nomes das variáveis que poderão ser acessadas, para leitura, é claro. Veja um exemplo:
# Definição da classe Cliente
class Cliente
attr_reader :nome, :idade
def initialize(nome, idade)
@nome = nome
@idade = idade
end
def obter_nome
@nome
end
def obter_idade
@idade
end
end
# Cria uma instância da classe Cliente e inicializa as
# variáveis de instância @nome e @idade
cliente = Cliente.new("Osmar J. Silva", 35)
# Acessa as variáveis de instância sem a necessidade de
# métodos acessórios
puts cliente.nome
puts cliente.idade
Sem o uso do método attr_reader, a linha: puts cliente.nome causaria o seguinte erro: teste.rb:25: undefined method `nome' for #<Cliente:0x27f540c @nome="Osmar J. S ilva", @idade=35> (NoMethodError) |
HTML5 ::: Canvas Element ::: Linhas |
Computação gráfica usando HTML 5 - Como usar o método lineTo() do objeto Canvas do HTML5 para desenhar retasQuantidade de visualizações: 3526 vezes |
|
O método lineTo() do objeto Canvas do HTML5 nos permite desenhar linhas retas entre um ponto x e um ponto y. Para isso, usamos o método moveTo() para mover a caneta (ou pena) de desenho para um coordenada x, y e a partir deste ponto nós especificamos as coordenadas x, y para a outra extremidade da linha. O trecho de código a seguir desenha uma linha saindo das coordenadas x = 20, y = 20 e chegando até x = 300, y = 150. Veja: contexto.moveTo(20, 20); // move a caneta para x, y contexto.lineTo(300, 150); // coordenadas x, y E aqui estão os códigos HTML e JavaScript para o exemplo completo:
<!doctype html>
<html>
<head>
<title>O objeto Canvas do HTML5</title>
</head>
<body>
<Canvas id="canvas1" width="500" height="350"></Canvas>
<script type="text/javascript">
// obtemos uma referência ao elemento Canvas
var canvas = document.getElementById("canvas1");
// obtemos o contexto de desenho
var contexto = canvas.getContext("2d");
contexto.beginPath(); // inicia ou reseta o caminho anterior
contexto.moveTo(20, 20); // move a caneta para x, y
contexto.lineTo(300, 150); // coordenadas x, y
contexto.stroke(); // finaliza o desenho
</script>
</body>
</html>
Ao abrir esta página HTML nós teremos o seguinte resultado:  |
C++ ::: Fundamentos da Linguagem ::: Tipos de Dados |
Como usar o tipo de dados long ou long int da linguagem C++Quantidade de visualizações: 23117 vezes |
O tipo de dados long (também chamado de long int) da linguagem C++ é uma variação do tipo int e geralmente possui a mesma capacidade de armazenamento deste. Nós o usamos quando queremos representar números inteiros, ou seja, sem partes fracionárias, assim como int. É importante verificar se o seu compilador trata int e long da mesma forma. Veja um trecho de código demonstrando o uso deste tipo (note que estes estudos foram feitos no Windows XP - 32 bits - usando Dev-C++):
#include <iostream>
using namespace std;
int main(int argc, char *argv[]){
// declara uma variável do tipo long
long quant = 590;
cout << "Quantidade: " << quant << "\n\n";
system("PAUSE"); // pausa o programa
return EXIT_SUCCESS;
}
Veja que a maioria dos compiladores C++ não faz distinção entre os tipos long e long int. A capacidade de armazenamento do tipo long depende da arquitetura na qual o programa está sendo executado. Uma forma muito comum de descobrir esta capacidade é usar os símbolos LONG_MIN e LONG_MAX, definidos no header climits (limits.h). Veja:
#include <iostream>
using namespace std;
int main(int argc, char *argv[]){
cout << "Valor mínimo: " << LONG_MIN << "\n";
cout << "Valor máximo: " << LONG_MAX << "\n\n";
system("PAUSE"); // pausa o programa
return EXIT_SUCCESS;
}
Ao executar este programa você terá um resultado parecido com: Valor mínimo: -2147483648 Valor máximo: 2147483647 Veja que o tipo long aceita valores positivos e negativos. Tudo que você tem a fazer é tomar todo o cuidado para que os valores atribuidos a variáveis deste tipo não ultrapassem a faixa permitida. Veja um trecho de código que provoca o que chamamos de transbordamento (overflow):
#include <iostream>
using namespace std;
int main(int argc, char *argv[]){
long soma = LONG_MAX + 2;
cout << "Resultado: " << soma << "\n";
system("PAUSE"); // pausa o programa
return EXIT_SUCCESS;
}
Este programa exibirá o seguinte resultado: Resultado: -2147483647 Note que este não é o resultado esperado, visto que LONG_MAX + 2 deveria retornar: 2147483647 + 2 = 2147483649 Porém, como o valor máximo que pode ser armazenado em um long é 2147483647, o procedimento adotado pelo compilador foi tornar o número negativo e subtrair 1. É claro que, se você testar este código em arquiteturas diferentes o resultado poderá ser diferente do exemplificado aqui. Em termos de bytes, é comum o tipo long ser armazenado em 4 bytes, o que resulta em 32 bits (um byte é formado por 8 bits, lembra?). Veja um trecho de código que mostra como usar o operador sizeof() para determinar a quantidade de bytes necessários para armazenar um variável do tipo long:
#include <iostream>
using namespace std;
int main(int argc, char *argv[]){
cout << "Tamanho de um long: " << sizeof(long)
<< " bytes\n\n";
system("PAUSE"); // pausa o programa
return EXIT_SUCCESS;
}
O resultado da execução deste código será algo como: Tamanho de um long: 4 bytes |
Python ::: Dicas & Truques ::: Strings e Caracteres |
Como pesquisar substrings em strings usando a função index() da linguagem PythonQuantidade de visualizações: 8955 vezes |
Este exemplo mostra como pesquisar uma substring em uma string usando o método index() do Python. A assinatura desta função é:index(substring[, start[, end]]) onde substring é a substring a ser pesquisada e start e end são argumentos opcionais que definem os índices de início e fim da pesquisa. Se a substring não for encontrada, uma exceção do tipo ValueError é levantada. Se for encontrada, o índice do primeiro caractere é retornado. Veja o código Python completo para a dica:
def main():
frase = "Gosto de Python e JavaScript"
try:
indice = frase.index("Python")
except ValueError:
print("A palavra não foi encontrada")
else:
print("A palavra foi encontrada no índice", indice)
if __name__== "__main__":
main()
Ao executarmos este código Python nós teremos o seguinte resultado: A palavra foi encontrada no índice 9. |
C# ::: Dicas & Truques ::: Arquivos e Diretórios |
Como usar a classe FileSystemWatcher em seus programas C#Quantidade de visualizações: 9215 vezes |
|
Podemos usar objetos da classe FileSystemWatcher quando queremos monitorar mudanças em um determinado diretório do sistema. Estas alterações podem ser observadas em arquivos e subdiretórios do diretório especificado. Usando objetos desta classe nós podemos monitorar modificações em arquivos no computador local, em um drive na rede ou em um computador remoto. Veja a posição desta classe na hierarquia de classes da plataforma .NET:
System.Object
System.MarshalByRefObject
System.ComponentModel.Component
System.IO.FileSystemWatcher
Para adicionar um componente FileSystemWatcher em sua aplicação C# basta localizá-lo na seção Components da Toolbox. Em seguida clique no mesmo e arraste-o para o formulário. Para definir o diretório a ser monitorado, clique no componente, acesse suas propriedades e defina o caminho do diretório na propriedade Path. Um exemplo de diretório poderia ser "C:\arquivo de codigos". Neste exemplo veremos como detectar alterações nos arquivos e sub-diretórios. Desta forma, vá nos eventos do componente FileSystemWatcher e insira o código abaixo para o evento Changed:
private void fileSystemWatcher1_Changed(object sender,
FileSystemEventArgs e){
// vamos verificar o que foi modificado neste diretório
textBox1.AppendText("Arquivo: " + e.FullPath + " sofreu alterações: " +
e.ChangeType + Environment.NewLine);
}
Execute a aplicação e experimente criar um arquivo txt no diretório "C:\arquivo de códigos" e modificar seu conteúdo várias vezes. Volte à aplicação e a caixa de texto terá um conteúdo parecido com: Arquivo: C:\arquivo de codigos\dados2.txt sofreu alterações: Changed Arquivo: C:\arquivo de codigos\dados2.txt sofreu alterações: Changed |
Desafios, Exercícios e Algoritmos Resolvidos de C# |
Veja mais Dicas e truques de C# |
Dicas e truques de outras linguagens |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |
