【Python】基础语法三

> 作者：დ旧言~
> 座右铭：松树千年终是朽，槿花一日自为荣。

> 目标：了解Python的函数、列表和数组。

> 毒鸡汤：有些事情，总是不明白，所以我不会坚持。早安!

> 专栏选自：Python基础知识_დ旧言~的博客-CSDN博客

> 望小伙伴们点赞👍收藏✨加关注哟💕💕

一、函数

1.1、函数是什么

编程中的函数和数学中的函数有一定的相似之处：

数学上的函数, 比如 y = sin x , x 取不同的值, y 就会得到不同的结果.
编程中的函数, 是一段 可以被重复使用的代码片段 .

代码示例: 求数列的和, 不使用函数

# 1. 求 1 - 100 的和
sum = 0
for i in range(1, 101):
    sum += i
print(sum)
 
# 2. 求 300 - 400 的和
sum = 0
for i in range(300, 401):
    sum += i
print(sum)
 
# 3. 求 1 - 1000 的和
sum = 0
for i in range(1, 1001):
    sum += i
print(sum)

可以发现, 这几组代码基本是相似的, 只有一点点差异. 可以把重复代码提取出来, 做成一个函数

实际开发中, 复制粘贴是一种不太好的策略. 实际开发的重复代码可能存在几十份甚至上百份.
一旦这个重复代码需要被修改, 那就得改几十次, 非常不便于维护.

代码示例: 求数列的和, 使用函数

1.2、语法格式

创建函数/定义函数：

def 函数名(形参列表):
    函数体
    return 返回值

调用函数/使用函数：

函数名(实参列表)           // 不考虑返回值
返回值 = 函数名(实参列表)   // 考虑返回值

函数必须先定义, 再使用:

1.3、函数参数

在函数定义的时候, 可以在 ( ) 中指定 "形式参数" (简称形参), 然后在调用的时候, 由调用者把 "实际参数"(简称实参) 传递进去.这样就可以做到一份函数, 针对不同的数据进行计算处理.

代码案例:

# 定义函数
def CalcSum(begin,end):
    sum = 0
    for i in range(begin,end + 1):
        sum += i
    print(sum)
 
# 调用函数
CalcSum(1, 100)
CalcSum(300, 400)
CalcSum(1, 1000)

上面的代码中, begin, end 就是函数的形参. 1, 100 / 300, 400 就是函数的实参：

在执行 sum(1, 100) 的时候, 就相当于 beg = 1, end = 100 , 然后在函数内部就可以针对 1-100 进行运算.
在执行 sum(300, 400) 的时候, 就相当于 beg = 300, end = 400 , 然后在函数内部就可以针对300-400 进行运算.

注意:

一个函数可以有一个形参, 也可以有多个形参, 也可以没有形参.
一个函数的形参有几个, 那么传递实参的时候也得传几个. 保证个数要匹配.

1.4、函数返回值

函数的参数可以视为是函数的 "输入", 则函数的返回值, 就可以视为是函数的 "输出" ：

此处的 "输入", "输出" 是更广义的输入输出, 不是单纯指通过控制台输入输出.
我们可以把函数想象成一个 "工厂". 工厂需要买入原材料, 进行加工, 并生产出产品.
函数的参数就是原材料, 函数的返回值就是生产出的产品.

下列代码：

def calcSum(begin, end):
    sum = 0
    for i in range(begin, end + 1):
        sum += i
    print(sum)
calcSum(1, 100)

# 可以转换成
def calcSum(begin, end):
    sum = 0
    for i in range(begin, end + 1):
        sum += i
    return sum
sum = calcSum(1, 100)
print(sum)

这两个代码的区别就在于, 前者直接在函数内部进行了打印, 后者则使用 return 语句把结果返回给函数调用者, 再由调用者负责打印.

我们一般倾向于第二种写法：

实际开发中我们的一个通常的编程原则, 是 "逻辑和用户交互分离". 而第一种写法的函数中, 既包含了计算逻辑, 又包含了和用户交互(打印到控制台上). 这种写法是不太好的, 如果后续我们需要的是把计算结果保存到文件中, 或者通过网络发送, 或者展示到图形化界面里, 那么第一种写法的函数,就难以胜任了.
而第二种写法则专注于做计算逻辑, 不负责和用户交互. 那么就很容易把这个逻辑搭配不同的用户交互代码, 来实现不同的效果.

一个函数中可以有多个 return 语句：

def isOdd(num):
    if num % 2 == 0:
        return False
    else:
        return True
 
