python自定义函数和内置函数

函数

1.定义

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
先定义，后使用

1.2分类

系统函数
自定义函数

1.3语法：

def functionname(parameters):
    "函数_文档字符串"
    function_suite
    return [expression]

1.4函数的返回值

函数执行完毕之后的返回的结果
如果没有给出返回值，默认返回None
返回多个值时，返回类型为元组

2.参数问题

2.2分类

位置参数

默认情况下，函数调用时参数的个数，位置参数与函数定义时一致

def fun1(a, b):
  print(a, b)
  
fun1(1, 2)

关键字参数

可以将实参的值通过关键字来指定给具体给哪个形参
如：

def fun1(a, b):
    print(a, b)
  
fun1(b=1, a=2)

默认参数

在定义时，形参如果给出了默认值，这时候，就是默认参数。所有的默认参数必修放在最后
默认参数在调用时，如果没有实参对他进行赋值，他的值为默认值，否则为指定值

def fun1(a, b=2, c=3):
print(a, b, c)

fun1(1)
fun1(1, 3, 4)

　可变参数（可以实现函数定义，以及函数调用时，参数个数不匹配的情况）

*args ：可以给任意个参数

def fun1(*args):
  print("type(args):", type(args))
  print("args:", args)
  print("*args:", *args)
  print("-" * 30)
  
fun1()
fun1(1)
fun1(1, 2)
fun1([1, 2, 3])

**kwargs ：只能给键值对的参数(a=1, b=2)

def fun1(**kwargs):
  print("type(kwargs):", type(kwargs))
  print("kwargs:", kwargs)
  print("-" * 30)
  
fun1()
fun1(a=1, b=2, c=3)

*args 与 **kwargs 一起使用

def fun1(*args, **kwargs):
  print("type(args):", type(args))
  print("args:", args)
  print("*" * 10)
  print("type(kwargs):", type(kwargs))
  print("kwargs:", kwargs)
  print("-" * 30)

fun1()
fun1(1)
fun1(1, 2, 3, a=4, b=5)

2序列解包

使用 *：

完成str、list、tuple的解包
对于字典，只解包key
返回类型：tuple

a = [1, 2, 3]
b = *a,
print(type(b))
print(b)

a = [1, 2, 3]
b = (1, 2, 3)
c = "hello"
d = {'a': 1, 'b': 2}
print("a:", *a, "
b:", *b, "
c:", *c)
print("d:", *d)

使用 **：

完成dict的解包
解包为： key1=value1 key2=value2
不能直接打印

def fun1(**kwargs):
    print(kwargs)

d = {'a': 1, 'b': 2}
fun1(a=1, b=2)
fun1(**d)

3. 内置函数

3.1查看内置函数

```
import builtins
print(dir(builtins))
```

3.2 常用内置函数

abs(x)：求绝对值

x ：数值表达式，可以是整数，浮点数，复数。

max(x)：求最大值

x ：Iterable（list,tuple,str,dict,set）
关键字key，默认以每个元素中的0号索引值查找最大元素

list1 = [(1001, "James", 40), (1000, "Jack", 20), (1002, "Lucy", 28)]
m = max(list1)
print(m)

指定关键字key，自定义选择每个元素中的索引值，查找最大元素

list1 = [(1001, "James", 40), (1000, "Jack", 20), (1002, "Lucy", 28)]
m = max(list1, key=lambda item:item[2])
print(m)

map() :

有两个参数，第一个参数是一个函数，第二个参数是可迭代的内容。函数会依次作用在可迭代内容的每一个元素上进行计算，然后返回一个新的可迭代内容

如：

def fun1(n):
    return n ** 2
    
list1 = [1, 2, 3, 4]
list2 = map(fun1, list1)
print(type(list2)
print([item for item in list2])

def fun1(a, b):
    return a + b
    
list1 = [1,2,3,4]
list2 = [2,3,4]
list3 = map(fun1, list1, list2)
# list3 = map(lambda a,b:a+b, list1, list2)
print([item for item in list3])

filter()：

函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新“列表”（迭代器）

def func2(x):
  return x % 2 == 0
  
list1 = filter(func2, [1, 2, 3, 4, 5])
print(type(list1))
print([item for item in list1])

zip()：

zip 函数接受任意多个可迭代对象作为参数,将对象中对应的元素打包成一个tuple,然后返回一个可迭代的zip对象。这个可迭代对象可以使用循环的方式列出其元素。若多个可迭代对象的长度不一致,则所返回的列表长度与参数中长度最短的可迭代对象相同

list1 = [1,2,3]
tuple1 = ('a', 'b', 'c', 'd')
str1 = "Hello"
v = zip(list1, tuple1, str1)
print(type(v))
print([item for item in v])