Python——函数用法和底层分析 ( 上 ) [ 笔记 ]

于 2019-08-26 17:47:16 发布
阅读量202 收藏 1
点赞数
分类专栏： Python 文章标签： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43595176/article/details/100069228
版权

Python——函数用法和底层分析（上）

067. 函数简介

  函数是可重用的程序代码块。 函数的作用，不仅可以实现代码的复用，更能实现代码的一致性。一致性指的是，只要修改函数的代码，则所有调用该函数的地方都能得到体现。

函数的基本概念

  1. 一个程序由一个个任务组成；函数就是代表一个任务或者一个功能。
  2. 函数是代码复用的通用机制。

Python函数的分类

  1. 内置函数
      我们前面使用的str()、list()、len()等这些都是内置函数，我们可以拿来直接用。
  2. 标准库函数
      我们可以通过import语句导入库，然后使用其中定义的函数。
  3. 第三方库函数
      Python社区也提供了很多高质量的库。下载安装这些库后，也是通过import语句导入，然后可以使用这些第三方库的函数。
  4. 用户自定义函数
      用户自己定义的函数，显然也是开发中适应用户自身需求定义的函数。

函数的定义和调用

核心要点

  Python中，定义函数的语法如下：
def   函数名([参数列表]):
  “文档字符串”
  函数体/若干语句

要点：

  1. 我们使用 def 来定义函数，然后就是一个空格和函数明书
    (1) Python执行def时，会创建一个函数对象，并绑定到函数名变量上。
  2. 参数列表
    (1) 圆括号内是形式参数列表，有多个参数则使用逗号隔开
    (2) 形式参数不需要声明类型，有多个参数则使用逗号隔开
    (3) 无参数，也必须保留空的圆括号
    (4) 实参列表必须与形参列表一一对应
  3. return返回值
    (1) 如果函数体中包含return语句，则结束函数执行并返回值
    (2) 如果函数体不包含return语句，则返回None值
  4. 调用函数之前，必须要先定义函数，即先调用def创建函数对象
    (1) 内置函数对象会自动创建
    (2) 标准库和第三方库的函数，通过import导入模块时，会执行模块中的def语句
# 函数的定义和调用
def test01():   # 函数的定义
    print("!"*10)
    print("?"*10)

print(id(test01))
print(type(test01))
print(test01)

test01()   # 函数的调用

for i in range(5):   # 循环结构下调用函数
    test01()

pic5-1

068. 函数的参数和注释

形参和实参

  • 形参：形式参数是在定义函数时使用的，形式参数的命名只要符合“标识符”命名规则即可。
  • 实参：在调用函数时，传递的参数称为“实际参数”，简称“实参”。
  1. 圆括号内是形式参数列表，有多个参数则使用逗号隔开。
  2. 形式参数不需要声明类型，有多个参数则使用逗号隔开。
  3. 无参数，也必须保留空的圆括号。
  4. 实参列表必须与形参列表一一对应。
# 形参和实参
def printMax(a,b):   # 此处的a,b为形参
    if a>b:
        print(a,"较大值")
    else:
        print(b,"较大值")
printMax(10,20)   # 此处的10,20为实参

