python编程基础---------------------异常处理与函数基础

上一次我们学习了python OS操作和python基础文件操作，估计在此过程中，各位都遇到了很多错误，下面就让我们来学习怎么处理这些错误。

1.异常处理

作为Python初学者，在刚学习Python编程时，经常会看到一些报错信息，在前面我们没有提及，这章节我们会专门介绍。

Python有两种错误很容易辨认：语法错误和异常。

Python 的语法错误或者称之为解析错，是初学者经常碰到的，如下实例

>while True print('Hello world')
  File "<stdin>", line 1, in ?
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

我们知道，代码一旦有了错误就不会在执行下去，那我们怎么处理这些异常让代码执行下去呢，请看下面实例：

list = [1,2,3,4,5,6,7,8]
# IndexError: list index out of range
# print(list[14])
dic = {}
# 如果dic有name属性，则修改name的值，如果没有name属性，则添加name属性的值
dic['name']='张三'
# KeyError: 'age'
# print(dic['age'])

# 将有可能引起错误的代码放进try里面
# 如果出现错误，代码会根据错误类型，进入到指定的except
# 这样做的好处：代码不会因为错误而中断执行
try :
    print('-----------------------')
    # print(list[14])
    print(dic['age'])
except IndexError as e :
    print('捕获了一个索引错误{}'.format(e))
except KeyError as e:
    print('捕获了一个关键字错误{}'.format(e))
print('hello world')

try语句按照如下方式工作；

首先，执行try子句（在关键字try和关键字except之间的语句）
如果没有异常发生，忽略except子句，try子句执行后结束。
如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。
如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。

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

处理程序将只针对对应的try子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。

一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:

except (RuntimeError, TypeError, NameError):
        pass

最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。

try :
    pass
except:
    pass
else:
    pass
# finally,下面的代码一定会执行
finally:
    pass

使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而except又没有捕获的异常。

2.抛出异常

Python 使用 raise 语句抛出一个指定的异常。例如:

age = input('请输入你的年龄')
age = int(age)
if age < 0 :
    print('年龄不对')
    # raise  升起；在此抛出异常
    raise  Exception('年龄不对，请务必输入一个大于0的年龄')

3.函数基础

定义一个函数：

你可以定义一个由自己想要功能的函数，以下是简单的规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

语法：

Python 定义函数使用 def 关键字，一般格式如下：

def 函数名（参数列表）:
    函数体

实例1：

#无参数，无返回值
def fun1():
    print('hello world')
fun1()

实例2：

# 参数的实质就是变量
# 声明方法时候的参数，叫做形参，
def fun1(name):
    print('大家好，我的名字是{}'.format(name))
# 声明方法的时候，如果有参数，
# 那么调用方法一定也要有参数
# 声明方法的时候的参数叫做形参（形参即为变量）
# 调用方法的时候的参数叫做实参（实参为给变量赋值）
fun1('lalala')
# 少了一个必须的参数
# TypeError: fun1() missing 1 required positional argument: 'name'

实例3：

# 没有参数有返回值的方法
# 局部变量：在局部声明的变量，在方法内部声明的变量，全部是局部变量
# 局部变量的作用范围
# 即为声明这个变量的方法
# 出了这个方法的范围，就不能在使用这个变量
def fun1():
    result = 1+2+3+4+5+6+7+8+9
    # 将这个值拿到方法的外面使用
    return result
print('1+9的结果是{}'.format(fun1()))

实例4：

# 又返回值有参数

def fun1(name,age):
    result = '我的姓名是{},我的年龄是{}'.format(name,age)
    return result
print(fun1('张三',17))

实例5：

# 返回值return
# 作用1：将方法内部的结果，让外面来使用
def fun1():
    content1 ='我是井水，我只能在fun1这个方法里面使用'
    # 将井水运送出进
    return content1
print(fun1())

# 作用2：截断
def fun1():
    print('今天走了一步')
    print('今天走了两步')
    # 截断：return后面的代码不执行
    return
    print('今天走了三步')
fun1()

def isOpen(open):
    if open == True:
        return
    print('打开灯')
isOpen(True)

