Python学习笔记3：函数function

回顾return

return作为一个返回值，可以将函数内部我想要的值进行返回。

如果有返回值的时候不会有任何的输出，需要使用输出的函数进行输出。

如果在函数中遇到了return，下main的代码就不会执行。

一 变量的作用域

（1）全局变量

在函数外部声明的变量为全局变量，在函数内、外部都可以获取

name = 'Nian'
myList = [1, 2, 3]

def demo():
print(name)
print(myList)

demo()

（2）局部变量

在函数内部声明的变量为局部变量，在函数外部获取不到

def demo():
name = 'Nian'

demo()
print(name)  # name 'name' is not defined

（ 3）关键字global

声明函数内、外部使用同一个变量

name = 'Nian'

def demo():
global name
print(name)
name = 'Luck'

print(name)

demo()
print(name)

'''
Nian
Nian
Luck
'''

（4）关键字nonelocal

在函数嵌套的时候可以获取外层函数的变量，函数内、外部逗使用的同一个变量。

def demo1():
num = 1

def demo2():
# print(num)
nonlocal num  # 使函数内外使用同一个变量
num = 2

demo2()
print(num)  # 2

demo1()

（5）可变类型，不可变类型

可变类型：比如你只修改了列表中的某个值，但是本身没有动

不可变类型：比如字符串、int...当你在给一个新的值的时候，原来的值会被丢弃，生成一个新的变量

myList = [1, 2, 3, 4]
myInt = 9

def demo():
myList[0] = 666
myInt = 777

demo()
print(myList)  # [666, 2, 3, 4]
print(myInt)  # 9

二 递归函数

递归函数就是自己调用自己的过程

优点：代码简短

缺点：代码不好维护，消耗大量cpu

def demo(n):
print(n)
if n > 1:
demo(n - 1)
print(n)

demo(3)

# 递归的分解
# 函数内部调用外部函数
# def func1():
#     func2()
#
# def func2():
#     print('我是func2函数')
#
# func1()

三 特殊的问题

a = 10

def demo():
a = a + 1

# 等同于：
def demo():
print(a)
a = 10

demo()  # local variable 'a' referenced before assignment

四 函数的导入

# import myfunction.returnFunction
# print(myfunction.returnFunction.demo(1, 2))

# 从myfunction文件夹导入returnFunction文件
# from myfunction import returnFunction
# print(returnFunction.demo(1, 2))

# 起别名
from myfunction import returnFunction as func
print(func.demo(1, 2))

五 列表推导式

概念

列表推导式提供了创建列表的简单途径

例子：

# 快速生成列表的一种方式
myList = [x for x in range(1, 5, 2)]
print(myList)  # [1, 3]

# 多维列表
myList = [[x ** 2] for x in range(1, 5, 2)]
print(myList)  # [[1], [9]]

myList = [(x, x ** 2) for x in range(1, 5, 2)]
print(myList)  # [(1, 1), (3, 9)]

# 带if条件，作为过滤
myList = [x for x in range(1, 20) if x % 2 == 0]
print(myList)  # [2, 4, 6, 8, 10, 12, 14, 16, 18]

# myList中 < 10 的过滤出来
myList2 = [i for i in myList if i < 10]
print(myList2)  # [2, 4, 6, 8]

# myList中的元素 + 1
myList3 = [i + 1 for i in myList]
print(myList3)  # [3, 5, 7, 9, 11, 13, 15, 17, 19]

# 循环嵌套
myList = [[i, x] for i in range(1, 4) for x in range(1, 3)]
print(myList)  # [[1, 1], [1, 2], [2, 1], [2, 2], [3, 1], [3, 2]]

# 行列转置
myList = [[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]
]
# myList2 = [[row[i] for row in myList] for i in range(4)]
# print(myList2)

nullList = []
for i in range(4):
# print(i)
subList = []
for row in myList:
# print(row[i])
subList.append(row[i])
nullList.append(subList)

六 迭代器

可迭代对象

可以直接作用于for循环的对象称为可迭代对象（iterable），可以使用isinstance判断是否为可迭代对象。

可用于for循环的数据类型：

list    str dict      set     tuple

判断是否为可迭代对象，需要引入Iterable

from collections import Iterable

# 判断是否为可迭代对象
print(isinstance([], Iterable))
print(isinstance({}, Iterable))
print(isinstance('', Iterable))
print(isinstance(1, Iterable))

迭代器

迭代器是从对象集合的第一个元素开始访问，只能前进，不能后退。

迭代器有两个方法：iter()和next()——（iter是将可迭代对象转换成迭代器，next是将迭代器的元素依次访问）

当迭代器的元素都访问完以后，再次访问会报StopIteration的错误。

七 生成器

使用了yield函数的成为生成器

生成器也实现了迭代器的功能

使用列表生成式，这样生成出来的(x for x in range(1, 5))是生成器，并不是像列表一样一次性生产，而是用一个产一个。

使用(x for x in range(1, 5))的好处：

节约资源

# 对比节约资源
myGener = (x for x in range(10000000))
print('就是这么速度')

myGener2 = [x for x in range(1000000)]
print('你再看看我的这个慢速度')

加上yield函数（调用一次执行一次，避免一次性全部执行完毕，节约电脑资源）

配合

yield

next()

def demo():
print('a')
yield
print('b')
yield
print('c')
yield

# demo()
# print(demo())

# funcGener = demo()
# next(funcGener)
# next(funcGener)
# next(funcGener)
# next(funcGener)  # 当走完以后，会报StopIteration

def func():
for i in range(100):
print(i)
yield
# func()
myFunc = func()
next(myFunc)
next(myFunc)
next(myFunc)

八 异常处理

需求：当程序出现问题时，不让程序结束，而是越过错误，继续执行。

一个try语句可以包含多个except子句，分别来处理不同的异常，但是最多只会有一个分支被执行。

一个except子句可以包含多个异常，异常的名称放在元组里。

主体结构

try:
# 可能会发生异常的代码
except:  # 捕获所有的异常
# 处理出现的异常

# 一个try语句对应多个except
# try:
#     int('a')
# except TypeError as e:
#     print(e)
# except ValueError as v:
#     print(v)

try:
int('a')
except (TypeError, ValueError) as e:
print(e)

可选的else子句

如果想使用else子句，必须放在except之后，这个子句将在try语句没有任何异常的时候去执行。

格式：

# 可选的else子句
try:
# int('a')
a = 1
except (TypeError, ValueError) as e:
print(e)
else:
print('没有问题，就能看到')

finally

try子句中不管有没有发生异常，finally都会去执行。

# 配合finally
try:
int('a')
# a = 1
except (TypeError, ValueError) as e:
print(e)
else:
print('如果没有问题，就能看到')
finally:
print('你有没有异常，我都执行')