# python学习笔记（二）--函数和异常处理

函数

回顾return

return作为一个返回值 可以将函数内部我想要返回的值 进行返回 如果有返回值的函数 在调用的时候不会有任何的输出 需要使用输出函数进行输出

如果在函数中 遇到了return那么return下面的代码 将不会在执行 也就是说 遇到了return认为函数已经执行完毕

一变量的作用域

(1)全局变量

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

name = '张三'
myList = ['x', 'y']

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

demo()

(2)局部变量

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

# 局部变量 在函数外部获取不到
def demo():
    name = '张三'
    myList = ['x', 'y']

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

(3)关键字global声明函数内外使用同一个变量

name = '张三'
def demo():
    global name
    print(name)
    name = '李四'
print(name)
demo()
print(name)

(4)关键字nonlocal

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

def demo1():
    num = 1
    def demo2():
        # print(num)
        nonlocal num
        num = 2
    demo2()
    print(num)

demo1()

(5)可变类型 不可变类型

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

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

myList = ['a', 'b', 'c', 'd']
myInt = 3

def demo():
    myList[0] = 'f'
    myInt = 10

demo()
print(myList)  # 可变类型内外使用都已一样 不需要加global
print(myInt)

二递归函数

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

优点：代码简短

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

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

# 分开的写法
def func1(n):
    print(n)
    func2(n - 1)
    print('func1', n)

def func2(n):
    print(n)
    func3(n - 1)
    print('func2', n)

def func3(n):
    print(n)
    print('func3', n)

func1(3)

三 特殊的问题

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

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

四 函数的导入

# import myfunc.returnfunction
# print(myfunc.returnfunction.demo(10, 20))
# from myfunc import returnfunction  # 从myfunc的文件夹中导入returnfunction
# print(returnfunction.demo1(10, 20, 30))

# from myfunc import returnfunction as func # 从myfunc文件夹导入
# # returnfunction as func 起别名
# print(func.demo1(10, 20, 30))

import random as ran
ran.randint(1, 10)

五列表推导式

概念：

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

简单的列表

myList = [x for x in range(1, 5, 2)]

带if过滤的

# 偶数
myList1 = [x for x in range(1, 50) if not(x % 2)]
# 小于30的偶数
myList2 = [x for x in myList1 if x < 30]
# 把列表中小于30的数 依次加1
myList2 = [i+1 for i in myList1 if i < 30]
print(myList2)

列表的嵌套：

lis = []
for i in range(1, 11):
  for x in range(1, 4):
    lis.append([i, x])
  print(lis)

六迭代器

可迭代对象

可以直接作用于for循环的对象称为可迭代对象(Iterable)可以使用isinstance判断是否为可迭代对象

可用于for循环的数据类型

list  string dict set tuple 

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

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

迭代器

1. 迭代器是从对象的第一个元素开始访问， 只能前进 不能后退
2. 迭代器由两个方法iter() next() (iter是将可迭代器对象转换成迭代器， next是可以将迭代器的元素一个一个访问)
3. 当迭代器的元素都访问以后 再次访问会报StopIteration的错误

七生成器

使用yield函数称为生成器

生成器也是先了迭代器的功能

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

使用(x for x in range(1, 5))创建列表的好处

节约资源

# 对比节约资源
# myGener = (x for x in range(100000))
# print('就是这么速度')
myGener = [x for x in range(100000)]
print('你在看看我的速度')

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

配合

yield

next()

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

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

八异常处理

1. 需求： 当程序出现问题时不让程序结束 而是越过错误继续执行
2. 一个try语句可以包含多个except子句 分别来处理不同的异常 最多只是一个分支会执行
3. 一个except子句可以包含多个异常 这些异常的名称放在括号里 或者称为元组里

主体结构

try:
    # 可以会发生异常的代码
except:
    # 处理出现的异常

(1)捕获一个特定的异常处理

# 捕获一个错误的异常处理
try:
    1 + 'a'
except TypeError as e:
  print(e)

(2)一个try语句对应多个except子句

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

(3)一个except子句 捕获特定的n个异常

# 一个except 字句 捕获特定的n个异常
try:
    # 1 + 'a'
    int('a')
except (TypeError,ValueError) as e:
    print(e)

(4)可选的else字句

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

格式：

try:
    ……
except：
    ……
else:
    ……

try:
    # 1 + 'a'
    # int('a')
    1 + 1
except (TypeError,ValueError) as e:
    print(e)
else:
    print('只有在没有任何异常的情况下，才能看到我')

(5)finally

finally子句  有没有异常 都会去执行

# 配合finally语句的执行
try:
    # 1 + 'a'
    int('a')
    # 1 + 1
except (TypeError,ValueError) as e:
    print(e)
else:
    print('只有在没有任何异常的情况下，才能看到我')
finally:
    print('你有没有异常我都执行')