*************************************************第一章*************************************************
环境变量的搭建：-------------------------------------
我的电脑-->属性-->高级系统设置-->环境变量-->系统变量
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'比较地址值
1511
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
