学函数的目的是什么？函数是做什么的？
学函数目的： ①不学函数容易造成：1、复杂度增大；2、组织结构不够清晰；3、可读性差；4、代码冗余；5、可扩展性差
②学函数后可以： 1、使用函数可以提高编写的效率以及代码的重用；2、函数是带名字的代码块，随用随调； 3、使用函数，程序编写，阅读，测试和修复都将更容易美观
函数作用：把独立功能的代码块封装到函数里面去，从而达到一个多次使用的效果减少代码量，冗余 结构也比较清楚， 保持代码的一致性

函数的定义

函数标准格式

def 函数名(参数)：
    函数接口
    函数体
    return 返回值

函数名命名规则： 字母、数字和下划线组成，和变量命名规则一致

return 后面可以返回任意表达式，但不能是赋值语句

函数的调用

函数名(参数)

注：要先定义才能调用哦！

示例：

def func(a,b):   #传值(形参)
    print('开始了')
    result = a - b
    return result
print('--结束--')  # 遇到return 后面的都不会执行了 代表函数结束了  返回值都出来了呀   问题：函数里可有有多个renturn 吗（选择执行的时候可有有多个）
a = func(10,5)      #传值
print(a)

结果：
5

函数的参数

• 形参：函数没有调用的时候，它没有任何意义；在调用时，必须传入参数，所以也叫必须参数
• 实参：与形参位置是一一对应的，所以也叫位置参数；缺一不可，缺了或多了都会报错

必备参数

参数能够接受任意类型的对象

必备参数 你写了几个 就必须要传几个

实例：

def func(a,b):
    print('开始了')
    result = a - b
    return result
	print('结果%d'%result)
	print('--结束--')
func(180)  # 报错
func(180，100)  #正确

默认参数

默认参数 你可以去传 如果传了 就拿你传的参数，入果没传 就按默认的参数去执行；一定要放在必须参数后面，否则会报错。

实例：

def func(a,b=160):
    print('开始了')
    result = a - b  
    return result
result = func(180) 
print('result：%d'%result)
print('--结束--')

执行结果：
result：20

不定长参数

问题：传10个必备参数，可以定义10 我要100个呢？所以就有了不定长参数这一概念。

①在定义函数时，可以在形参前边加上一个*，这样这个形参将会获取到所有的实参，它将会将所有的实参保存到一个元组中。
*a会接受所有的位置实参，并且会将这些实参统一保存到一个元组中（装包）

实例：

def f1(*args):
    print(args)
li = [1, 2, 3]
f1(4, 5, 6)
f1(li, 2333)
f1(*li)  #注意li是一个列表所以要加*解包

执行结果：
(4, 5, 6)
([1, 2, 3], 2333)
(1, 2, 3)

②**形参可以接收其他的关键字参数，它会将这些参数统一保存到一个字典中，字典的key就是参数的名字，字典的value就是参数的值
**形参只能有一个，并且必须写在所有参数的最后

实例：

def func(**kwargs):  # 关键字传参
    print(kwargs)
func(a=1,b=2,c=3)  #键等于值的形式  
执行结果：
{
    
    'a': 1, 'b': 2, 'c': 3}


def func(*args,**kwargs):
    print(args,kwargs)
func(1,2,3,4,5,a = 1,b = 3)
执行结果：(1, 2, 3, 4, 5) {
    
    'a': 1, 'b': 3}

关键字参数

通过关键字去找对应的必须参数，这样就不需要一一对应了

实例：

def func(str1, str2):
    print(str1, str2)
# 观察这两个调用的结果是否一致？
func(str1='hello', str2='你好')
func(str2='hello', str1='你好')

执行结果：
hello 你好
你好 hello

高级内置函数

查看python当中所有的内置函数：dir(__builtins__) 返回的是列表

a = [1,2,3,4]
print(len(a))
结果:4

min(a)  小
max(a)  大
sorted(a) 排序
reversed(a)  返序
sum(a)  求和

进制转换与ASCII变换

bin(12)   2进制
oct(8)    8进制
hex(11)   16进制
ord('a')  # 97         # ascii
ord('A')  # 65
chr(97)   # 'a'
chr(65)   # 'A'

enumerate() 枚举

li = ['a','b','c']
a = list(enumerate(li,100))
print(a)
输出结果：[(100, 'a'), (101, 'b'), (102, 'c')]


for i ,j  in enumerate(li):
    print(i,j)
输出结果：
0 a
1 b
2 c


a = dict(enumerate(li,100))
print(a)
输出结果：
{
    
    100: 'a', 101: 'b', 102: 'c'}


a = '1+2+3'
eval(a)  转换成表达式执行
eval('a=1') # 报错
# 将字符串str当成有效的表达式来求值并返回计算结果。
b = 1
'b = 1'

exec()

i = 3
j = 2
exec('um = i + j')  # 返回值永远是空
print(um)
执行结果：5
#ans变量并没有显式的定义，但仍然可以在print函数中调用。这是exec语句执行了"um = i + j"中的代码，定义了sum变量。

i = 3
j = 2
exec('print(i + j)')
执行结果：5

a = 'for i in range(5):print(i)'
exec(a)
执行结果：1 2 3 4 5

filter()

def func(x):
    return x > 10
li = [2,5,8,10,22,44]
#list(filter(func,li))   #过滤函数，过滤条件
print(list(filter(func,li)) )
执行结果：
[22, 44]

map()

def func2(num):
    return num * 10

list1 = [1,2,3,4,5]
print(list(map(func2,list1)))#函数对象 ， 可迭代对象
执行结果：
[10, 20, 30, 40, 50]

zip()

t1 = [1,2,3,4]
t2 = ['a','b','c','d']
print(list(zip(t1,t2)))
执行结果：
[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]