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)