python--函数基础一

一、函数意义：可读性，复用性强

# def my_len(s):        #def 关键词开头，my_len函数名
#     i=0
#     for k in s:
#         i+=1
#     print(i)
#     return i             #返回值，没有返回值则打印出的是none
# lenth=my_len()     #函数调用
# print(lenth)

函数

1.返回值三种类型:

返回值的3种情况
1.1没有返回值 —— 返回None
        不写return
        只写return:结束一个函数的继续
        return None  —— 不常用

1.2返回1个值
    # 可以返回任何数据类型
    # 只要返回就可以接收到
    # 如果在一个程序中有多个return，那么只执行第一个
1.3返回多个值
    # 用多个变量接收：有多少返回值就用多少变量接收
    # 用一个变量接收: 得到的是一个元组

def func():
     return {'k':'v'}
print(func())       ------->      #{'k': 'v'}

def func2():
     return 1,2,3
r= func2()
print(r)         ------->  # (1,2,3)

返回值

2.

s = '金老板小护士'

def my_len(s):------------>s形式参数，形参;

ret=my_len('金老板小护士') ----->传递参数：传参;#'金老板小护士':实际参数，实参

#参数
    #没有参数
        #定义函数和调用函数时括号里都不写内容
    #有一个参数
        #传什么就是什么
    #有多个参数
        #位置参数

#站在实参的角度上：
    #按照位置传参
    #按照关键字传参
    #混着用可以:但是 必须先按照位置传参，再按照关键字传参数
            #  不能给同一个变量传多个值

#站在形参的角度上
    #位置参数：必须传,且有几个参数就传几个值
    #默认参数: 可以不传，如果不传就是用默认的参数，如果传了就用传的

def classmate(name,sex='男'):
    print('%s : %s'%(name,sex))

classmate('二哥')
classmate('小孟')
classmate('大猛')
classmate('朗哥','女')
输出：
二哥 : 男
小孟 : 男
大猛 : 男
朗哥 : 女

参数练习

#只有调用函数的时候
    #按照位置传 ： 直接写参数的值
    #按照关键字： 关键字 = 值

3.动态参数

#定义函数的时候：
    #位置参数 ： 直接定义参数
    #默认参数，关键字参数 ：参数名 = '默认的值'
    #动态参数 : 可以接受任意多个参数
                #参数名之前加*，习惯参数名args，
                #参数名之前加**，习惯参数名kwargs
    #顺序：位置参数，*args,默认参数,**kwargs

普通参数例题

# 动态参数有两种：可以接受任意个参数
    #*args   ： 接收的是按照位置传参的值，组织成一个元组
    #**kwargs： 接受的是按照关键字传参的值，组织成一个字典
    #args必须在kwargs之前

def sum(*args):
    n = 0
    for i in args:
        n+=i
    return n
print(sum(1,2))                     -------》3
print(sum(1,2,3)) -------》6
print(sum(1,2,3,4)) -------》10

def func(**kwargs):
    print(kwargs)

func(a = 1,b = 2,c =3)  -         ------》{'a': 1, 'c': 3, 'b': 2}#字典
func(a = 1,b = 2)                      -------》{'a': 1, 'b': 2}
func(a = 1)                                    -------》{'a': 1}

动态参数例题

def func(*args,default = 1,**kwargs):
    print(args,kwargs)
func(1,2,3,4,5,default=2,a = 'aaaa',b = 'bbbb',)
输出：(1, 2, 3, 4, 5) {'a': 'aaaa', 'b': 'bbbb'}
注释： #顺序：位置参数，*args,默认参数,**kwargs

混合动态参数

4.动态参数的另一种传参方式

def func(*args):   #站在形参的角度上，给变量加上*，就是组合所有传来值。
    print(args)
func(1,2,3,4,5)
                              输出 ----》(1, 2, 3, 4, 5)
l = [1,2,3,4,5]
func(*l)  #站在实参的角度上，给一个序列加上*，就是将这个序列按照顺序打散
                              输出-------》(1, 2, 3, 4, 5)
def func(**kwargs):
    print(kwargs)
func(a=1,b=2)                 输出 -----》{'b': 2, 'a': 1}
d = {'a':1,'b':2}            #定义一个字典d
func(**d)
                              输出----------》{'b': 2, 'a': 1}

5.默认参数陷阱

如果默认参数可变的数据类型，在每一次调用的时候，没有传入参数的就会公用一个数据类型资源.

def xing(l=[]):
    l.append(1)
    print(l)
    return  l
xing()                #[1]
xing()                #[1, 1]
xing([1,2])      #[1, 2, 1] #传入参数了，就不会沿用公共的数据类型资源了
xing()     #[1, 1, 1]

6 三种类型的命名空间：

一：内置命名空间----->python解释器
二:全局命名空间-----》我们写的代码，但不是函数代码
三：局部命名空间-----》函数
                 当调用函数的时候 才会产生这个名称空间 随着函数执行的结束 这个命名空间就又消失了
三个层级命名空间只能从下往上调用，不能从上往下调用

函数名====》函数内存地址
函数名（）===》调用函数
函数内存地址（）====》调用函数
7 两种作用域
全局作用域：===》作用全局====>内置和全局命名空间都可以作用   globals()
局部作用域===》作用局部====》函数                      locals()
8.名字空间的使用层级

#在正常情况下，直接使用内置的名字
#当我们在全局定义了和内置名字空间中同名的名字时，会使用全局的名字
#当我自己有的时候 我就不找我的上级要了
#如果自己没有 就找上一级要 上一级没有再找上一级 如果内置的名字空间都没有 就报错
# 多个函数应该拥有多个独立的局部名字空间，不互相共享

def max(l):
    print('in max func')
print(max([1,2,3]))         输出-----------》in max func
#当我们在全局定义了和内置名字空间中同名的名字时，会使用全局的名字

def input():
    print('in input now')
input()                              输出 ----------》in input now
#当我自己有的时候 我就不找我的上级要了

def func():
    input = 1
    print(input)
func()                               输出-----------》1
#如果自己没有 就找上一级要 上一级没有再找上一级 如果内置的名字空间都没有 就报错