函数

  

# 函数是对功能或者动作的封装
# 函数的定义:
def yue():
    print("拿出手机")
    print("打开陌陌")
    print("找一找心怡的对方.")
    print("出来吃吃饭")
    print("唱唱歌")
    print("跳跳广场舞")

# 函数的调用:  函数名()
yue()
print("回家休息休息")
yue() # 动作就可以在任何时候， 在任何位置， 进行访问

# 当函数执行之后。可以给调用者一个返回值
def yue(): # 参数
    print("拿出手机")
    print("打开陌陌")
    print("找一找心怡的对方.")
    print("出来吃吃饭")
    print("唱唱歌")
    print("跳跳广场舞")
    return "小姐姐", "小护士", "广场舞大妈"
    # return "小姐姐"  # return表示返回。 这个函数在调用之后会得到一个结果
ret = yue() # 当函数有返回值的时候。 我们可以不接受返回值
print(ret)

# 在函数中如果不写return 表示函数没有返回值。调用方接收到的是None
# return 可以终止一个函数的运行
# 在函数中写了return。 但是return后面不跟值， 表示函数没有返回值。 接受的是None。
# 在函数中写return。 return后面跟一个值
# 在函数中写return。 return 后面可以跟上多个值, 表示返回多个值。 接收方收到的是元组

# 形参
def yue(tools): # 在函数声明的位置。 给出来的参数叫形参。 形式上的一个参数. 用一个变量来表是
    print("拿出手机")
    print("打开%s" % tools)
    print("找一找心怡的对方.")
    print("出来吃吃饭")
    print("唱唱歌")
    print("跳跳广场舞")

# 实参
# 在函数调用的时候。把实参的值赋值给形参的过程叫传参
yue("微信") # 在函数调用的地方给出的具体的值。 参数叫实参. 实际参数
yue("陌陌")
yue("探探")

def chi(good_food, no_good_food, drink):
    print("我要吃",good_food, no_good_food, drink)

# chi("大米饭", "冰峰", "炸鸡")
# chi(drink="哇哈哈", no_good_food="薯条", good_food="盖浇饭")
chi("小米饭", "辣条", drink="可乐")

def regist(name,sex="男", age=18): # 语法上不允许
    print(name, age, sex)

regist("刘", 22)
regist("李", 27)
regist("高", 18, "女")
regist("李", 27)

# 实参的分类:
# 1. 位置参数. 按照位置。 给形参赋值
# 2. 关键字参数. 按照形参的名字给参数赋值
# 3. 混合参数, 位置参数必须放在前面。 关键字参数放后面
# 
# 形参的分类(3大类)
# 1. 位置参数 按照位置来声明形参
# 2. 默认值参数, 当给参数传递值的时候。 默认值不起作用, 不给值。 默认值起作用. 保证你至少有个值能用
# 顺序: 位置参数必须放在前面。 默认值参数必须放在后面
# 
# 
# 函数：对功能或者动作的封装
# 登陆验证
def login(username, password):
    if username == 'alex' and password == "123":
        return True
    else:
        return False

# 使用场景
name = input("请输入你的账号:")
pws = input("请输入你的密码:")
if login(name, pws):
    print("进入空间")
else:
    print("用户名或密码错误， 请重新登陆!")

# f(x) = x + 1
# f(3) = 3 + 1 = 4
def f(x):
    return x + 1
print(f(2))

s = "你好啊我叫塞利亚"
print(len(s))

def my_len(s):
    count = 0
    for el in s:
        count+=1
    return count
print(my_len(s))

　

def chi(*food): # * 表示的是不定参数. 可以传递任意个信息 参数名是food, 接受到的是元组
    print("我要吃", food)

chi("一锅大米饭", "一箱辣条", "一桶方便面", "4L可乐")
chi("方便面")
chi("一大锅米饭", "一小锅小米饭", "一箱辣条", "一桶方便面", "4L可乐")

# * 表接收位置参数的动态传参
# 传参的顺序
# 位置 *args 默认值 **kwargs
# 
# 如果默认值参数在*args前面. 如果想让默认值生效. *args将永远接不到值
def func( a, b, *args,c = 5): # arguments参数
    print(a, b, c, args)

func(1,2,3,4,5,6,8,c = 10)

