propias - parametros por omision python

Argumentos de función(en Python, por ejemplo)

Question

¿Cuáles son los argumentos de [función]? ¿Para qué se usan?
Empecé a aprender Python muy recientemente; Soy nuevo en la programación y me disculpo por esta pregunta básica.

En cada tutorial de Python que sigo hablan de argumentos . He buscado la respuesta a esta pregunta y he encontrado muchas respuestas, pero son un poco difíciles de entender. Es posible que me falta algo de trasfondo conceptual.
Entonces ... cuando defino una función, ¿para qué sirven las cosas entre paréntesis? Ejemplo:

def hi( This is the part that i dont get):
     print ''hi''

Editar:
Posteriormente, se cerraron y fusionaron dos preguntas de seguimiento relacionadas con este, de ahí el rasgo parcial fuera de contexto de algunas de las respuestas.
Las preguntas de seguimiento fueron: [parafraseado]

• ¿Pueden los argumentos solo ser usados ​​para la entrada?
  ¿Cuáles son otros ejemplos del uso de argumentos?
• ¿Por qué usar argumentos, en lugar de tener la función llamada raw_input?
• ¿Por qué se describe el concepto de aprobación de argumentos como algo tan poderoso? me parece que simplemente los estamos usando para reemplazar cosas que el usuario podría haber tipeado en el teclado.

Answer 1

En ese caso, para usar argumentos, es simplemente una demostración sobre cómo usarlos, tal vez no el más efectivo como lo demostró. Las funciones son muy útiles. por ejemplo, si quería agregar dos números:

def add(num1, num2):
  x = num1 + num2
  return x
add(1,3)

Las funciones son útiles para realizar tareas repetitivas, digamos que en su ejemplo tuvo que saludar a cientos de nombres, en lugar de tener que hacer un ciclo de esa función raw_input() para leer su nombre y agregarle texto, simplemente puede llamar una función para realizar la tarea y pasar argumentos (el nombre de la persona).

Según su segunda pregunta, los argumentos son solo variables pasadas a la función, así que cualquier variable que pase a ella desde el exterior, por ejemplo, paso los números 1 y 3 a mi función add en el interior de esa función que simplemente se conocen como num1 num2 .

En su caso, al pasar demasiados argumentos, se obtendría esto:

