python学习笔记（五）——函数基础和函数参数

学函数的目的是什么？函数是做什么的？
学函数目的： ①不学函数容易造成：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__) 返回的是列表

函数	作用
len	长度
max	最大值
min	最小值
sorted	排序
reversed	返序
sum	求和
bin	2进制
oct	8进制
hex	16进制
ord	ASCII对应数值
chr	数值对应ASCII
exec	执行以string类型存储的Python代码
filter	过滤器，每个可迭代对象去执行函数，获取满足条件的，不满足的删去
map	对于可迭代参数，应用函数，结果返回
zip	配对

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')]