python入门经典

大杂烩

变量类型

a = 1
print(type(a))

input

password = (int)input("输入password")
print(password)

格式化输出

name = "fendouing"

print("我的名字叫 %s" % (name))

student_no = 100024
print("我的学号是 %06d" % student_no)

price = 8.5
weight = 7.5
money = price * weight
print("苹果单价 %.2f 元/斤，购买了 %.3f斤，需要支付 %.4f元" %(price,weight,money))

高级变量

列表

注意列表的+=操作相当于extend操作

from utils import firstutils

name = ['zhangsan','lisi','wangwu']

print(name[0])

print(name.index('lisi'))

# 如果超出范围程序会报错
name[0] = 'yangliu'
print(name)

name.append('wangziqi')
print(name)

name.insert(1,'happy')
print(name)

temp_list = ['悟空','师弟']
name.extend(temp_list)
print(name)

name.remove('lisi')
print(name)
# 默认弹出最后一个
t = name.pop()
print(name)
print(t)
# 指定弹出位置
t = name.pop(3)
print(name)
print(t)

name.clear()
print(name)

name.append('end')
print(name)

name = ['张三','李四','王五']
print(name)
# del本事是把一个变量从内存中删除
del name[1]
print(name)

print(len(name))

print(name.count('张三'))

num_list = [6,8,4,1,10]
num_list.sort(reverse = True)
print(num_list)

num_list.reverse()
print(num_list)

for num in num_list:
    print(num)

元组

元组不能修改

from utils import firstutils


info_tuple = ('zhangsan',18,1.75)

print(type(info_tuple))

print(info_tuple[0])

print(info_tuple.index(1.75))

print(info_tuple.count('18'))

for item in info_tuple:
    print(item)

print("%s 年龄是 %d 身高是 %.2f" % info_tuple)

info_str = "%s 年龄是 %d 身高是 %.2f" % info_tuple
print(info_str)

list_ = list(info_tuple)
print(type(list_))

字典

string为最常用的key，字段是无序的

from utils import firstutils


xiaoming = {
    'name':'小明',
    'age':18,
    'gender':'男',   
}
print(xiaoming)

print(xiaoming['name'])
xiaoming['name'] = '小小明'

xiaoming.pop('name')
print(xiaoming)

# pop的时候设置默认值
value = xiaoming.pop('name','Alice')
print(value)

print(len(xiaoming))

temp_dice = {
    'weight':60,
    'age':20
    }
xiaoming.update(temp_dice)
print(xiaoming)

for i in xiaoming:
    print("%s - %s" % (i,xiaoming[i]))



xiaoming.clear()
print(xiaoming)

t_dic = {
    'age':22,
    'height':177,
    'name':'fendou',
    'sex':'男'
}

print(t_dic.get('id','123'))

t_dic.setdefault('age',18)
# 没有则天讲
t_dic.setdefault('weight',135)
print(t_dic)

# 返回并删除
print(t_dic.pop('sex'))
print(t_dic.pop('x','defalut'))

# 返回字典中最后一对儿键值对儿
print(t_dic.popitem())

print(dict.fromkeys(['a','b','c'],1))

print(t_dic.keys())
for each in t_dic.keys():
    print(each)

print(t_dic.values())
for each in t_dic.values():
    print(each)

print(t_dic.items())
for x,y in t_dic.items():
    print(x,y)

字符串

from utils import firstutils


str1 = 'hello python'
print(str1)
print(str1[1])

print(len(str1))
# 没找到报错
print(str1.index('llo'))

space_str = '  \t \n \r'
print(space_str.isspace())

num_str = '1.1'
print(num_str)
print(num_str.isdecimal())
print(num_str.isdigit())
print(num_str.isnumeric())

print(str1.startswith('hello'))
# 没找到返回-1
print(str1.find('ell'))

print(str1.replace('l','aa'))
print(str1)

# 对其
poem = [
    '登鹳鹤楼',
    '\t\n王之涣',
    '白日依山尽',
    '黄河入海流\t\n',
    '欲穷千里目',
    '更上一层楼'
]
for poem_item in poem:
    print("|%s|" % poem_item.strip().center(10,' '))

poem_str = '等黄鹤楼\t 王之涣\t 白日依山尽  黄河入海流\t\t 欲穷千里目 \t更上一层楼'
poem_list = poem_str.split()
print(poem_list)
print(' '.join(poem_list))

