实验4 函数与异常处理编程

Posted Hj-soo320

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了实验4 函数与异常处理编程相关的知识，希望对你有一定的参考价值。

task1

源代码：

print(sum)
sum = 42
print(sum)

def inc(n):
    sum = n+1
    print(sum)
    return sum

sum = inc(7) + inc(7)
print(sum)

运行结果：

 

问题：task1.py源码中，共有4处有python语句 print(sum) （line1, line3, line7, line11)。 

这4处使用的标识符sum是同一个对象的名称吗？如果不是，请以文字方式回答这4处中标识符
sum的作用域。
答：不是。line1为内置作用域 ，line3和line11为全局作用域，line7为局部作用域
 
task2_1
源代码：
def func1(a, b, c, d, e, f):
    \'\'\'
    返回参数a,b,c,d,e,f构成的列表
    默认，参数按位置传递; 也支持关键字传递
    \'\'\'
    return [a, b, c, d, e, f]

def func2(a, b, c, *, d, e, f):
    \'\'\'
    返回参数a,b,c,d,e,f构成的列表
    *后面的参数只能按关键字传递
    \'\'\'
    return [a, b, c, d, e, f]

def func3(a, b, c, /, d, e, f):
    \'\'\'
    返回参数a,b,c,d,e,f构成的列表
    /前面的参数只能按位置传递
    \'\'\'
    return [a, b, c, d, e, f]

# func1调用：按位置传递、按参数传递都可以
print(func1(1, 9, 2, 0, 5, 3))
print(func1(a=1, b=9, c=2, d=0, e=5, f=3))
print(func1(1, 9, 2, f=3, d=0, e=5))

# func2调用：d,e,f必须按关键字传递
print( func2(11, 99, 22, d=0, e=55, f=33) )
print( func2(a=11, b=99, c=22, d=0, e=55, f=33) )

# func3调用：a,b,c必须按位置传递
print( func3(111, 999, 222, 0, 555, 333))
print( func3(111, 999, 222, d=0, e=555, f=333) )

运行结果：

 

task2_2

源代码：

list1 = [1, 9, 8, 4]
print(sorted(list1))
print(sorted(list1, reverse=True))
print(sorted(list1, True))

运行结果：

问题：python内置函数sorted()中，参数reverse的传递方式是否必须使用关键字传递？

答：是。
 

task2_3

源代码：

def func(a, b, c, /, *, d, e, f):
    return ([a, b, c, d, e, f])
print(func(1, 2, 3, d=4, e=5, f=6))

运行结果：

 

task3

源代码：

def solve(a, b, c):
    \'\'\'
    求解一元二次方程, 返回方程的两个根
    :para: a,b,c: float 方程系数
    :return: tuple
    \'\'\'
    delta = b*b - 4*a*c
    delta_sqrt = abs(delta)**0.5
    p1 = -b/2/a
    p2 = delta_sqrt/2/a
    if delta >= 0:
        root1 = p1 + p2
        root2 = p1 - p2
    else:
        root1 = complex(p1, p2)
        root2 = complex(p1, -p2)
    return root1, root2
