python基础（一）

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等语句，都需要用:结尾

 

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

例子：

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

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

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

 

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

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版本时候，发现没问题，看下图

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  第三个参数时限制最多替换多少次

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

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.（函数）进行引用，属于点标记法来引用模块中的任何内容

11.if函数

if mood ==  0:

elif mood == 1:

elif mood ==2:

else:

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

#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

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循环更加灵活，不只是可以计数器变量进行循环，比如对序列进行遍历，可以通过一个变量来获取序列中的元素

比如  下面那个例子

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

20.索引

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

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

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

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)

运行程序 输出的结果是

 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()”就可以访问私有属性了

 

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__  输出的

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()