num_str = '0123456789'
print(num_str[2:6])
print(num_str[0:-1])
print(num_str[1::2])
print(num_str[-1])
print(num_str[-2:])
# 逆序
print(num_str[-1::-1])

内置

内置函数

str1 = 'sadsafsdfsdf'
print(max(str1))

t_dic = {'a':'z','b':'y','c':'x'}
# 比较针对key比较
print(max(t_dic))

print([1,1,1] < [2,2,2])
print('aaaa' < 'bbbb')

hash函数只能接受不可变参数

hash('hello')
hash([1,2,3])

__dir__查看对象有哪些属性和方法

def class A:
	pass
print(dir(A))
__class__
__delattr__
__dict__
__dir__
__doc__
__eq__
__format__
__ge__
__getattribute__
__gt__
__hash__
__init__
__init_subclass__
__le__
__lt__
__module__
__ne__
__new__
__reduce__
__reduce_ex__
__repr__
__setattr__
__sizeof__
__str__
__subclasshook__
__weakref__

issubclass isinstance hasattr getattr setattr delattr

class A:
    pass

class B(A):
    def __init__(self,name):
        super().__init__()
        self.name = name
    pass
class C:
    pass
# 查询B是否为A的子类
print(issubclass(B,A))
# True

t = B('Tom')
# 如果第二个对象不是类或者由类对象组成的元组 会抛出一个TypeError异常
print(isinstance(t,B))
print(isinstance(t,(A,B)))
print(isinstance(t,C))
# True
# True
# False

# 检查此对象是否有该属性
print(hasattr(t,'name'))
print(hasattr(t,'x'))
# True
# False

# 得到此对象中对应属性的值
print(getattr(t,'name'))
print(getattr(t,'x','default'))
# Tom
# default

# 设置对象中指定的属性
setattr(t,'age',18)
setattr(t,'name','jerry')
print(t.age)
print(t.name)
# 18
# jerry

# 删除对象中指定的属性
delattr(t,'name')
delattr(t,'height')
# AttributeError: height

lambda

fun = lambda x, y : x + y
print(fun(1,2))

filter

filter 将任何非True的内容过滤掉

t_list = list(filter(lambda x : x % 2, [1,2,3,4,5,6,7,8,9]))
print(t_list)

map

map 可以把输入参数映射为输出参数

t_map = list(map(lambda x : x * 2, [1,2,3,4,5]))
print(t_map)

reduce

reduce 将第一个参数和第二个参数做运算，然后返回值在和第三个参数做运算，然后…一直下取

from functools import reduce

resutl = reduce(lambda x , y : x + y,[1,2,3,4,5,6,7,8,9,10])
print(resutl)

zip

zip 将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表

a = [1,2,3]
b = ['a','b','c']
print(list(zip(a,b)))
print(dict(zip(a,b)))

内置操作运算