文档字符串（函数的注释）

  程序的可读性最为重要，一般建议在函数体开始的部分附上函数定义说明，这就是“文档字符串”，也有人称为“函数的注释”。我们通过 三个单引号 或者 三个双引号 来实现，中间可以加入多行文字进行说明。
  我们调用help(函数名.__doc__可以打印输出函数的文档字符串。

# 形参和实参
def printMax(a,b):   # 此处的a,b为形参
    '''用于比较两个数的大小'''   # 函数的注释 / 文档字符串
    if a>b:
        print(a,"较大值")
    else:
        print(b,"较大值")
printMax(10,20)   # 此处的10,20为实参
print(printMax.__doc__)   # 打印输出函数的文档字符串

运行结果：
pic5-2

069. 返回值

  1. 如果函数体中包含return语句，则结束函数执行并返回值。
  2. 如果函数体不包含return语句，则返回None值。
  3. 要返回多个返回值，使用列表、元组、字典、集合将多个值“存起来”即可。
# 返回值
def add(a,b):
    print("计算两个数的和：{0}+{1}={2}".format(a,b,(a+b)))
    return (a+b)   # 返回值
c = add(20,30)   # 将返回值赋给c
print(c)   # 打印c
print(add(20,30))   # 可也直接调用

def test():
    print("abc")
    print("123")
    return   # return有两个作用：①返回值 ②结束函数执行
    print("hello")   # return后不执行
d = test()   # 将返回值赋给d
print(d)   # 返回值为None

070. 函数也是对象，内存底层分析

  Python中，“一切都是对象”。 实际上，执行def定义函数后，系统就创建了相应的函数对象。

# 函数也是对象
def test01():
    print("123")

test01()   # 可直接调用

c = test01   # 另一种方法，将test01的值赋给c
c()   # c与test01指向同一个对象

071. 变量的作用域（全局变量和局部变量）

  变量起作用的范围称为变量的作用域，不同作用域内同名变量之间互不影响。变量分为：全局变量、局部变量。

全局变量：

  1. 在函数和类定义之外声明的变量。作用域为定义的模块，从定义位置开始到模块结束。
  2. 全局变量降低了函数的通用性和可读性。应尽量避免全局变量的使用。
  3. 全局变量一般做常量使用。
  4. 函数内要改变全局变量的值，使用global声明一下。

局部变量：

  1. 在函数体中（包括形式参数）声明的变量。
  2. 局部变量的引用比全局变量快，优先考虑使用。
  3. 如果局部变量和全局变量同名，则在函数内隐藏全局变量，只使用同名的局部变量
# 全局变量、局部变量
a = 3   # 全局变量
def test01():
    b = 4   # 局部变量,作用域仅在函数内
    print(b*10)
    global a   # 需要改变全局变量a时，应用global声明
    a = 300
    print(a)   #  打印全局变量a（若无global声明变量a，则此时的a是局部变量，非全局变量）
    print(locals())  # 打印局部变量
    print(globals())  # 打印全部变量
test01()   # 调用时启动栈帧

072. 局部变量和全局变量的效率测试

  局部变量的查询和访问速度比全局快，优先考虑使用，尤其是在循环的时候。
  在特别强调效率的地方或者循环次数较多的地方，可以通过全局变量转为局部变量提高运行速度。

# 局部变量和全局变量的效率
import math
import time
# 全局变量
def test01():
    start = time.time()
    for i in range(1000000):
        math.sqrt(30)
    end = time.time()
    print("使用全局变量的耗时{0}".format((end-start)))
# 局部变量
def test02():
    b = math.sqrt
    start = time.time()
    for i in range(1000000):
        b(30)
    end = time.time()
    print("使用局部变量的耗时{0}".format((end-start)))
test01()
test02()

运行结果：
pic5-3

073. 参数的传递

  函数的参数传递本质上就是：从实参到形参的赋值操作。 Python中，“一切皆对象”，所有的赋值操作都是“引用的赋值”。所以Python中参数的传递都是“引用传递”，不是“值传递”。具体操作时分为两类：

  1. 对“可变对象”进行“写操作”，直接作用于原对象本身。
  2. 对“不可变对象”进行“写操作”，会产生一个新的“对象空间”，并用新的值填充这块空间。（起到其他语言的“值传递”效果，但不是“值传递”）

可变对象有：
  字典、列表、集合、自定义的对象等

不可变对象有：
  数字、字符串、元组、function等

传递可变对象的引用

  传递参数是可变对象（例如：列表、字典、自定义的其他可变对象等），实际传递的还是对象的引用。在函数体中不创建新的对象拷贝，而是可以直接修改所传递的对象。

# 传递可变对象的引用
a = [10,20]
print(id(a))   # 打印a的id
print(a)   # 打印a
def test01(m):
    print(id(m))   # a和m是同一个对象
    m.append(30)   # 由于m是可变对象，不创建对象拷贝，直接修改这个对象
    print(m)   # 打印m
test01(a)
print(a)   # 此时的a已经改变

运行结果：
pic5-4

074. 传递不可变对象的引用

  传递参数是不可变对象（例如：int、float、字符串、元组、布尔值），实际传递的还是对象的引用。在“赋值操作”中，由于不可变对象无法修改，系统会新创建一个对象。

075. 浅拷贝和深拷贝

  • 浅拷贝（copy）：不拷贝子对象的内容，只是拷贝子对象的引用。
  • 深拷贝（deepcopy）：会连子对象的内存也全部拷贝一份，对子对象的修改不会影响原对象。
# 浅拷贝和深拷贝
import copy
def testCopy():
    '''测试浅拷贝'''
    a = [10, 20, [7, 8]]
    b = copy.copy(a)
    print("a：", a)
    print("b：", b)  # 浅拷贝只是拷贝子对象的引用
    b.append(30)
    b[2].append(25)
    print("---浅拷贝---")
    print("a：", a)
    print("b：", b)
def testDeepCopy():
    '''测试深拷贝'''
    a = [10, 20, [7, 8]]
    b = copy.deepcopy(a)
    print("a：", a)  # 深拷贝,子对象的修改不会影响原对象
    print("b：", b)
    b.append(30)
    b[2].append(25)
    print("---深拷贝---")
    print("a：", a)
    print("b：", b)

运行结果：
pic5-5
pic5-6

076. 传递不可变对象是浅拷贝

  传递参数是不可变对象（例如：int、float、字符串、元组、布尔值），实际传递的还是对象的引用。但在“写操作”时，会创建一个新的对象拷贝。这个拷贝使用的是“浅拷贝”，不是“深拷贝”。

# 传递不可变对象时，不可变对象里面包含的子对象是可变的，
# 则方法内修改了这个可变对象，原对象也发生了改变
a = (10,20,[5,6])   # 元组是不可变对象
print("a：",a)
def test01(m):
    print("m：",id(m))
    m[2][0] = 88   # 修改的是列表，列表是可变对象
    print(m)
    print("m：", id(m))
test01(a)
print(a)

运行结果：
pic5-7

小胡小胡一团浆糊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值