while True:
    try:
        t = input(\'输入一元二次方程系数a b c, 或者，输入#结束: \')
        if t == \'#\':
            print(\'结束计算，退出\')
            break
        a, b, c = map(float, t.split())
        if a == 0:
            raise ValueError(\'a = 0, 不是一元二次方程\')
    except ValueError as e:
        print(repr(e))
        print()
    except:
        print(\'有其它错误发生\\n\')
    else:
        root1, root2 = solve(a, b, c)
        print(f\'root1 = root1:.2f, root2 = root2:.2f\')
        print()

运行结果：

 

task4

源代码：

def list_generator(x, y, s=1):
    l = []
    while x <= y:
        l.append(x)
        x = x+s
    return l

list1 = list_generator(-5, 5)
print(list1)

list2 = list_generator(-5, 5, 2)
print(list2)

list3 = list_generator(1, 5, 0.5)
print(list3)

运行结果：

 

task5

源代码;

def is_prime(n):
    if n == 2:
        return True
    else:
        for i in range(2, int(n**0.5)+1):
            if n % i == 0:
                return False
        return True

for i in range(4, 21, 2):
    for s in range(2, i):
        if is_prime(i-s):
            print(f\'i = s + i-s\')
            break

运行结果：

 

task6

源代码：

# 编码函数encoder()定义
def encoder(a):
    c = \'\'
    for i in a:
        if i.isalpha():
            temp = ord(i)+5
            if chr(temp).isalpha():
                c += chr(temp)
            else:
                c += chr(temp-26)
        else:
            c += i
    return c

# 解码函数decoder()定义
def decoder(x):
    z = \'\'
    for i in x:
        if i.isalpha():
            temp = ord(i)-5
            if chr(temp).isalpha():
                z += chr(temp)
            else:
                z += chr(temp+26)
        else:
            z += i
    return z

# 主体代码逻辑
text = input(\'输入英文文本:\')

encoded_text = encoder(text)
print(\'编码后的文本: \', encoded_text)

decoded_text = decoder(encoded_text)
print(\'对编码后的文本解码: \', decoded_text)

运行结果：

 

task7

源代码：

def Collatz(n):
    if n % 2 == 0:
        return n//2
    else:
        return n*3+1

try:
    n = int(input(\'Enter a positive integer:\'))
    if n <= 0:
        raise ValueError
    num = [n]
    while True:
        n = Collatz(n)
        num.append(n)
        if n == 1:

            print(num)
            break


except ValueError:
    print(\'Error: must be a positive integer\')

运行结果：

 

task8

源代码：

def func(n):
    while True:

        if n == 1:
            return 1
        else:
            return 2*func(n-1)+1


while True:
    x = input()
    if x == \'#\':
        print(\'计算结束\')
        break
    n = int(x)
    ans = func(n)
    print(f\'n = n, ans = ans\')

运行结果：

 

Python-匿名函数与异常处理

目录

匿名函数

什么叫匿名函数？

我们之前学过的叫有名函数，就是有名字的函数

匿名函数 就是没有名字的函数，

语法

lambda 参数:返回值

# 演示匿名函数的使用

f = lambda x:x
print(f)
# <function <lambda> at 0x00000000005D1E18>
s = f(1)        # 注意 ，匿名函数调用拿到的是返回值。
print(s)
# 1

匿名函数一般与python内置方法连用。

max/min()

'''
用法：
max(可迭代对象，匿名函数)
返回最大值
'''
比如说我们想要求出以下字典的最高/最低薪资的人的名字

salary_dict = 
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000

print(max(salary_dict))     # 如果直接用max函数的话会按照字符串首字母顺序来排序
# tank

# 我们可以定义一个函数
def func(k):
    return salary_dict[k]
print(min(salary_dict,key=func))     
# sean
print(max(salary_dict,key=func))
# jason
'''
key=func  做的事情：
1. 循环salary_dict 取出所有的key值
2. 将每个key值放入func函数中，返回values，返回薪资
3. max函数进行排序
'''

# 用匿名函数实现
print(max(salary_dict,key=lambda name:salary_dict[name]))
# jason
print(min(salary_dict,key=lambda name:salary_dict[name]))
# sean

sorted()

'''
sorted(可迭代对象，reverse)
sorted，排序，返回值找一个变量接收
'''
lis = [1, 3, 2, 5, 8, 6]
lis = sorted(lis,reverse=True)      # reverse=True 反转
print(lis)
# [8, 6, 5, 3, 2, 1]

salary_dict = 
    'nick': 3000,
    'jason': 100000,
    'tank': 5000,
    'sean': 2000

def f2(item):
    return salary_dict[item]
res = sorted(salary_dict,key=f2,reverse=True)
print(res)
# ['jason', 'tank', 'nick', 'sean']

# 用匿名函数实现
res = sorted(salary_dict,key=lambda item:salary_dict[item],reverse=True)
print(res)
# ['jason', 'tank', 'nick', 'sean']

map()

'''
map(匿名函数，可迭代对象)
映射
'''

name_list = ['jason', 'tank', 'sean']

def f1(item):
    return item + "hahahhahahhahahhaha"
res = map(f1,name_list)
print(list(res))
# ['jasonhahahhahahhahahhaha', 'tankhahahhahahhahahhaha', 'seanhahahhahahhahahhaha']

# 匿名函数实现
res = map(lambda name:f"name sb",name_list)
print(list(res))
# ['jason sb', 'tank sb', 'sean sb']

filter()

'''
filter(匿名函数，可迭代对象)
筛选,按照某种条件对可迭代对象操作。
'''
name_list = ['nick', 'jason sb', 'tank sb', 'sean sb']

# 匿名函数实现
res = filter(lambda name:name.endswith("sb"),name_list)
print(list(res))
# ['jason sb', 'tank sb', 'sean sb']

lis = [2,3,4,5,6,7]
def function(item):
    if item > 5:
        return True
    else:
        return False
res = filter(function,lis)
print(list(res))
# [6, 7]

# 匿名函数实现
res = filter(lambda item:item > 5,lis)
print(list(res))
# [6, 7]

内置函数

技术图片

## 需要掌握

1.bytes() # 解码字符
res = bytes("你好" ,encoding="utf8")  # 解码成二进制
print(res)

'''
2.chr()/ord()
按照ascil码 将数字转换为对应字符
ord 将字符转换为数字
'''
print(chr(65))
print(ord("A"))

'''
3.divmod()
将商 余数以元组形式返回
'''
print(divmod(10,3))

'''
4.ennumerate()  ********************重要
带有索引的值
'''
l = ["a","b","c"]
for i in enumerate(l):
    print(i)
# (0, 'a')
# (1, 'b')
# (2, 'c')

'''
5.eval()    ********************重要
将字符串两边的引号去掉，变成剩下的数据类型
'''
lis = "[1,2,3]"
print(type(list))
# <class 'type'>
print(type(eval(lis)))
# <class 'list'>

'''
6.hash()
是否可哈希
'''
print(hash(10))
# 10

##############################################################################################

## 了解
'''
1. abs()    ***
求绝对值
'''
print(abs(-1))
# 1

'''
2. all()
可迭代对象内元素全为真则返回真
'''
print(all([1,2,3]))
# True

'''
3. any()
可迭代对象内有一元素为真，则为真
'''
print(any([1,2,3,0]))
# True

'''
4. bin()
    oct()
    hex()
    二进制、八进制、十六进制转换
'''
print(bin(17))
print(oct(17))
print(hex(17))
# 0b10001
# 0o21
# 0x11

'''
5. dir()
列出所有time的功能
'''
print(dir())
# ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__',
#  '__name__', '__package__', '__spec__', 'i', 'l', 'lis', 'res']

'''
6. frozenset()
不可变的集合
'''
set8 = frozenset(1,2,3,4,5)
print(set8)
# frozenset(1, 2, 3, 4, 5)
# set8.add(10)
# AttributeError: 'frozenset' object has no attribute 'add'

'''
7. globals()
loacals()
查看全局、局部名字
'''
def func():
    a = 1
    # print(locals())   # 以字典形式返回
    # print(globals())    # 打印全局名字
func()
# 'a': 1
# '__name__': '__main__', '__doc__': '\n1.bytes()\n解码字符\n', '__package__': None, '
# __loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000001DCB208>,
#  '__spec__': None, '__annotations__': ,
# '__builtins__': <module 'builtins' (built-in)>,
# '__file__': 'C:/Users/Administrator/Desktop/老男孩python文档/老男孩Python程序编写/练习/第三章Python基础--文件操作&函数/内置函数.py', '__cached__': None, 'res': b'\xe4\xbd\xa0\xe5\xa5\xbd', 'l': ['a', 'b', 'c'], 'i': (2, 'c'), 'lis': '[1,2,3]', 'set8': frozenset(1, 2, 3, 4, 5), 'func': <function func at 0x00000000004F1E18>

'''
8. pow()
返回 xy（x的y次方） 的值。
'''
print(pow(5,2))
# 25

'''
9. round()  ***
返回浮点数x的四舍五入值。
'''
print(round(5.1))
# 5

'''
10. slice()
切片对象，主要用在切片操作函数里的参数传递。
slice 语法：
class slice(stop)
class slice(start, stop[, step])
'''
myslice = slice(5)
print(myslice)

'''
11. sum()   ***
进行求和计算
'''
print(sum(range(100)))
# 4950

'''
12. __import__()
通过字符串导入模块
'''
m = __import__("time")
print(m.time())
# 1569325150.957757

'''
面向对象函数，-----^_^-----
classmethod
staticmethod
property
delattr
hasattr
getattr
setattr
isinstance()
issubclass()
object()
super()
'''

面向过程编程

什么叫面向过程，面向 流程 编程

面向过程编程是解决问题的一种思想，过程是解决问题的步骤

将复杂的问题拆解成一个个流程，从而做完整个事情

优点：复杂的问题流程化，简单化

缺点：扩展性差

'''
注册功能
接受用户输入用户名，进行合法性校验，拿到合法的用户名
'''
def check_user():
    username = input(">>>").strip()
    if username.isalpha():
        return username
    else:
        print("用户名必须为字母，傻逼")

'''
分层实现功能
用户功能层：实现用户具体的功能
接口层：连接数据处理层和用户功能层
数据处理层：处理数据后把结果交给接口层
'''

异常处理

什么是异常

异常就是程序运行时候的报错

异常的种类

在python中不同的异常是不同的类型，一个异常标识一种错误

异常处理

try:
    代码
except 错误类型:
    代码
print(1)
num = input('请输入数字:')
dic = 'a': 1

try:
    print(dic['b'])     # KeyError
    1 / int(num)        # 报错之后,不运行下面的代码
except ZeroDivisionError:
    print('傻逼,不能输入0')
except KeyError:
    print('傻逼,不知道什么错误')

print(2)
# 万能捕捉异常

print(1)
num = input('请输入数字:')
dic = 'a': 1
try:
    print(dic['b'])     # KeyError
    1 / int(num)    # 报错之后,不运行下面的代码
except Exception as e:      # 万能异常,只要有错误,就捕捉
    print(e)    # 打印错误的描述信息
    print('傻逼,不知道什么错误')
print(2)

try...except总结

  1. 把错误处理和真正的工作分开
  2. 代码更加清晰，复杂的工作任务更容易实现
  3. 代码更加有健壮性

finally语句

finally 表示无论报不报错都执行下面的代码

# 异常捕捉只能捕捉逻辑错误
fr = open('test.py')
try:
    # 文件中途报错
    1 / 0
except Exception as e:
    print(e)
finally:    # 无论你报不报错,都执行这一行
    print('finally')
    fr.close()

主动抛出异常raise

try:
    raise TypeError('抛出异常，类型错误')
except Exception as e:
    print(e)

断言assert

assert 1 == 1

try:
    assert 1 == 2
except Exception as e:
    print(e)

以上是关于实验4 函数与异常处理编程的主要内容，如果未能解决你的问题，请参考以下文章

实验4 函数与异常处理编程

实验四 函数与异常处理编程

实验四 函数与异常处理编程

实验四 函数与异常处理编程

实验四函数与异常处理编程

实验四 函数与异常处理编程