![在这里插入图片描述](https://img-blog.csdnimg.cn/20210227225246655.png)


print([1,2] + [3,4])

print((1,2) + (3,4))

print("a" * 4)

print(['a'] * 4)

print(3 in (1,2,3))

print(4 not in (1,2,3))

t_dic = {'a':1,'b':2,'c':3}
# 对字典进行in操作的比较的是key值
print('a' in t_dic)

print([1,2] < [2,3])

可变类型和不可变类型

a = 1
# id查看a指向的内存区域的地址
print(id(a))

print(id(1))

b = a
print(id(b))

不可变类型
内存中的数据不允许被修改。

• 数字类型
• 字符串
• 元组

可变类型

• 列表
• 字典

a = [1,2,3]
print(id(a))
a.append(4)
print(id(a))

dic = {'a':1,'b':2}
print(id(dic))
dic.update({'c':3})
print(id(dic))

注意
列表可变指的是append remove pop clear等方法，以下代码a所指向的内存地址仍然改变

a = [1,2,3]
print(id(a))
a = [2,3,4]
print(id(a))

全局变量和局部变量

global

局部变量是在函数内部使用的变量，只能在函数内部使用
全局变量是在函数外部定义的变量，所有函数内部都可以使用这个变量

注意
在函数内部，可以通过全局变量的引用获取相应的值。但是不允许修改全局变量引用的值

num = 10
print(id(num))
def demo1():
    print('demo1' + '-' * 50)
    
    # 只是定义了一个局部变量 并不会修改全局变量
    num = 100
    print(id(num))
    print(num)


def demo2():
    print('demo2' + '-' * 50) 
    # 局部可以引用全局变量的值
    print(id(num))
    print(num)

demo1()
demo2()

如果需要在函数内部修改全局变量的值，需要使用global关键字

num = 10

def demo1():
    global num

    num = 99
    print(num)
    
def demo2():
    print(num)

demo1()
demo2()
    

nonlocal

当再函数内部还有嵌套函数的时候，可以这样引用外部变量

def fun():

    num = 10
    def t_fun():
        nonlocal num
        num = 100

    t_fun()
    print(num)

fun()

字典元组的拆包和装包

多个返回结果，实际是返回了一个元组

def demo():
    A = 1
    B = 2

    return A,B

result = demo()

a,b = demo()

print(type(result))
print(result)
print(a)
print(b)

def demo(*args,**kwargs):
    print(args)
    print(kwargs)


gl_nums = (1,2,3)
gl_dic = {'name':'小明','age':18}

demo(gl_nums,gl_dic)

# 拆包操作   *(元组) **(字典)相当于把元组和字典拆开
demo(*gl_nums,**gl_dic)

# 装包操作
demo(1,2,3,name = '小明',age=18)

模块和包

pyc文件

pyc文件

#firsttutils.py
def fun(a ,b):
    return a + b

#first.py
from utils import firstutils
a = 1
b = 2
print(firstutils.fun(a,b))

当其他模块导入firstutils模块的时候，由于firstutils会自动生成一个.pyc文件，这个文件是C语言编写的解释器生成的二进制文件这样就不用每次加载firstutils的时候重新解释一遍firstutils文件了，提高运行效率

模块

一个独立的python文件就是一个模块

from ... import ...
import ... as ...
import ...
from ... import ... as ...
# 导入所有
from ... import *(慎用)

注意
如果从两个不同模块中导入了相同名字的函数，则后面的函数覆盖前面的函数，这时需要使用as取别名

python解释器导入文件时，搜索当前目录指定模块儿名的文件，如果没有，再搜索系统目录。

开发原则
当一个模块儿被导入时，所有没有缩进的代码都会被执行一遍。使用name属性解决。当前执行的文件,name__属性等于__main
name

if __name__ == ‘__main__’:
	... 

包

包是一个包含多个模块儿的目录，包含一个__init__.py文件

好处
可以使用 import 包名 一次性导入包中所有模块

__init__作用是导入包下的模块儿，以便其他模块儿只需要导入包就可以使用包下的所有模块儿

目录结构

----message
--------__ init__,py
--------send.py
--------receive.py
----first.py

# __init__.py
from . import receive
from . import send

# send.py
def fun_send():
    print('send ---')

# receive.py
def fun_receive():
    print("receive ---")

# first.py
import message

message.send.fun_send()
message.receive.fun_receive()

文件

文件读写常用方法

# open打开文件时文件指针移动的文件的开始
# open()默认只读
file = open('demo.txt',encoding='utf-8')
# read默认读取文件所有内容
# read方法执行完成后 文件指针会移动到文件的末尾
text = file.read()
print(text)

file.close()

file.close()

注意
w,a方式打开文件，如果文件不存在就会创建文件，r+,w+,a+都是以读写方式打开文件

readline

file = open('demo.txt',encoding='utf-8')

while True:

    line = file.readline()
    print(line)

    if not line:
        break
    

file.close()

readlines

file = open('demo.txt',encoding='utf-8')


for line in file.readlines():
    print(line)

file.close()

writelines

file = open('demo1.txt',encoding='utf-8',mode = 'w')

lines = ['我今天吃了三个馒头\n','你们还好吗\n','有人敲门了啊\n']

file.writelines(lines)

file.close()

大文件复制

file_read = open('demo.txt',encoding='utf-8')
file_write = open('demo1.txt',encoding='utf-8')

while True:
    line = file_read.readline()
    
    if not line:
        break    
    file_write.write(line)

file_read.close()
file_write.close()

property通过属性来设置属性
当我们未来修改getSize setSize delSize 用户调用接口那边不需要修改

class C:
    def __init__(self,size):
        super().__init__()
        self.size = size
    def getSize(self):
        return self.size
    def setSize(self, value):
        self.size = value
    def delSize(self):
        del self.size
    x = property(getSize,setSize,delSize)

c = C(18)
print(c.size)
print(c.x)
c.x = 10
print(c.size)

del c.x
print(c.size)

文件/目录常用操作

import os

# 重新起名
os.rename('demo.txt','t_demo.txt')

# 重新命名
os.remove('t_demo.txt')

#当前工作目录所有的文件
print(os.listdir('.'))

#是否是文件夹
print(os.path.isdir('message'))

#创建目录
os.mkdir('test')

#当前目录
print(os.getcwd())

文件的with语句

# 不用手动调用f.close()

# 不用手动调用f.close()
with open('demo.txt',encoding = 'utf-8') as f:
    for line in f:
        print(line)

闭包

python中所有东西都是对象
如果在一个内部函数里(FunY里)，对FunY外部作用域中的变量进行了引用，那么FunY叫做闭包

def FunX(x):
    def Funy(y):
        return x * y

    return Funy

i = FunX(8)
print(i)

print(i(5))

类

class Cat:
    """这是一个猫类"""
    def eat(self):
        print('小猫爱吃鱼')

    def drink(self):
        print('小猫爱喝水')

tom = Cat()
tom.eat()
tom.drink()
# 按照十六进制输出
print('%x' % id(tom))

类的外部给对象增加属性(不推荐)

class Cat:
    """这是一个猫类"""
    def eat(self):
        print('小猫爱吃鱼')

    def drink(self):
        print('小猫爱喝水')

tom = Cat()
tom.name = 'lina'

print(tom.name)

self

self指向对象的自己的内存地址。

class Cat:
    """这是一个猫类"""
	...
    def print_self(self):
        print(self)

tom = Cat()
print('%x' % id(tom))
tom.print_self()

_ init _和 _ del _方法

_ init _方法
类名()创造对象时，会做如下事情

• 为对象分配内存空间
• 为对象的属性设置初始值–调用 _ init _方法(内置方法)

_ del _方法
对象销毁之前执行

class Cat:
    """这是一个猫类"""
    def __init__(self, name):
        super().__init__()
        print('------初始化------')
        self.name = name

    def eat(self):
        print('%s爱吃鱼' % self.name)

    def drink(self):
        print('%s爱喝水' % self.name)

    def print_self(self):
        print(self)

    def __del__(self):
        print('------对象销毁-------')

tom = Cat('Tom')
tom.drink()
tom.eat()

tom = Cat('Tom')
tom.drink()
tom.eat()

_ str _

print(对象)默认调用的对象_ str _函数

    def __str__(self):
        return '我的名字叫 %s' % self.name

私有属性和私有方法

定义属性和方法时，在属性名或者方法名前面加两个下划线，就是定义私有属性和方法

class People:
    """这是一个猫类"""
    def __init__(self, name,age):
        self.name = name
        self.__age = age

    def __secret(self):
        print('%s 的年龄是 %d' % (self.name,self.__age))

tom = People('Tom',18)

# 可以这样访问私有方法和私有属性
print(tom._People__age)
tom._People__secret()

# 报错
print(tom.__age)
# 报错
tom.__secret()

继承

子类继承父类的属性和方法
注意
不能直接调用父类的属性

class Animal():
    def __init__(self):
        super().__init__()
        self.name = 'Animal'
    def eat(self):
        print('%s在叫-----------' % self.name)
    
class Cat(Animal):
    def __init__(self):
        super().__init__()
        # print(super().name)
        self.name = 'Cat'

tom = Cat()
tom.eat()

重写

子类对象重写父类方法

class Animal():
	...
    def eat(self):
        print('调用的是父类的方法')
    
class Cat(Animal):
	...
    def eat(self):
        print('调用的是子类的方法')
tom = Cat()
tom.eat()

super()的使用

在子类重写父类方法时，可以使用super().父类方法来调用父类方法的执行

class Animal():
	...
    def eat(self):
        print('调用的是父类的方法')
    
class Cat(Animal):
	...
    def eat(self):
    	super().eat()
        print('调用的是子类的方法')
tom = Cat()
tom.eat()

注意
还可以使用类名.方法名调用父类的方法
类名.方法名(self)

class Animal():
	...
    def eat(self):
        print('调用的是父类的方法')
    
class Cat(Animal):
	...
    def eat(self):
    	Animal.eat(self)
        print('调用的是子类的方法')
tom = Cat()
tom.eat()

super().方法 就是使用super()对象出来的方法。

调用父类私有属性和方法

注意
子类一般不能不能通过super().的方实访问父类中的私有属性和方法

class Animal():
    def __init__(self):
        super().__init__()
        self.__name = 'Animal'
    def __eat(self):
        print('调用的是父类的方法')
    
class Cat(Animal):
    def __init__(self):
        super().__init__()
    
    def test_fun(self):
        print(self._Animal__name)
        self._Animal__eat()
        
        # 报错
        print(self.__name)
        # 报错
        self.__eat()

tom = Cat()
tom.test_fun()

多继承

class C(A,B):
	pass

当继承多个对象中包含同名搞得属性和方法的时候，python底层的MRO–方法搜索顺序会决定执行那个函数和属性。

__ mro __ 属性查看对象调用方法的顺序

class A:
    pass

class B:
    pass

class C(A,B):
    pass
# 确定C对象调用方法的顺序
print(C.__mro__)

多态

子类重写了父类的方法

class Animal:

    def shout(self):
        print('-------Animal的shout----------')

class Cat(Animal):
    def shout(self):
        print('-------Cat的shout----------')
        
class Dog(Animal):
    def shout(self):
        print('-------Dog的shout----------')

def fun(animal):
    animal.shout()

fun(Animal())
fun(Cat())
fun(Dog())

类属性和类方法

python中一切皆对象
类是一个特殊的对象,所以可以有自己的对象和方法

class Tool:
    # 类属性
    count = 0

    def __init__(self ,name):
        super().__init__()
        self.name = name

        Tool.count += 1

    # 类方法  cls和self类似 代表当前类
    # 类方法 通常会访问类属性
    @classmethod
    def show_tool_count(cls):
        print('工具对象的数量是 %d' % cls.count)

for i in range(3):
    Tool(i)
    Tool.show_tool_count()

print(Tool.count)

注意
不推荐使用对象名.类属性访问类属性，因为如果是获取值的话没问题，要是给类属性赋值的话会出现问题

class Tool:
    # 类属性
    count = 0

    def __init__(self):
        super().__init__()
        Tool.count += 1


tool1 = Tool()
tool2 = Tool()
tool3 = Tool()
# 此时会为tool1对象单独的生成一个count属性
tool1.count = 99

print(Tool.count)
print(tool1.count)

静态方法

当一个方法既不需要访问实例属性也不需要访问类型新的时候，那么这个方法就是静态方法

class Tool:
	...
    @staticmethod
    def static_fun():
        print('这是一个静态方法')
        
Tool.static_fun()

__new__内置方法

使用类名()创建对象的时候,python解释器会调用new方法为
对象分配内存空间
_ _new__是一个由object基类提供的内置的静态方法作用为

1. 在内存中为对象分配内存空间
2. 返回对象的引用

_ new__是一个由Object基类的内置静态方法，调用时需要主动传递cls参数
注意
重写new 方法一定要返回**return super(). new _(cls)**否则就得不到对象的引用

单例模式

# 单例模式
class MusicPlayer(object):

    instance = None

    def __new__(cls,*arg,**kwargs):
        if cls.instance == None:
            cls.instance = super().__new__(cls)

        return cls.instance


player1 = MusicPlayer()
player2 = MusicPlayer()
#返回True
print(id(player1) == id(player2))

魔法方法

_ len _(self) : 定义被len()调用时的行为。
_ getitem _(self,key) :相当于self[key]
_ setitem _(self,key) : 相当于self[self] = value
_ delitem _(self,key) : 相当于del self[key]
_ iter _(self) : 定义迭代器行为
_ reversed(self) _ : 定义当被reversed()方法调用时的行为
_ contains _(self,item) : 定义当使用成员测试运算符(in 或 not int)时的行为

示例

class ContainList(object):
    def __init__(self, c_list):
        super().__init__()
        self.list = c_list

    def __len__(self):
        return len(self.list)

    def __getitem__(self, key):
        return self.list[key]
t_list = [0,1,2,3,4,5]
C = ContainList(t_list)
print(len(C))
print(C[2])

迭代器

for key in list内部原理就是使用以下两个函数
iter() 和 next()

class ContainList(object):
    def __init__(self, c_list):
        super().__init__()
        self.list = c_list
        self.index = 0;
    def __iter__(self):
        # 返回一个迭代器 通常是自己
        print('-------iter()--------')
        return self
    def __next__(self):
        print('-------next()--------')
        self.index += 1
        if self.index == len(self.list):
            raise StopIteration()
        return self.list[self.index]
    
t_list = [0,1,2,3,4,5]
C = ContainList(t_list)
for item in C:
    print(item)

yield

协同程序:就是可以运行的独立函数调用，函数可以暂停或者挂起，并在需要的时候从程序离开的地方继续或者重新开始

def myGen():
    print('生成器执行')
    yield 1
    yield 2

it = myGen()
print(next(it))
print('---------')
print(next(it))

print('*' * 10)
for i in myGen():
    print(i)

e = (i for i in range(10))
print(e)
for i in e:
    print(i)

推导式

注意
列表，字典，集和都有推导式，但是元组没有推导式，元组的推导式返回一个迭代器

# 列表
t_list = [i for i in range(10) if not (i % 2) and i % 3]
print(t_list)
t_fun = [lambda x : x * i for i in range(3)]
print(t_fun)
print([(x, y) for x in range(3) for y in ['a' , 'b' , 'c']])

# 字典
t_dic = {i : i % 2 == 0 for i in range(10)}
print(t_dic)

# 集和
t_set = {i for i in range(10)}
print(t_set)

# 元组 元组返回的是一个迭代器
t_tuple = (i for i in range(10))
print(t_tuple)
print(next(t_tuple))
print(next(t_tuple))

with语句底层

with语句和_ enter _还有 _ exit _方法有关
enter 函数的返回值 作为 as 的引用
无论with语句中发布发生异常，exit方法都会被调用

class Sample:
    def __enter__(self):
        return self
    def __exit__(self,type,value,trace):
        print('type',type)
        print('value',value)
        print('trace',trace)

    def do_something(self):
        bar = 1 / 0
        return bar + 10

with Sample() as sample:
    sample.do_something()

异常

根据错误类型捕获异常

try:
    input_num = 'a'
    # num = int(input_num)

    result = 8 / 0
    print(result)
except ZeroDivisionError:
    print('除0错误')
except ValueError:
    print('请输入正确的值')
# 这里捕获所有的异常 as 后面是捕获的异常信息
except Exception as result:
    print('这里捕获所有的异常 %s' % result)

# 无论发不发生异常都会进行到这里
print('------end------')

finally和else

try:
    result = 8 / 0
    print(result)
except ValueError:
    print('请输入正确的值')
# 这里捕获所有的异常
except Exception as result:
    print('这里捕获所有的异常 %s' % result)
else:
    print('尝试成功')
finally:
    print('无论是否出现异常都会执行')

try:
    input_num = 'a'
except ValueError:
    print('请输入正确的值')
# 这里捕获所有的异常
except Exception as result:
    print('这里捕获所有的异常 %s' % result)
else:
    print('尝试成功')
finally:
    print('无论是否出现异常都会执行')

异常捕获的完整结构

try:
    # 尝试执行的代码
except 错误类型1:
    # 针对错误类型1，对应的代码处理
except 错误类型2:
    # 针对错误类型2，对应的代码处理
except (错误类型3,错误类型4):
    # 针对错误类型3和4，对应的代码处理
except Exception as result:
    # 捕获所有的异常
    # 打印错误信息
    print(result)
else:
    # 没有异常才会执行的代码
    pass
finally:
    # 无论是否发生异常都会执行的代码
    pass

异常传递

异常的传递，当函数/方法出现异常后，会将异常传递给函数/方法的调用一方，如果传递到主程序，仍然没有异常处理，则程序报错
在开发中，经常在主程序中捕获异常

def fun1():
    num = 1 / 0
def fun2():
    fun1()

fun2()

raise

def input_password():
    pwd = '123456'
    if len(pwd) < 8:
        ex = Exception('密码长度不够长')
        raise ex
try:
    input_password()
except Exception as result:
    print(result)

assert

assert 表达式,异常消息
如果表达式为False，则抛出一个AssertionError异常，并且消息为异常消息，如果表达式为真则继续执行

try:
    assert 1 == 0,'失败'
except AssertionError as result:
    print(result)