>>> add(1,2)
3
>>> add(1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() takes exactly 2 arguments (3 given)
>>> 

¡La mejor de las suertes! y siéntase libre de enviarme un correo electrónico si necesita más ayuda (sbrichards (at) mit.edu)

Answer 2

Esta no es una pregunta de Python, sino más bien una pregunta de programación genérica. Una muy básica.

Antes de responder la pregunta sobre los argumentos , y en vista de las otras preguntas que hizo, es útil analizar el concepto de variables .
Una variable es una pieza de memoria nombrada en la que se puede almacenar y recuperar información de interés para el programa subyacente. En otras palabras, es un nombre simbólico, elegido por el programador, que está asociado a su contenido. Utilizando varias construcciones de lenguaje generalmente conocidas como asignaciones , el programador puede leer o escribir el contenido de una variable.
Es importante tener en cuenta que el valor (es decir, el contenido) de una variable no necesita definirse cuando se escribe el programa. Solo es necesario en tiempo de ejecución. Esto permite que el programa describa las acciones que se realizarán en elementos simbólicos sin saber exactamente el valor que tienen estos elementos. Considere este fragmento, parte de un programa más grande:

# ... some logic above
ball_volume = 4.0 / 3 * math.pi * ball_radius
if ball_volume > 200:
   print ("Man, that''s a big ball")
# ... more logic below

En el momento en que se escribe el programa, no es necesario conocer el valor real de ball_radius; sin embargo, con la suposición de que esta variable contendrá el valor numérico de una pelota hipotética, el fragmento es capaz de describir cómo calcular el volumen de la pelota. De esta manera, cuando el programa se está ejecutando, y de alguna manera (más sobre esto más adelante) la variable ball_radius se ha inicializado con algún valor apropiado, la variable ball_volume también se puede inicializar y usar, aquí en el enunciado condicional (if) y posiblemente abajo. (En algún momento la variable puede quedar fuera del alcance , pero este concepto que controla cuándo determinadas variables son accesibles para el programa va mucho más allá de este manual).
En algunos idiomas, el tipo de datos que pueden asociarse con una variable en particular debe definirse explícitamente y no puede modificarse. Por ejemplo, algunas variables solo pueden contener valores enteros, otras variables valores de cadena (texto) etc. En Python no existe tal restricción, se puede asignar y reasignar una variable a cualquier tipo de datos, pero, por supuesto, el programador necesita haga un seguimiento de esto, por ejemplo, para evitar pasar algunos datos de texto a una función matemática.

Los datos almacenados dentro de la variable pueden provenir de fuentes muy diferentes. Muchos de los ejemplos proporcionados en los tutoriales y la documentación introductoria hacen que estos datos provengan de la entrada del teclado (como cuando se usa raw_input como se menciona en algunas de sus preguntas). Eso es porque permite pruebas interactivas por parte de las personas que prueban estos fragmentos de tutoriales. Pero la utilidad de los programas sería bastante limitada si las variables solo obtienen sus datos de la entrada interactiva del usuario. Hay muchas otras fuentes y esto es lo que hace que la programación sea tan poderosa: las variables se pueden inicializar con datos de:

• bases de
• archivos de texto o archivos varios formatos de base de datos (XML, JSON, CSV ..)
• archivos binarios con varios formatos
• conexiones a internet
• dispositivos físicos: cámaras, sensores de temperatura ...

En pocas palabras, los Argumentos , también llamados Parámetros , son variables pasadas a la función que [típicamente] se usan para proporcionar salida y comportamiento diferentes de la función. Por ejemplo:

>>> def say_hello(my_name):
...    print("Hello,", my_name, "!")

>>> say_hello("Sam")
Hello, Sam !
>>> customer_name = "Mr Peter Clark"    #imagine this info came from a database
>>> # ...
>>> say_hello(customer_name)
Hello, Mr Peter Clark !
>>>

En el ejemplo anterior, my_name es como cualquier variable local de la función say_hello ; esto permite que la función defina lo que hará con el valor subyacente cuando se llame a la función, en tiempo de ejecución.
En tiempo de ejecución, la función puede invocarse con un valor inmediato (un valor que está "codificado" en la lógica, como "Sam" en el ejemplo), o con [el valor de] otra variable (como customer_name ). En ambos casos, al valor de la variable my_name de la función se le asigna un valor, "Sam" y "Mr Peter Clark", respectivamente. En el último caso, este valor es lo que contenga la variable customer_name . Tenga en cuenta que los nombres de las variables utilizadas dentro de la función ( my_name ) y cuando se llama a la función ( customer_name ) no necesitan ser iguales. (estos se llaman los "parámetros formales" y los "parámetros reales", respectivamente)

Tenga en cuenta que, si bien la mayoría de los argumentos pasan como entrada a una función , en algunas condiciones, se pueden usar como salida , es decir, para proporcionar valores nuevos / modificados en el nivel de la lógica que llamó a la función. Hacerlo requiere el uso, implícita o explícitamente, de la especificación de la convención de llamada apropiada (Ver Argument passing conventions continuación)

Ahora ... más allá de esta comprensión básica del propósito de los parámetros, las cosas se vuelven un poco más complicadas que eso (pero no mucho). Discutiré estos conceptos adicionales en general e ilustraré cómo se aplican a Python.

Valores predeterminados para argumentos (también conocidos como argumentos "opcionales")
Cuando se declara la función, puede especificar el valor predeterminado para algunos parámetros. Estos valores se usan para los parámetros que no se especifican cuando se llama a la función. Por razones obvias, estos parámetros opcionales se encuentran al final de la lista de parámetros (de lo contrario, el compilador / intérprete del lenguaje puede tener dificultades para determinar qué parámetro es cuál ...)

>>> def say_hello(dude = "Sir"):
...     print("Hello,", dude, "!")
...
>>> say_hello()
Hello, Sir !
>>> say_hello("William Gates")
Hello, Bill !            #just kidding ;-)
Hello, William Gates !   # but indeed. works as the original function when param
                         # is specified

Número variable de parámetros
En algunos casos, puede ser útil definir una función para que pueda aceptar una cantidad variable de parámetros. Si bien estas listas de valores de parámetros finalmente se pasan en algún tipo de contenedor (lista, matriz, colección ...) varios idiomas ofrecen formas convenientes de acceder a dichos valores de parámetros.

>>> def add_many(operand1, *operands):
...    Sum = operand1
...    for op in operands:
...       Sum += op
...    return Sum
...
>>> add_many(1, 3, 5, 7, 20)
36
>>> add_many(1, 3)
4

Argumentos con nombre (Argumentos de palabras clave)
Con Python y algunos otros idiomas, es posible nombrar explícitamente los argumentos al llamar a la función. Por lo tanto, la aprobación de argumentos se basa de manera predeterminada en una posición ("1er argumento, 2º argumento, etc.), Python le permitirá nombrar los argumentos y pasarlos en cualquier orden. Esto es principalmente una sutileza sintáctica, pero puede ser útil, en combinación con Argumentos por defecto para funciones que aceptan muchos argumentos. También es una buena función de auto-documentación.

>>> def do_greetings(greeting, person):
...    print (greeting, "dear", person, "!")
...
>>> do_greetings(person="Jack", greeting="Good evening")
Good evening dear Jack !

En Python, incluso puede pasar un diccionario en lugar de varios argumentos nombrados, por ejemplo, con do_greetingsas-is, imagine que tiene un diccionario como:

>>> my_param_dict = {"greeting":"Aloha", "person":"Alan"}

>>> do_greetings(**my_param_dict)
Aloha dear Alan !

Para concluir, y aunque las formas sofisticadas de pasar argumentos y la capacidad de métodos para manejar un número variable de argumentos son características útiles de varios idiomas, se deben mencionar dos conceptos clave:

Argumento convención de paso : por valor o por referencia
Hasta ahora, todas las funciones que utilizamos no alteraron el valor de los parámetros que se les pasaron. Podemos imaginar cuantas veces las funciones quieran hacer esto, ya sea para realizar alguna conversión o cálculo en dichos valores, para su propio uso interno, o para cambiar efectivamente el valor de la variable para que los cambios se reflejen en el nivel de la lógica que llamó a la función. Ahí es donde las convenciones para aprobar argumentos son útiles ...
los argumentos que se pasan por valor pueden ser alterados por la función para sus propios cómputos internos, pero no se modifican al nivel del método de llamada.
los argumentos que se pasan por referencia reflejarán los cambios realizados en ellos, al nivel del método de llamada.
Cada idioma especifica las formas en que se pasan los argumentos. Una convención típica es pasar enteros, valores numéricos y otros tipos básicos por valor y pasar objetos por referencia. La mayoría de los idiomas también ofrecen palabras claves que permiten alterar su convención predeterminada.

En python, todos los argumentos se pasan por referencia. Sin embargo, algunos tipos de variables son inmutables (números, cadenas, tuplas ...) y, por lo tanto, no pueden ser alterados por la función.

Implícito "yo" o "este" argumento de los métodos de clase
En los lenguajes orientados a objetos, los métodos (es decir, funciones dentro de una clase) reciben un argumento adicional que es el valor del objeto subyacente (la instancia de la clase), permitiendo que el método use varias propiedades miembros de la clase en su cálculo y / o alterar el valor de algunas de estas propiedades.

en Python, este argumento se declara al nivel de la definición del método, pero se pasa implícitamente. Al ser declarado, puede llamarse casi todo lo que uno desee, aunque por convención, esto se llama típicamente " yo" .

>>> class Accumulator:
...   def __init__(self, initialValue = 0):
...        self.CurValue = initialValue
...   def Add(self, x):
...        self.CurValue += x
...        return self.CurValue
...
>>> my_accu = Accumulator(10)
>>> my_accu.Add(5)
15
>>> my_accu.Add(3)
18

Answer 3

En pocas palabras, son datos que se "pasan" a la función para decirle qué hacer. Wikipedia tiene detalles.

http://en.wikipedia.org/wiki/Function_argument

Por ejemplo, su función hi() podría necesitar saber a quién saludar:

def hi(person):
    print "Hi there " + person + ", how are you?"

O una función matemática puede necesitar un valor para operar:

def square(x):
     return x * x

Answer 4

En tu ejemplo, no se usan.

Si su función necesita comportarse de manera diferente dependiendo de qué argumentos le dé, entonces para qué son los argumentos.

def hi_name(name):
    print ''Hi '' + name

hi_name("John doe")

Esto imprime "Hola John Doe".

Ahora volvamos a lo básico sobre las funciones .

Answer 5

Las cosas entre paréntesis se llaman argumentos. Básicamente, estas son variables con las que desea que funcione la función. Por ejemplo, supongamos que tiene una función y desea que imprima una palabra cuando la llame. Con argumentos, puede definir cuál será esa palabra. Aquí hay un ejemplo:

def hi(word):
    print word

ahora, si hago algo como esto:

hi(''Hello!'')

se imprimirá:

''Hello!''

hola () se pasa ''Hello!'' como una variable llamada word , y luego imprime esa palabra.

Answer 6

Las funciones serían inútiles si no puede darles la información que deben manejar.
Los argumentos son tal información.

def GiveMeANumberAndIDuplicateIt(x):
    return x * 2

def DontGiveMeAnythingAtAll():
    return None

Answer 7

Si el arg es un objeto mutable , también puede usarlo como un contenedor de salida, por ejemplo, así:

def sort_my_arg(foo)
  foo.sort()

x = [1, 3, 2]
sort_my_arg(x)
print x

Otro uso elegante que he visto es utilizar un contenedor mutable como argumento predeterminado , que se crea en el tiempo de definición de la función, por lo que para los cálculos que consumen mucho tiempo puede usarlo como un caché.

def complicated_calculation(x, cache={})
  if cache.has_key(x):
    # we have already computed this one
    pass
  else:
    # complete some complicated deterministic calculation, and add it to cache
    # ...
    cache[x] = result
  return cache[x]

Answer 8

Un argumento es una variable especial que existe solo en esa función.

En tu ejemplo, tienes una función que toma 2 argumentos:

def add(num1,num2):
    x = num1 + num2
    return x

Cuando llamo a esta función con add() , tengo que agregar entre paréntesis lo que quiero que sean num1 y num2 . En tu caso, tienes 1 y 3 , así que lo llamas así add(1,3) .

Lo que está diciendo es que quiere llamar a add() y quiere que el primer argumento, num1 sea ​​igual a 1 , y el segundo argumento, num2 , que sea igual a 3 .