python基础（一）

秒速五厘米 2022-06-02 05:08 472阅读 0赞

1.range函数

a)第一种情况for i in range(10) 循环十次，其中i的值从0取值到9

b)第二种情况 in  range（1,10）从1顺序的取到10 步伐为1 但是不包括10,如果是in rangle（10,1）这个是错误的，必须写成in  rangle(10,1,-1)

c)第三种情况 in  range(1,10,2)  从1顺序的取到10 步伐为2

例子截图：此处注意那个“”日“”  python是用缩进格（tab）来判断是否属于for句下面，还有for if等语句，都需要用:结尾

![Center][]

2.raw\_input函数，此函数为提示用户按下键盘某个键，退出程序，如果不按下回车键，运行程序会报错，提示有一个程序正在运行，目的在于持久性的运行程序。

例子：

![Center 1][]

3.符号  python中，单引号‘’   双引号""  三双引号"""    """（小编不知道这叫什么，所以起了个别名）

a)对于创建字符串来说，既可以使用单引号 ，也可以使用双引号，当然小编也用三双引号试了下

貌似计算机，并不是很关系具体你用的是把那个，输出的字符串都是一样的，如下图：

![Center 2][]

b)对于双引号跟三双引号的作用，是这样的

![Center 3][]

4.print函数，顾名思义 就是打印函数，比较简单，比如print("xjp")就会打印字符串xjp，多个参数时，print（"xxx","jjj","ppp"）,在输出的结果中，各个数据的值之间是分开的，这是print函数的默认行为

a)比如\\n代表换行

b)\\t代表对齐,

c)\\a代表响一下电脑的蜂鸣器（cmd 或者 控制台），

d)特殊字符前面加个“\\”比如当你想输出\\的时候，前面需要加一个\\，比如print("\\t\\t\\t \\\\ \\\\ \\\\ \\\\ \\\\")  输出的是\\ \\ \\ \\ \\，

e)如果需要输出重复字符串，print("xjp"\*5) 就会输出xjpxjpxjpxjpxjp

5.python数值类型

a)整数比如整数 0 ，100 -100

b)浮点数比如带小数的数字，比如3.3，-99.5，,1.0

6.运算符    “+”  “-”   “\*”   “/(真除，7/3=2.3333)”  “//（整数 7//3=2）”   “%（求模）7%3=2”,python(3.X版本不同版本有区别，比如你使用python2.7.1   3/2=1)

7.input说白了 这个函数就相当于c语言中的scanf，也就是获取用户输入的字符串

比如 name = input("what's your name？ ：")  中间的字符串是用来提示用户的，input会等待用户输入点东西，但用户按下enter的时候,input就会以字符串的形式全部存入到name中。，如果需要转化数值类型，直接在前加上int(),float() ,str()

小编发现，当我用python2.7时候，input报错了，说name没定义，但是实际name的值可以赋值进去了，在此小编没有去深究，当使用python3.5版本时候，发现没问题，看下图

![Center 4][]

8.字符串格式转变的几个函数写的几个方法，使用的函数

a）全部变成大写字母输出 name="xiejiangpeng"    则 print(name.upper())    输出XIEJIANGPENG

b）全部变成小写字母输出 name="Xiejiangpeng"     则print(name.lower())    输出xiejiangpeng

c）变成标题格式输出    name= "xie  jiang  peng"    则print(name.title())      输出Xie  Jiang  Peng

d）字符串中某段字符串替换   name= xiejiangpeng  则print(name.replace("x","hello"))  输出 helloiejiangpeng ，意思是将字符串中所有的x  用hello代替，创建一个新的字符串，另外此函数还可以加第三个参数，例如当name= xie xie  xie     print(name.replace("x","hello",2))  则输出 helloie  helloie  xie  第三个参数时限制最多替换多少次

此外提供一些字符串方法：

![Center 5][]

9.复合赋值运算符

运算符                          范例                             等价于

\*=                                x\*=5                            x=x\*5

/=                                x/=5                            x=x/5

%=                              x%=5                           x=x%5

\+=                              x+=5                            x=x+5

\-=                               x-=5                             x=x-5

10.随机函数，randint   randrange，使用时需要导入 random包，然后通过random.（函数）进行引用，属于点标记法来引用模块中的任何内容

