solução de problemas (*problem solving*)

The process of formulating a problem, finding a solution, and expressing it.

linguagem de alto nível (*high-level language*)

A programming language like Python that is designed to be easy for humans to read and write.

linguagem de baixo nível (*low-level language*)

A programming language that is designed to be easy for a computer to run; also called “machine language” or “assembly language”.

portabilidade (*portability*)

A property of a program that can run on more than one kind of computer.

interpretador (*interpreter*)

A program that reads another program and executes it

*prompt* (“sinal de pronto”)

Characters displayed by the interpreter to indicate that it is ready to take input from the user.

programação funcional (*program*)

A set of instructions that specifies a computation.

``print``, instrução (``print`` *statement*)

An instruction that causes the Python interpreter to display a value on the screen.

operador (*operator*)

A special symbol that represents a simple computation like addition, multiplication, or string concatenation.

valor (*value*)

One of the basic units of data, like a number or string, that a program manipulates.

tipo (*type*)

A category of values. The types we have seen so far are integers (type int), floating-point numbers (type float), and strings (type str).

inteiro (*integer*)

A type that represents whole numbers.

ponto-flutuante (*floating-point*)

A type that represents numbers with fractional parts.

*string* (“cadeia de caracteres”)

A type that represents sequences of characters.

linguagem natural (*natural language*)

Any one of the languages that people speak that evolved naturally.

linguagem formal (*formal language*)

Any one of the languages that people have designed for specific purposes, such as representing mathematical ideas or computer programs; all programming languages are formal languages.

*token* (“símbolo”)

One of the basic elements of the syntactic structure of a program, analogous to a word in a natural language.

sintaxe (*syntax*)

The rules that govern the structure of a program.

analisar (*parse*)

To examine a program and analyze the syntactic structure.

*bug*

An error in a program.

depuração (*debugging*)

The process of finding and correcting bugs.

variável (*variable*)

A name that refers to a value.

atribuição (*assignment*)

A statement that assigns a value to a variable.

diagrama de estado (*state diagram*)

A graphical representation of a set of variables and the values they refer to.

palavra-chave (*keyword*)

A reserved word that is used to parse a program; you cannot use keywords like if, def, and while as variable names.

operando (*operand*)

One of the values on which an operator operates.

expressão (*expression*)

A combination of variables, operators, and values that represents a single result.

avaliar (*evaluate*)

To simplify an expression by performing the operations in order to yield a single value.

instrução (*statement*)

A section of code that represents a command or action. So far, the statements we have seen are assignments and print statements.

executar (*execute*)

To run a statement and do what it says.

modo interativo (*interactive mode*)

A way of using the Python interpreter by typing code at the prompt.

modo de script (*script mode*)

A way of using the Python interpreter to read code from a script and run it.

*script*

A program stored in a file.

ordem das operações (*order of operations*)

Rules governing the order in which expressions involving multiple operators and operands are evaluated.

concatenar (*concatenate*)

To join two operands end-to-end.

comentário (*comment*)

Information in a program that is meant for other programmers (or anyone reading the source code) and has no effect on the execution of the program.

erro sintático (*syntax error*)

An error in a program that makes it impossible to parse (and therefore impossible to interpret).

exceção (*exception*)

An error that is detected while the program is running.

semântica (*semantics*)

The meaning of a program.

erro semântico (*semantic error*)

An error in a program that makes it do something other than what the programmer intended.

função (*function*)

A named sequence of statements that performs some useful operation. Functions may or may not take arguments and may or may not produce a result.

definição de função (*function definition*)

A statement that creates a new function, specifying its name, parameters, and the statements it contains.

objeto-função (*function object*)

A value created by a function definition. The name of the function is a variable that refers to a function object.

cabeçalho (*header*)

The first line of a function definition.

corpo (*body*)

The sequence of statements inside a function definition.

parâmetro (*parameter*)

A name used inside a function to refer to the value passed as an argument.

chamada de função (*function call*)

A statement that runs a function. It consists of the function name followed by an argument list in parentheses.

argumento (*argument*)

A value provided to a function when the function is called. This value is assigned to the corresponding parameter in the function.

variável local (*local variable*)

A variable defined inside a function. A local variable can only be used inside its function.

valor devolvido (*return value*)

The result of a function. If a function call is used as an expression, the return value is the value of the expression.

função produtiva (*fruitful function*)

A function that returns a value.

procedimento (*void function*)

A function that always returns None.

``None``

A special value returned by void functions.

módulo (*module*)

A file that contains a collection of related functions and other definitions.

``import``, instrução (``import`` *statement*)

A statement that reads a module file and creates a module object.

objeto-módulo (*module object*)

A value created by an import statement that provides access to the values defined in a module.

notação de ponto (*dot notation*)

The syntax for calling a function in another module by specifying the module name followed by a dot (period) and the function name.

composição (*composition*)

Using an expression as part of a larger expression, or a statement as part of a larger statement.

fluxo de execução (*flow of execution*)

The order statements run in.

diagrama de pilha (*stack diagram*)

