python 函数

函数的使用

形参，实参

import  time

# 创建logger函数，等待传入的值为，形参
def logger(date):

    print("starting action1")
    with open("log.txt","a") as f:
        f.write("end save date: %s
" %date)

# 传入的值为，实参
logger(time.strftime("%Y-%m-%d %X"))

必须参数

必须要，对应，传入数量也必须一样

def print_info(name,age):
    print("name:%s" % name)
    print("age:%s" % age)
print_info("Kidd",16)

　

关键词参数

根据形参的参数，来传实参

def print_info(name,age):
    print("name:%s"%name)
    print("age:%s"%age)
print_info(age=16,name="Kidd")

默认参数

给形参传默认值，默认值形参，必须放到形参的最后

# 使用默认参数
def print_info(name,age=18):
    print("name:%s"%name)
    print("age:%s"%age)
print_info("Kidd")


# 不使用默认参数
def print_info(name,age=18):
    print("name:%s"%name)
    print("age:%s"%age)
print_info(age=16,name="Kidd")

不定长参数

传入任意数量的实参  *

传入任意数量的关键词实参  **

def function(name="Bob",*args,**kwargs):
    print(name)
    print(*args)
    for key in kwargs:
        print("%s:%s"%(key,kwargs[key]))
function("Kidd",1,2,3,age=16,sex="男")


运行结果:
Kidd
1 2 3
age:16
sex:男

实参传入* , **

# 实参传 * 将列表，元祖中的元素提取出来
def func(*args):
    print(args) # (1, 2, 3, 4, 5, 6, [7,8,9])
func(*(1,2,3,),*[4,5,6],[789])


# 实参传 ** 将关键字传参，替换成了字典传参
def func1(**kwargs):
    print(kwargs)
student1 = {"一斑":{"小明":{"age":15},"小红":{"age":14}}}
student2 = {"二班":{"小李":{"age":15},"小张":{"age":16}}}
func1(**student1,**student2)

# {'一斑': {'小明': {'age': 15}, '小红': {'age': 14}}, '二班': {'小李': {'age': 15}, '小张': {'age': 16}}}

return

作用：函数的结束，函数的返回值

# return默认值None
def function(*args):
    number = sum(args)
    print(number) # 6
number = function(1,2,3)
print(number) # None



# 使用return
def function(*args):
    number = sum(args)
    return number
number = function(1,2,3)
print(number) # 6



# 返回多个数
def function(*args):
    number = sum(args)
    return number,7,[6,7],"6,7"
number = function(1,2,3)

# 返回一组元祖
print(number) # (6, 7, [6, 7], '6,7')

作用域

python的作用域，一共分为4种，分别是built,global,enclosing,local

x = int(2.0) # int built-in
count = 0 # global
def father():
    father_name = "father" # enclosing
    def son():
        son_name = "son" # local

高阶函数

1、函数名可以参数输入

2、函数名可以作为返回值

def first_portion(n):
    return n * n
def second_portion(one,two,other):
    result = other(one) + other(two)
    return result
print(second_portion(1,2,other=first_portion)) # 5

闭包 

闭包 = 函数 + 定义函数时的环境

def outside(num):
    def inside():
        print(num)
    return inside
out = outside(10)
out()

递归函数

#阶乘

#使用 for 循环
def multiply(n):
    number = 1
    for i in range(1,n+1):
        number = i * number
    return number
mul = multiply(5)
print(mul) # 120



#使用递归
def multiply(n):
    if n == 1:
        return 1
    return n * multiply(n-1)
mul = multiply(5)
print(mul) # 120



# 使用reduce 和 lambda
from functools import reduce
mul = reduce(lambda a,b : a*b,range(1,6))
print(mul)

 使用递归，要有一个明确的结束条件，

递归的效率低，不如for循环

def addition(n):
    if n <= 2:
        return n
    return addition(n-1) + addition(n-2)
add = addition(1)
print(add)

 斐波那契数列

def func(n):
    b,a,v = 0,1,0
    for i in range(n):
        v = a + b
        b = a
        a = v
        print(a)
func(5)


def func1(n):
    b, a = 0, 1
    for i in range(n):
        b,a = a,a+b
        print(a)
func1(5)

两个结果一样，根据规律，使用最简单的

内置函数

filter(function,iterable)

# filter函数，相当于过滤器
iter_object = [1,2,3,4,5]
def filter_function(num):
    if num > 1:
        return num
object = filter(filter_function,iter_object)
print(list(object)) # [2, 3, 4, 5]

map(func,iter1,iter2)

会根据提供的函数对指定序列做映射。

iter_name = ["小明:","小张:","小李:"]
iter_sex = ["男","女","男"]
def map_function(iter1,iter2):
    return iter1 + iter2
iter_content = map(map_function,iter_name,iter_sex)
print(list(iter_content)) # ['小明:男', '小张:女', '小李:男']

reduce(function,sequence)

对参数序列中元素进行累积

from functools import reduce
def add(x,y):
    return x + y
num = reduce(add,range(1,101))
print(num) # 5050

lambda

lambda 匿名函数，它是一个表达式
用法:    参数 : 返回值

mul = reduce(lambda x,y:x*y,range(1,6))
print(mul) # 120

filter_lambda = filter(lambda a : a>1,range(1,6))
print(list(filter_lambda)) # [2, 3, 4, 5]

map_lambda = map(lambda a : a ** 2,range(1,6))
print(list(map_lambda)) # [1, 4, 9, 16, 25]

chr

chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

其中 A-Z 对应的数值为 65-90

其中 a-z 对应的数值为 97 -122

for i in range(256):
    if chr(i) == "A":
        print(i) # 65
    elif chr(i) == "a":
        print(i) # 97

ord

Given a string representing one Unicode character, return an integer representing the Unicode code point of that character. For example, ord('a') returns the integer 97 and ord('€') (Euro sign) returns 8364. This is the inverse of chr().

ord('a') #97

enumerate(iterable, start=0)

Return an enumerate object. iterable must be a sequence, an iterator, or some other object which supports iteration. The __next__() method of the iterator returned by enumerate() returns a tuple containing a count (from start which defaults to 0) and the values obtained from iterating over iterable.

for n,i in enumerate(range(1,10),1):
    print(n,i)

eval(expression, globals=None, locals=None)

The arguments are a string and optional globals and locals. If provided, globals must be a dictionary. If provided, locals can be any mapping object.

x = 1
eval('x+1') #2

pow(x, y[, z])

Return x to the power y; if z is present, return x to the power y, modulo z (computed more efficiently than pow(x, y) % z). The two-argument form pow(x, y) is equivalent to using the power operator: x**y.

pow(2,2) # 4
pow(2,2,3) # 1

More

https://docs.python.org/3/library/functions.html