Python初级笔记6 函数

函数概念

• 函数是一段具有特定功能的代码的集合。
• 函数的目的主要在于降低编程难度与增加代码复用。
• 一组语句等价于一个函数，，需要使用这组语句的地方直接调用函数名即可。
• 函数的定义也叫函数的声明，定义后的函数不能直接运行需要通过调用

---

函数定义 

python使用保留字def定义函数

def 函数名（参数）：

        函数体

        return（返回值列表）

• 函数遇见return会立即返回退出，不会执行函数内return下边的代码
• 没有设置返回值时，默认的返回值时null
• return只能返回一个值
• 不需要定义参数类型，因为python是弱数据语言

def print_hi():
    print("helo world")
print_hi()

结果：

PS E:\学习笔记\Python> & E:/Python/python.exe e:/学习笔记/Python/3.28/函数.py
helo world

---

 本地变量（局部变量）和全局变量：

• 局部变量：

• 声明在函数内部的变量，可以return出去，外面可以拿个变量接住
• 形参，在函数括号中，是局部变量
• 局部变量只能在函数内部被访问

• 全局变量：

• 不在函数内定义，在任何地方都可以被读取
• 函数内部可以访问全局变量
• 默认情况下全局变量不能被函数内更改
• 在函数内用global就可以更改全局变量 

a=0
def hello():
    print("hello world!!")
    global a
    a+=1
for i in range(0,4):
    hello()
print(f"一共运行了{a}遍")

• ：每当一个程序被调用的时候 ，会立刻在内存中形成一个执行栈（先进后出），函数调用的时候会把堆中函数程序地址压入栈中，函数执行完毕会立刻弹栈。
• 磁盘：存储数据的地方，cpu不可能直接从磁盘读取数据，因为读写速度慢。
• 内存：可以理解为一个缓冲区，内存读写速度快。
• 比如，要运行一段程序，程序在磁盘中存着，将磁盘中的程序加载到内存中向CPU提供数据
• 函数存放到堆中，因为栈的空间有限，
• 局部变量在被函数调用的时候会被压入栈中，函数执行完毕会出栈，失去内存地址，访问不到局部变量

运算器+控制器=cpu
存储器=内存+磁盘

---

值传递与引用传递 

1、值传递

• 传递的是值
• 将数值赋给形参，形参传回去变成局部变量，函数无法直接修改全局变量

def t(a,b):
    a+=6
    b+=2
x=1
y=9
t(x,y)
print(x)
print(y)

函数外的X，Y没有改变 

结果：

PS E:\学习笔记\Python> & E:/Python/python.exe e:/学习笔记/Python/3.29/值传递与引用传递.py
1
9

2、引用传递 

• 传递的是内存地址
• 列表是引用对象

def k(a):
    a.append("zhang")

list1=[1,2,3,5,"tyu"]
k(list1)
print(list1)

数组在函数中被修改，是因为地址被传回去了 

结果：

PS E:\学习笔记\Python> & E:/Python/python.exe e:/学习笔记/Python/3.29/值传递与引用传递.py
[1, 2, 3, 5, 'tyu', 'zhang']

---

练习 

def isvalid(a,b,c):
    if a+b>c and a+c>b and b+c>a:
        return 1
    else:
        print("错误")
        return 0
def valid(a,b,c):
    if isvalid(a,b,c)==1:
        p=0.5*(a+b+c)
        v=(p*(p-a)*(p-b)*(p-c))**0.5
        print(f"三角新面积为：{v}")
    else:
        pass

a,b,c=eval(input("enter three num="))
valid(a,b,c)

---

 默认参数值

大多情况下，该参数值不需要改变，书写位置一般在正常参数后面，方便用户调用函数

def t(a,b=5):
    return a+b
a,b=eval(input("enter the num="))
k=t(a)
print(k)

结果：

PS E:\学习笔记\Python> & E:/Python/python.exe e:/学习笔记/Python/3.29/默认参数.py
enter the num=1,3
6

若指向列表：

def test(num=[]):
    num.append("zhangsan")
    print(num)
test()
test()

 结果：

PS E:\学习笔记\Python> & E:/Python/python.exe e:/学习笔记/Python/3.29/默认参数.py
['zhangsan']
['zhangsan', 'zhangsan']

注意：默认参数指向不可变数据类型

---

可变参数（*args）

返回一个元组