A graphical representation of a stack of functions, their variables, and the values they refer to.

*frame* ()

A box in a stack diagram that represents a function call. It contains the local variables and parameters of the function.

*traceback* ()

A list of the functions that are executing, printed when an exception occurs.

método (*method*)

A function that is associated with an object and called using dot notation.

laço (*loop*)

A part of a program that can run repeatedly.

encapsulamento (*encapsulation*)

The process of transforming a sequence of statements into a function definition.

generalização (*generalization*)

The process of replacing something unnecessarily specific (like a number) with something appropriately general (like a variable or parameter).

argumento nomeado (*keyword argument*)

An argument that includes the name of the parameter as a “keyword”.

assinatura (*interface*)

A description of how to use a function, including the name and descriptions of the arguments and return value.

refatoração (*refactoring*)

The process of modifying a working program to improve function interfaces and other qualities of the code.

plano de desenvolvimento (*development plan*)

A process for writing programs.

*docstring*

A string that appears at the top of a function definition to document the function’s interface.

pré-condição (*precondition*)

A requirement that should be satisfied by the caller before a function starts.

pós-condição (*postcondition*)

A requirement that should be satisfied by the function before it ends.

divisão pelo piso (*floor division*)

An operator, denoted //, that divides two numbers and rounds down (toward zero) to an integer.

operador de módulo (*modulus operator*)

An operator, denoted with a percent sign (%), that works on integers and returns the remainder when one number is divided by another.

expressão booleana (*boolean expression*)

An expression whose value is either True or False.

operador relacional (*relational operator*)

One of the operators that compares its operands: ==, !=, >, <, >=, and <=.

operador lógico (*logical operator*)

One of the operators that combines boolean expressions: and, or, and not.

instrução condicional (*conditional statement*)

A statement that controls the flow of execution depending on some condition.

condição (*condition*)

The boolean expression in a conditional statement that determines which branch runs.

instrução composta (*compound statement*)

A statement that consists of a header and a body. The header ends with a colon (:). The body is indented relative to the header.

desvio (*branch*)

One of the alternative sequences of statements in a conditional statement.

condicional encadeado (*chained conditional*)

A conditional statement with a series of alternative branches.

condicional aninhado (*nested conditional*)

A conditional statement that appears in one of the branches of another conditional statement.

``return``, instrução (``return`` *statement*)

A statement that causes a function to end immediately and return to the caller.

recursão (*recursion*)

The process of calling the function that is currently executing.

caso base (*base case*)

A conditional branch in a recursive function that does not make a recursive call.

recursão infinita (*infinite recursion*)

A recursion that doesn’t have a base case, or never reaches it. Eventually, an infinite recursion causes a runtime error.

variável temporária (*temporary variable*)

A variable used to store an intermediate value in a complex calculation.

código morto (*dead code*)

Part of a program that can never run, often because it appears after a return statement.

desenvolvimento incremental (*incremental development*)

A program development plan intended to avoid debugging by adding and testing only a small amount of code at a time.

código provisório (*scaffolding*)

Code that is used during program development but is not part of the final version.

guarda (*guardian*)

A programming pattern that uses a conditional statement to check for and handle circumstances that might cause an error.

reatribuição (*reassignment*)

Assigning a new value to a variable that already exists.

atualização (*update*)

An assignment where the new value of the variable depends on the old.

inicialização (*initialization*)

An assignment that gives an initial value to a variable that will be updated.

incrementar (*increment*)

An update that increases the value of a variable (often by one).

decrementar (*decrement*)

An update that decreases the value of a variable.

iteração (*iteration*)

Repeated execution of a set of statements using either a recursive function call or a loop.

laço infinito (*infinite loop*)

A loop in which the terminating condition is never satisfied.

algoritmo (*algorithm*)

A general process for solving a category of problems.

objeto (*object*)

Something a variable can refer to. For now, you can use “object” and “value” interchangeably.

sequência de formatação (*sequence*)

An ordered collection of values where each value is identified by an integer index.

*item* (item)

One of the values in a sequence.

índice (*index*)

An integer value used to select an item in a sequence, such as a character in a string. In Python indices start from 0.

código provisório (*slice*)

A part of a string specified by a range of indices.

string vazia (*empty string*)

A string with no characters and length 0, represented by two quotation marks.

imutável (*immutable*)

The property of a sequence whose items cannot be changed.

percorrer (*traverse*)

To iterate through the items in a sequence, performing a similar operation on each.

busca (*search*)

A pattern of traversal that stops when it finds what it is looking for.

contador (*counter*)

A variable used to count something, usually initialized to zero and then incremented.

invocação (*invocation*)

A statement that calls a method.

argumento opcional (*optional argument*)

A function or method argument that is not required.

objeto-arquivo (*file object*)

A value that represents an open file.

redução a um problema resolvido (*reduction to a previously solved problem*)

A way of solving a problem by expressing it as an instance of a previously solved problem.

caso especial (*special case*)

A test case that is atypical or non-obvious (and less likely to be handled correctly).