• 【Python】-----基础知识

    • 注释

    1. 定义：让计算机跳过这个代码执行
    2. 用三个单引号/双引号都表示注释信息，在Python中单引号与双引号没有区别，但必须是成对出现

              

    • 输出与输入

    • 程序是有开始，有结束的，程序运行规则：从上而下，由内到外
    1. 输出：程序把结果展示给用户  print
    2. 输入：用户给计算机下命令     input
    • 格式化输入与输出    Python占位符：用特殊占位符来进行占位，然后具体要显示什么值，后面来确定
    1. 方式一：使用%d   %s  %f来占位     %(值1，值2，值3）

          %d:整数     %s:字符串   %f:小数

           

      2.方式二：使用{}来表示占位符，  .format(值1，值2，值3）

           

     3. 方式三：在引号面前加f,只适用于变量

          

    • 数据类型 

    • 整数 int ：表示数据大小，会自动扩容，所以python里面是没有long 、short、byte这些
    • 浮点数 float ：python里面的float是双精度浮点数
    • 字符串：使用 ' 或者 '' 都可以
    1. 如果字符串里面包含双引号，字符用单引号括起来
    2. 如果字符串里面包含单引号，字符用双引号括起来
    3. 如果两者都包含，使用第三方引号引起来
    • 布尔:非0则为true ，在判断字符串时，里面没有数字才为False

        

    • 复数 ：实数+虚数 0.99j
    • 意义：
    1. 不同类型所占的内存空间不同( int 4, float 8, boolean 1, str 变长）
    2. 不同类型对应操作不同
    • 类型的相互转换：

       

    •  变量

    • 定义：为了保存所用的结果，用来存储数据的空间。 “=”表示赋值

    • 变量由数字，字母，下划线构成

    1. 不能包含特殊符号 （ *a ,**a)
    2. 数字不可以开头
    3. 变量名不可与python关键字重复

    • “=”表示赋值  (a=10,b=10)

    • 连续赋值，多个变量赋值同一个值（a=b=10)

    • 多个变量给多个值 （name,age,id="111",11,"233")

    • *来表示一个变量接受多个值（注意只能有一个*)

    • 运算符

    • 算数运算符

    1. + 
    2. * 
    3.   -   
    4. /    ，0不可以做除数，会报错；整数/整数，如果除不尽会得到小数
    5. **（进行乘方运算）
    6. % 
    7.  //(取整除法，针对结果向下取整））

    • 关系运算符（<=   >=  ==  !=)

    1. 可以针对数字/字符串进行比较（先看首字母在字母表上的顺序，谁小谁排在前面）
    2. 浮点数比较存在误差，所以比较的时候需要作差，看差值是否小于预期误差范围

          

    • 逻辑运算符(Not >And >Or) ,结果都为True/False

    1. and 一假则假
    2. or  一真则真
    3. not 

    • 赋值运算符(=  +=  -=  /=)    Python没有++/--操作

    1. Python中字符串可以相加
    2. Python中整数可以和浮点数相加
    3. Python中布尔值也可以相加（1---True  0---False)

    • 成员运算符

    • 运算符优先级

    1. 算数优先级大于比较优先级
    2. 比较优先级大于逻辑优先级
    3. 逻辑优先级内部Not >And >Or

    • 基础语法 

    • 顺序语句

    • 条件语句

    1. 单分支语法

        

         2. 多分支语法

        

         3. 多项分支

        

    • 循环语句

    1.     while循环

        

       2.   for 循环

       

    comntinue:立即结束当下循环

    break:结束本轮循环

    •  遍历数据应用

    • 列表 

    • 列表的定义：将多个数据组合在一起的容器  

         标识符：【 】   
         关键字： list  (在定义变量的时候，不要使用关键字去命名
         列表创建好以后是可以改变的（散装辣条）

    • 列表的创建

    1. # 定义了空列表
    2. a=[]
    3.  
    4. #直接给数据
    5. a= [1,2,3,4]

    • 列表的操作

    1. """
    2. 列表的切片操作，可以一次取出一组连续数据
    3. """
    4.  
    5. b=[1,2,3,4]
    6. #此时【1：3】 指的是前闭后开区间
    7. print(b[1:3])
    8. #省略后边界
    9. print(b[1:])
    10. #省略前边界
    11. print(b[:3])
    12. #切片操作涉及步长
    13. print(b[::1])
    14. #步长也可以是负数，从后往前去取
    15. print(b[::-1])
    16. #当切片范围超出有效下标后，不会报错
    17. print(b[1:100:2])
    18.  
    19.  
    20.  
    21.  
    22. """
    23. 列表的增加操作  列表的变量名.对应方法名
    24. """
    25. #列表插入操作  ,使用append来新增元素，使用insert在任意位置新增
    26. list=[1,2,3,4]
    27. list.append(99)
    28. print(list)
    29.  
    30. list.insert(2,100)
    31. print(list)
    32.  
    33.  
    34.  
    35. """
    36. 列表的打印下标元素操作
    37. """
    38. list1=[1,"1111","String",9]
    39. print(list1[1])
    40.  
    41.  
    42.  
    43. """
    44. 列表的查询操作   in/ not 打印操作都为true、false
    45. """
    46. list2=[1,333,555,7]
    47. print(1 in list2)
    48. print(1 not in list2)
    49.  
    50.  
    51.  
    52. """
    53. 列表与列表之间的操作  + 连接,最好不要使用这个，  用extend在企业里面，
    54. """
    55. list3=[3,3,4,4]
    56. list4=[5,5,5,5]
    57. print(list3+list4)
    58.  
    59. list3.append(list4)
    60. print(list3)
    61.  
    62. #字符串是可以当作整个列表的，数字是不可以的，boolean不可以
    63. list3.extend("小加")
    64. print(list3)
    65.  
    66.  
    67.  
    68.  
    69. """
    70. 列表的删除操作  pop删除是按照下标删除,从后往前删 ， remove是按照值来删除
    71. """
    72. list6=[1,2,3,4,5,5]
    73. # 如果有多个重复数据，会删除靠前面的这一个值
    74. list6.remove(5)
    75. print(list6)
    76.  
    77. # 根据下标进行删除,不给下标从后往前删
    78. list6.pop()
    79. print(list6)
    80.  
    81.  
    82. # 请删除列表中的第2至第4个元素，并输出删除元素后的列表
    83. li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
    84. del li[1:4]
    85. print(li)
    86.  
    87.  
    88.  
    89. """
    90. 修改元素,先要找到具体的值，赋新的值会完成修改
    91. """
    92. list8=[1,1,1,1,1]
    93. list8[3]=100
    94. print(list8)
    • 列表有关内存的问题
    1. #有关内存问题
    2. list=[1,2,3,4]
    3. #list2与list指向同一个，所以给list3增加数据也会让list增加，工作中不要这样做！！！
    4. list2=list
    5. list2.append(99)
    6. print(list2)
    7. print(list)
    8.  
    9. #切片完成，从新生成
    10. list2=list[0:]
    11. list2.append(100)
    12. print(list)
    13. print(list2)
    • 统计元素个数
    1. """
    2. 统计元素个数,一个萝卜一个坑，如果里面的元素包含数组，那么也不会进行
    3. """
    4. list1=[1,2,4,5,[1,2,3,4]]
    5. print(list1.count(2))   //打印出1
    6.  
    7. #得到下标为4里面的列表的元素中是否包含2
    8. print(list1[4].count(2))  //打印出1

    • 字典 

    • 字典定义：具有键值对映射关系的一组无序数据集合   key: value (key不变，value是可以随便的变 ） 

    • 关键字： dict

    • 标识符：  { }

    • 字典的创建

        

    • 字典的应用

    1. """
    2. 字典的新增，对应不存在的key
    3. """
    4. a={
    5.     "name":11,
    6.     "id":123
    7. }
    8. a['score']=90
    9. print(a)
    10.  
    11.  
    12.  
    13. """
    14. 字典的修改,修改存在的数据
    15. """
    16. a={
    17.     "name":11,
    18.     "id":123
    19. }
    20. a['id']="xiaohua1"
    21. print(a)
    22.  
    23.  
    24.  
    25. """
    26. 字典删除，key不为空,这一类、key都会删除，使用pop   ,popitem--从后往前删除
    27. """
    28. a.pop('id')
    29. print(a)
    30. #从后往前删除
    31. a.popitem()
    32. print(a)
    33.  
    34. #清空 cler
    35. a.clear()
    36. print(a)
    37.  
    38.  
    39.  
    40.  
    41. """
    42. #字典的查找  in  not in
    43. """
    44. a={
    45.     "name":11,
    46.     "id":123,
    47.     "xiaohua":123
    48. }
    49. print('name' in a)
    50. print('name' not in a)
    51.  
    52. """
    53. 取出所有key与value的值,获取所有的键值对
    54. """
    55. a={
    56.     "name":11,
    57.     "id":123,
    58.     "xiaohua":123
    59. }
    60. print(a.keys())
    61. print(a.values())
    62. #获取所有的键值对
    63. print(a.items())

    • 元组 

    • 标识符：（）

    • 关键字：tuple

    • 定义：元组不可变，程序运行的时候无法改变

    • 面试题：

    1. 1.列表和元组的区别？
    2.  
    3. 列表：可以变的
    4.  
    5. 元组：不可变的，程序运行时候无法改变
    6.  
    7.  
    8. 2.既然元组不可变，那么存在的意义？
    9.  
    10. 任何变化的数据都有可能造成安全性问题 ；  处于安全考虑

    • 元组的操作

    1. #获取元组的某个元素
    2. tp=(1,2,3,4)
    3. print(tp[-1])
    4.  
    5. #元组可以生成一个新的元组，并不是元组的拼接
    6. tp1=(1,2,3,4)
    7. tp2=('a','b')
    8. res=tp1+tp2
    9. print(res)
    10.  
    11. #乘法是把元组进行了两遍的打印
    12. ret=tp1*2
    13. print(ret)
    14.  
    15. #给你元组要进行一些修改，可以转化成列表可变的，修改完在转回来,相当于重定义
    16. tp3=(1,2,3,4)
    17. list=list(tp3)
    18. print(list)
    19. list.append(9)
    20. tp3=tuple(list)
    21. print(tp3)
    22.  
    23. #元组的赋值
    24. num1=(1,) #为元组类型，元组的值一个都得拿逗号隔开
    25. num2=(1)  #为整型
    26. print(type(num1))
    27. print(type(num2))

    • 集合

    • 集合定义：由不同元素组成的数据结构（无序排列）

    • 标识符：{ }

    • 集合内的元素，不能重复；集合和集合之间可以做运算

    • 关键字：set

    • 集合的应用

    1. #集合定义
    2. # set={1,"aaa",3,4}
    3. # print(set)
    4. #集合操作
    5. #查询---需要先转换(转换后列表是有序的），在查询（所以查询是有序的）
    6. set={"欢迎","来到","笑话"}
    7. list=list(set)
    8. print(list[0])
    9.  
    10. #集合的增加值  add(也是无序的）
    11. set={"欢迎","来到","笑话"}
    12. set.add("!!!")
    13. print(set)
    14.  
    15. #集合的删除,无序的删除---pop
    16. set={"欢迎","来到","笑话"}
    17. set.pop()
    18. #指定的删除---remove（value)
    19. set={"欢迎","来到","笑话"}
    20. set.remove("来到")
    21. print(set)
    22. #删除多次也不会报错，就算没有这个数据也可以----discard
    23. set={"欢迎","来到","笑话"}
    24. set.discard("欢迎")
    25. set.discard("欢迎")
    26. set.discard("欢迎")
    27. set.discard("欢迎")
    28. print(set)

    • 集合的运算

    1. #交集：两个集合的相同数据
    2. set1={"xiaoxiao","jiajia"}
    3. set2={"xiaoxiao","1111"}
    4. print("交集：",set1.intersection(set2))
    5.  
    6. #并集：合并重复去除掉
    7. print("并集：",set1.union(set2))
    8.  
    9. #差集：把自己有的对方没有的元素获取
    10. set1={"xiaoxiao","jiajia"}
    11. set2={"xiaoxiao","1111"}
    12. print("差集：",set1.difference(set2))
    13.  
    14. #交叉补集：共有部分全部移除掉，只留下独有的部分
    15. set1={"xiaoxiao","jiajia"}
    16. set2={"xiaoxiao","1111"}
    17. print("差集：",set1.symmetric_difference(set2))

    • 函数 

    • 定义：将一段代码封装在一个自定义函数名里，这些封装的代码只有调用的时候才执行

          

    • 在Python中只要求个数，对类型无要求。Python中一个函数可以返回多个值

    • 函数的返回值：函数在执行时需要将执行结果传递给调用函数的位置，所以使用return来进行，如果不写return，直接返回none; 

    1. 获取这个值可以直接打印/通过变量来接收返回值 ； 
    2.  return表示函数的结束，return后面的代码归属于这个函数也不会执行
    3. return后面可以写返回值，也可以不写

    • 函数的参数：

    1. 可以不写形式参数是可以打印的
    2. 写参数，如调用的时候不给参数，那么会报错
    3. 不定长参数  * --表示传入数据为元组    **---表示传入类型为字典
    1. #元组--*
    2. def print_1(*args):
    3.     print(args)
    4. print_1(1,2,3,4,5)
    5.  
    6.  
    7. #字典--**
    8. def print_1(**kwargs):
    9.     print(kwargs)
    10. print_1(name="xiaojia",id="1",age=10)

    • 函数注释（注释可以写，也可以不写）

    1. #函数的注释与嵌套，函数的注释用来说明当前函数的含义
    2.  
    3. def fun1(name):
    4.     """
    5.     :param name:  //函数的说明
    6.     :return: //输入这个还能输之后的结果
    7.     """
    8.     bool =False
    9.     if name=="xiaojai":
    10.         bool=True
    11.     return bool

    • 函数的嵌套

    1. 函数打印的结果

    1. 两个同级函数是可以相互调用的
    1. def fun1():
    2.     print("今天该我了")
    3.     fun2()
    4. def fun2():
    5.     print("今天该你了")
    6.     fun1()
    7. fun2()
    1. 函数内部还可以直接定义函数，但是需要调用函数才可以执行
    1. def fun3():
    2.     print("111")
    3.     def fun4():
    4.         print("222")
    5.     fun4()
    6. fun3()

    • 作用域函数

        

    1. 局部变量修改成全局变量 (global---关键词修改成全局变量，需要先定义）
    1. x=10
    2. def text():
    3.     global x
    4.     x=20
    5.     print(f"函数内部：",{x}) #20
    6. text()
    7. print(f"函数外部：",{x}) #20
    1. 循环内部重新定义全局变量，全局变量会被修改
    1. x=10
    2. while True:
    3.     x=20
    4.     print(x)
    5.     break

    • 有关函数的应用

    1. # abs() #绝对值
    2. #divmod() #返回商和余数
    3. x=int(input("输入一个数："))
    4. a,b=divmod(x,2)
    5. print(a) #2
    6. print(b)  #1
    7.  
    8. # round() #四舍五入 ,奇数做四舍五入操作，偶数不四舍五入------银行家算法
    9. print(round(1.5)) #2
    10. print(round(2.5)) #2
    11. print(round(3.5)) #4
    12. print(round(4.5)) #4
    13. # pow() #次方

    • 匿名函数（没有名字的函数）--通过lambda来实现匿名函数

        

            lambda  自定义参数：逻辑表达式

    • 函数的调用与引用

    1. def fun1():
    2.     print('执行11')
    3. fun1() #调用函数
    4. print(fun1) #得到的是函数所在的内存地址，函数本体
    函数引用：只有函数名称，没有小括号，对应的是这个函数的内存地址
    引用+小括号----调用               调用-小括号-----引用

    • 日志信息 

    • 定义：记录程序运行的流程是否正常，可以解决bug发生的问题，实际过程中python是放在服务器上执行的，我们可以自己写去看实际情况

    • 日志级别

    1. """
    2. 日志的级别： debug调试信息--全部都会输出
    3.   info正常输出--不会输出debug  
    4.   warning警告提示--不会输出debug,info   
    5.   error报错信息---只输出一个error级别
    6. 级别可以自己设定
    7. """
    8. import logging
    9. logging.basicConfig(level=logging.INFO)
    10. logging.debug("调试信息")
    11. logging.info("正常信息")
    12. logging.warning("警告信息")
    13. logging.error("错wu信息")

    • 装饰器

    1. 规则：在需要执行函数的头部，加上@---如果存在@后面的函数名称，就会先去执行这个函数
    2. 调用装饰器需要在函数头部加上@后面加上装饰器名称，
    •     
       3.应用
    1. #去上海之前跟我吃饭，到上海后跟我唱歌
    2. import logging
    3. def log(func):
    4.     def b():
    5.         logging.info("去上海: ")
    6.         func()
    7.     return b
    8. @log
    9. def func1():
    10.     print("跟我一起去吃饭")
    11. @log
    12. def func2():
    13.     print("一起去唱歌")
    14. func1()
    15. func2()

    • 模块和包

    • 模块：文件名（不包含.py后缀）

    • 包：就是python中的文件夹（带有--init--py)

    1. #模块
    2. import  time
    3. print(time.time())
    4.  
    5. #from  模块名称  import 函数名称
    6.  
    7. from time import time
    8. print(time())

    • 文件 

    • 文件读取（需要把文件存储到内存空间里面），文件打开后一定要关闭，打开文件是需要申请一定的系统资源，不在使用文件，资源应该被释放

    1. #文件读取
    2. f=open("C:/111/小明.txt",'r',encoding='utf-8')
    3. msg=f.read()
    4. print(msg)
    5.  
    6. #按行读取
    7. msg=f.readline()
    8. print(msg)
    9.  
    10. #读取出来的数据，存储为列表
    11. cont=f.readlines()
    12. for i in cont:
    13.     print(i)
    14.  
    15.  
    16.  
    17. #关闭文件之后是不可以在次进行读取，但是可以打印之前保存的数据
    18. f.close()
    19. print(msg)

    • 写文件

    1. #写文件
    2. #W----覆盖写入文件
    3. f=open("C:/111/小明.txt",'w')
    4. f.write("凄凄切切钱钱钱钱钱")
    5.  
    6. #a----追加写入
    7. n=0
    8. while n<3:
    9.     if n==0:
    10.         print("11111")
    11.     else:
    12.         print("22222")
    13. n+=1
    14. f.close()
    如果写入数据在文件里面，直接打开文件的时候，是不可以读取的，因为光标在末尾

    • 面向对象

    • 类里面，称之为方法叫做开发所编写生成的功能

    1. class 自定义类：
    2.  
    3.     属性
    4.     方法---功能
    5.  
    6. 类里面调用方法的时候需要实例化对象
    7.  
    8. class Student:
    9.     name='xiaohau1'
    10.     age=11
    11.     id=20
    12.     def eat(self):
    13.         print("吃东西")
    14.     def drink(self):
    15.         print("喝水")
    16.  
    17. #实例化一个对象
    18. xiaoxiao=Student()
    19. print(xiaoxiao.name)
    20.  
    21. #对象属性进行修改
    22. xiaoxiao.name="1111"
    23. print(xiaoxiao.name)
    1. 应用
    1. #创建英雄
    2. class Hero():
    3.     name="英雄名字"
    4.     type="英雄类型"
    5.     des_1="英雄技能1"
    6.     des_2="英雄技能2"
    7.     des_3="英雄技能3"
    8.     #实例化对象的时候，一定要先执行这个构造函数
    9.     def init(self,name,type,desc_1,desc_2,desc_3):
    10.         #当前变量的值接收进来，给到当前对象的属性
    11.         self.name=name
    12.         self.type=type
    13.         self.des_1=desc_1
    14.         self.des_2=desc_2
    15.         self.des_3=desc_3
    16.     #技能
    17.     def skill_1(self):
    18.         print("f{name}英雄，释放了--{desc_1}技能")
    19.  
    20.     def skill_2(self):
    21.         print("f{name}英雄，释放了--{desc_2}技能")
    22.  
    23.     def skill_3(self):
    24.         print("f{name}英雄，释放了--{desc_3}技能")
    25. #实例化对象
    26. liuban=Hero(name='11',type='22',des_1='33',des_2='44',des_3='55')

    • 封装：封装一个get方法去获取私有属性的值

       公有属性：常规属性   私有属性：双下划线开头，只能在自己类中进行调用

       类外面使用：对象名称.属性名称  

       类里面使用：self.属性名称

    1. 私有属性的获取与调用和修改
    1. #设置属性
    2. class Person():
    3.  
    4.     #构造函数
    5.     def __init__(self,name,age,sex):
    6.        self.name=name
    7.        self.age=age
    8.  
    9.        # 带有__为私有属性
    10.        self.__sex=sex
    11.  
    12.     def eat(self):
    13.         print("1111")
    14.  
    15.     #修改私有属性的值,
    16.     def set_sex(self,newsex):
    17.         self.__sex=newsex
    18.  
    19.     #获取私有属性的值
    20.     def get_sex(self):
    21.         return self.__sex
    22.  
    23. jiashuai=Person("xiaoxiao",1,1)
    24.  
    25. #私有属性的调用
    26. print(jiashuai.get_sex())
    27.  
    28. jiashuai.set_sex(newsex="笑话")
    29. print(jiashuai.get_sex())
    1. 类的公有和私有方法
           私有方法：双下划线开头的方法
    1. #获取类的私有方法：
    2. class Person():
    3.  
    4.     #私有方法
    5.     def __eat(self):
    6.         print("1111")
    7.  
    8.     #公有方法
    9.     def drink(self):
    10.         print("2222")
    11.  
    12.     #写一个run方法
    13.     def run(self):
    14.         self.__eat()
    15. jiashuai=Person()
    16.  
    17. #调用公有方法
    18. jiashuai.drink()
    19.  
    20. #调用私有方法,无法直接调用,需要在类里面写一个run方法
    21. jiashuai.run()

    • 继承 

    • 定义
    1. class 子类名称（父类名称）：
    3.    子类独有的方法或者属性

    • 应用

    1. #父类
    2. class Animal():
    3.       name="xiaohau"
    4.      #私有属性
    5.       __age="11"
    6.       def eat(self):
    7.         print("公有属性方法")
    8.       def __drink(self):
    9.         print("私有属性方法")
    10.  
    11.  
    12.  #获取父类私有属性
    13.       def get_age(self):
    14.         return self.__age
    15.       #run方法去运行
    16.       def run(self):
    17.          self.__drink()
    18.  
    19.  
    20. #子类继承父类
    21. class cat(Animal):
    22.     def sleep(self):
    23.         print("子类公有属性方法")
    24.  
    25. #实例化猫
    26. lili = cat()
    27. print(lili.name)
    28. #调用类里面父类的私有属性
    29. print(lili.get_age())
    30. #调用父类里面的私有方法
    31. print(lili.run())

    • 多继承

    1. 定义
    1. class 子类名称（父类1，父类2）：
    2.    属性或者方法
    3. ""
    1. 遵循就近选择，当两个类的方法一致，会就近继承打印
    2. 如果依次继承方法--（方法重构），方法重名时，只遵循子类方法执行
    1. class Monkey():
    2.     def eat(self):
    3.         print("吃")
    4. class God():
    5.     def fly(self):
    6.         print("fei")
    7.     def eat(self):
    8.         print("吃先")
    9. class sunwukong (Monkey,God):
    10.     def qujing(self):
    11.         print("取取经")
    12. swk=sunwukong()
    13. swk.fly()
    14. swk.eat()

    • 多态（支付场景） 

    • 应用

    1. class paymennt():
    2.     def pay(self):
    3.         print("支付")
    4. class weixin(paymennt):
    5.     def pay(self):
    6.         print("微信支付")
    7. class zhifubao(paymennt):
    8.     def pay(self):
    9.         print("支付宝支付")
    10. class aaa():
    11.     #设置参数来接收对象的值
    12.     def pay(self,oij):
    13.         #调用这个对象的支付方式
    14.         oij.pay()
    15. #这个地方传值----重点
    16. ooo=aaa()
    17. ali=weixin()
    18. ooo.pay(ali)  #微信支付

    •  异常

    • 异常：程序无法执行下去

    • 异常的解决

        1.try ......except
    1. try :
    2.    逻辑代码
    3. except:
    4.    一旦try里面代码报错，会离立即执行except
    5.  
    6.  
    7. try:
    8.     n = 1/0  #0不可以做被除数
    9.     print(n)
    10. except:
    11.     print("请检查try里面代码")
    12.  
    13.  
    14.  
    15. #异常嵌套
    16. try:
    17.     n = 1/0
    18.     print(n)
    19. except:
    20.     print("请检查try里面代码")
    21.  
    22.     #play B
    23.     str=input("输入字符串：")
    24.     try:
    25.         print(str[5])
    26.     except:
    27.         print("输入有无")
        2. try......finallly
    1. try:
    2.    逻辑性代码
    3. finally:
    4.    逻辑性代码
    5.  
    6.  
    7. try:
    8.     #可能会出现的异常，报错的上一行及以上都会执行
    9.     n = 1/0
    10. except:
    11.     #对try的异常处理信息
    12.     print(111)
    13. finally:
    14.     #不管处理不处理，都要执行
    15.     n = 1/0
     3. 获取异常处理的信息
    1. try:
    2.     #可能会出现的异常，报错的上一行及以上都会执行
    3.     n = 1/0
    4.  
    5. except Exception as  e:
    6.     print(e)

    • 断言 

    • 一旦匹配不成功，返回值为False，这时候会抛出异常，终端程序执行

    • assert   预期结果==实际结果

    自定义报错信息：

    • with 和as 

    1. 打开文件方式：
    2. file=open(文件路径，编码格式，读取方式）
    3.  
    4. with open(文件路径，编码格式，读取方式) as f:
    5. print(f.read())
  • 相关阅读:
    Spring之BeanFactory
    Oracle
    useMemo 使用误区
    C#使用Scoket实现服务器和客户端互发信息
    智能驾驶功能软件平台设计规范 第一部分：系统架构
    git时出现的若干问题以及解决方案
    Java高级技术之Gradle
    require、loadfile、dofile、load、loadstring
    AUTOSAR 多核操作系统时序监控系统设计
    【机翻】RTnet – 灵活的硬实时网络框架
  • 原文地址：https://blog.csdn.net/m0_69078476/article/details/136396113