Python基础知识学习（七）

1. 异常处理

# 程序报错
list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# print(list[14])
# IndexError: list index out of range


# 如果dic有name属性 则修改这个属性的值
# 如果没有name属性 则添加name属性
dic = {}
dic['name'] = '张三'
# print(dic['age'])
# KeyError: 'age'

# 程序报错时  会影响其后的代码执行   用try...except...避免
# 如果出现错误，代码会根据错误类型 进入到指定的except
# 这样做的好处是代码不会因为错误中断执行
try:
    print(list[14])
    print(dic['age'])
except IndexError as e:
    print('捕获了一个索引错误{}'.format(e))
except KeyError as e:
    print('捕获了一个关键字错误{}'.format(e))
# 错误类型有20多种，每种都写一次很麻烦

# 换种写法
try:
    print(list[14])
# Exception 和 IndexError, KeyError...等错误为父子关系，前者包含所有类型错误。
except Exception as e:
    print('捕获了一个错误{}'.format(e))

# 标准格式：
# try:
#     pass
# except:
#     pass
# else:
#     pass
# finally:
#     pass
try:
    print('这是一个标准格式')
except IndexError as e:
    print('上一行代码出现了索引错误{}'.format(e))
else:
    print('目前代码感觉良好')
finally:
    print('代码结束')


# list = []
# print(list[10])


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

2.函数

# 正常打印
print('1'
      '2'
      '3'
      '4'
      )

print('5'
      '6'
      '7'
      '8'
      )

print('9')

# 需要多次打印时   写成函数    需要时调用函数即可
# 定义函数的方法：   def + 方法名字 + (参数（形参）)
def mySelf():
    print('1'
          '2'
          '3'
          '4'
          )

    print('5'
          '6'
          '7'
          '8'
          )

    print('9')

# 无参数无返回值的方法
def fun1():
    print('Hello World')
fun1()


# 有参数没有返回值的方法
# 参数的实质就是变量
# 声明方法是如果有参数，那么调用方法一定要有参数
# 生命方法时用的参数 叫做形式参数 即为形参（形参就是变量）
# 调用方法时的参数叫做实参（实参给变量赋值）
def fun1(name):
    print('大家好，我的名字是{}'.format(name))
fun1('渣渣辉')

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


# 有返回值 有参数的方法
def fun1(name, age):
    result = '我的姓名是{},我的年龄是{}'.format(name, age)
    return result
print(fun1('张三', 17))

# 全局变量---------------------------------------------------
name = '张三'
def fun1():
    # global 全球的，全局的
    global name
    name = '李四'
    print(name)
fun1()


# 默认参数------------------------------------------------
# 想让那个参数成为默认参数都可以，但是一定要注意：默认参数一定要放在参数列表的队尾
def fun1(name, age = 17, fond = '吃鸡'):
    print('我是{},我的年龄是{}，我的爱好是{}'.format(name, age, fond))
fun1('小明', 18, 'OW')

# def fun1(age = 17, fond = '吃鸡', name):
#     pass
# 上面的写法是错误的  默认参数一定要写在参数列表的队尾


# 关键参数-----------------------------------------------
def fun1(name, age = 17, sex = '男', fond = 'game'):
    print('我是{},我今年{},我是{}的，我喜欢{}'.format(name, age, sex, fond))
fun1('小明')
fun1('小兰', '19', '女')
fun1('小张', fond='吃饭')
# 直接指定给某个参数赋值，这个参数就是关键参数

fun1(fond='学习', age=7, name='小王')
# fun1(age=7, fond='吃饭')
# 如果参数中有的参数为非默认参数，那么调用方法时一定要给它赋值


# args用法--------------------------------------------------
# arguments 参数
def fun1(a, b, *args):
    print('a的值是:{}'.format(a))
    print('b的值是:{}'.format(b))
    print('args的值是:{}'.format(args))
    print('{}+{}={}'.format(a, b, a+b))
fun1(10, 15)
fun1(10, 15, 20)
fun1(10, 15, 20, 25)
fun1(10, 15, 20, 25, 30)



# 返回值 ****************************************
# 作用1：将方法内部的结果 让外面来使用
def jing():
    jingshui = '我是井水，我只能在fun1这个方法里使用，外面用不到'
    return jingshui
print(jing())
# 作用2：在方法中return后面的代码不执行
def fun1():
    print('今天走了一步')
    print('今天走了两步')
    return
    print('今天走了三步')
fun1()

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

3. 函数高级

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

def fun1(*args, sep = ''):
    pstr = sep.join(args)
    print(pstr)

#  sep 固定代码块  用print时 后面写sep
print('a', 'b', 'c', sep='~~~')
fun1('a', 'b', 'c', sep='!!!')

# map--------------------------

def my_map(string):
    allNumberList = {
        '0': 0,
        '1': 1,
        '2': 2,
        '3': 3,
        '4': 4,
        '5': 5
    }
    return allNumberList[string]
# map 接受俩个参数：参数1是函数 参数2是序列
# map函数的意义就是将序列里面的每一个值都在
# 前面的函数中进行处理，并返回一个新的列表
result = list(map(my_map,'54321'))
print(result)

# * 指针
def fun1(*args):
    print(args)
    # 将元组里面的每一个元素转化成字符串放入list里面
    # 问题：为什么将元组转化成列表？    因为元组不可变  列表可变
    args = list(map(str, args))
    print(args)
fun1(1, 2, 3)

# reduce---------------------------------------------------------
# reduce()函数接收的参数和map()一样
# 参数1：函数  参数2：序列
# 不同的是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, *args, **kwargs):
    print('a的值是{}'.format(a))
    print('args的值是{}'.format(args))
    print('kwargs的值是{}'.format(kwargs))
fun1('你好')
fun1('nice', 'to', 'meet', 'you')
# name 和 age 不是关键参数
fun1('hello', name='张三',age=18)
fun1(a = 10, b = 10)
fun1(10, [{'name': '张三'}])

result = '12 / 3 * 4'
# eval()该方法将括号里面的内容当成代码来执行
# 慎用 确保安全的前提下使用
content = eval(result)
print(content)

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


list1 = [1, 11, 56, 24, 99, 65, 46]
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':17,
            'height':185
                }
    },
    {
        'name':'李四',
        'info':{
            'age':18,
            'height':165
                }
    },
    {
        'name':'王五',
        'info':{
            'age':19,
            'height':195
                }
    }
]
list3 = sorted(list3, key=lambda x: x['info']['age'])
print(list3)