4.高级函数

好了，我们现在已经知道函数是干嘛的了，也知道了函数的定义方法，现在让我们来看看高一级的函数：

# join()方法用于对序列中的元素进行加工
# 加工的内容为使用join()方法的对象的内容
space = '--'
word = 'hello world'
print(space.join(word))


def fun1(*args,sed=''):
    pstr = sed.join(args)
    print(pstr)
fun1('a','b','c',sed='!!!')
# sep 系统函数
print('a','b','c',sep='------')


def A(y):
    return y*2
def B(x):
    print(x *2)
# 参数可以为方法
B(A(5))
# map-----------------------------
# 从头到尾找到每一个元素

def my_map(string):
    allnumberlist={
        '0':0,
        '1':1,
        '2':2,
        '3':3,
        '4':4,
        '5':5
    }
    return allnumberlist[string]
# map 接收两个参数，参数1为函数，参数二是序列
# map函数的意义就是讲序列里面的每一个值都在前面的函数中进行处理，
# 并返回一个新的列表map只能用list和tuple
result = tuple(map(my_map,'52321'))
print(result)

dic  = {
'0':0,
        '1':'张三',
        '2':'李四',
        '3':'王五',
        '4':'赵六'
}
print(dic['3'])
# *:指针，不定长参数 **args  指针的指针
def fun1(*args):
    print(args)
    # 将元组里面的每一个元素转化成字符串放入list里面
    # ？为什么将元组转化成列表
    # 元组不可变，列表可变
    args=list(map(str,args))
    print(args)
fun1(1,2,3)


# reduce------------------
# reduce()函数接收的参数和map（）一样
# 参数一：函数，参数二：x序列
# 不同的是，reduce()对序列里面每一个元素反复
# 调用函数，并返回一个最终结果
from functools import reduce
def my_reduce(x,y):
    return x+y
print(reduce(my_reduce,[1,2,3,4,5,6,7,8,9,10]))


def fun1(a,b=10,*args,**kwargs):
    print('a的值是{}'.format(a))
    print('b的值是{}'.format(b))
    print('args的值是{}'.format(args))
    print('kwargs的值是{}'.format(kwargs))
fun1('你好')
fun1('nice','to','meet','you')
fun1('hello',name='张三',age=18)
fun1(10,None,[{'name':'张三'}])



result='12 / 3 * 4'
# eval()将括号里面的内容当成代码来执行
# 慎用 确保安全
context = eval(result)
print(context)

# 匿名函数--------------
# lambda 匿名函数，后面只能写比较简单的逻辑
# 与列表推导式比较相似
result = lambda x,y:x+y
print(result(5,6))
# 相当于
def fun1(x,y):
    return x+y
print(fun1(5,6))

list1=[1,11,15,9]
list1 = sorted(list1,key=lambda x : x)
print(list1)

list2 = [
    {
        'name':'张三',
        'age':16
    },
    {
        'name':'李四',
        'age':17
    },
{
        'name':'王五',
        'age':13
    }
]
list2=sorted(list2,key=lambda x: x['age'],reverse=True)
print(list2)


list3 =[
    {
        'name':'张三',
        'info':{
            'age':15,
            'height':165
        }
    },
    {
        'name':'李四',
        'info':{
            'age':12,
            'height':175
        }
    },
]
list3=sorted(list,key=lambda x : x['info']['age'])
print(list3)

下面有几个小小的练习题：

# 1.设计一个函数，只能接收两个参数，却能计算4个数之和
# 1.程序1：
# def fun1(a,b,c=0,d=2):
#     result = a+b
#     return result
# print(fun1(5,10))


# 2.设计一个函数，可以进行过滤，如果参数不是网址，则抛出
# def fun3(url):
#     if not url.startswith('http://www'):
#         raise Exception('你输入的不是网址')
#     else:
#         pass
# a = input('请输入一个网址：')
# fun3(a)




# 3.设计一个函数，自动比较惨参数里面所值的大小并进行排序
# a= input('请输入一些数')
# list1=[]
# list1.extend(a)
# list1 = sorted(list1,key=lambda x : x)
# print(list1)