função python3
Função é uma boa organização, reutilizável, usada para atingir um segmento de código único, ou funções associadas.
A função pode ser aplicada para melhorar a modularidade e reutilização de código. Você já sabe que Python oferece muitas funções internas, como print (). Mas você também pode criar sua própria função, que é chamado de uma função definida pelo usuário.
Definir uma função
Você pode definir uma função a partir da função que você quer, as seguintes regras simples:
- bloco de funçãodef palavra-chave no início, seguido do nome da função e identificadores entre parêntesis ().
- Todos os parâmetros de entrada e argumentos devem ser colocados entre parênteses no meio, pode ser utilizada para definir os parâmetros entre parênteses.
- A primeira linha da declaração função pode, opcionalmente, utilizar um documento string - são utilizados para a descrição da função.
- conteúdo função começando com dois pontos e recuo.
- voltar final [expressão] da função, opcionalmente retornar um valor para o chamador. voltar sem uma expressão equivalente para retornar Nenhum.
gramática
funções definidas pelo Python usando o palavra-chave def, o formato geral é a seguinte:
def 函数名(参数列表): 函数体
Por padrão, o nome do parâmetro e parâmetro de valor é na ordem definida na declaração da função combina.
Exemplos
Vamos usar a função para a saída "Olá mundo!":
>>> def hello() : print("Hello World!") >>> hello() Hello World! >>>
Aplicação do ponto mais complexo, para trazer as variáveis de parâmetro função:
#!/usr/bin/python3 # 计算面积函数 def area(width, height): return width * height def print_welcome(name): print("Welcome", name) print_welcome("w3big") w = 4 h = 5 print("width =", w, " height =", h, " area =", area(w, h))
Exemplos de saída acima:
Welcome w3big width = 4 height = 5 area = 20
chamada de função
Definir uma função: dar a função de um nome, especifique os parâmetros da função contém, e a estrutura bloco de código.
Após a conclusão da estrutura básica desta função, é possível realizar outra chamada de função a ser executada diretamente do prompt de comando do Python.
Os exemplos seguintes são chamados função printme ():
#!/usr/bin/python3 # 定义函数 def printme( str ): "打印任何传入的字符串" print (str); return; # 调用函数 printme("我要调用用户自定义函数!"); printme("再次调用同一函数");
Exemplos de saída acima:
我要调用用户自定义函数! 再次调用同一函数
Parâmetros passados por parâmetros de valor e passar por referência
Em Python, todos os parâmetros (variáveis) são passados por referência. Se você alterar um parâmetro em uma função, então esta função é chamada de função, os parâmetros originais também são alteradas. Por exemplo:
#!/usr/bin/python3 # 可写函数说明 def changeme( mylist ): "修改传入的列表" mylist.append([1,2,3,4]); print ("函数内取值: ", mylist) return # 调用changeme函数 mylist = [10,20,30]; changeme( mylist ); print ("函数外取值: ", mylist)
E passou para a função do objeto no final para adicionar novos conteúdos usando a mesma referência. Assim, os resultados da saída são os seguintes:
函数内取值: [10, 20, 30, [1, 2, 3, 4]] 函数外取值: [10, 20, 30, [1, 2, 3, 4]]
parâmetros
O que se segue é o tipo de parâmetro formal pode ser usado ao chamar a função:
- parâmetros necessários
- argumentos
- Os parâmetros por defeito
- parâmetros de comprimento variável
parâmetros necessários
parâmetros necessários na ordem correta para ser passado para a função. Quando o número de chamadas e deve ser a mesma declaração.
printme Call () função, você deve passar em um parâmetro ou erro de sintaxe irá ocorrer:
#!/usr/bin/python3 #可写函数说明 def printme( str ): "打印任何传入的字符串" print (str); return; #调用printme函数 printme();
Exemplos de saída acima:
Traceback (most recent call last): File "test.py", line 10, in <module> printme(); TypeError: printme() missing 1 required positional argument: 'str'
argumentos
argumentos e função de palavra-chave chama uma chamada de função relacionamento próximo usando argumentos para determinar o valor do parâmetro passado.
Ao usar a palavra-chave do parâmetro permite que o parâmetro de função ordem de chamada é inconsistente com a afirmação, porque interpretador Python capaz de combinar os valores dos parâmetros usando o nome do parâmetro.
O exemplo a seguir printme function () é chamado com o nome do parâmetro:
#!/usr/bin/python3 #可写函数说明 def printme( str ): "打印任何传入的字符串" print (str); return; #调用printme函数 printme( str = "本教程");
Exemplos de saída acima:
本教程
O exemplo a seguir demonstra o uso de parâmetros de função não precisa usar a ordem especificada:
#!/usr/bin/python3 #可写函数说明 def printinfo( name, age ): "打印任何传入的字符串" print ("名字: ", name); print ("年龄: ", age); return; #调用printinfo函数 printinfo( age=50, name="w3big" );
Exemplos de saída acima:
名字: w3big 年龄: 50
Os parâmetros por defeito
Quando a função é chamada, se o parâmetro não for aprovada, ele usará os parâmetros padrão. O exemplo a seguir, se nenhum parâmetro a idade de entrada, o valor padrão:
#!/usr/bin/python3 #可写函数说明 def printinfo( name, age = 35 ): "打印任何传入的字符串" print ("名字: ", name); print ("年龄: ", age); return; #调用printinfo函数 printinfo( age=50, name="w3big" ); print ("------------------------") printinfo( name="w3big" );
Exemplos de saída acima:
名字: w3big 年龄: 50 ------------------------ 名字: w3big 年龄: 35
parâmetros de comprimento variável
Você pode precisar de uma função que pode lidar com mais do que o original da declaração de parâmetros. Estes parâmetros são chamados os parâmetros de comprimento variável, e os dois tipos de parâmetros são diferentes, não nomear declaração. A sintaxe básica é a seguinte:
def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串" function_suite return [expression]
Com um asterisco (*) serão armazenados em nomes de variáveis todos os parâmetros variáveis sem nome. Se nenhum argumento quando a função é chamada, é uma tupla vazia. Não podemos passar variável sem nome para uma função. Os exemplos que se seguem:
#!/usr/bin/python3 # 可写函数说明 def printinfo( arg1, *vartuple ): "打印任何传入的参数" print ("输出: ") print (arg1) for var in vartuple: print (var) return; # 调用printinfo 函数 printinfo( 10 ); printinfo( 70, 60, 50 );
Exemplos de saída acima:
输出: 10 输出: 70 60 50
função anônima
python usando lambda para criar uma função anônima.
A chamada anônima, o que significa que já não usam esta afirmação forma de definição padrão para definir uma função.
- Apenas uma expressão lambda, o corpo da função é muito mais simples do que def.
- O corpo é uma expressão lambda, ao invés de um bloco de código. Nós só pode empacotar uma lógica limitada na expressão lambda.
- função lambda tem o seu próprio espaço de nomes, e não pode ser acessado fora de sua própria lista de discussão ou os parâmetros espaço global.
- Embora a função lambda só parece escrever uma única linha, mas não o mesmo que funções inline em C ou C ++, este propósito não é ocupada ao chamar a função de memória de pilha pequena para aumentar a eficiência operacional.
gramática
Lambda sintaxe da função contém apenas uma instrução, como segue:
lambda [arg1 [,arg2,.....argn]]:expression
Os exemplos que se seguem:
#!/usr/bin/python3 # 可写函数说明 sum = lambda arg1, arg2: arg1 + arg2; # 调用sum函数 print ("相加后的值为 : ", sum( 10, 20 )) print ("相加后的值为 : ", sum( 20, 20 ))
Exemplos de saída acima:
相加后的值为 : 30 相加后的值为 : 40
instrução de retorno
return [expressão] declaração é usada para sair da função, seletivamente para o chamador retorna uma expressão.instrução de retorno sem parâmetros retorna Nenhum. Não há exemplos anteriores demonstram como retornar um valor, o exemplo a seguir demonstra o uso da instrução de retorno:
#!/usr/bin/python3 # 可写函数说明 def sum( arg1, arg2 ): # 返回2个参数的和." total = arg1 + arg2 print ("函数内 : ", total) return total; # 调用sum函数 total = sum( 10, 20 ); print ("函数外 : ", total)
Exemplos de saída acima:
函数内 : 30 函数外 : 30
Âmbito variável
Pyhton, a variável não é a posição em que o programa pode acessar, o acesso depende de onde a variável é atribuído.
- Variáveis globais
- As variáveis locais
variáveis globais e locais
A definição da função de variáveis internas têm um alcance local, tal como definido na função exterior tem escopo global.
As variáveis locais só pode ser declarada dentro de uma função de seu acesso a variáveis globais pode ser acessado em todos os processos. Quando você chamar uma função, todos os nomes de variáveis em declarações de função será adicionada ao escopo. Os exemplos que se seguem:
#!/usr/bin/python3 total = 0; # 这是一个全局变量 # 可写函数说明 def sum( arg1, arg2 ): #返回2个参数的和." total = arg1 + arg2; # total在这里是局部变量. print ("函数内是局部变量 : ", total) return total; #调用sum函数 sum( 10, 20 ); print ("函数外是全局变量 : ", total)
Exemplos de saída acima:
函数内是局部变量 : 30 函数外是全局变量 : 0