![Center 6][]

11.if函数

if mood ==  0:

elif mood == 1:

elif mood ==2:

else:

![Center 7][]

12.while函数  例如：记住此程序中name变量必须初始化，值可以为“”   也可以“xxxwdf”  但是为空的时候，代码的可读性更加好，为了优化代码的目的我们可以使用“”

![Center 8][]

#encoding=utf-8
    x=1
    while x<100:
        x=x+1
        print(x)

13.break和continue的用法   前者是结束循环，后者是结算此次循环，

根据下面这个例子可以理解

记住tab缩进  否则出现莫名其妙的错误，次例子输出结果是

1 2 3 4 6 7 8 9 10

![Center 9][]

14.逻辑运算符not，可以用来检测用户是否输入了字符（回车不算）

\#not 练习  
\#coding=utf-8  
name = ""  
while not name:  
        name=input("请输入你的名字：")  
~                                                                                 
~                                                                                
~

程序运行后，name初始化为空字符串，相当于False，因此not False也就意味着True,当用户没有输入数据按下回车时，程序就会继续提示要求用户输入你的名字

当用户输入数据时，此条件就为False了

15.逻辑运算符，or  and  一般用于if  while  连接条件语句，组合成一个新的条件语句

16.函数isdigit()检查字符是否由纯数字组成、当字符串str为纯数字的时候，str.isdigit()为True 当不是纯数字组成的时候，str.isdigit() 为False

17.quit()  exit()二个函数放的位置可以结束程序运行

18.for循环用法，比其它语言的for循环更加灵活，不只是可以计数器变量进行循环，比如对序列进行遍历，可以通过一个变量来获取序列中的元素

比如  下面那个例子

![Center 10][]

19.len函数，用途 计算字符串长度的函数 比如str=q !(中间有个空格)   print(len(str))    会打印出3，另外检查一个字符串中是否含有某个字符 ，可以用if  "str1"  in  str

![Center 11][]

20.索引

a）正位置索引，比如str="xjp"  那么print(str\[0\]) 打印出来的是"x"

b）负位置索引，比如str="xjp" 那么print(str\[-1\]) 打印出来的是“p”

21.函数randrange的用法，比如random.randrange(num1,num2)  随机取num1到num2中的数据

![Center 12][]

21 利用for循环 以及in   去除元素 代码如下

#演示利用for循环创建新的字符串
    message = input("请输入一个字符串\n")
    new_message =""
    VOWELS = "aeiou"
    for letter in message:
        if letter.lower() not in  VOWELS:
            print(letter.lower())
            new_message += letter
    
    print("新的字符串为",new_message)

其中 for  letter.lower()    还有VOWELS是代表大写  这种大写在python中有特殊的含义 代表不变的常量

22.切割字符串代码 可以根据索引随意切割 代码如下，其中None在这里是为了初始化start的值，代表的意思为“无”

# 对字符串进行切片
    word = "xjplove"
    print(
        """
    字符串1索引图
    0   1   2   3   4   5   6   7
      x   j   p   l   o   v   e
    -7  -6  -5  -4  -3  -2  -1              
           """
    )
    print("请输入 你需要切断的数字")
    start = None
    while start !="":
        start = (input("\nStart"))
    
        if start:
            start = int(start)
    
            finish = int(input("finish:"))
    
            print("word[", start,":",finish,"] is",end=" ")
            print(word[start:finish])

23.list中的内置函数