result = isOdd(10)
print(result)

如果 num 是偶数, 则进入 if 之后, 就会触发 return False , 也就不会继续执行 return True

一个函数是可以一次返回多个返回值的. 使用 , 来分割多个返回值：

def getPoint():
    x = 10
    y = 20
    return x, y
a, b = getPoint()

如果只想关注其中的部分返回值, 可以使用 _ 来忽略不想要的返回值：

def getPoint():
    x = 10
    y = 20
    return x, y
_, b = getPoint()

1.5、变量作用域

观察以下代码：

def getPoint():
    x = 10
    y = 20
    return x, y
x, y = getPoint()

在这个代码中, 函数内部存在 x, y, 函数外部也有 x, y.但是这两组 x, y 不是相同的变量, 而只是恰好有一样的名字.

变量只能在所在的函数内部生效.在函数 getPoint() 内部定义的 x, y 只是在函数内部生效. 一旦出了函数的范围, 这两个变量就不再生效了.

在不同的作用域中, 允许存在同名的变量，虽然名字相同, 实际上是不同的变量：

注意:

在函数内部的变量, 也称为 "局部变量"
不在任何函数内部的变量, 也称为 "全局变量"

如果函数内部尝试访问的变量在局部不存在, 就会尝试去全局作用域中查找：

如果是想在函数内部, 修改全局变量的值, 需要使用 global 关键字声明：

1.6、函数执行过程

解释说明：

调用函数才会执行函数体代码. 不调用则不会执行.
函数体执行结束(或者遇到 return 语句), 则回到函数调用位置, 继续往下执行.

这个过程还可以使用 PyCharm 自带的调试器来观察：

点击行号右侧的空白, 可以在代码中插入断点
右键, Debug, 可以按照调试模式执行代码. 每次执行到断点, 程序都会暂停下来.
使用 Step Into (F7) 功能可以逐行执行代码.

1.7、链式调用

前面的代码很多都是写作：

# 判定是否是奇数
def isOdd(num):
   if num % 2 == 0:
       return False
   else:
       return True
 
result = isOdd(10)
print(result)

实际上也可以简化写作：

print(isOdd(10))

把一个函数的返回值, 作为另一个函数的参数, 这种操作称为链式调用.

1.8、嵌套调用

函数内部还可以调用其他的函数, 这个动作称为 "嵌套调用" ：

def test():
   print("执行函数内部代码")
   print("执行函数内部代码")
   print("执行函数内部代码")

test 函数内部调用了 print 函数, 这里就属于嵌套调用.

一个函数里面可以嵌套调用任意多个函数：

1.9、函数递归

概念：

递归是嵌套调用中的一种特殊情况, 即一个函数嵌套调用自己：

代码示例: 递归计算 5!

def factor(n):
    if n == 1:
        return 1
    return n * factor(n - 1) # 自己调用自己
result = factor(5)
print(result)

注意: 递归代码务必要保证

存在递归结束条件. 比如 if n == 1 就是结束条件. 当 n 为 1 的时候, 递归就结束了.
每次递归的时候, 要保证函数的实参是逐渐逼近结束条件的.
不能满足上述条件, 就会出现 "无限递归" . 这是一种典型的代码错误.

递归的优点：

递归类似于 "数学归纳法" , 明确初始条件, 和递推公式, 就可以解决一系列的问题.
递归代码往往代码量非常少.

递归的缺点：

递归代码往往难以理解, 很容易超出掌控范围
递归代码容易出现栈溢出的情况
递归代码往往可以转换成等价的循环代码. 并且通常来说循环版本的代码执行效率要略高于递归版本.

1.10、参数默认值

概念：

Python 中的函数, 可以给形参指定默认值.带有默认值的参数, 可以在调用的时候不传参.

代码示例: 计算两个数字的和

def add(x, y, debug=False):
    if debug:
        print(f'调试信息: x={x}, y={y}')
    return x + y
print(add(10, 20)) # 使用默认值
print(add(10, 20, True)) # 不使用默认值

此处 debug=False 即为参数默认值. 当我们不指定第三个参数的时候, 默认 debug 的取值即为 False.

带有默认值的参数需要放到没有默认值的参数的后面：

1.11、关键字参数

概念：

在调用函数的时候, 需要给函数指定实参. 一般默认情况下是按照形参的顺序, 来依次传递实参的.
但是我们也可以通过 关键字参数, 来调整这里的传参顺序, 显式指定当前实参传递给哪个形参.

