To add to what @Robert says, I think of this as seeking a parameterization technique that allows the common code to be written once (so it can be maintained in one place) and then reused instead of pasting.
However, you have to determine the kind of parameterization that will let you factor the common part to be written just once.
Often function parameters suffice, but that's not the only approach.
There are also classes and methods as @Robert says. Sometimes we use overrides and/or interfaces: I think of overrides and interfaces as a form of parameterization: The use of base class or interface serves to express a bundle of formal parameters and the concrete subclass or interface implementation serves binding of the bundle of actual parameters.
Don't forget that in many (esp. functional) languages we can have higher-order functions, meaning functions can take parameters that refer to functions, which enables other use cases. Abstract and interface methods act a lot like function parameters, perhaps with a bit more structure.
Another tool that some languages provide is generic types. Sometimes common code cannot be expressed with normal parameters: what differs between scenarios is the types being operated over, even if the code is the same in any case. In those situations generics help.
You can discuss some design pattern in terms of parameterization, such as a Observer and Visitor pattern, which abstracts specific data structure or its traversal from an action to be performed. These can be implemented by OOP techniques (using overrides or interfaces) and also by higher-order functions.
And still, other techniques (monads) allow other kinds of common code to be collected so as to be written only once. There is ongoing research in other kinds of parameterization.
In general, though, I think one can make a mental link of many of the techniques to reduce copied (pasted) code to variations on parameterization.