深度学习阶段一_Python基础09_10

最新推荐文章于 2022-11-30 23:59:06 发布

秋雨行舟

最新推荐文章于 2022-11-30 23:59:06 发布

阅读量111

点赞数

本文链接：https://blog.csdn.net/qq_38918049/article/details/96878069

版权

19:异常处理及测试

错误异常处理：

错误类型

语法错误

语义错误

逻辑错误

异常处理 try: 有可能出现异常代码

except 异常类型 as 实例：捕获特定异常

finally：不论是否遇到异常均会执行

else：未遇到异常时

raise: 手动抛出异常

SyntraisexError ：语法错误，例如：少了个引号，还有其他可以看官方文档

# try:
#     x = 5 / 0
# except ZeroDivisionError as e:
#     print('不能除0', e)
# except:
#     print('其他错误')
# else:
#     print('没有异常')


class Person:
    def __init__(self, name):
        self.name = name


p = Person('Peter')

f = open('data.txt')
try:                # 执行可能出现问题的代码
    f.read()
except:             # 还不知道有没有别的异常
    print('文件操作遇到错误')
finally:    # 不管前面咋样,有没有问题，都要执行这个
    f.close()

def method():
    raise NotImplementedError('该方法代码还未实现')


method()

测试：

import unittest
from test1 import get_formatted_name

class NameTestCase(unittest.TestCase):
    def test_title_name(self):
        formatted_name = get_formatted_name('Tom', 'Lee')
        self.assertEqual(formatted_name, 'Tom Lee')

if __name__ == '__main__':
    unittest.main()

测试用例：

def get_formatted_name(first, last):
    full_name = "{} {}".format(first, last)
    return full_name.title()


print(get_formatted_name('tom', 'lee'))

20：unittest单元测试

单元测试测试级别

单元测试对代码最基本单元（函数，方法）的测试

给予特定条件判断结果是否符合预期

相对整个程序的测试，单元测试简化了测试任务

unittest 模块

集成测试

系统测试

验收测试

回归测试

代码组织断言 assertEqual(值，表达式) 是否相等

assertTrue() 是否为真

assertIn() 是否包含

assertAlmostEqual() 是否约等于

assertIs() 是否为同引用

assertIsNone() 是否为空

assertIsstance() 是否某类型实例

assertGreater 是否大于

.........

装置测试用例类继承自 unittest.TestCase

test_ 定义功能测试函数名

setUp() 函数定义准备初始化代码

tearDown() 函数执行清理工作

import unittest


def add(a, b):
    return a + b


def subtract(a, b):
    return a - b


class MyTest(unittest.TestCase):

    def test_add(self):
        self.assertEqual(8, add(5, 3))  # 断言是否相等

    def test_subtract(self):
        self.assertEqual(2, subtract(5, 3))


if __name__ == '__main__':
    unittest.main()

import unittest

'''测试单元  断言方法
'''

person = {'name':'Mike','age':20}
number = [1, 3, 2, 88, 7, 44]
s = '优品课堂'


class TestAssert(unittest.TestCase):
    def test_assert_method(self):
        # self.assertEqual('Mike', person.get('name'))
        # self.assertTrue('优品课堂' in s)
        # self.assertIn('优品课堂', s)
        # self.assertAlmostEqual(3.3, 1.1 + 2.2)
        # self.assertIs(True + 1, 2)
        # self.assertIsNone(person.get('None', None))
        # self.assertIsInstance(s, str)
        self.assertGreater(7, number[0])

if __name__ == '__main__':
    unittest.main()

'''计算器
'''


class Calculator:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def add(self):
        return self.x + self.y

    def subtract(self):
        return self.x - self.y


if __name__ == '__main__':
    c = Calculator(5, 3)
    print(c.add())

------------------'''另一个.py文件'''--------------------
import unittest
from test1 import Calculator


'''计算器
'''


class CalculatorTest(unittest.TestCase):
    def setup(self):
        self.c = Calculator(5, 3)

    def test_add(self):
        # c = Calculator(5, 3)
        self.assertEqual(8, self.c.add())

    def test_subtract(self):
        # c = Calculator(8, 4)
        self.assertEqual(2, self.c.subtract())

    def tearDown(self):
        del self.c


if __name__ == '__main__':
    unittest.main()

21：数值、日期与时间

数值与日期数值格式化

小数位处理

随机数 random.choice() 序列中随机选择一个值

random.sample() 获取指定数目的序列

random.shuffle() 打乱顺序

random.randint() 生成范围内的随机整数

random.random() 生成随机浮点数

random.getrandbits() 生成指定bit位数的随机数

日期和时间 datetime date

time

datetime year

month

day

...........

格式转换字符串到日期时间 datetime.datetime.strptime(’txt‘, '格式')

                                               日期时间到字符串     datetime.datetime.strftime('格式')

占位符 %Y 四位年份

%y 两位年份

%m 二位月份

%d 二位日期

%H 二位小时

%M 二位分钟

%S 二位秒数

%f 微秒

%w 星期数，0.... 6

............

时间差 timedelta days

