python 函数（简单定义和作用）

---

前言

函数：本篇 “BOKE” 简单介绍了函数的定义，作用和一些方法,初写文章还望海涵

---

以下是本篇文章正文内容

函数

1. 作用

1, 让代码看起来更加清晰整洁

2， 一次封装，随处调用

def s():
    a = input("请您任意输入一个数字：")
    if a.isdigit():
        return ("您当前输入的数字为：%s" %a)
    else:
        return ("您的输入有误，请重新输入")

# 请你连续输入多个数字，并打印
while True:
    ss=s()  # 此时就简简单单调用个 s() 函数就可以实现
    print(ss)

2. 定义

1， def 解释器只要看到 “def” 就知道了是在定义函数

2， 函数名称

3， 函数名后面跟一对 （）

4，（） 后面跟 “：”

5， 最后一步 换行缩进后 写要封装的代码内容

此时此刻 函数已经定义完毕

def method():
    return "封装的内容"  # “return”  关键字下面有提起
s=method()

3. 参数

1， 定义函数时 例如：def f1（a，b）其中的 a，b 叫做形参，形参的名称可以随便定义

2， a和b 所接受到的值可以在函数体中使用

3， 调用函数时的 例如： f1（5,6） 其中的 5和6 叫做实参，其实就是你想使用的真实的数据（有另一种写法，如下所示：）

def f1(a):
    print(("我的实际值其实是和实参“n”一样为%d"%a))
n=5
f1(n)      # 此时的  n  具体值其实还是  5

# 上面的两种传入  实参  的方法看情况，简单的话直接传入即可，复杂的话就定义一下再写，（总结：就是让代码看起来  整洁，清晰）

3.1默认参数

def default(age=10):      # age=10  就是默认参数
    print(f"我的年龄是{age}岁")   # 不传入实参的话，直接输出“10”这个结果（默认的结果）

default(age=20)   # 如果不传入实参“20”进去，也不会报错，因为形参的位置有默认参数“10”

3.2关键字参数

def key(name,age):
    print(f"我的名字是{name}，年龄为{age}")   # 附结果：我的名字是tom，年龄为10

key(age=10,name="tom")    # 即使交换两个实参的位置也不会影响传递的准确性，因为声明了age就是10，name就是“tom”

3.3位置参数

def location(one,two,tree,four,five):
    print(one,two,tree,four,five) # 输出结果为： 1,2,3,4,5（方便大家理解）

location(1,2,3,five=5,four=4)  # ”位置参数“ 一定要写在 “关键字参数” 前面

3.4不定长参数

（“不定长参数，”其实就是“可变参数”）

*args ：可以接收0~任意多个位置参数，并打包成 “tuple”元组
**kwargs：可以接收0~任意多个关键字参数，并打包成“dict”字典

def add(*args, **kwargs):
    print(args, type(args))
    print(kwargs,type(kwargs))
    # print(kwargs, type(kwargs))
    total = 0
    for arg in args:
        if type(arg) in (int, float):
            total += arg
    for value in kwargs.values():
        if type(value) in (int, float):
            total += value
    return total


print(add(1, 2, 4, a=3))

""" 附输出的结果：
(1, 2, 4) 
{'a': 3} 
10

"""

下面这个例子加以理解：
def printinfo(arg1, *vartuple):  # 加了星号（*）的变量名会存放所有未命名的变量参数。下面具体对应（60,50）这两个实参
    "打印任何传入的参数"
    print ("输出: ")
    print(arg1)
    for var in vartuple:
        print(var)

printinfo(10)
printinfo(70, 60, 50)

4. 返回值

4.1 return语句