举个栗子：

形如上述 test(x=10, y=20) 这样的操作, 即为 关键字参数.

二、列表和元组

2.1、列表是什么, 元组是什么

概念：列表是一种让程序猿在代码中批量表示/保存数据的方式。

就像我们去超市买辣条, 如果就只是买一两根辣条, 那咱们直接拿着辣条就走了.
但是如果一次买个十根八根的, 这个时候用手拿就不好拿, 超市老板就会给我们个袋子.
这个袋子, 就相当于列表

注意：

元组和列表相比, 是非常相似的, 只是列表中放哪些元素可以修改调整, 元组中放的元素是创建元组的时候就设定好的, 不能修改调整
列表就是买散装辣条, 装好了袋子之后, 随时可以把袋子打开, 再往里多加辣条或者拿出去一些辣条.元组就是买包装辣条, 厂家生产好了辣条之后, 一包就是固定的这么多, 不能变动了.

2.2、创建列表

创建列表主要有两种方式：

[ ] 表示一个空的列表
使用list()函数，list()函数可以将其他数据类型（如字符串、元组等）转换为列表.

举个栗子：

如果需要往里面设置初始值, 可以直接写在 [ ] 当中：

2.3、访问下标

可以通过下标访问操作符 [ ] 来获取到列表中的任意元素：

通过下标不光能读取元素内容, 还能修改元素的值：

如果下标超出列表的有效范围, 会抛出异常：

因为下标是从 0 开始的, 因此下标的有效范围是 [0, 列表长度 - 1]. 使用 len 函数可以获取到列表的元素个数：

下标可以取负数. 表示 "倒数第几个元素" ：

2.4、切片操作

概念：

通过下标操作是一次取出里面第一个元素.
通过切片, 则是一次取出一组连续的元素, 相当于得到一个 子列表

使用 [ : ] 的方式进行切片操作：

alist[1:3] 中的 1:3 表示的是 [1, 3) 这样的由下标构成的前闭后开区间.
也就是从下标为 1 的元素开始(2), 到下标为 3 的元素结束(4), 但是不包含下标为 3 的元素.
所以最终结果只有 2, 3

切片操作中可以省略前后边界：

切片操作还可以指定 "步长" , 也就是 "每访问一个元素后, 下标自增几步" ：

切片操作指定的步长还可以是负数, 此时是从后往前进行取元素. 表示 "每访问一个元素之后, 下标自减几步" ：

如果切片中填写的数字越界了, 不会有负面效果. 只会尽可能的把满足条件的元素过去到：

2.5、遍历列表元素

"遍历" 指的是把元素一个一个的取出来, 再分别进行处理：

使用 for 按照范围生成下标, 按下标访问：

使用 while 循环 手动控制下标的变化：

2.6、新增元素

使用 append 方法, 向列表末尾插入一个元素(尾插)：

使用 insert 方法, 向任意位置插入一个元素：

2.7、查找元素

使用 in 操作符, 判定元素是否在列表中存在. 返回值是布尔类型：

使用 index 方法, 查找元素在列表中的下标. 返回值是一个整数. 如果元素不存在, 则会抛出异常：

2.8、删除元素

使用 pop 方法删除最末尾元素(尾删) ：

pop 也能按照下标来删除元素：

使用 remove 方法, 按照值删除元素：

2.9、连接列表

使用 + 能够把两个列表拼接在一起：

使用 extend 方法, 相当于把一个列表拼接到另一个列表的后面：

2.10、关于元组

概念：元组使用 ( ) 来表示.

atuple = ( ) # 创建空元组
atuple = tuple() # 使用函数创建元组

说明：

元组不能修改里面的元素, 列表则可以修改里面的元素
因此, 像读操作,比如访问下标, 切片, 遍历, in, index, + 等, 元组也是一样支持的.但是, 像写操作, 比如修改元素, 新增元素, 删除元素, extend 等, 元组则不能支持.
另外, 元组在 Python 中很多时候是默认的集合类型. 例如, 当一个函数返回多个值的时候.

元组相比于列表来说, 优势有两方面:

你有一个列表, 现在需要调用一个函数进行一些处理. 但是你有不是特别确认这个函数是否会把你的列表数据弄乱. 那么这时候传一个元组就安全很多.
我们马上要讲的字典, 是一个键值对结构. 要求字典的键必须是 "可hash对象" (字典本质上也是一个hash表). 而一个可hash对象的前提就是不可变. 因此元组可以作为字典的键, 但是列表不行.