*************************************************第一章*************************************************
环境变量的搭建:-------------------------------------
我的电脑-->属性-->高级系统设置-->环境变量-->系统变量
first:变量名:path
变量值:C:\Users\Carlinfo\AppData\Local\Programs\Python\Python35
C:\Users\Carlinfo\AppData\Local\Programs\Python\Python35\Scripts
second:
第一步:新建系统变量
变量名:PYTHON_HOME
变量值:C:\Users\Carlinfo\AppData\Local\Programs\Python\Python35
第二步::编辑系统变量
变量名:Path
变量值:
%PYTHON_HOME% %PYTHON_HOME%\Scripts
cmd窗口命令:--------------------------------------
切换盘符:盘符:+回车符
打开文件命令:cd文件路径
清屏:cls
*************************************************第二章*************************************************
标识符的命名规则:---------------------------------
1,数字.字母.下划线组成 2,不能以数字开头 3,不能使用python的关键字和保留字 4,严格区分大小写
注释:------------------------------------------------
1,单行注释(不会加载到内存中) 2,多行注释(会加载到内存 ,1.把py文件复制到python解析器中的lib目录中
2.进入python命令下 3,输入import文件名 输入help('文件名'))
数据类型:--------------------------------------------
1,整数型(int)2,浮点型(float)3,布尔型(bool)4,字符串(str)5,None型(None)
类型转换:
1,float,bool,None转换成int
float转换成int直接取整
bool转换成int True是1 False是0
str转换成int 字符串必须是整数字符串
None不能转换成int类型
2,int,bool,str,None转换成float
int类型转换成float 默认加一个小数点
bool类型转换成float True是1.0 False是0.0
3,int,float,str,None转换成bool类型
int类型转换成bool类型 0是False 非0就是True
float类型转换成bool类型 0.0是False 1.0就是True
4,int,float,bool,None转换成str类型
直接输出字符串
5,int,float,bool,str型都不能转换成None型
输入输出:----------------------------------------------
%s格式化为字符串
%d格式化为整数
%f格式化为浮点型
0.2f表示保留两位小数
\n表示换行 \t表示制表符 end=""表示不换行
运算符:------------------------------------------------
算术运算符://取整 %求余
比较运算符:!= 不等于 俩数值不等时 返回True ==恒等于 比较运算符结果都是bool型
位于运算符:& 与 |或 ^异或 ~反 <<左移 >>右移
& 同时取1就取1 否则取0
| 有一个1就取1
逻辑运算符:not非 非真即假 非假即真
and并且 全真为真
or或者 一真即真
&全真为真
|一真为真
&和| 即可以作为位于运算(如果两边是数值就是位于运算符)
又可以做为逻辑运算符 如果两个是bool表达式
and优先级高于or
*************************************************第三章*************************************************
循环:------------------------------------------------
流程控制语句;
break 中断
continue 继续
break条件成立直接跳出循环体(只能跳出一层循环)
continue条件成立结束该次循环,继续执行下一次循环
a=0
while a<=10:
a+=1
if a==5:
continue;
print('循环第%s次'%a)
print(**)
*************************************************第四章*************************************************
容器:------------------------------------------------
列表的增删查改:
li=[1,5,8,4,9,6,7,1,3]
li.append(30) #尾部添加
li.insert(0,'小明') #指定位置插入
li.extend('8') #向尾部添加多个元素
print(li[0]) #根据索引获取元素
print(li.index(5)) #查找列表中第一次出现指定元素的下标
print(len(li)) #返回列表长度
li[2]='小弟' #根据索引修改指定元素
print(li)
print(li.pop()) #删除尾部元素,返回此元素
print(li.pop(2)) #删除索引对应的元素
del li[0] #根据下标删除元素
print(li)
li.remove(1) #移除列表中第一次出现的元素
print(li)
li.reverse() #反转排序
print(li)
li.sort() #由小到大
li.sort(reverse=True) #由大到小降序排列
print(li)
#遍历地常用用法--------------------------------------------
names=['斧头帮老大','包租婆','火云邪神','包租公','光']
#第一种:
a=0
while a<len(names):
print(names[a])
a+=1
#第二种:
for a in names:
print(a)
#第三种:
for a in range(len(names)):
print(names[a])
#第四种:
for x,y in enumerate(names):
print('索引是:%s--->对应的值是:%s'%(x,y))
#元组-------------------------------------------------------
a=(), #代表元组的嵌套
1,类似于列表只不过是无法修改元素
2,声明包含一个元素的元组要在元素后加逗号
#列表和元组的转换-------------------------------------------
#list()1,把字符串每个字符转换为列表的每个元素2,把元组中每个转换为列表的元素
#tuple()1,把字符串每个字符转换为元素2,把列表中每个元素转换为元组的元素
#字典-------------------------------------------------------
特点:
#1,字典中的键是唯一的,建议统一使用字符串类型
#2,字典是无序的指的是添加和取出元素的顺序不同
#3,字典中的键重复则值覆盖
#4,字典中的数据操作,根据键去操作值,不要根据值去操作键
person={'姓名':'冯宝宝','性别':'女','优点':['活得久','能吃',],'缺点':'活得太久',}
print(person['姓名'])
常用操作:
1,添加;修改
dict[key]=value:如果字典里没有相同的键就是添加
如果有相同的键就是修改
2,删除
dict.pop(key);根据键 删除键值对 返回的是被删除的值 如果没有对应的键则报错
del dict[key];根据键 删除值对 返回的是被删除的值 如果字典中没有对应的键报错
dict.popitem();随机删除一个
dict.clear;清空字典
清空:清空的是容器中的元素 容器本身还在
删除:数据容器一块删除
字典的获取:
1,dict[key];根据键获取值 如果不存在 会报错
2,dict.get(key);根据键获取值 键不存在会报错返回None
3,len(dict);获取字典中键值对个数
4,str(dict);把字典转换成字符串
5,dict.keys();获取所有的键
6,dict.values();获取所有的值
7,dict.items();获取所有的键值对
8,dictx.copy();复制字典
字典的遍历:
dictx={"1":"张三","2":"李四","3":"王五","4":"赵六"}
第一种方式:
for k in dictx:
#print(dictx[k]);
#print(dictx.get(k));
print("key:%s---->value:%s"%(k,dictx.get(k)));
第二种方式:获取键值
keyList=dictx.keys();
for k2 in keyList:
print("key:%s---->value:%s"%(k2,dictx.get(k2)));
第三种方式:获取键值对
kValues=dictx.items();
for k3,v3 in kValues:
print("key:%s---->value:%s"%(k3,v3));
集合set:------------------------------------------------------------
1,不允许元素重复的.
2,无序的.指的是添加元素和取出元素的顺序是不一致的.
3,可以过滤重复元素
4,是可变数据类型
1.添加:
set.add(value);向set中添加元素
set.update(set);向集合中添加set中包含的元素
2.删除:
1.set.remove(value);删除set中指定的元素,如果set中没有此元素 会报错
2.set,discard(value);删除set中指定的元素,如果set中没有此元素 则不会报错
3.set.pop();随机删除一个元素
4.set.clear();清空set
3.特殊用法:
| 并集
& 交集
intersection 交集
- 差集
difference 差集
in 判断
union() 联合
issubset() 子集
issuperset() 父集
多维:------------------------------------------------------------
listy=[[44,45,46],[7,8,9,1,6],[11,22,33,44]];
"""
listx=[12,2,3,4];
print(listx);
print(listx[0]);
listy=[[44,45,46],[7,8,9,1,6],[11,22,33,44]];
print(listy);
print(listy[0][0]);
print(len(listy));
print("******************");
listy=[[44,45,46],[7,8,9,1,6],[11,22,33,44]];
#外层循环遍历横坐标
for x in listy:
#内层循环遍历纵坐标
for y in x:
print(y);
传递:-------------------------------------------------------------
可变类型: list ,dict,set,object
不可变类型:int float str tuple None
"""
"""
不可变类型,两个变量引用一个值时,id号是相同的,
修改一个变量的值,另一个变量不会影响
"""
a=10;
b=a;
print(a);
print(b);
print(id(a));
print(id(b));
a=50;
print(a);
print(id(a));
print(id(b));
"""
可变类型:两个变量引用同一个元素时,id号是相同的
当一个变量发生变化时,另一个变量也会发生变化
"""
listx=[2,3,4];
print(listx);
listy=listx;
print(listy);
print(id(listx));
print(id(listy));
listx.append(6);
print(listx);
print(listy);
print(id(listx));
print(id(listy));
*************************************************第五章*************************************************
字符串:
1,在双引号中可以使用单引号
2,在单引号中可以使用双引号
3,转义 \在行尾表示续行符 \\反斜杠符 \'单引号 \"双引号 \n换行 \t制表符 \r回车符
字符串常见操作:
-----------------------------查找:
1,string.find(str,beg=0,end=len(string))
检查str是否存在string中存在返回下标,否则返回-1
2,string.rfind(str,beg=0,end=len(string))
与find用法相同只不过从右边开始找
3,string.index(str,beg=0,end=len(string))
类似于find函数,但是找不到报异常
4,string.rindex(str,beg=0,end=len(string))
类似于rfind函数,但是找不到报异常
-----------------------------统计:
1,string.count(str,beg=0,end=len(string))
检查str是否包含在string中的次数,beg;end表示范围
-----------------------------分隔:
1,string.split("-",num=string.count(str))
-为分隔符切片string,如果num有指定值,则分隔num个子字符串
2,string.splitlines([keepends])
按照行('\r','r\n','\n')分隔,返回一个包含各行作为元素的列表,如果
参数keepends为False,不包含换行符,为True,则保留换行符
3,string.partition(str)
find()和split()的结合体,从str出现的第一个位置起,把字符串string分为一个三元素的元组
(string_pre_str,str,string_post_str),如果string中不包含str则string_pre_str==string
4,string.rapartition(str)
类似partition()函数,从右边开始
-----------------------------判断:
1,string.startswith(obj,beg=0,end=len(string))
检查字符串是否以obj开头,是则返回True否则返回Fasle。 beg与end表示指定的范围
2,string.endswith(obj,beg=0,end=len(string))
检查字符串是否以obj结尾,是则返回True否则返回Fasle。 beg与end表示指定范围
3,string.isalnum()
所有字符都是字母或数字及(汉字)则返回True,否则返回Fasle
4,string.isalpha()
所有字符都是字母则返回True,否则返回Fasle
5,string.isdigit()
所有字符都是数字
------------------------------大小写:
1,string.capitalize()
布字符串的第一个字符大写
2,string.upper()
转换string中的小写字母为大写
3,string.lower()
转化string中的大写为小写
-------------------------------对齐:
1,string.ljust(width)
返回一个原字符串左对齐,并使用空格填充至长度width的新字符串
2,string.rjust(width)
右对齐
3,string.center(width)
返回一个原字符串居中,并使用空格填充至长度width的新字符串
--------------------------------裁剪:
1,string.strip([obj])
删除string字符串前后的obj,如果不传参数,删除前后空格
2,string.lstrip([obj])
删除左边的obj。。。。。
3,string.rstrip([])
删除右边的obj。。。。。
-------------------------------合并:
1.'-'.join(li)
以-为分隔符,将li中的所有元素(字符串表示)合并为一个新的字符串
li=['df','4','du','1','3','12']
print(",".join(li))
-----------------------------------日期模块-time
模块导入:import time
1,常用的函数:
time.time()------------------返回至1970年的浮点秒数
time.ctime()-----------------获取当前日期时间
time.localtime()-------------将一个时间转换为当前时区的struct_time(时间数组格式的时间)
import time
a=time.localtime()
print(a)
print(a.tm_year)
tm_year: --------------------获取年
tm_mon:----------------------月(1-12)
tm_mday----------------------日(1-31)
tm_hour----------------------时(0-23)
tm_min-----------------------分(0-59)
tm_sec-----------------------秒(0-59)
tm_wday----------------------星期几(0-6)
tm_yday----------------------一年中的第几天
--------------------------------------日期时间格式化
time.strftime():把一个时间的元组或者struct_time(如time.localtime()和time.gmtime())转化为格式化的时间字符串
y=time.strftime('%Y-%m-%d %H:%M:%S %A')
print(y)#2018-03-6 7:34:23 mondy
时间日期格式化符号:
%y----------------------------两位数的年份表示
%Y----------------------------四位数表示年份
%m----------------------------月
%d----------------------------日
%H----------------------------时(24小时制)
%l----------------------------时(12小时制)
%M----------------------------分
%S----------------------------秒
%A----------------------------本地星期几
--------------------------------------日期时间:datetime
模块导入:from datetime import datetime
获取当前日期对象
dt=datetime.now()
print(dt)
格式化日期
xx=dt.strftime('%Y/%m/%d %H:%M:%S%A')
print(xx)#2018/01/04 11:23:34 Friday
gg=dt.strftime('%Y{y}%m{m}%d{d}').format(y='年',m='月',d='日')
print(gg)#2018年01月04日
解析日期
s=dt.strptime('2018-12-2 16:55:45','%Y-%m%d %H:%M:%S')
print(s)
*************************************************第六章*************************************************
函数:
1:参数列表:
1.参数的个数,可以有任意个
2.参数类型可以是任意类型,由于python是弱类型语言 所以不用指定类型
3.括号后边加冒号
4.return可写可不写
5.调用函数
2:函数使用
1.声明函数
2.调用函数
3:函数的分类:
1.没有返回值 没有参数的函数
2.没有返回值 有参数的函数
3.有返回值 没有参数的函数
4.有返回值 有参数的函数
4:
如果函数调用时,需要外部提供参数才能运行 那么可以使用有参数的函数
函数一旦有了参数 就要进行传递参数
在声明函数括号中的参数称为形式参数 形参
在调用方法时 传进的参数称为实际参数 实参
在参数传递的过程中,形参的个数要和实参的个数保持一致(可变参数除外)
5:return
流程控制语句:
break:用在循环中 条件成立 跳出循环体(一重)
continue:用在循环中 条件成立 结束当次循环 继续下一次循环
return:用在循环中 作为流程控制语句 条件成立 跳出循环体(一重或多重)
return必须写在函数中
6:函数参数:
1.可变和不可变参数
2.必选参数
3.默认值参数
4.可变参数
5.关键字参数
可变类型:list dict set object
不可变类型:int float str bool None tuple
参数是不可变类型:如果值发生变化 互不影响
参数是可变类型:1指向没有发生变化,如果值发生变化,互相影响 2指向发生变化,如果值发生变化,不会互相影响
7.递归函数
递归有循环的条件
递归必须有跳出函数的条件
递归函数就是自己调用自己
递归能完成的循环也能完成
递归的特点 代码少
递归的缺点 占用内存比较大 速度比较慢
一般情况下大型数据都不建议使用递归
数据较大的 建议使用循环
8.匿名函数
g=lambda a,b,c,d:a*b*c*d
print(g(1,2,3,4))
def f(a,b,c,d):
return a*b*c*d
q=f(1,2,3,4)
print(q)
*************************************************第七章*************************************************
系统模块:
1.os系统模块
os.name获取现在正在使用的平台系统,windows返回nt ;linux返回posix
2.如何表示路径
1.'E:\\111'
2.r'E:\111'
3.'E:/111'
3.重命名文件
a='E:\\111\\aaa.py'
b='E:\\222\\bbb.py'
os.rename(a,b)
4.重命名文件夹
a="E:\\111"
b="E:\\222"
os.rename(a,b)
5.remove() 只能删除文件,不能删除文件夹
6.创建目录(文件夹):
创建一级:
mkdir() 只能创建一级
创建多级:
makedirs() 既能创建一级 又能创建多级
7.获取当前目录
tt=os.getcwd()
8.改变当前目录
os.chdir('E:\\')
9.删除文件夹 不能删除文件
yy='E:\\444'
os.rmove(yy)
10.获取父级目录
parent=os.path.dirname(r'E:\1\2')
数学模块:
fmod(x,y)**************求x/y的余数
ceil(x)*****************取不小于x的最小整数
floor(x)****************求不大于x的最大整数
fabs(x)*****************求绝对值
pow(x,y)***************求x的y次幂
log10(x)****************求以10为底的对数
sqrt(x)*****************求x的平方根
factorial*****************求x的阶乘
trunc(x)****************求x的整数部分
*************************************************第八章*************************************************
IO流:
1.读取文件的思路:
1.建立待读取的文件(必须是存在的)------pth=r'C:\xxx'
2.打开文件------------------------------file=open(pth,'r')
3.读取文件------------------------------cent=file.read()
4.输出读取的内容------------------------print(cent)
5.关闭资源------------------------------file.close()
2,写入文件的思路;
1,建立待写入的文件-------------------------pth=r'C:\xxx'
2,获取文件的父级目录----------------------parent=os.path.dirname(pth)
1)判断父级目录是否存在----- if not os.path.exists(parent):
2)如果父级目录不存在 创建父级目录 os.makedirs(parent)
3,打开文件---------------------------------file=open(pth,'r')
4,建立待写入的内容------------------------x='小明'
5,写入内容--------------------------------file.write(x)
6,关闭资源--------------------------------file.close()
3,使用IO流copy文件思路:
1.建立待复制的文件(必须存在)
2.建立待复制文件去往的目标文件(不一定存在)
3.获取目标文件的父级目录
4.判断父级目录是否存在
5,如果父级目录不存在 就创建父级目录
6,打开待复制的文件
7,打开目标文件
8,读取文件
9,写入目标文件
10,关闭资源
def copyFiles2():
#建立待复制的文件
from_file=r"E:\20190119\下午\timg.jpg";
#建立目标文件
to_file=r"E:\20190119\下午\timg副本.jpg";
#获取文件父级目录
parent_file=os.path.dirname(to_file);
#判断父级目录是否存在
if not os.path.exists(parent_file):
#创建父级目录
os.makedirs(parent_file);
#打开待复制的文件 字节可以完成任何类型文件的读写(文字,视频,图片...)
files=open(from_file,"rb");
#打开目标文件
tFiles=open(to_file,"wb");
#读取文件
cent=files.read();
#写入目标文件
tFiles.write(cent);
#关闭资源
files.close();
tFiles.close();
print("复制完毕...");
copyFiles2();
4,读取文件的方式
1,read()读取所有内容 并且返回
2,readline()读取一行
3,readlines()读取所有的内容 以列表的形式返回
5.序列化 反序列化
序列化:把对象的信息转换为有序的数据序列 存储到指定位置,进行持久化保存
序列化有 加密的功能
反序列化:
把指定位置的数据,加载至内存,重新构建对象
python语言中,实现数据的序列化和反序列化 需要使用模块 pickle
def readmessage():
#建立待读取的文件
paths=r"E:\day21\上午\文本序列化信息.txt";
#打开文件
files=open(paths,"rb");
#读取文件
cent=pickle.load(files);
print(cent);
files.close();
def writemessage3():
#建立待写入的文件
paths=r"E:\day21\上午\字典序列化信息.txt";
#获取父级目录
parent_path=os.path.dirname(paths);
#判断父级目录是否存在
if not os.path.exists(parent_path):
#创建目录
os.makedirs(parent_path);
#打开文件
files=open(paths,"wb");
#建立待写入的信息
s={"name":"张三","age":20,"sex":"男"};
s2={"name":"李四","age":20,"sex":"男"};
#lists=[s,s2];
dictx={"nname":s,"uname2":s2};
#写入信息
pickle.dump(dictx,files);
files.close();
def readmessage2():
#建立待读取的文件
paths=r"E:\day21\上午\字典序列化信息.txt";
#打开文件
files=open(paths,"rb");
#读取文件
cent=pickle.load(files);
print(cent);
files.close();
#writemessage2();
#readmessage()
writemessage3();
readmessage2();
*************************************************第九章*************************************************
面向对象编程:opp
类:用来描述具有相同属性和方法的对象的集合,定义了该集合中每个对象所共有的方法和属性,对象就是类的实例
方法:类中定义的函数
类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且周期函数体之外,类变量通常不作为实例变量使用
方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写
局部变量:定义在方法中的变量,只作用于当前实例的类。
实例变量:在类的声明中,属性是用变量来表示的。这种变量就称为实例变量,是在类声明的内部但是在类的其他成员方法之外声明的
self: 代表的是类的实例,代表当前对象的首地址,如果对象没有引用了首地址 它称为垃圾对象 垃圾对象会被垃圾回收机制 自动回收
魔法方法 :
__init__()魔法方法 在其他语言中称为构造方法(构造器)
魔法方法__init__()在实例化对象时会自动调用
一个类如果没有显示定义__init__()魔法方法 那么系统会为该类提供一个默认的无参数的__init__()方法
一个类如果显示定义了魔法方法__init__()name会把系统提供的默认无参数的__init__()方法覆盖
魔法方法在实例化对象时会自动调用
魔法方法在实例化对象的同时 可以初始化变量
方法重载:
overload overloading
在同一个类,有多个方法时 方法名相同 参数列表不同 就是方法重载
python不支持方法重载
传递:
可变类型:dict list object
不可变类型:int float str tuple bool None
对象也是可变类型
对象作为参数进行传递是值传递还是引用传递?
python语言中,对象作为参数进行传递 是值传递和引用的综合使用
形式参数如果接收的数据类型是不可变类型 就是值传递
形式参数如果接受的数据类型的是可变类型 就是引用传递
封装:
就是把属性和行为私有化 达到封装的目的
属性的访问级别:
1,私有的
2,公开的
私有属性:就是在属性之前添加__
私有属性和行为只能在本类中直接使用
属性一旦私有化就应该对外界提供功能的setter和getter方法以便于外界对属性的设置和获取
setter函数的书写:
1.使用def关键字
2.函数名 set+你设置的属性
3.set函数都有参数 参数就是你设置的属性名
getter函数的书写:
1.使用def关键字
2.函数名 get+你获取的属性
3.get函数没有参数
函数的封装:
函数一旦封装 只能在本类内部使用 外界无法访问
所以一般情况下 函数很少封装
限制类中 可以出现的属性
__slots__=["__name","sex","say"];
继承:
同类事物具有共性 又有特性
根据抽象原则,抽取同类事物的共性 舍去特性 就形成了同类事物的父类
子类只需要关注自己特有的属性和行为
新类可以从现有的类 向外派生这样的过程叫做继承
新类被称为子类
现有的类被称为父类
在python3中所有的类 都直接或者间接继承object类
object类是所有类的超类(基类)
继承的语法: (同时有继承多个父类时,哪个父类名在前为准)
class 子类名(父类名,父类名,...父类n):
在python语言中 一个子类可以继承多个父类
一个类父类也可以有多个子类
继承是有传递性的
子类继承父类 非私有的属性和行为
子类继承父类私有属性的setter和geetter方法
子类无法继承父类的魔法方法. __init__()
子类除了从父类继承的属性和行为外
还可以扩展自己特有的属性和行为 这称为子类扩展
方法重写:
子类从父类继承的某个实例方法 不满足子类的需求时
可以对父类方法 进行重新实现这称为方法重写 方法覆盖 方法覆写 override overriding
子类中定义了和父类一样的方法(继承到)
不同的对象调用同一个方法 展现不同的效果(为后期多态打下前提)
子类从父类继承的方法,如果子类重写 调用的就是重写的方法、
如果子类没有重写 调用的父类的方法
super()函数 ;
指向父类对象
在子类中可以使用super().函数名 调用父类的函数
如果父类的类变量 被子类同名的类变量隐藏时
可以使用super().变量 | 父类名.变量名 |对象名 调用被隐藏的父类类变量
多态:
多态:
故名思意就是多种形态
多态产生的前提:
1.继承
2.函数重写
3.向上转型
"""
class Animal:
def eat(self):
print("动物就喜欢吃");
class Dog(Animal):
def eat(self):
print("狗喜欢吃排骨");
class Cat(Animal):
def eat(self):
print("猫喜欢吃鱼");
a=Animal();
a.eat();
a=Dog();
a.eat();
a=Cat();
a.eat();
实例成员和类成员:
""
实例变量:
self.变量名声明的
实例变量只能使用对象名调用
类变量:
在函数之外,直接在类体中 声明的变量
类变量可以使用对象名调用 也可以使用类名调用
每个对象都会有自己独特的实例变量
类变量会被所有的对象共享
实例方法:
在声明方法时 有self参数
静态方法:和以前的普通的方法是一样的 但是需要添加一个装饰器(@staticmethod)
类方法:
需要一个装饰器(@classmethod) 类方法需要传一个参数cls(class的简写)
类方法,实例方法,静态方法都可以使用对象名直接调用
*************************************************第十章*************************************************
异常:excption
程序运行过程中 出现的例外
程序语法正确 只不过是操作问题 造成程序崩溃或或者不能正常运行
错误:Error err
语法错误 自行处理
异常出现之后怎么处理
try:
可能出现异常的代码块
except 异常类型 as 异常名:
处理异常代码
try:
可能出现异常的程序代码块
except (异常类型1,异常类型2,异常类型3,...) as 异常名:
处理异常的代码;
try:
可能出现异常的程序代码块
except 异常类型1 as异常名:
处理异常代码块
except 异常类型2 as 异常名:
处理异常代码
...
except 异常类型n as 异常名:
处理异常代码块
try:
可能出现异常的代码块
except:
处理异常的代码块
else:
执行了 异常处理代码 else语句就不会执行
如果没有执行 异常处理代码 else就会执行
finally:
无论异常是否出现 总会被执行的程序代码块
如果except之后跟了多个异常类型 那么它会第一个依次查找
如果匹配之后 后边的就不会再运行了
try里面放的是可能出现的异常代码块
不要把所有代码块都放在try里面
因为try里面的代码越多 程序执行速度就会放慢
python语言中出现异常
就是常见的异常信息,python解析都已经进行了相对的定义
出现异常之后 python解析找到对应的类 然后实例化一个对象 抛出
"""
"""
try:
a=int(input("请输入一个数字:"));
print(a);
except ValueError as va:
print("你输入的不是数字,异常信息:%s"%va);
except FileNotFoundError as fe:
print("你读取的文件不存在,异常信息:%s"%fe);
else:
print("try except之后的else语句");
finally:
print("无论异常是否发生,总会被执行的程序语句");
"""
try:
a=float(input("请输入一个数字:"));
b=float(input("请输入一个数字:"));
print(a+b);
except:
print("你输入的不是数字");
自定义异常:
python解析器并不是把所以的异常信息都定义了
如果遇见解析器没有定义的异常
这时我们需要自定义异常
定义一个类 去继承Exception
"""
class SexException(Exception):
def __init__(self,msgs):
self.msgs=msgs;
def main():
sex=input("请输入性别:男/女");
if sex=="男" or sex=="女":
print(sex);
else:
try:
#抛出异常
raise SexException("你输入的不是男或者女!!!");
except SexException as se:
print(se);
main();
*************************************************第十一章*************************************************
自定义模块:
判断:
'=='比较字面值
'is'比较地址值