# 关键字的动态传参
# *args 位置参数 接收到的是元组
# **kwargs 关键字的动态传参, 接收到的是字典
def func(**kwargs): # key word arguments
    print(kwargs)

func(a=10, b=20, jay="周杰伦", jj="林俊杰")

# 无敌模式. 所有的参数都能接收
def func(*args, **kwargs):
    print(args)
    print(kwargs)

func(1, 2, 5, jj="陶喆", jay="zhoujielun", soup="胡辣汤")

def func(*args): # 在这里. 其实相当于把传进来的参数做了一次聚合, 聚合成一个元组
    print(args)

lst = "娃哈哈"
func(*lst) #  在实参位置 * 表示打散, 打散的是可迭代对象


def func(**kwargs): # ** 把接收到的关键字参数打包(聚合)成字典
    print(kwargs) # 一定是字典

dic = {"张无忌": "明教教主", "谢逊": "金毛狮王", "范瑶": "光明右使"}

# func(张无忌=dic['张无忌'], 谢逊=dic['谢逊'], 范瑶=dic['范瑶'])
func(**dic) # 这里的** 是把字典打散. 字典的key作为参数的名字, 字典的值作为参数的值传递给形参

# 在形参上
#   1. 位置参数
#   2. 默认值参数
#   3. 动态参数
#       1. *args  位置参数的动态传参. 系统会自动的把所有的位置参数聚合成元组
#       2. **kwargs  关键字的动态传参. 系统会自动把所有的关键字参数聚合成字典
#       3.  def func(*args, **kwargs): 无敌传参
#       4. 顺序:  位置参数, *args, 默认值, **kwargs
#       5. 在使用的时候, 可以任意的进行搭配
#   4. 在实参上. *, **表示的打散.  在形参. *,** 表示聚合

　　

# 最开始会开辟一个自己的命名空间- 内置名称空间
a = 10
print(a)
# 直接在py文件一个层面上是全局名称空间
def func():
    hasakey = 10
# 在函数内部属于局部名称空间
func()
# 加载顺序: 内置 => 全局 => 局部
# 取值顺序: 局部 => 全局 => 内置

a = 10 # 全局
def func():
    # a = 20
    print(a)

func()

# 作用域: 变量或者函数的声明周期
# 全局作用域: 全局名称空间+内置名称空间
# 局部作用域: 局部名称空间
a = 10 # 全局
def func():
    liuwei = "刘伟"

# 1. globals() 查看全局作用域中的所有内容
qiao = "乔峰"
def 抗收音机():
    bgm = "难念的经"
    print("娃哈哈")
    print(locals())
抗收音机()

print(globals()) # 查看全局作用域中的内容
print(locals()) # locals()查看的是当前作用域中的内容

　　

def func1():
    print("我是func1")

def func2():
    print("我是func2")
    func1()

def func3():
    func2()
    print("我是func3")
func3()
# 这样的代码不是嵌套. 互相调用
# 
# 函数可以互相嵌套
def outer():
    def inner():
        print("我是内部")
    print("我是外部")
    inner()

outer()

def outer():
    print("我是外面的")
    def inner_1():
        def inner_2():
            print("我是里面的2")
        inner_2()
        print("我是里面的1")
    inner_1()
    print("我是外面的收尾")

outer()

a = 10
def func():
    global a #表示在当前作用域中的使用的a是全局中的变量
    a = 20 # 所有的a都是外面的了
    print(a) # 现在只有看的权利

print(a) # 10
func() # 20
print(a) # 20


def outer():
    a = 10
    def inner():
        nonlocal a # 找的是局部当中, 离他最近的上层的那个变量
        a = 20
        print(a)
    print(a) # 10
    inner() # 20
    print(a) # 20
outer()



a = 1
def fun_1():
    a = 2
    def fun_2():
        nonlocal a
        a = 3
        def fun_3():
            a = 4
            print(a)
        print(a)
        fun_3()
        print(a)
    print(a)
    fun_2()
    print(a)
print(a)
fun_1()
print(a)

# global 引入全局变量, 可以定义全局变量
# nonlocal 引入局部中离他最近的外层变量

def func():
    global a # 没有也得有. 自动帮你创建
    a = 20

func()
print(a)