#列表  python的苦力
    #1.append追加一个列值
    list1=[None]*1
    list1.append(1)
    print(list1)
    #2.count统计某个字符出现的字数
    print(["x","x","1","s","x"].count("x"))
    print(list("xiejiangpengx").count("x"))
    #3.extend跟+区别  这个是重新创建一个新的list
    a=[1,2,3]
    b=[4,5,6]
    a.extend(b)
    print(a)
    #4.index 找到list中某个值对应的索引位置
    namelist=["xiejiangpeng","pengmin","dog","rubbish"]
    print(namelist.index("pengmin"))
    #5.insert 在某个位置插入值(可以是个列表)
    list_insert=[1,3,4]
    cc=[2,2]
    list_insert.insert(1,cc)
    list_insert.insert(2,"xiejiangpeng")
    print(list_insert)
    #6.pop 移除列表中的某个元素(默认是最后一个) 其中可以返回这个值 跟append刚好相反
    #x.append(x.pop())也是返回x这个列表
    list_pop=[1,2,3]
    list_pop.pop()
    list_pop.pop(1)
    print(list_pop)
    #7.remove 删除某个值 但是不会返回
    list_remove=["to","be","or","not"]
    list_remove.remove("be")
    print(list_remove)
    #8.reverse 反向存放 比如1,3，2 就会变成2,3,1
    list_reverse=[1,3,2]
    list_reverse.reverse()
    print(list_reverse)
    #9.sort  可能是从小到大排序 复制list=list_t[:] 将list_t的每个分片都复制给sort
    list_sort=[1,2,4,3]
    list_sort.sort()
    print(list_sort)

24.元组tuple

tuple1=1,#定义一个元素的元组 后面加一个逗号
    tuple2=1,2,3,4,5#定义多个元素的元组 逗号分隔
    list=[1,2,3,4]#定义一个列表元组
    tuple_list=list,list,list
    print(tuple1)
    print(tuple2)
    print(tuple_list)

25.字符串格式化操作

#%s叫做转换说明符 用来标记需要插入的转换值得为之，s表示值会被格式化成字符串
    xjp="https://%s.%s"
    value=("xiejiangpeng","com")
    print(xjp%value)
    #如果字符串中包含%的字符 必须使用%% 这样python就不会误认为百分号是转换说明符了
    pm="%%xiejiangpeng.%s"
    value1=("com")
    print(pm%value1)
    
    #引入模板字符串 substitute模板方法传递进来的关键字参数foo替换字符串中的$foo
    from string import Template
    s=Template('$x,glorious $x!')
    print(s.substitute(x='slurm'))
    #当引入的字符串 是单词的一部分的时候  需要使用括号括起来
    s1=Template('xie${x}peng')
    print(s1.substitute(x='jiang'))
    #字符串中有$符中 可以使用$$来结局这个问题
    s2=Template("make $$ selling ${x}")
    print(s2.substitute(x='slurm!'))
    #可以使用dict变量提供值/名称对
    s_dict=Template('$name and $sex' )
    message={}
    message['name']="xiejiangpeng"
    message['sex']="男"
    print(s_dict.substitute(message))
    #字符串格式化：完整
    print('%s,%s,%s' %(1,2,3))
    #字段宽度(左边为空 宽度也就是整体数字)和精度（几位小数）
    print('%10.2f' %12.565566)#十个宽度 二个小数点保留
    print('%010.2f' %12.565566)#十个宽度 前面默认用0填充
    print('%-10.2f' %12.565566)#十个宽度 前面默认用0填充 -代表左对齐数值
    print('%+10.2f' %12.565566)#十个宽度 前面默认用0填充 +代表不管正数负数都标记符号 对齐一下正负数
    print('%''10.2f' %12.565566)#十个宽度 前面默认用0填充 ""代表正数前面加空格 对齐一下正负数

26.字符串方法调用：

