【Python】条件·循环·函数：Python编程的三大基石深度剖析

student = {'name' : 'Tom','age' : 18}
#1，key和value都是新创建的变量，
#2，字典需要调用items()
for key,value in student.items():
    print(key,value)
#步长为2
for i in range(2,11,2):
    print(i)

运行结果：

name Tom

age 18

常见的用法：

遍历索引和值

enumerate(可迭代对象)会把序列包装成（索引，元素）的成对迭代器：

python 复制代码

fruits = {'apple','banana','orange'}
for index,value in enumerate(fruits):
    print(index,value)

运行结果：

0 apple

1 orange

2 banana

2，while循环

while循环适合"当条件满足时一直进行循环

语法：while 条件表达式：

语句

break语句：立刻结束当前的循环，直接跳出最外层

continue语句：跳过本轮循环，进入下一轮循环，当前循环下的代码不执行。

循环当中的else

for和while都可以带上else

规则：循环正常结束，执行else

循环因为break而提前结束：不执行else

输出结果：没找到

3，嵌套循环

循环的内部还可以写循环

展示：九九乘法表

python 复制代码

for i in range(1,10):
    for j in range(1,i+1):
        print(f"{j} * {i} = {i*j}",end = '  ')
    print()

end表示打印完后末尾追加一个怎样的字符

三，异常处理结构

1，认识异常

程序运行时可能出现的错误就叫异常。

除数不为0 数组索引越界字典的键不存在文件不存在输入的不是数字

这些错误可以称之为异常。

提前处理，可以让程序更稳固

语法：

try:

可能出现异常的代码

except 异常的类型：

出错的处理的代码

出错不同，异常的类型就不同

展示：

python 复制代码

try:
    x = int(input("请输入一个整数："))
    print(x)
except ValueError:
    print("输入的内容不是整数")

2，获取异常类型

python 复制代码

#获取异常对象
try:
    x = int("abc")
    print(x)
except ValueError as e:#将异常重命名为e,然后打印
    print("异常类型：",e)

3，处理多个异常

python 复制代码

#分别进行处理
try:
    x = int(input("请输入一个整数"))
    sum = 10 / x
except ValueError:
    print("请输入正确的整数")
except ZeroDivisionError:
    print("除数不能为0")
#合并进行处理
try:
    a = int(input("请输入一个整数"))
    b = 10 / a
except (ValueError,ZeroDivisionError):
    print("请输入正确的值")

4，else子句

python 复制代码

#else子句
try: 
    x  = int(input("请输入一个整数："))
except ValueError:
    print("请输入正确的整数")
else: #正确时就执行else
    print("这个整数是：",x)

出错时执行except，正确时执行else

5,finally子句

finally无论是否发生异常都会执行

python 复制代码

#finally子句
try:
    f = open('test.txt','r',encoding='utf-8')
    content = f.read()
except FileNotFoundError:    
    print("文件不存在")
finally:
    print("程序结束")

常见用途：

关闭文件，释放资源，做收尾工作

注意：要捕获具体的异常，不要滥用异常处理

四，函数的定义和使用

1，认识函数

函数的功能：1，复用代码，降低重复劳动 2，便于测试和维护 3，让程序更清晰

函数定义的基本语法：

def 函数名(参数列表)：

函数体

2，返回值return

return的作用：1，返回函数结果 2，让程序提前结束

演示没有return:

python 复制代码

#没有return的函数演示
def demo():
    print("函数体")
x = demo()
print(x)

结果：函数体

None

没有return时，函数默认返回None

Python当中的return能够返回多个返回值

python 复制代码

#返回多个返回值
def demo1(a):
    return min(a),max(a),sum(a)
num = {1,2,4,7}
mn,mx,sm = demo1(num)
print(mn,mx,sm)

结果：1 7 14

python实际返回的是一个元组

函数可以作为参数传递个其他函数

展示：

python 复制代码

#numpy是一个外部库
import numpy as np
#函数作为参数
def demo2(func,value):
    return func(value)
print(demo2(np.square,6))
print(np.square(6))

3，lambda表达式

lambda用来定义简单的匿名函数

语法：lambda 参数：表达式

只有一行，适合函数只有短小逻辑

展示：

python 复制代码

sum = lambda a,b : a+b
print(sum(2,3))

结果：5

常见用法：作为key函数

python 复制代码

#按照年龄进行降序排序
student = [('Tom',20),('xiaoli',30),('zhangsan',12)]
sum = sorted(student,key = lambda item:item[1],reverse= True)
print(sum)

