Python全栈-第十课学习笔记

Python第十课学习笔记

形参角度

万能参数。
*和**的魔性用法。

# 万能参数
# 下面的例子相当于写死了程序，未来添加功能不方便
def eat(a,b,c,d):
	print('我请你吃：%s,%s,%s,%s' %(a,b,c,d))
    
eat('蒸羊羔', '蒸熊掌', '蒸鹿邑','烧花鸭')

# 未来改的时候只能在源码上改
def eat(a,b,c,d,e,f):
	print('我请你吃：%s,%s,%s,%s,%s,%s' %(a,b,c,d,e,f))
    
eat('蒸羊羔', '蒸熊掌', '蒸鹿邑','烧花鸭','烧雏鸡','烧子鹅')

# 急需要一种形参，可以接受所有的实参。  万能参数
# 万能参数： *args, 约定俗称：args
# 函数定义时，*代表聚合。他将所有的位置参数聚合成一个元组，赋值给了args。
def eat(*args):
	print(args)
	print('我请你吃：%s,%s,%s,%s,%s,%s' % args)
    
eat('蒸羊羔', '蒸熊掌', '蒸鹿邑','烧花鸭','烧雏鸡','烧子鹅')

# 写一个函数：计算你传入函数的所有的数字的和。
def func(*args):
	count = 0
	for i in args:
		count += i
	return count
print(func(1,2,3,4,5,6,7))

# **kwargs
# 函数的定义时：** 将所有的关键字参数聚合到一个字典中，将这个字典赋值给了kwargs.
def func(**kwargs):
	print(kwargs)
func(name='jarvis',age=18,sex='boy')

# 万能参数：*args, **kwargs，
def func(*args,**kwargs):
	print(args)
	print(kwargs)
func()
print()

# * **在函数的调用时，*代表打散。
def func(*args,**kwargs):
    print(args) # (1,2,3,22,33)
    print(kwargs)
    
func(*[1,2,3],*[22,33])  		# func(1,2,3,22,33) 将两个列表打散

func(**{'name': 'jarvis'},**{'age': 18})  # func(name='jarvis',age='18') 将两个字典打散

仅限关键字参数（了解）

形参的最终顺序

# 形参角度的参数的顺序
# *args 的位置？
# 错误的位置
def func(*args,a,b,sex= '男'):
	print(a,b)
func(1,2,3,4)

# args得到实参的前提，sex必须被覆盖了。
# 方法一
def func(a,b,sex= '男',*args,):
	print(a,b)
	print(sex)
	print(args)
func(1,2,3,4,5,6,7,)

#方法二
def func(a,b,*args,sex= '男'):
	print(a,b)
	print(sex)
	print(args)
func(1,2,3,4,5,6,7,sex='女')

# **kwargs 位置？
def func(a,b,*args,sex= '男',**kwargs,):
    print(a,b)
    print(sex)
    print(args)
    print(kwargs)
func(1,2,3,4,5,6,7,sex='女',name='jarvis',age=80)

# 形参角度第四个参数：仅限关键字参数 (了解)
# 仅限关键字参数必须在*args和**kwargs中间，并且只能通过关键值参数进行传值
def func(a,b,*args,sex= '男',c,**kwargs,):
	print(a,b)
    print(sex)
    print(args)
    print(c)
    print(kwargs)
func(1,2,3,4,5,6,7,sex='女',name='Alex',age=80,c='666')

# 形参角度最终的顺序：位置参数,*args,默认参数，仅限关键字参数，**kwargs

名称空间

