Python 函数的基本知识

---

一、for循环

for循环表达式 虽然与 while 一样都是循环的关键字，但 for 循环通常用来遍历可迭代的对象
我们一定要注意以下几点：
1、 for … in …: 属于固定格式
2 、iterable 表示 可迭代的对象
3 、i 是 变量名(可更改)，代表可迭代对象里面的每个元素
1、range()
这个呢比较简单，我们就用几行代码来表示

print(type(range))  # <class 'type'> range是类
print(range(10))    # 1.默认从0开始 2.默认返回的是range()对象
print(list(range(10)))# 3.左闭右开
range(start,stop,step)
print(list(range(1, 10, 2)))    # 4.步长默认为1
print(list(range(1:10:2)))  # 5.不是切片的冒号

循环控制 for循环嵌套的应用，打印输出九九乘法表

for i in range(10):
    for j in range(1,i+1):
        print("{}x{}={}".format(j,i,i*j),end=' ')
    print()
"""
输出：
1x1=1 
1x2=2 2x2=4 
1x3=3 2x3=6 3x3=9 
1x4=4 2x4=8 3x4=12 4x4=16 
1x5=5 2x5=10 3x5=15 4x5=20 5x5=25 
1x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36 
1x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49 
1x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64 
1x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81 
"""

二、函数

1、函数介绍

