Python函数

函数基本操作

1)函数定义

• 函数是对程序逻辑进行结构化或过程化的一种编程方法
• 将整块代码巧妙地隔离成易于管理的小块
• 把重复代码放到函数中而不是进行大量的拷贝,这样既能节省空间,也有助于保持-致性
• 通常函数都是用于实现某一种功能

2)创建函数

• 函数是用def语句来创建的,语法如下:

  def function_name(arguments):        
      "function_documentation_string" 
       function_body_suite

• 标题行由def关键字,函数的名字,以及参数的集合(如果有的话)组成
• def子句的剩余部分包括了一个虽然可选但是强烈推荐的文档字串,和必需的函数体

3)调用函数

• 同大多数语言相同，python用一对圆括号调用函数
• 如果没有加圆括号，只是对函数的引用
• 函数一般都使用return返回值。如果函数没有return语句，将返回None。

>>> def add():
...   a = 10 + 20
...
>>> x = add()
>>> print(x)
None

>>> def add():
...   a = 10 + 20
...   b = [1, 2, 3]
...   c = 100 + 200
...   return 'hello world'
...
>>> x = add()
>>> print(x)

>>> def add():
...   a = 100
...   b = 200
...   c = a + b
...   return c
...
>>> x = add()
>>> print(x)
300
>>> c + 5     # NameError。在函数内使用的变量是局部变量，只能在函数内使用

• 参数：
  • 形式参数，形参：在函数名括号中的变量
  • 实际参数，实参：在调用函数时，传递的具体数据

# 斐波那契数列
def fib_func(l):
    list = [0, 1]
    for i in range(l - 2):
        list.append(list[-1] + list[-2])
    return list

_length = [10, 20, 30, 5, 6, 9]
for i in _length:
    print(fib_func(i))

4)函数参数

• 形式参数： 函数定义时,紧跟在函数名后(圆括号内)的参数被 称为形式参数,简称形参。由于它不是实际存在变量, 所以又称虚拟变量
• 实际参数： 在主调函数中调用一个函数时,函数名后面括弧中的参数(可以是一个表达式)称为“实际参数”,简称实参
• 默认参数： 就是声明了默认值的参数，因为给参数赋予了默认值,所以在函数调用时,不向该参数传入值也是允许的

def pstar(a='*', b=5):   # 定义默认参数
    print(a * b)

pstar()   # 可以不传递参数
pstar('^')   # 只传递第一个参数
pstar('%',10)   # 依次传递参数给a，b 

• 位置参数：与shell脚本类似，程序名以及参数都以位置参数的方式传递给python程序，使用sys模块的argv列表接收

[root@localhost day03] vim weizhi.py
import sys

print(sys.argv)
[root@localhost day03] python3 weizhi.py hao 123
['weizhi.py', 'hao', '123']

# 优化模拟cp脚本
import sys

def copy(src_file,dest_file):
    with open(src_file, 'rb') as src:
         with open(dest_file, 'wb') as dest:
             while 1:
                 data = src.read(4096)
                 if not data:
                     break
                 dest.write(data)

copy(sys.argv[1], sys.argv[2])

---

调用函数

1)函数参数

• 参数的形式是arg，称作位置参数
• 参数的形式是key=val，称作关键字参数

>>> def get_info(name, age):
...   print('%s is %s years old' % (name, age))
...
>>> get_info('dc', 20)     # OK
dc is 20 years old 
>>> get_info(20, 'dc')     # 语法正确，语义不对
20 is dc years old 
>>> get_info(age=20, name='dc')  # OK
dc is 20 years old 
>>> get_info(age=20, 'dc')   # 语法错误，关键字参数必须在位置参数后面
>>> get_info(20, name='dc')  # name得到了多个值
>>> get_info('dc', age=20)   # OK
dc is 20 years old 
>>> get_info()      # Error，参数不足
>>> get_info('dc', 20, 200)  # Error，参数过多

2)参数组

• 定义函数时，在参数前加*，表示使用元组接收参数
• 定义函数时，在参数前加**，表示使用字典接收参数

>>> def func1(*canshu):
...   print(canshu)
... 
>>> func1()
()
>>> func1('hao', 123)
('hao', 123)
>>> func1('hao', 123, 'tom', 'jerry')
('hao', 123, 'tom', 'jerry')
>>> def func2(**canshu):
...   print(canshu)
... 
>>> func2()
{}
>>> func2(name='tom', age=20)
{'name': 'tom', 'age': 20}

• 调用时，在参数前加*表示将参数对象拆分成多个参数
• 调用时，在参数前加**表示将参数对象拆分成多个key=val形式的参数

>>> def myadd(x, y):
...   return x + y
>>> nums = [10, 20]
>>> myadd(nums)     # Error，nums传给x，y没有得到值
>>> myadd(nums[0], nums[1])
30
>>> myadd(*nums)
30
>>> d1 = {'x': 100, 'y': 200}
>>> d2 = {'a': 5, 'b': 8}
>>> myadd(**d1)    # myadd(x=100, y=200)
300
>>> myadd(**d2)    # myadd(a=5, b=8) =>myadd函数的参数只有x和y，没有a和b

匿名函数

• 正常定义的函数可以实现匿名函数的功能
• 当函数非常简单时，只有一行代码，可以使用匿名函数替代
• 用lambda关键字创造匿名函数
• 匿名是因为不需要以标准的def方式来声明
• 一个完整的lambda“语句”代表了一个表达式，这个表达式的定义体必须和声明放在同一行

>>> def add(x, y):
...   return x + y
>>> add(10, 20)
30
# 上面的函数可以写为下面匿名函数的形式
>>> myadd = lambda x, y: x + y
>>> myadd(10, 20)
30

filter函数

• filter(func,seq):调用一个布尔函数func来迭代遍历每个序列中的元素;返回一个使func返回值为true的元素的序列
• 第一个参数是函数。该函数接收一个参数，返回True或False
• 第二个参数是序列对象
• 如果布尔函数比较简单,直接使用 lambda匿名函数就显得非常方便了

from random import randint

def my(x):
    return True if x % 2 == 1 else False

if __name__ == '__main__':
	#过滤出10个数中的奇数
    nums = [randint(1,100) for i in range(10)]
    print(nums)
    result1 = list(filter(my, nums))
    print(result1)
    result2 = list(filter(lambda x:True if x % 2 == 1 else False, nums))
    print(result2)

map函数

• map(func,seq)：调用一个函数func来迭代遍历每个序列中的元素,返回一个经过func处理过的元素序列
• 第一个参数是函数。该函数接收一个参数，加工后返回
• 第二个参数是序列对象
• 如果布尔函数比较简单，直接使用lambda匿名函数就显得非常方便了

def func1(x):
   return x + 100

from random import randint

if __name__ == '__main__':
   nums = [randint(1, 100) for i in range(10)]
   print(nums)
   result1 = map(func1, nums)
   print(list(result1))
   result2 = map(lambda x: x + 100, nums)
   print(list(result2))