在python解释器开始执行之后, 就会在内存中开辟一个空间, 每当遇到一个变量的时候, 就把变量名和值之间的关系记录下来, 但是当遇到函数定义的时候, 解释器只是把函数名读入内存, 表示这个函数存在了, 至于函数内部的变量和逻辑, 解释器是不关心的. 也就是说一开始的时候函数只是加载进来, 仅此而已, 只有当函数被调用和访问的时候, 解释器才会根据函数内部声明的变量来进行开辟变量的内部空间. 随着函数执行完毕, 这些函数内部变量占用的空间也会随着函数执行完毕而被清空.
我们首先回忆一下Python代码运行的时候遇到函数是怎么做的，从Python解释器开始执行之后，就在内存中开辟里一个空间，每当遇到一个变量的时候，就把变量名和值之间对应的关系记录下来，但是当遇到函数定义的时候，解释器只是象征性的将函数名读入内存，表示知道这个函数存在了，至于函数内部的变量和逻辑，解释器根本不关心。
等执行到函数调用的时候，Python解释器会再开辟一块内存来储存这个函数里面的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量回储存在新开辟出来的内存中，函数中的变量只能在函数内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。
我们给这个‘存放名字与值的关系’的空间起了一个名字-------命名空间。
代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间；
在函数的运行中开辟的临时的空间叫做局部命名空间也叫做临时名称空间。

# 名称空间；命名空间。
a = 1      		#开辟全局名称空间
b = 2			#放入全局名称空间
def func():		#放入全局名称空间
	f = 5		#放入局部名称空间
	print(f)	#执行完局部名称空间消失
c = 3			#放入全局名称空间
func()			#开辟局部名称空间

# 内置名称空间：python源码给你提供的一些内置的函数，print input
# python分为三个空间：
# 内置名称空间（builtins.py）
# 全局名称空间（当前py文件）
# 局部名称空间（函数，函数执行时才开辟）

# 加载顺序：
# 内置名称空间 ---> 全局名称空间  ----> 局部名称空间（函数执行时）
def func():		#放入全局名称空间
	pass
func()			#开辟局部名称空间
a = 5			#放入全局名称空间

# 取值顺序（就近原则） 单向不可逆
# （从局部找时）局部名称空间  ---> 全局名称空间  --->  内置名称名称空间
# LEGB原则
# L:local
# E:enclosed
# G:global
# B:built-in
name = '1234'
def func():
    name = 'jarvis'
    print(name)
    
func()

作用域

# python两个作用域：
# 全局作用域：内置名称空间 全局名称空间
# 局部作用域：局部名称空间

# 局部作用域可以引用（无法改变）全局作用域的变量
date = '周五'
def func():
	a = 666
	print(date)
	print(a)
func()

# 局部作用域不能改变全局变量。
count = 1
def func():
	count += 2
	print(count)
func()  
# local variable 'count' referenced before assignment
# 局部作用域不能改变全局作用域的变量，当python解释器读取到局部作用域时，发现了你对一个变量进行修改的操作，解释器会认为你在局部已经定义过这个局部变量了，他就从局部找这个局部变量，报错了。

# 使用可以，不能改变
# local variable 'count' referenced before assignment
def func():
    count = 1
    def inner():
        count += 1
        print(count)
    inner()
func()

函数的嵌套（高阶函数）

# 练习题
# 例1（分别打印什么）
def func1():
    print('in func1')
    print(3)

def func2():
    print('in func2')
    print(4)

func1()
print(1)
func2()
print(2)
# in func1 3 1 in func2 4 2


# 例2（分别打印什么）
def func1():
    print('in func1')
    print(3)

def func2():
    print('in func2')
    func1()
    print(4)

print(1)
func2()
print(2)


# 例3（分别打印什么）
def fun2():
    print(2)

    def fun3():
        print(6)

    print(4)
    fun3()
    print(8)

print(3)
fun2()
print(5)

内置函数 globals() locals()

"""
本文件：研究内置函数：globals locals
"""
a = 1
b = 2
def func():
    name = 'jarvis'
    age = 18
    print(globals())  	# 返回的是字典：字典里面的键值对：全局作用域的所有内容。
    print(locals())  	# 返回的是字典：字典里面的键值对：当前作用域的所有的内容。
print(globals())  		# 返回的是字典：字典里面的键值对：全局作用域的所有内容。
print(locals())  		# 返回的是字典：字典里面的键值对：当前作用域的所有的内容。
func()

posted @ 2020-04-17 00:13 Raoguozhong 阅读(117) 评论(0) 编辑收藏举报

刷新页面返回顶部

Raoguozhong

Python全栈-第十课 学习笔记

Python第十课 学习笔记

形参角度

名称空间

公告

Python全栈-第十课学习笔记

Python第十课学习笔记