python-变量-参数-递归函数

变量作用域（全局变量和局部变量）

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

全局变量

        1.在函数和类定义之外声明的变量。作用域为定义的模块,从定义位置开始直到模块结束。

        2.全局变量降低了函数的通用性和可读性。应尽量避免全局变量的使用。

        3.全局变量一般做常量使用。

        4.函数内要改变全局变量的值,使用global声明一下

局部变量

        1.在函数体中(包含形式参数)声明的变量。

        2.局部变量的引用比全局变量快,优先考虑使用。

        3.如果局部变量和全局变量同名,则在函数内隐藏全局变量,只使用同名的局部变量

全局变量和局部变量效率测试

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

#测试局部变量、全局变量的效率

import math
import time

def test01():
    start = time.time()
    for i in range(10000000):
        math.sqrt(30)
    end = time.time()
    print("耗时{0}".format((end-start)))

def test02():
    b= math.sqrt
    start = time.time()
    for i in range(10000000):
        b(30)
    end = time.time()
    print("耗时{0}".format((end-start)))

test01()
test02()

参数的传递

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

         1.对“可变对象”进行“写操作”, 直接作用于原对象本身。

         2.对“不可变对象”进行"写操作””,会产生-个新的“对象空间” ,并用新的值填充这块空间。( 起到其他语言的“值传递"效果，但不是“值传递”)

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

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

传递可以变对象的引用

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

#测试参数的传递
#传递可变对象

a =[10, 20]

print(id(a))
print(a)
print("****************************")
def test01(m):
    print(id(m))
    m.append(300)
    print(id(m))


test01(a)
print(a)

 传递不可变对象的引用

        传递参数是不可变对象(例如: int. float. 字符串、元组、布尔值) , 实际传递的还是对象的引用。在"赋值操作”时,由于不可变对象无法修改,系统会新创建一个对象。

#测试传递不可变对象
a = 100
def f1(n):
    print("n",id(n))    #传递进来的是a对象的地址
    n = n+200           #由于a是不可变对象.因此创建新的对象n
    print("n",id(n))    #n已经变成了新的对象
    print("n")
f1(a)
print("a",id(a))

传递不可变对象含可变子对象

#传递不可变对象时，发生的拷贝是“浅拷贝”
a = (10,20,[5,6])
def test01(m):
    print("m",id(m))
    m[2][0] = 888
    print(m)
    print("m",id(m))

test01(a)

 深拷贝和浅拷贝

了解参数传递底层原理，可以用内置函数copy(),deepcopy()

        浅拷贝:不拷贝子对象的内容,只是拷贝子对象的引用。

        深拷贝:会连子对象的内存也全部拷贝一份,对子对象的修改不会影响源对象

#测试深浅拷贝

import copy

a = [10, 20, [5, 6]]
b = copy.copy(a)

print("a:", a)
print("b", b)

b.append(30)
b[2].append(7)
print("浅拷贝")
print("a",a)
print("b",b)

def testDeepCopy():
    a = [10, 20, [5, 6]]
    b = copy.deepcopy(a)

    print("a:", a)
    print("b", b)

    b.append(30)
    b[2].append(7)
    print("深拷贝")
    print("a", a)
    print("b", b)

testDeepCopy()

参数的类型

位置参数

        函数调用时,实参默认按位置顺序传递,需要个数和形参匹配。按位置传递的参数,称为:“位置参数”

默认值参数

        我们可以为某些参数设置默认值,这样这些参数在传递时就是可选的。称为“默认值参数”，默认值参数放到位置参数后面。

命名参数

        我们也可以按照形参的名称传递参数,称为“命名参数”也称"关键字参数”，

可变参数

        可变参数指的是“可变数量的参数”。分两种情况:

        1. *param(-个星号) , 将多个参数收集到一个“元组"对象中。

        2. **param (两个星号) , 将多个参数收集到一个“字典"对象中。

强制命名参数

        在带星号的"可变参数”后面增加新的参数,必须是“强制命名参数”。

递归函数

递归函数指的是:自己调用自己的函数,在函数体内部直接或间接的自己调用自己。递归类似于大家中学数学学习过的“数学归纳法”。每个递归函数必须包含两个部分 :

        1.终止条件

                表示递归什么时候结束。-般用于返回值,不再调用自己。

        2.递归步骤

                把第n步的值和第n-1步相关联。

递归函数由于会创建大量的函数对象、过量的消耗内存和运算能力。在处理大量数据时.谨慎使用。

#测试递归函数的基本原理

def test01(n):
    print("test01:",n)
    if n==0:
        print("over")
    else:
        test01(n-1)
    print("test01***",n)

test01(3)

 阶乘计算

#使用递归函数，计算阶乘

def factorial(n):

    if n==1:
        return 1
    else:
        return n*factorial(n-1)

result = factorial(7)
print(result)