[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None

1， 函数的内部通过 “return” 关键字 向函数的外部返回的内容， 这就叫做函数的 “返回值”

2， 接受函数的返回值：在函数外部定义一个变量接受一下即可

def fashion(f):
    return f"这里是我的{f}"
f=fashion("领域")
print(f)

def o():
    return   # 因为“return”后面没有要返回的东西 ，所以返回结果为：None
s=o()
print(s)  # 附结果：None

2021.9.14

5. 作用域

1，一个函数，就会生成一个独立的作用域
2，在一个函数内部声明的变量，只能在这个函数内部访问，在此函数外部无法访问
3，在函数内部声明的变量，叫做局部变量，在函数外部声明的变量叫做全局变量

5.1全局变量

全局变量---------(函数内部不能直接访问全局变量)

age = 18
def f1():
    global age   # 告诉函数内部，操作的是全局变量、
    age = 30
    print(f"函数内部打印的 age：{age}") # 解释器会认为i在 f1 函数内部又声明了一个叫做 age 的变量，值位 30
f1()
print(age)

# 函数内部不声明与全局变量同一个变量名的变量话，默认访问的就是全局变量

age = 30


def f1():
    # 函数内部如果没有声明与全局变量同名的变量，则默认访问的就是全局变量
    print(age)
    age = 40


f1()

多个函数公用全局变量：（经典辨别函数的 “作用域”）

glo_num = 10


def test1():
    global glo_num
    glo_num = 20


def test2():
    print(glo_num)


test1()
test2()

5.2局部变量

局部变量---------（只能在函数内部访问，而全局不能访问的）

s=0
def part():
    s=5
    print(s)   # 输出结果为 “5”：访问的是 s=5 中的s
part()
print(s)   # 输出结果为 “0” :访问的为全局的“s”

5.3拆包：

t1 = ('a', 'b', 'c', 'd', 10, 20)

# 拆包
n1, n2, n3, n4, n5, n6 = t1
print(n1, n2, n3, n4, n5, n6)


# 拆包应用-元组拆包
def f1():
    return 10, 20


n1, n2 = f1()
print(n1, n2)

# 字典拆包
dict1 = {'name': 'TOM', 'age': 18}
a, b = dict1
print(a, b)
print(dict1[a])

2021.9.15

6. 内存地址

1， 如果两个变量所引用的值一样的话，那么这两个变量用来储蓄的内存地址也是一样的

a=10
b=10
print(id(a),id(b))

2, 反之，如果两个变量所引用的值不同的话，那么这两个变量用来储蓄的内存地址是不一样的

c=1
d=2
print(id(c),id(d))

7. 变与不变

7.1 不可变类型

1，“int” 类型是不可以改变的

i1 = 1
i2 = i1
i1 = 2         # 因为 “int”类型的不可变性，所以这就是重新赋值 （之前的“i1=1” 已经无效了）

print("此时”i1“所引用的的内存地址：%s"%id(i1),
      "此时”i2“所引用的的内存地址：%s"%id(i2))    

# 附上运行结果方便理解(此时”i1“所引用的的内存地址：19624080   此时”i2“所引用的的内存地址：19624064)

7.2可变类型

2, “list” 列表是可变的类型

l1=[1,2,3]
print("l1引用的内存地址为：%s"%id(l1))
# l1引用的内存地址为：15173000

l2=l1
print("l2引用的内存地址为：%s"%id(l2))
# l2引用的内存地址为：15173000

l1.append(4)   #   由于“list”的可变性，所以只是在原列表 “l1” 中增加了 “4” 这个值，因此，并不需要重新去赋值

print("此时”l1“所引用的的内存地址：%s"%id(l1),
      "此时”l2“所引用的的内存地址：%s"%id(l2))

# 附上运行结果：此时”l1“所引用的的内存地址：15173000 此时”l2“所引用的的内存地址：15173000

小结： 总之，对于 “int” 这种不可变的数据类型，只能通过重新赋值来进行一系列操作，因此内存地址也发生了变化；

​ 对于 ”list“ 这种可变的数据类型，将会在原有的 ”模板“ 中进行一系列操作，所以内存地址自始自尊也不会发生变化

3，“dict” 字典也是可变类型，所以同理

def dic(a):
      a["fist"]=3
      print("此时的 “dict1” 所指向的地址是:%s"%id(dict1)) # 附结果：（此时的 “dict1” 所指向的地址是:22962656）

dict1={"fist":1,"second":2,"third":3}
print("此时的 “dict1” 所指向的地址是:%s"%id(dict1))   # 附：此时的 “dict1” 所指向的地址是:22962656
dic(dict1)
print("此时的 “dict1” 所指向的地址是:%s"%id(dict1))   # 附：此时的 “dict1” 所指向的地址是:22962656

# 可以看出在 “dict” 中同样只是在原有的基础上进行改变，所以所指向的内存地址永远不变