数据分析篇--Python基础篇--04函数基础和函数的参数

一、函数基础和函数的参数

'''
编程来源于生活
1.什么是函数？
在程序中，函数就是具备某一功能的工具  实现将工具准备好
即函数的定义遇到应用场景拿来就用即函数的调用   所以务必记住
函数的使用必须遵循先定义后调用的原则（先制造了工具，有工具才能使用）
2.为何要用函数  不用函数产生的问题
    程序冗长
    程序的扩展性差
    程序的可读性差
3.如何使用函数
    1.函数的定义阶段：****
    只检测函数的语法   不执行函数体代码
    def 函数名+括号+冒号
    缩进+体代码
    2.函数调用阶段：******
    函数的调用：函数名+括号
        1.先找到名字     （找到工厂位置）
        2.根据名字调用代码      （加了括号执行工厂进行加工）
'''
def factory():
    '''
    这个注释是告诉别人功能的
    这是一个工厂
    :return:
    '''
    print('正在制造手机')     #代码相当于员工和机器
    print('正在制造手机')     #代码相当于员工和机器
    print('正在制造手机')     #代码相当于员工和机器
    print('正在制造手机')     #代码相当于员工和机器
    print('正在制造手机')     #代码相当于员工和机器
# name = 'zhanxi'
# print(id(factory))
#1.先找到名字    （找到工厂位置）
# print(factory)
factory()
factory()

##函数三大特性
# 功能  参数  返回值
# 有代码（有功能）
def factory():      #制造一个工厂
    print('正在制造手机')     #代码相当于员工和机器、
factory()
### 无代码（用来测试，先做好项目的需要）
def shopping():
    pass
shopping()

二、函数参数

# 参数
# 无参参数
# 应用场景仅仅只是执行一些操作，比如与用户交互，打印（工厂制造手机，不需要外界资源）
# 无参函数
def factory():      #制造一个工厂
    print('正在制造手机')     #代码相当于员工和机器、
factory()

# 有参函数
# 需要根据外部传进来的参数  才能执行相应的逻辑，计算（工厂制造手机，需要a零件和b零件）
def factory(a,b):      #制造一个工厂
    #形参：指的是在定义函数阶段括号内指定变量名，即形参本质就是“变量名”
    #形参可以看是作一个变量名
    print('a是%s' %a)
    print('b是%s' %b)
    #2.实参：指的是在调用函数阶段括号内传入的值，即实参本质就是“值”
    #调用函数的参数称为实参
    #形参与实参的关系：在调用函数时，会将实参（值）赋值（绑定）给形参（变量名）
###注意：但凡按照位置定义的形参，必须被实参传值，多一个也不行，少一个也不行
###错误示范：print（1）   print（123）
factory(1,2)

#关键字实参
# 在调用函数阶段，按照key=value的形式指名道姓的为形参传值
# 注意：
#   1.可以完全打乱顺序，但仍能指名道姓的为指定的形参传值
#   2.可以混合使用位置实参与关键字实参，但是必须注意：
#       1.位置实参必须放到关键字实参前面
#       2.不能对一个形参重复赋值

def factory(a,b):      #制造一个工厂
    print('a是%s' %a)
    print('b是%s' %b)
factory(a=1,b=2)
factory(b=1,a=2)
# 错误示范
factory(a=1,a=1)
factory(a=1,2)
factory(1,a=2)

# 默认参数：指的是在定义函数阶段，就已经为某个形参赋值了，改形参称之为有默认值的形参，简称默认形参
# 注意：
# 1.在定义阶段就已经被赋值，意味着在调用阶段不用为其赋值
# 2.位置形参应该放到默认形参前面
# 3.默认形参的值在函数定义阶段就已经固定死了
def factory(a,b=2):
    #形参：指的是在定义函数阶段括号内指定的变量名，即形参本质就是“变量名”
    #形参可以看作是一个变量名
    print('a是%s' %a)
    print('b是%s' %b)
factory(1)
factory(1,45)

# 位置形参vs默认形参
# 对于大多数情况下传的值都不相同时   应该定义成位置形参
# 对于大多数情况下传的值都相同时     应该定义成默认形参
def register(name,age,sex = '男'):
    print(name,age,sex)
register('zhangxi',18)
register('bojiahao',18)
register('xuwei',20)
register('liuhaiyan',20,'女')
register('yangzuofan',19)

##可变长度的参数（不定长参数）
# 1.在形参中带*：会将调用函数时溢出位置实参保存成元组的形式，然后赋值*后的变量名
def foo(x,y,*z):
    print(x)
    print(y)
    print(z)
    print(type(z))      #输出为元组
    #元组打散
    print(*z)
foo(1,2,3,4,5,6,7,8)


# 实参打散
def foo(x,y,z):
    print(x,y,z)
# foo(1,*(2,3,4)) #报错
foo(1,*(2,3))
foo(*[1,2,3])
foo(*'123')

# 字典无序  不能打散
dic = {'name':'zhangxi','age':'20'}
print(**dic)

# 1.在形参中带*： 会将调用函数时溢出位置实参保存成元组的形式，然后赋值*后的变量名
# 2.在形参中带**：会将调用函数时溢出关键字实参保存成字典的形式，然后赋值**后的变量名
def foo(x,y,**z):
    print(x)
    print(y)
    print(z)

# 错误
foo(1,2,3)
# 正确
foo(1,2,a=1,b=2,c=3)

# 实参可以打散字典变成关键字实参进行传参
a = {'a':1,'b':2,'c':3}
foo(1,2,**a)


## 规范  在形参中带*和**的，*后面的变量名应该为args，**后跟的变量名应该为kwargs
def factory(*args,**kwargs):
    print(args)
    print(kwargs)