结果： $('xiaoli', 30), ('Tom', 20), ('zhangsan', 12)$

lambda适合取代一下短小函数，也适合传给key= ,map(),filter()函数

不适合逻辑复杂，需要多行处理的

4，递归函数

递归：函数在函数体当中调用自己

要想完成递归，需要找到两部分内容：

1，递归的终止条件

2，进行问题缩小的递归过程

做题时优先找到递推公式，以及递推的结束条件。

递归的结束条件也是起始条件。

展示：计算阶乘

递归的优缺点：

优点：1，大幅减少代码量

2，适合处理树，回溯，分治的问题

缺点：1，性能开销大

2，可能会引起栈溢出

3，调试困难

5，生成器函数

带有yield的函数就是生成器函数

生成器函数的特点：

1，不会直接执行完函数体

2，每次会返回一个生成器对象

3，每次取值时执行到下一个yield对象

展示：生成1~n的平方

squares处没有执行函数体，而是生成了一个生成器对象

list(result)：将生成器对象转化为列表就是消耗生成器对象，此时才开始执行

生成器的优点:

1,节省内存，生成器是要一个就算一个，给一个。函数则是全部执行。

list会直接生成10000个平方计算后的数字，占用大量内存；但是gen一个数字也不会计算，而只是创建一个生成器对象（generator对象)，内存占用几乎为0，只储存生成器状态。

2，生成器只能被逐步消耗

将g类比成一个一次性筷子，当第一次使用完后，就不能再使用

6，嵌套函数

函数的内部还可以定义函数

python 复制代码

def outer(x):
    def inner(y):
        return x + y
    return inner(3)
print(outer(5))

outer(5)->inner(3)->x+y

最终的值是由inner(3)进行返回的

五，参数类型与调用方式

1，默认参数

默认参数的常见规则：

默认参数需要在非默认参数的后面

默认参数在函数定义时计算一次，只要之后不额外传参使用的就时同一个

错误使用：使用可变的默认参数

python 复制代码

def append_item(item,items=[]):
    items.append(item)
    return items
print(append_item(1))
print(append_item(2))

运行结果： $1$

1,2

由于tiems在调用时只计算一次，之后再次调用就不会重新计算，而是共享之前的计算值，所以第二次调用会复用第一次的列表

正确的使用方法：使用None作为默认值

python 复制代码

def append_item2(item,items=None):
    if items is None:
        items = []
    items.append(item)
    return items
print(append_item2(1))
print(append_item2(2))

运行结果： $1$

2

将初始值定义为空，每次调用只要为空，就初始化为新的空列表

2，可变位置参数*args

用于接收数量不确定的位置参数

args实际是一个元组

python 复制代码

def total_sum(*args):
    return sum(args)
print(total_sum(1,2,3,4))
print(total_sum(3,4,5,6,7))

结果：10

3，可变关键字参数**kwargs

用于接收数量不确定的关键字参数

kwargs实际上是一个字典

python 复制代码

def show_info(**kwargs):
    print(kwargs)
show_info(name = 'Tom',age = '18', id = '234556')

结果：

{'name': 'Tom', 'age': '18', 'id': '234556'}

4，混合使用参数

python 复制代码

def demo(a,b,*args,**kwargs):
    print('a = ',a)
    print('b = ',b)
    print('args = ',args)
    print('kwargs = ',kwargs)
demo(1,2,3,4, name = 'Tom',age = 18)

结果：

a = 1

b = 2

args = (3, 4)

kwargs = {'name': 'Tom', 'age': 18}

5，参数解包

1，列表元组解包

python 复制代码

def add(a,b,c):
    return a+b+c
sums = [1,2,3]
print(add(*sums))

结果：6

2，字典解包

python 复制代码

def info(name,age):
    print(name,age)
student = {'name':'zhangsan','age':18}
info(**student)

结果：zhangsan 18

六，变量作用域

局部变量只能在函数内部进行访问

全局变量可以在整个模块进行访问

想要在函数内部修改全局变量，需要使用global

python 复制代码

count = 0
def increable():
    global count
    count += 1
increable()
print(count)

结果：1

nonlocal关键字

当函数嵌套，内层函数想要改变外层函数的局部变量时，可以使用nonlocal关键字

python 复制代码

def outer():
    count = 0
    def inner():
        nonlocal count
        count += 1
        print(count)
    inner()
    inner()
outer()

结果：1 2