def s(a,b,*c):
    print(f"c={c}")
    sum=a+b
    for i in c:
        sum+=i
    return sum
print(f"sum={s(1,1,2,2,3)}")

结果:

PS E:\学习笔记\Python> & E:/Python/python.exe e:/学习笔记/Python/3.29/可变参数.py
c=(2, 2, 3)
sum=9

让第一个参数不是数组

如果说传进去的是元组或者列表，只需要在元组或者列表前加*，就会把元组或列表作为可变参数传进去

def s(*c):
    print(f"c={c}")

a=[6,9,0]
print(s(*a))
print(s(a))

 结果：
PS E:\学习笔记\Python> & E:/Python/python.exe e:/学习笔记/Python/3.29/可变参数.py
c=(6, 9, 0)
None
c=([6, 9, 0],)
None

---

关键字参数 （命名参数）

将键值对传回去

def x(name,age,**kw):
    print(f"name={name},age是{age},其他是{kw}")

# x("zhangsan",13,job="画家",hobby="sing")
d={"job":"漫画家","hobby":"画画睡觉吃饭"}
x("zhangsan",13,**d)

结果：

PS E:\学习笔记\Python> & E:/Python/python.exe e:/学习笔记/Python/3.29/关键字参数.py
name=zhangsan,age是13,其他是{'job': '漫画家', 'hobby': '画画睡觉吃饭'} 

---

函数作为参数

def t():
    print("test1----")

def t2(fn):
    fn()
    print("test2~~~")
t()
t2(t)

结果：

PS E:\学习笔记\Python> & E:/Python/python.exe e:/学习笔记/Python/3.29/函数参数.py
test1----
test1----
test2~~~

匿名函数 lambda表达式

lambda 参数[参数]：函数 

def t2(fn):
    fn()
    print("test2~~~")
t2(lambda:print("佳人们谁懂"))

结果：

PS E:\学习笔记\Python> & E:/Python/python.exe e:/学习笔记/Python/3.29/函数参数.py
佳人们谁懂
test2~~~

def t2(fn):
    print(fn(1,4))
    print("test2~~~")
t2(lambda a,b:a+b)#自动返回，不用return

 结果：

PS E:\学习笔记\Python> & E:/Python/python.exe e:/学习笔记/Python/3.29/函数参数.py
5
test2~~~

函数名=lambda<参数列表>：表达式

>>> f=lambda x,y:x+y
>>> print(type(f))
<class 'function'>
>>> f(2,3)
5

---

偏函数 

使用偏函数可以有效固定所谓预先确定的参数来缓存函数参数，然后在函数运行时获得所需要的剩余参数，最后将缓存的函数参数释放，并且传递最终的参数中去，从而使用最终确定的所有参数去调用函数。

偏函数语法：

partial(func,*arg,**keywords) 

语法说明：

第一部分是函数，这个函数是自定义的函数，也可以使python的内置函数

第二部分是可变参数*args；

第三部分是一个关键字参数，如python内置函数int的第二个参数就是命名关键字参数。

运用偏函数实现十六进制数至十进制数的转换
 

import functools        #导入functoolsi模块

int_tran functools.partial(int,base=16)

print(int_tran('100'))

#第一个参数为Pythonl内置的int0数
#int()函数可以把字符串转换为整数，当仅传入字符串时，
int()函数默认按十进制转换
#如果传入base参数，就可以做N进制的转换，此处可选参
数给定的参数值是base=16

程序的运行结果为：
256
#based的值取10表小示转换为十进制数
print(int_tran('1000',base=10))

例子

def multiply(x, y):

    return x * y

from functools import partial

double = partial(multiply, y=2)

print(double(3))  # Output: 6

例子2： 

编写一个数据处理程序，需要处理不同类型的数据。它可以接受任意类型的数据，并根据 data_type 参数的值来决定如何处理数据。

def process_data(data, data_type):
    if data_type == 'text':
        return data.lower()
    elif data_type == 'number':
        return data * 2
    else:
        return str(data)

现在，我们希望创建一些特定的函数来处理文本数据和数字数据。我们可以使用偏函数来轻松地做到这一点：

from functools import partial

process_text_data = partial(process_data, data_type='text')
process_number_data = partial(process_data, data_type='number')

print(process_text_data('Hello World'))  # Output: 'hello world'
print(process_number_data(5))  # Output: 10