factory()
factory(1,2,3,4,a=1,b=2,c=3)        #可带无穷个

三、拆包

# 一个元素对应一个变量
a,b,c = [1,2,3]
print(a)
print(b)
print(c)

# 多个元素对应一个变量
*a,b,c = [1,2,3,4,5,6,7,8]
a,*b,c = [1,2,3,4,5,6,7,8]
a,b,*c = [1,2,3,4,5,6,7,8]
#只能有一个变量带*
print(a)
print(b)
print(c)

四、函数的返回值

# 什么时返回值
# L = [1,2,3,4]
# # a = L.append(5)
# a = L.pop()
# print(L)
# print(a)

# 返回值是一个函数的处理结果（物流）   return
'''
注意：
    1.return是一个函数结束的标志，函数内可以有多个return
        但只要执行依次，整个函数就会结束运行
        默认return None
    2.return的返回值无类型限制，即可以是任意数据类型
    3.return的返回值无个数限制，即可以用逗号分隔开多个任意类型的值
        0个：返回None ， ps：不写return默认会在函数最后一行添加return None
        1个：返回的值就是该值本身
        多个：返回值是元组
    4.return关键字：return是函数结束的标志，利用这一点就可以结束循环
'''

# 默认return None
def factory(a):
    
	if a == 1:
    	return 'www'
	return 1	
	return [1,2,3]
	pass
	return True
	return True ,1,2,'aaa'      #返回元组


a = factory(1)
print(a)

# return关键字：return是函数结束的标志，利用这一点就可以结束循环
def factory(a):
    print('=====')
    print('=====')
    print('=====')
    print('=====')
    print('=====')
    while True:
        while True:
            while True:
                if a == 3:
                    return
                a += 1
                print(a)
factory(1)

def factory(a):     #制造一个工厂
    print('正在制造手机')     #代码相当于员工和机器
    print(a)        #这个a是在函数里面用  相当于自己做了一个a零件  工厂自己用
    return a        #这个a是吧这一个a零件给到物流公司return 发往全世界
a = factory(1)
print(a)

五、装饰器：

# 函数调用的三种方式
# 1.语句形式
def foo():
    print('from foo')
foo()
# 2.2表达式形式
def foo(x,y):
    res = x + y
    return res
res = foo(1,2)
print(res)
res1 = foo(1,2)*100
print(res1)
# 2.3 可以当作参数传给另一个函数
def max(x,y):
    if x>y:
        return x
    else:
        return y
print(max(1,2))
print(max(3,2))
print(max(3,5))
print(max(max(1,2),max(3,2)))

六、局部变量和全局变量的修改

# 1.外部不能访问函数内部的变量
def foo():
    x = 1
print(x)


# 函数内部能够访问函数外部的变量
x = 123
def foo():
    print(x)
foo()


# 函数里面不能修改函数外部的变量
x = 123
def foo():
    # 局部变量在赋值前被引用
    x = x+1
foo()


# global  能让我们在函数里面去修改全局变量的值
x = 123
def foo():
    global x
    x = x+1
    print(x)
foo()


# nonlocal  让嵌套函数能够修改嵌套函数之外的值
def foo1():
    a = 100
    def foo2():
        nonlocal a
        a += 1
        print(a)
    foo2()
foo1()

七、常用的内置函数

# 1.已经写好的一些函数   美观  强大

# #绝对值
print(abs(-5))
print(abs(5))


# all（可迭代对象）   返回的是布尔值
# 可迭代对象里面的值全部为真才是真  其余为假
# 可迭代对象是空则为真
print(all([1,'',None]))
print(all([1,'aaa',2]))
print(all(''))


# any (可迭代对象）
# 可迭代对象里面的值全部为假才是假  其余为真
# 可迭代对象是空则为假
print(any([0,'',None,1]))
print(any([0,'',None,]))
print(any([]))


# 聚合函数   求最大值  最小值   求和
a = [1,2,5,7,9]
# #求最大值
print(max(a))
# #求最小值
print(min(a))
# #求和
print(sum(a))


# # ascii  英文的字符编码
# # ord()  可以把字符转换成编码
# # chr()  可以把编码转换成字符
print(ord('a'))
print(chr(97))
print(ord('A'))
print(chr(65))


# # 拉链函数   zip
t1 = ['a','b','c','d','e']
t2 = [1,2,3,4]
# # 通过索引
print(zip(t1,t2))
# print(list(zip(t1,t2)))
print(dict(zip(t1,t2)))     #转换成字典


# # 介绍  exec 函数   可以执行字符串里面的代码
exec("print('hello world')")

exec('''
for i in range(0,10):
    print(i)
''')

八、对于函数来说 return是什么

    return表示把程序流程从被调函数转向主调函数并把表达式的值带回主调函数，实现函数值的返回，返回时可附带一个返回值，由return后面的参数指定。
    return通常是必要的，因为函数调用的时候计算结果通常是通过返回值带出的。如果函数执行不需要返回计算结果，也需要返回一个状态码表示函数执行的顺利与否（-1和0就是最常用的状态码），主调函数可以通过返回值判断被调函数的执行情况。

九、练习

输入三个数字，写一个函数将三个数字从小到大输出
x=int(input('x='))
y=int(input('y='))
z=int(input('z='))
if x>y:
    x,y=y,x
if x>z:
    x,z=z,x
if y>z:
    y,z=z,y
print(x,y,z)

定义一个函数，计算1到999的和，用for循环完成

def main():
    sum = 0
    for x in range(0,999):
        sum += (x + 1)
        print(sum)
if __name__ == '__main__':
    main()