"""字符串的方法"""
    
    #1.find 在一个很长的字符串中找子串 找到了返回第最左端索引假设是[3:] 就返回3 这里空格也算一个字符 没有找到返回-1
    str1="my name is xiejiangpeng"
    print(str1.find("name is"))
    #2.join 连接序列中的每个元素 记住是用'xx'字符串的方法 其中xx可以使用1xx2xx3 而不是list.join
    list=['1','2','3']
    print(''.join(list))
    #3.lower返回字符串的小写字母
    str2="ewqarfewDIOIJDILJNDLINLIinewlirnilh"
    print(str2.lower())
    #4.replace 替换字符串 例如下方就会将xiejiangpeng改换成pengmin
    str3="my name is  xiejiangpeng"e("xiejiangpeng","pengmin"))
    print(str3.replac
    #5.split 将字符串分割成序列  跟join刚好相反 默认按照空格分割
    str4="xiejiangpeng+sss"
    print(str4.split("+"))
    #6.strip 除去二测(不包括内部)空格的字符串
    str5=" ddd dd  d"
    print(str5.strip())

27 字典的创建和相关方法：

#ecoding=utf-8
    """字典基础"""
    
    #1.首先他可以将元组[(AA,a),(BB,b)]衍射成为字典形式
    List_Tuple=[('AA','a'),('BB','b')]
    List_Dict=dict(List_Tuple)
    print(List_Dict)
    #2.可以通过关键字来进行创建字典
    d=dict(name='xie',age='42')
    print(d)
    #3.字典的基本操作
    #a.len(dict)返回dict中键+值的数量 也就是项的数量 多少对
    #b.dict[k] 返回键k上 对应的值
    #c.dict[k]=v 将键k上面对应的值 重新进行赋值
    #d.del dict[k] 删除键k上对应的值
    #e. k in dict 检查dict中是否存在键为K的项
    #f.对dict中的key进行升序排列for key in sorted(Dict.keys())：
    
    #4.利用字典插入字符串对
    temp="""<html>`
    <head><title>%(title)s</title></head>
    <body>
    <h1>%(title)s</h1>
    <p>%(text)s</p>
    </body>
    </html>
    """
    data={'title':'My Home Page','text':'Welcome to my home page'}
    print(temp % data)
    
    #5.字典的方法
    #a.clear方法 清除字典中所有的项 所以无返回值（或者返回None）
    a={'name':'xiejiangpeng','sex':'男','age':'22'}
    # print(a.clear())
    # print(a)
    #b.copy方法
    b=a.copy()
    print(b)
    #c.fromkeys 使用给定的键值创立新的字典(中间需要放[])，每个值，默认为None
    FromKeysDict={}.fromkeys(['a','b'])
    print(FromKeysDict)
    #d.get 获取里面的某个值 相对于dict["name"]而言，当里面的键不存在的时候 不会报错 而是会返回None
    print(a.get("name"))
    #e.has_key  检查字典中是否包含某个键(python3中没有这个函数了)
    # print(a.has_key("name"))
    #f.items返回字典的项，以元组的形式
    itmesDict={'name':'xiejiangpeng','sex':'男','age':'22'}
    print(itmesDict.items())
    #g.keys将字典里面的键以列表的形式返回
    keysdict={'name':'xiejiangpeng','sex':'男','age':'22'}
    print(keysdict.keys())
    #f.pop用于删除某个项（填键）同时返回键对应的值
    popdict={'name':'xiejiangpeng','sex':'男','age':'22'}
    print(popdict.pop("name"))
    print(popdict)
    #g.popitem随机删除一个项，同时会返回这个项 因为dict是无序的　
    popitemdict={'name':'xiejiangpeng','sex':'男','age':'22'}
    print(popitemdict.popitem())
    print(popitemdict)
    #h.setdefault()获得给定键的值，如果没有这个键,  追加一个同时返回这个键值，如果存在;不追加一个项，同时返回这个键对应的值
    setdefaultdict={'name':'xiejiangpeng','sex':'男','age':'22'}
    print(setdefaultdict.setdefault('hoppy','吃饭'))
    print(setdefaultdict)
    #i.values返回dict中的值
    valuesdict={'a':'1','b':'2','c':'3'}
    print(valuesdict.values())
    28.布尔值：False-->(包括，None，0，"",(),[],{})空列表或者空元组或者开空字典均识别为假，但是他们的反向均为真也就是True，也就是说在pyhon中所有的值都可以作为布尔值，所以几乎我们不需要对他们进行转化（python会自动转化这些值）

29.比较运算符，除了我们经常使用的a==b,已经a>=c这类，还有下面的

比如：a is b     \#a和b是同一个对象（比如a=b=\[1\]  那么a is  b 输出为真），但是下面哪个 输出却是假

a=\[1\]

b=\[1\]

print(a is  b)

比如：a is not  b     \#a和b是不同一个对象

比如：a in  b     \#a是b的容器（比如 序列的成员）

比如：a in   not  b     \#a不是b的容器（比如 不是序列的成员）

其中is叫做同一运算符，记住不是比较值是否相等，而是比较是不是绑定在同一个对象，给你们举个例子：

比如x=y=\[1,2,3\]    z=\[1,2,3\]        x in y 输出是真；但是x in z输出却是假

其中in 叫做成员资格运算符 这个比如 x in "xjepeng"  意思是后者里面是否包含前者

29.assert 断言  比如下方判断输入的值是否在某个区间，当跟断言不一直的时候，引发异常

#encoding=utf-8
    num=raw_input("num:")
    a=int(num)
    try:
        assert 1<a<100
    except Exception as cc:
        print("输入的值不在范围内:")

30.pass的用法  比如下面这个例子：

#encoding=utf-8
    a=int(raw_input("num"))
    if a==1:
        print("1")
    elif a==2:
        #还没有想好怎么搞,但是我们不填会报错 所以需要用下pass
        pass
    else:
        print("not")

31.del删除  删除某些变量（不是删除值） 或者元组 或者字典或者列表

#encoding=utf-8
    a=int(raw_input("num"))
    x=a
    try:
        del a
        print(a)
    except Exception as ex:
        print(ex)
        print("不好意思 变量已经被删除了")

32.函数;参数传值

a、一般情况传值

#encoding=utf-8
    #name没有默认值的要放最前面，另外后面的参数给默认值，如果不传的时候会取，传值的时候会使用传的值
    def  hello(name,greeting="hello"
               ,fuhao="!"):
        print("greeting,name值的顺序为：")
        print('%s,%s,%s' % (greeting,name,fuhao))
    
    
    hello("1","2")
    #当我们忘了参数的顺序的时候，可以加参数名=值来进行赋值,效果跟上面的是一样的
    hello(name="2",greeting=2)

b.收集参数

#encoding=utf-8
    #其中*的意思是 收集其他位置的参数，如果没有传，那么这个值就是一个空元组
    def hello(title,*xie):
        print(title)
        #输出取到参数的每一个值
        for xie in xie:
            print(xie)
    
    
    hello("hello")
    hello("hello","1")
    hello("hello","1","2","3")

c.参数收集 \*（单个参数）

#encoding=utf-8
    def add(x,y):
        return  x+y
    
    print(add(1,2))
    value=(1,2)
    #使用*value变量名跟上述一个意思
    print(add(*value))

d.参数收集 \*\*（比如字典）

#encoding=utf-8
    def add(name='xiejiangpeng',age="15"):
        print("name跟age的值为")
        print('%s,%s' % (name,age))
    
    
    value={'name':'xiejiangpeng','age':'18'}
    #使用**value变量名 下面二个代表是相同的意思
    add(name="xiejiangpeng",age="15")
    add(**value)

e.参数收集的逆过程 \* add中输出的是一个元组

def add(*xie):
        for xie in xie:
            print(xie)
    
    add("xiejiangpeng","15","eatfood")

f.参数收集的逆过程\*\* add中得到的是一个字典

def add(**xie):
        print(type(xie))
    
    add(name="xiejiangpeng",age="15",hobby="eatfood")

33.全局变量global

#encoding=utf-8
    a=1
    def add():
        global a
        a=a+1
    add()
    print(a)#a的值输出就是2

34.闭包函数 ：函数里面有一个函数，并且外层函数返回值是里面的函数，并且里面的函数可以访问他的定义的作用域，比如下面这个例子 输出就是20

#encoding=utf-8
    def add1(x):
        def add2(c):
            return  c*x
    
        return  add2
    
    temp=add1(4)
    print(temp(5))

35.递归

def mi(n):
        if n==1:
            return 1
        return n*mi(n-1)

36.isinstance判断是否属于某个对象（类型，类检查）

#encoding=utf-8
    def getprice(object):
        if isinstance(object,tuple):
            print("是一个元组")
            print(object[1])#返回元组中的第一个元素
        elif isinstance(object,dict):
            print("是一个字典")
            print(object["price"])
        else:
            print("都不是")

37.多态列子

#encoding=utf-8
    """
    多态：程序接受到一个对象，完全不了解该对象的内部实现方式，他可能有很多种“形状，你要做的就是得到某个东西，这就够了
         不知道对象到底是什么类型，但是又需要对象做点什么的时候，这个时候就会使用多态，但是这不限制他其中的方法
         下面这个例子就跟多态类似
         其中使用了repr函数，是多态特性代表之一，可以对任何东西使用，比如下面 我输入一个任何类型的对象，都会打印出这个对应对应的长度，也就是说
         我们关心类型是什么，只是关心输入的对象长度是多少，也就是多态的意思，也叫所谓 “鸭子类型”。
    """
    #repr() 将对象转化为供解释器读取的形式
    def lenth_messagfe(x):
        print("the length of ",repr(x),"is",len(x))
    lenth_messagfe("Fnord")
    lenth_messagfe([1,2,3])

38.封装（互不干扰），封装是指向程序中的其他部分隐藏对象的具体实现细节的原则，听起来这个可能有点想多态，也是用对象，但是不晓得其中内部的细节，二者的概念有些相似，因为他们都是抽象的原则，他们都会帮助处理程序组建而不是过多关心多余细节，就像函数做的一样，但是封装并不是等同多态，因为多态可以让用户对于不知道什么是类（对象类型）的对象进行方法调用，但是封装却是可以不用关心对象是如何构建的而直接进行使用。 类的相关基础：

39.类和类型的基本知识

a.首先我们创建一个普通的Person类，其中self的意思代表是本身，假设没有的话，成员方法就没法访问他们要对其特性的进行操作的对象本身了。

#encoding=utf-8
    """基础类"""
    class Person:
        def setName(self,name):
            self.name=name
        def getName(self):
            return  self.name
        def greet(self):
            print("Hello everyone My name I am %s。" % self.name)
    
    
    xiejiangpeng=Person()
    pengmin=Person()
    #相同的道理，特性在外部是可以访问的（前提是没有私有），比如下方直接对象访问其中的方法或者属性
    #访问方法
    xiejiangpeng.setName("xiejiangpeng")
    pengmin.setName("pengmin")
    xiejiangpeng.greet()
    pengmin.greet()
    #访问属性
    print(xiejiangpeng.name)

运行程序 输出的结果是

![70][]

b.现在我们介绍类的私有化，看下面的代码，跟上面的区别很小，就是函数（或者变量，比如下面setName()函数所传的name如果写成\_\_name / self.name=\_\_name 类的外部就访问不了.name 变量属性了）前面多了二个下划线\_\_，但是这个标识了他的私有，也就是在当前类才能进行访问：

#encoding=utf-8
    """基础类"""
    class Person:
        def setName(self,name):
            self.name=name
        #函数名前面加一个双下划线_标识私有特性（外界无法访问，之内在类内部使用）
        def __getName(self):
            return  self.name
        def greet(self):
            print("Hello everyone My name I am %s。" % self.__getName())
    
    
    xiejiangpeng=Person()
    xiejiangpeng.setName("xiejiangpeng")
    try:
        xiejiangpeng.__getName()
    except Exception as ex:
        print("由于__getName()方法只能在类内部使用，所以前面引用会引发异常")
        print(ex)

如果这样那么我非得要访问这个私有的属性/方法怎么办呢？ 很简单，在类的内部定义中，所有的双下划线都被“翻译”成前面加单下划线和类名的形式，所以我们将代码修改成“xiejiangpeng.\_Person\_\_getName()”就可以访问私有属性了

![70 1][]

40。.继承:说到底继承实际上是一种懒惰的行为，指的是程序员不想把同一段代码输入好几次，从而避免编写重复代码，举个例子，有个shape类，他可以在屏幕上画出指定的形状，但是呢，在现在需要创建一个rectangle的类，除了画出指定的图形，还需要计算出图形的面积，这个时候我们就可以使用rectangle继承shape类，使得在rectangle类对象上调用shape类内方法时候，程序会自动从shape类中调用。

a.单个继承

#encoding=utf-8
    """继承"""
    
    class Filter:
        def init(self):
            self.blocked=[]
        def filter(self,sequence):
            #去除sequence中包含的blocked
            return [x for x in sequence if x not in self.blocked]
    
    #继承Filter类
    class xjpFilter(Filter):
        def init(self):#重新超类汇总的init方法
            self.blocked=['xjp']
    #父类不过滤任何方法
    f=Filter()
    f.init()
    print(f.filter([1,2,3]))
    #子类 过滤掉‘xjp’
    xjpf=xjpFilter()
    xjpf.init()
    print(xjpf.filter(['xjp',2,'xjp']))

b.检查继承 可以用函数 issubclass(xjpFilter,Filter)   前面是子类，后面是父类（顺序不能乱，检查前者是否是后者的子类）

c.检查某个类的基类，xjpFilter.\_\_bases\_\_  输出的

![70 2][]

d.多个超类（一个子类，继承多个父类），只需要在class后面的圆括号（class1,class2）就行了

50.异常：python中使用exception object来表示异常的情况，遇到错误的时候，会引发异常，如果异常对象并未被处理或者捕捉，程序就会使用所谓的回溯（traceback，一种错误信息）终止执行

Exception：所有异常的基类  
AttributeError：特性引用或赋值失败时引发  
JOError：试图打开不存在文件(包括其他情况)时引发  
IndexError：在使用序列中不存在的索引时引发  
KeyError：在使用映射中不存在的键时引发  
NameError：在找不到名字(变量)时引发  
SyntaxError：在代码为错误形式时引发  
TypeError：在内建操作或者函数应用于错误类型的对象时引发  
ValueError：在内建操作或者函数应用于正确类型的对象，但是该对象使用不合适的值时引发  
Zerotvisionerror：在除法或者模除操作的第二个参数为0时引发  
a.自己引发异常，并且捕捉（）

#encoding=utf-8
    """异常"""
    try:
        #Exception(后面填写的内容为自己定义的异常数据)
        raise  Exception("自己引发一个异常")
    #其中Exception是所有的异常的基类，as ex中是将异常抛给ex
    except Exception as ex:
        print(ex)

b.不止一个except，比如下面哪个 可以根据引发的异常类型，从而书写不同的except子句

#encoding=utf-8
    """异常"""
    try:
        a=int(raw_input("请输入除数"))
        b=int(raw_input("请输入被除数"))
        c=a/b
    except ZeroDivisionError as ex:
        print("除数不能为0")
    except ValueError as ex:
        print("输入的值是非数字")

c.与else连接使用

#encoding=utf-8
    """异常"""
    #与else连起来使用，程序出现异常循环走try/except分支，当程序没有异常，走try/else分支
    while True:
        try:
            a=int(raw_input("请输入除数"))
            b=int(raw_input("请输入被除数"))
            c=a/b
        except Exception as ex:
            print("输入值非法")
    
        else:
            break

d. finally ：语句，不管是否引发异常，都会调用

#encoding=utf-8
    """异常"""
    import base64
    def Base64():
        try:
            with open("C:\\Users\\Administrator\\Desktop\\xiejiangpeng.jpg", "rb") as f:
                base64_data = base64.b64encode(f.read())
                print(base64_data)
        except Exception as ex:
            print(ex)
            print("找不到存在的文件")
        finally:
            print("不管try子句中是否发生异常，这个里的代码均会被运行")
            print("关闭文件")
    #调用函数
    Base64()

[Center]: /images/20220602/d5d970f510424198990510de3cce8304.png
[Center 1]: /images/20220602/5265e55e349c48439abbb61632f3fe39.png
[Center 2]: /images/20220602/62321c5181b642df8d6da457924f0ac9.png
[Center 3]: /images/20220602/71f465071a8743e6bf093d8bae10be6d.png
[Center 4]: /images/20220602/8edb6c1b54f34d469991c303fcb05d68.png
[Center 5]: /images/20220602/2f51a3ef24f548cc8fd3104ecf0085bb.png
[Center 6]: /images/20220602/890e911dc754428496e1e0675fd467a6.png
[Center 7]: /images/20220602/b8c29e67aa8b4c42a168409604f93b37.png
[Center 8]: /images/20220602/8651aeebe85d4c098af232a52f0bf11b.png
[Center 9]: /images/20220602/a7c1db67d216476abbdf04e7bd47f275.png
[Center 10]: /images/20220602/bd70f3fcd9d644af851d8f3c540c47b8.png
[Center 11]: /images/20220602/d73a6894bf8b4b1094b7e2b40e7f24f9.png
[Center 12]: /images/20220602/c9951955aebf4e6da765dc36b74bdba9.png
[70]: /images/20220602/d5e45a0dc1fb4a3ba6da67dc853a2d33.png
[70 1]: /images/20220602/9ee72ffee37f4244b3f523dcbb0000f4.png
[70 2]: /images/20220602/d2e72d17c6e6462ea468300a7ddb9738.png