seconds

hours

lst = list(range(1, 11))

import random

    random.choice(lst)    # 序列里面随机获取数值
    random.sample(lst, 3) # 序列里面随机找三个
    random.shuffle(lst)   # 打乱序列

import datetime

datetime.MAXYEAR    # 获取最大年份
datetime.MINYEAR    # 获取最小年份


today = datetime.date.today()    # 得到当前年份
today.year
today.month
today.day


print(today)
-----------------------------------------------------
import datetime


s = '2018-3-15'

t = datetime.datetime.strptime(s, '%Y-%m-%d')
print(t)   # 字符串转换成日期

import datetime

d = datetime.datetime(2018, 3, 5, 22, 44)
birthdate = datetime.datetime(2016, 5, 2, 19, 33, 44)
d - birthdate
'''datetime.timedelta(672, 11416)'''
diff = d - birthdate
diff.days
'''672'''
diff.seconds
'''11416'''
# 获取奥运会100天后的日期
o = datetime.datetime(2008, 8, 8, 20, 8)
o + datetime.timedelta(days=100)
print(d)

22 ：对象持久化

对象持久化扁平文件文本文件

pickle 序列化为字符串 .dumps（obj）：将对象序列化为字符串

.loads（s）：从字符串反序列化对象

序列化对象到文件 .dump(obj, file)

.load(file)

shelve shelve .open('dbfile')

.close()

db['key'] = obj

len(db)

del db['key']

数据库

ORM

文本文件：

# 使用的文本文件
scores = [88, 99, 77, 55]


def write_scores():  # 写入文件
    with open('data_list.txt', 'w', encoding='utf8') as f:
        f.write(str(scores))
    print('文件写入完成...')


def read_scores():    # 从文件读取内容
    with open('data_list.txt', 'r', encoding='utf8') as f:
        lst = eval(f.read())      # 读出来时字符串，而不是列表,使用eval来进行转换为Python的表达式
        # 修改第一个数为99
        lst[0] = 99
        print(lst)
        
        
if __name__ == '__main__':
    write_scores()

pickle：

import pickle
person = {'name': 'Tom', 'age': 20}
s = pickle.dumps(person)   # 将对象序列化为字符串
p = pickle.loads(s)        # 从字符串反序列化对象


import pickle
person = {'name': 'Tom', 'age': 20}
s = pickle.dumps(person)   # 将对象序列化为字符串
p = pickle.loads(s)        # 从字符串反序列化对象

pickle.dumps(person, open('pickle_db', 'wb'))   # w写  b二进制文本文件

p = pickle.load(open('pickle_db', 'rb'))
print(p)

shelve:

import shelve

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return self.name

def write_shelve():
    s = Student('Tom', 20)
    # print(s.name)
    # print(s.age)
    db = shelve.open('shelve_student_db')
    db['s'] = s
    db.close()

def read_shelve():
    db = shelve.open('shelve_student_db')
    st = db['s']
    print(st)
    print(st.name)
    print(st.age)
    db.close()


if __name__ == '__main__':
    read_shelve()

'''    Tom
Tom
20
'''

23:字符与编码

字符串概述类型 str 字符串

bytes 字节

bytearray 字节数组

字符编码架构字符集：赋值一个编码到某个字符，以便在内存中表示

编码 Encoding：转换字符到原始字节形式

解码 Decoding：依据编码名称转换原始字节到字符的过程

字符串存储编码只作用于文件存储或中间媒介转换对

内存中总是存储解码以后的文本

字符编码 ASCII 存储在一个Byte 0 - 127

latin-1 存储在一个Byte 128-255

UTF8 可变字节 0 - 127 使用单字节

128 - 2047 双字节存储

2047 3 - 4Byte

每Byte使用 128 - 255

UTF-16 2 Byte存储字符（另加2Byte作为标识）

UTF-32 4 Byte

内置函数 ord（）获取字符代码点

chr（）获取代码点对应字符

str.encode('编码') 将特定字符编码

bytes.decode（’编码‘）将字符编码解码为字符文本

类型转换 bytes 手动声明 b‘’

字符串编码 str.encode()

构造函数 bytes(）

bytearray bytearray（‘字符串’，‘编码’）

.decode() 解码为字符串

BOM 处理 open('data,txt', ' w|r', encoding = 'utf-8-sig')

s1 = 'ABCD'
s1.encode('ASCII')

open('data.txt', 'r', encoding='utf8').read()  # 读取txt文本

open('data.txt', 'rb', encoding='utf8').read() # 读取文本，并以二进制显示

bytes('abc', 'ascii')
# b'abc'
bytes('优品课堂', 'utf8')
# b'\xe4\xbc\x98........\x82'

open('data.txt', 'r', encoding='utf-8').read()  # 读取txt文本
# \ufeff优品课堂 codeclassroom.com
open('data.txt', 'r', encoding='utf-8-sig').read()  # 读取txt文本
# 优品课堂 codeclassroom.com    -sig创建顺序字节标记
open('data.txt', 'w', encoding='utf-8-sig').write()  # 读取txt文本