函数介绍： 函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。 函数作用：提高应用的模块性与代码的复用性
自定义函数
定义规则：
1、函数代码块以def关键词开头 ，后接函数标识符名称和圆括号()
2、圆括号中间 可以 放入参数
3、函数内容以冒号起始，并且缩进。 def function_name(param): print(’ func code ')
注意： 函数只有在调用时才会执行，通过function_name(param)进行调用
比如说我写一个实现两个数相加的函数，光写出来还不行，需要调用才能出结果

def add(a ,b):
    return a+b
i=10
j=20
print(add(i,j))
"""
输出：
30
"""

2、函数的参数

函数的参数可分为形参与实参，可变类型参数与不可变类型参数，位置参数，关键字参数，默认值参数 可变长度参数
形参与实参：
1、形参就是函数定义中的 参数，没有实际的值，通过别人赋值后才有意义，相当于变量。
2、实参就是调用函数时传入的 参数，是一个实际存在的参数。

def add(a ,b):#形参
    return a+b
i=10
j=20
print(add(i,j))#实参
"""
输出：
30
"""

3、可变类型参数与不可变类型参数：
（1）、不可变类型参数在函数体内对变量重新赋值，相当于重新开辟了一块内存来保存值
（2）、可变类型参数在函数体内可以改变原有的值
这两句话怎么理解呢，我们可以举个栗子，我们可以发现下面的代码段中，a输出的值不一样，因为整数是不可变类型的变量，在函数内部改变a的值相当于在内存中重新开辟了一个地址，函数内部的a与函数外部的a，是两个不同的a，只是同名而已。我们可以看出来这两个a的地址是不一样的。

def test1(a):
   a=10
   print("in：",a,id(a))
a=1
test1(a)
print("out:",a,id(a))
"""
输出：
in： 10 2003987760
out: 1 2003987472
"""

我们再来看这个例子，如果是可变数据类型，例如一个列表，函数当中的列表和函数外面的列表是同一个，所以可以被修改

def test1(li):
    li.append(10)
    print("in：",li,id(li))
li=[1,2,3,4,5]
test1(li)
print("out:",li,id(li))
"""
输出：
in： [1, 2, 3, 4, 5, 10] 2041451266696
out: [1, 2, 3, 4, 5, 10] 2041451266696
"""

4、位置参数：
位置参数也就是实参与形参顺序一一对应，而不论变量名
函数调用时的实参顺序，与函数定义的形参位置一一对应，比如说我举个栗子，a，b为两个不同的整数，调用时交换两个实参的位置，对应形参的位置，与原来不调换位置是不同的

def sum1(a, b):
   res = a + b
   print(f"a:{a}")
   print(f"b:{b}")
   print(f"{a} + {b} = {res}")

a = int(input("请输入a:"))
b = int(input("请输入b:"))
sum1(a,b)
sum1(b,a)# 位置参数：实参与形参的顺序是一一对应。不论变量名。实参与形参个数一致

"""
输出：
请输入a:10
请输入b:20
a:10
b:20
10 + 20 = 30
a:20
b:10
20 + 10 = 30
"""

5、关键字参数：
这里就有个特殊情况了，与位置参数不同，关键字参数是以形参 = 实参形式指定，不论参数位置
我们可以举个栗子

def sum1(a, b):
   res = a + b
   print(f"a:{a}")
   print(f"b:{b}")
   print(f"{a} + {b} = {res}")


a = int(input("请输入a:"))
b = int(input("请输入b:"))
sum1(a,b)
sum1(b=b,a=a)# 关键字参数：不受位置影响
"""
输出：
请输入a:10
请输入b:20
a:10
b:20
10 + 20 = 30
a:10
b:20
10 + 20 = 30
"""

6、默认值参数：
形参处进行赋值，所以当调用时不传该参数就默认使用形参处的值。当调用时传了该参数，则覆盖掉默认参数。
我再举个栗子：

def test_one(a, b=2):
    a = a + b
    print(a, b)

a = 1
test_one(a)#默认值参数，当不传时，就为形参指定的值。
test_one(a, 10)#如果在实参中传了，会覆盖掉形参中指定的值。
"""
输出：
3 2
11 10
"""

7、可变长度参数：
（1）、*args 接收时会转为元组数据类型
（2）、**kwargs 接收时会转为字典数据类型
解包操作：a,b,c = (1,2,3)
*args：可变长度的参数，你可以传也可不传，并且长度不做限制。但是会给你统一打包为元组。
我们举个栗子，这个例子就将传入的一系列元素打包成了元组输出：

def test1(*args):    # 形参
   print(args)

test1("whistle", 2, 3, 4, 5, 6)  
"""
输出：
('whistle', 2, 3, 4, 5, 6)
"""

这里我们要注意一下，python3.0以后，*args参数后面只能跟关键字参数

def test_one(*args, a=1, b):    # 形参
   print(args ,a,b)

test_one("amy", 2, 3, 4, 5, 7, a=10, b=20)   # (1, 2, 3)
"""
输出：
('amy', 2, 3, 4, 5, 7) 10 20
"""

（3）、**kwargs --> 可变长度的参数，你可以传也可不传，并且长度不做限制。实参传需要传入键值对，然后形参会将它打包为字典

def test_one(**kwargs):
   print(kwargs)

test_one(a=1, b=2, c=3)


a, b, c = (1, 2, 3)#拆包
print(a,b,c,sep="\n")
"""
输出：
{'a': 1, 'b': 2, 'c': 3}
1
2
3
"""

位置参数，形参实参个数一致 并且一一对应
元组拆包

def test_one(a, b, c):
   print(a, b, c)

tu = (1, 2, 3)
test_one(*tu)   # 1,2,3
test_one(1, 2, 3)
"""
输出：
1 2 3
1 2 3
"""

3、函数的返回值

当两个函数之间，想要互相使用到内部变量时，就可以应用到函数的返回值
函数的返回值定义
1、使用 return 关键字返回内容
2、将内容 返回到函数调用处
3、函数体中没有return语句时，函数运行结束, 则默认返回 None，也被称为隐含返回值
4、当执行函数体内代码时，遇到第一个 return 就将指定值返回到函数调用处，也就是执行到 return这行代码，后面的都不执行了。
小栗子： 摄氏度与华氏度关系如：摄氏度/1.8 + 32 = 华氏度需求：
定义函数1：用于输出摄氏度
定义函数2：通过摄氏度计算得出华氏度

#定义摄氏度函数
def c_temp():
   c_t = 14
   print(f"今天的摄氏度：{c_t}")
   # 如果不做任何返回，默认返回值为None
   # 将c_t返回到该函数的调用处
   return c_t

#定义华氏度函数
def f_temp(c_t):
   f_t = round(c_t/1.8 + 32, 2)
   print(f"今日的华氏度：{f_t}")

if __name__ == '__main__':#函数在定义完之后，统一在最后去调用
   c_t2 = c_temp()#接收摄氏度函数的返回值
   f_temp(c_t2)     #实参
"""
输出：
今天的摄氏度：14
今日的华氏度：39.78
"""

5、多个返回值时，用逗号隔开，默认为元组
def function_name(param1,param2): return param1 return param2 res = function_name(param)
例如我们可以利用这个来进行拆包和解包的操作

def test1():
   a,b,c=(1,2,3)
   return a,b,c
res=test1()
print(res)
a,b,c=test1()
print(a)
print(b)
print(c)
"""
输出：
(1, 2, 3)
1
2
3
"""

4、函数的作用域

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。
我们具体地来看几个例子
例1局部变量

def test_one():
   # 局部变量，该变量的作用域在函数体内部
   a = 5
   print(a)
a=10
print(a)
test_one()
"""
输出：
10
5
"""

例2，根据全局变量与局部变量的优先级，我们的结果来自不同的变量a

a = 100#全局变量

def test_one():
   print(f"a = {a}")   # 在局部没有时，则取全局变量中找。100

def test_two():
   a = 200     # 局部变量
   print(f"a = {a}")   # 当局部有该变量时，则优先局部的。200

test_one()
test_two()
"""
输出：
a = 100
a = 200
"""

Python 的作用域一共有4种， 分别是：
1、L(local)：局部作用域，即函数中定义的变量;
2、E(enclosing)：嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是 全局的;
3、G(global)：全局变量，就是模块级别定义的变量;

a = 100#全局变量

def test_one():
   print(f"a = {a}")   # 在局部没有时，则取全局变量中找。100

def test_two():
   global a#使用global关键字将局部变量转化为全局变量
   a =a+ 200#这两个a都是外边那个值为100的a     
   print(f"a = {a}")  

test_one()
test_two()
"""
输出：
a = 100
a = 300
"""

4、B(build-in)：内建作用域，系统固定模块里面的变量，比如:int()等;
global关键字 当我们需要在函数内部直接修改全局变量时，我们可以将函数内部的局部变量通过 global 关键字声明为全局变量。