认识python

优点：简单，易学，开源，高层语言，可移植性(跨平台性强)，解释性，完全面向对象，可扩展性，丰富的

​            库，代码规范

缺点：1.运行速度慢(现在可以用c++改写关键部分提高速度)

​            2.中文资料匮乏(国内正在火起，各方面资料会渐多起来)

​            3.构建框架选择多(中小型web程序开发天下无敌，python语言的优秀，吸引了很多人才)

注释

使用用自己熟悉的语言，在程序中对某些代码进行标注说明，增强程序的可读性

单行注释(行注释)：以#开头，#(# + 空格)右边的所有东西当做说明，而不是真正要执行的程序，起辅助说明作用

​                                     如果在代码尾端进行单行注释要空两个空白字符，后面格式如上

多行注释(块注释)：多行注释通常使用三对单引号或者双引号，一般注释内容太多或者对函数，类进行解释才会用

​                                    到多行注释

变量

变量的命名

标示符可以由 字母、下划线 和 数字 组成，不能以数字开头，不能与关键字重名(区分大小写)

小驼峰: firstName,  lastName    大驼峰：FirstName, LastName

两种划分方式

1.数字型(整型int，浮点数float,布尔型bool，复数型complex)和非数字型(字符串str，列表list，元组tuple

，字典dict)

2.可变类型(列表，字典)和不可变类型(其它)

变量的格式化输出

%s 字符串  /    %03d  十进制整数(中间数字代表位数)  /   %.2f  浮点数   /    %%  输出百分号

print 输出     input   输入   def  定义函数

if 语句

if  条件一 ：

​        print("条件成立输出")

​        if  条件二 ：

​                print("条件成立输出")

​        elif 条件三：

​                print("条件成立输出")

​        else:

​                print(条件成立输出"")

elif 条件四：

​        print(条件成立输出")

else:

​        print("条件成立输出")

逻辑运算

and(且)  or(或)   not(非)

逻辑运算符

+  加   -  减      *   乘     /  除    //   整除    %  取余    **   幂

== 等于    ！=  不等于   >   大于  <   小于   >=   大等于  <=   小等于

赋值运算

=  简单赋值  +=  加赋  -= 减法  *=  乘等 /=  除等  //=  取整等  %= 取余等   **= 幂赋值

while循环

break打破当前循环    continue  进入下一次循环 ，下面代码不执行(当前循环)

计数器 i += 1  循环前先定义i，值大多从零开始

九九乘法表

row = 1
​
while row <= 5:
​
​
# 假设 python 没有提供字符串 * 操作
# 在循环内部，再增加一个循环，实现每一行的 星星 打印
col = 1
​
while col <= row:
    print("*", end="")
​
    col += 1
​
# 每一行星号输出完成后，再增加一个换行
print("")
​
row += 1

函数

def 函数名(形参):
    函数封装的代码
    ……

函数名，模块名的命名规则与标识符相同，调用  函数名(实参)

返回值return    调用函数一方定义一个变量来接收函数的返回结果，return后面代码都不会被执行

可以返还多个值

def demo():

        *a = 1*            *b = 2*

返回多个结果，是一个元组    *`return a, b`*

局部变量和全部变量

变量的引用：【id()】>查数据的内存位置。hash>字典key的定义>key不能为可变类型

分类：定义在函数内部的变量是局部变量，定义在函数外部的变量是全局变量

global ：关键词后面的是一个全局变量，把局部变量提升为全局变量

如果函数内部定义了一个与全局变量相同name的变量，函数内部只会读取内部变量

shift + F6 修改相同序列下变量的名字，点击名字使用快捷键

变量值互换

a = 100b = 6a, b = b, aprint("a = %d" % a)  # 打印的a是变量a

print("b = %d" % b)  # 打印的b是变量b

在函数内部，针对参数使用赋值语句，无论参数是不是可变类型的数据，都不会修改到外部的实参变量

def demo(num, num_list):
    print("内部")
​
    num = 50
    num_list = [1, 2, 3]
    print(num)
    print(num_list)
    print("over")
​
​
gl_num = 60
gl_num_list = [4, 5, 6]
demo(gl_num, gl_num_list)
print(gl_num)
print(gl_num_list)

如果在函数内部，使用方法来改变了可变类型数据的值，函数外面的值也会改变

def demo(num_list):
    # 如果函数内部对这个参数重新赋值，外面的数值就不会被改变
    # num_list = [7, 8] > 重新赋值对外面没作用
    num_list.append(9) > 外面值会变
    num_list.extend([4, 5, 6]) > 外面值会变
    print(num_list)
​
gl_list = [1, 2, 3]
demo(gl_list)
print(gl_list)
​
加等于操作产生的效果
​
def demo(num, num_list):
​
    print("action!")
    # 1. num = num + num  这个格式就等于给变量重新赋值了，外面变量值也会改变
    num += num  # 加等于是不会改变可变类型外部变量的值
    # num_list = num_list + num_list
    num_list += num_list # 本质上是在调用extend方法
​
    print(num)
    print(num_list)
    print("over!")
​
​
gl_num = 9
gl_list = [4, 5, 6]
demo(gl_num)
print(gl_num)

注意！！！

加等于“不可变变量 += 不可变变量”内部值会改变，但函数外部变量的值不会变

加等于中“可变变量 +=(+) 可变变量”本质上是调用extend/join，所以函数外部的可变变量值也会改变

*args作为一个参数表示能接收一个元组

* 函数名(正常参数， 缺省参数， 多值参数)**

​        正常参数 > nums          缺省参数 > gender= True       多值参数  >  *nums(元组）/**nums（字典）

多值参数求和

1.

def  sum_numbers(*num) >>  sum_numbers(1,2,3,4,5)

2

def  sum_numbers(num) >>  sum_numbers((1,2,3,4,5,6))

两种形式结果相同，但1可以处理多值，2要定义多个变量，不符合实际，太麻烦

递归

函数自己调用自己

必须规定一个出口，即终止条件，否则会出现死循环(最小或者最大）   

递归函数调用时，进去时执行调用函数上面的代码，出来时执行调用函数下面的代码

递归函数不擅长数字和的累和，积。会容易死机

递归的层数一般不会太多，常用于遍历文件目录结构

高级变量类型  

列表   元组   字典   字符串

索引(除了字典，所有索引都是从零开始，最大索引=len()-1, 逆向索引从-1开始)

针对查的操作：[]是知道索引查值， ()是知道值查索引

列表 list

增删改查统计排序

增：append(末尾追加)，insert(根据索引插入指定位置)，extend(继承，把一个列表追加到原列表)

删：remove(指定值删除)，pop()(默认末尾删除，索引指定位置删除),  del(内存中删除), clear(清空列表)

改：list[索引] = 新值

查：list[索引] > 查值            list.index(值) > 查索引

统计： len(list)  > 查列表长度           list.count(值)  >  值出现的次数

排序：list.sort()  从小到大     list.sort(reverse=True)    从大到小         list.reverse()     逆序

for  in   迭次循环    while 循环

name_list = ["小明", "小花", "小芳", "小雨", "小白"]
​
# 使用循环遍历
# 在高级变量类型中，一般使用for + 变量 + in+ 列表，而不用while ,当然while也可以用。
​
for my_name in name_list:
    print("某的名字是 %s " % my_name)
​
# 使用while循环
# 第一步，先查询列表索引列表的位数， 用len查询 n-1 为最后一位元素的位置编号
b = len(name_list)
print(b)
​
# 定义计数器变量i
# 下面循环是反方向的
i = 4
​
while i >= 0:
    # 定义一个变量来接收i对应的值
    # my_name = name_list
​
    print("某的名字是 %s " % name_list)
​
    i -= 1

元组  tuple

元组不能进行增删改操作， 保护数据

循环迭历

info_tuple = ("zhangsan", 18, 1.75)
for my_age in info_tuple:
    print(info_tuple)
# 格式化字符串输出
# 格式化字符串后面的“（）”本质上都是元组
print("%s 的年龄是 %d 身高是 %.2f \n" % info_tuple * 10)

字典  dict

1.字典无序

2.一个key对应一个值value，值唯一

3.只能对key进行操作

4.key不能为可变数据类型(list, dict)

增删改查统计

增: dict.update({键值对})，dict_1.update(dict_2) 字典合并

删：dict.pop("key") ,dict.clear( )

改：dict["key"] = 新值

查：dict["key"]

统计：len(dict )

# 把字典根据值的大小进行排序
b = {"key": 9,
     "key1": 5,
     "key2": -1}
c = list(b.values())
c.sort()
# d = dict(c)
print(c)
e = {}
i = 0
for v in c:
    if i == 0:
        e.update({"key": v})
    elif i == 1:
        e.update({"key1": v})
    else:
        e.update({"key2": v})
    i += 1
print(e)

字符串：

判断

str.isspace  只有空白返回True

str.isalnum 全数字或者字母返回True

str.isalpha   只有字母返回True

str.isdecimal 只有数字返回True

str.islower 只有小写返回True

str.isupper 只有大写返回True

大小写替换：

str.upper() 全转大写

str.lower()  全转小写

str.swapcase()  翻转大小写

str.title()  每个单词首字母大写

去空白字符

str.lstrip() 去左边        str.rstrip()去右边        str.strip()去左右

拆分和拼接

str.split(str="", num)          以str为分隔符拆分，分隔成num个子字符串

str.join()                合并所有子字符串

切片

[起点:终点:步数]   左闭右开   取到终点前一位

步数为负则反着数

函数

max() 取大  min()取小  

面向对象

面向过程

1.面向过程和面向对象都是一种编程方式

2.特点 >>>>注重步骤和过程，需求复杂时代码也会很复杂，开发复杂项目时难度极大

面向对象(简称oop)

1.把不同的职能分给不同的人来处理

2.确定职责>>确定不同对象>>对象有多个方法>>完成最后总结,建立主框架顺序的让

   不同对象 调用 不同方法

3.面向对象是更大的封装，一个对象封装多个方法

4.类与对象

   类>>模板，一个类可以有多个对象，对象属性多样，类中定义的属性(变量)和方法(函数)，

​           对象中不能多也不能少

​           类的命名 >> 满足大驼峰命名法(每个单词的首字母都要大写)

​           类的三要素 >>> 类名(根据项目确定类名)、属性(对象的特征描述)、方法(对象具有的行为>动词)

   对象>>类创建出来的一个具体存在，调用类中的方法和属性

   print输出对象变量，会显示出十六进制的id地址(%x)

   self默认为调用类的对象id地址， 对象调用之后print对象的名字就可以在控制台看到内存地址

   初始化方法__ init__(), 又是内置方法  创建新对象后会自动调用初始化方法 >> 给类添加初始的属性

   把希望设置的属性值，定义成into的参数

   末置方法  ——del——(), del方法触发时机：删除对象时会先自动调用del方法执行最后代码，然后对

   象才被删除

​    ——“ ”——等方法不用指定可以自动调用

   同一个类创建出来的各个对象的属性是互不干扰的

• 面向对象的语法
  
  

class 派生类名（基类）:

类属性

​    def 方法1(self, 参数列表):

​        pass

​    def 方法2(self, 参数列表):

​        pass

@staticmethod

def 静态方法():

​        pass

@classmethod

def 类方法(cls, 参数列表):

​        pass

对象 = 类名（属性参数）

对象.实例方法

对象.实例属性

• 面向对象的三大特性
  
  

(1) 封装

(2) 继承

子类继承父类的所有属性和方法（包括私有属性和私有方法），但是子类无法

(3) 多态

• 异常捕获
  
  

(1) 完整语法格式：

try:

​    # 尝试执行的代码

​    pass

except 错误类型1:

​    # 针对错误类型1，对应的代码处理

​    pass

except 错误类型2:

​    # 针对错误类型2，对应的代码处理

​    pass

except (错误类型3, 错误类型4):

​    # 针对错误类型3 和 4，对应的代码处理

​    pass

except Exception as result:

​    # 打印错误信息

​    print(result)

else:

​    # 没有异常才会执行的代码

​    pass

finally:

​    # 无论是否有异常，都会执行的代码

print("无论是否有异常，都会执行的代码")

（2）异常抛出

重写函数，设置判断条件，通过Exception定义错误类型对象ex，并用raise抛出

• 模块
  
  

(1) import 模块名 as 别名

(2) from模块名import 工具名

(3) from模块名import* （导入模块下所有方法，可以直接引用）

一般代码页格式

# 导入模块

# 定义全局变量

# 定义类

# 定义函数

# 在代码的最下方

def main():

​    # ...

​    pass

# 根据 name 判断是否执行下方代码

if name == "main":

​    main()

• 文件
  
  

访问方式

说明

r以只读方式打开文件。文件的指针将会放在文件的开头，这是默认模式。如果文件不存在，抛出异常
w以只写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a以追加方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入
r+以读写方式打开文件。文件的指针将会放在文件的开头。如果文件不存在，抛出异常
w+以读写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a+以读写方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入

File = open（文件名, 读取方式）

file.write()

Text = file.read()

File. Close()

认识python

优点：简单，易学，开源，高层语言，可移植性(跨平台性强)，解释性，完全面向对象，可扩展性，丰富的

​            库，代码规范

缺点：1.运行速度慢(现在可以用c++改写关键部分提高速度)

​            2.中文资料匮乏(国内正在火起，各方面资料会渐多起来)

​            3.构建框架选择多(中小型web程序开发天下无敌，python语言的优秀，吸引了很多人才)

注释

使用用自己熟悉的语言，在程序中对某些代码进行标注说明，增强程序的可读性

单行注释(行注释)：以#开头，#(# + 空格)右边的所有东西当做说明，而不是真正要执行的程序，起辅助说明作用

​                                     如果在代码尾端进行单行注释要空两个空白字符，后面格式如上

多行注释(块注释)：多行注释通常使用三对单引号或者双引号，一般注释内容太多或者对函数，类进行解释才会用

​                                    到多行注释

变量

变量的命名

标示符可以由 字母、下划线 和 数字 组成，不能以数字开头，不能与关键字重名(区分大小写)

小驼峰: firstName,  lastName    大驼峰：FirstName, LastName

两种划分方式

1.数字型(整型int，浮点数float,布尔型bool，复数型complex)和非数字型(字符串str，列表list，元组tuple

，字典dict)

2.可变类型(列表，字典)和不可变类型(其它)

变量的格式化输出

%s 字符串  /    %03d  十进制整数(中间数字代表位数)  /   %.2f  浮点数   /    %%  输出百分号

print 输出     input   输入   def  定义函数

if 语句

if  条件一 ：

​        print("条件成立输出")

​        if  条件二 ：

​                print("条件成立输出")

​        elif 条件三：

​                print("条件成立输出")

​        else:

​                print(条件成立输出"")

elif 条件四：

​        print(条件成立输出")

else:

​        print("条件成立输出")

逻辑运算

and(且)  or(或)   not(非)

逻辑运算符

+  加   -  减      *   乘     /  除    //   整除    %  取余    **   幂

== 等于    ！=  不等于   >   大于  <   小于   >=   大等于  <=   小等于

赋值运算

=  简单赋值  +=  加赋  -= 减法  *=  乘等 /=  除等  //=  取整等  %= 取余等   **= 幂赋值

while循环

break打破当前循环    continue  进入下一次循环 ，下面代码不执行(当前循环)

计数器 i += 1  循环前先定义i，值大多从零开始

九九乘法表

row = 1
​
while row <= 5:
​
​
# 假设 python 没有提供字符串 * 操作
# 在循环内部，再增加一个循环，实现每一行的 星星 打印
col = 1
​
while col <= row:
    print("*", end="")
​
    col += 1
​
# 每一行星号输出完成后，再增加一个换行
print("")
​
row += 1

函数

def 函数名(形参):
    函数封装的代码
    ……

函数名，模块名的命名规则与标识符相同，调用  函数名(实参)

返回值return    调用函数一方定义一个变量来接收函数的返回结果，return后面代码都不会被执行

可以返还多个值

def demo():

        *a = 1*            *b = 2*

返回多个结果，是一个元组    *`return a, b`*

局部变量和全部变量

变量的引用：【id()】>查数据的内存位置。hash>字典key的定义>key不能为可变类型

分类：定义在函数内部的变量是局部变量，定义在函数外部的变量是全局变量

global ：关键词后面的是一个全局变量，把局部变量提升为全局变量

如果函数内部定义了一个与全局变量相同name的变量，函数内部只会读取内部变量

shift + F6 修改相同序列下变量的名字，点击名字使用快捷键

变量值互换

a = 100b = 6a, b = b, aprint("a = %d" % a)  # 打印的a是变量a

print("b = %d" % b)  # 打印的b是变量b

在函数内部，针对参数使用赋值语句，无论参数是不是可变类型的数据，都不会修改到外部的实参变量

def demo(num, num_list):
    print("内部")
​
    num = 50
    num_list = [1, 2, 3]
    print(num)
    print(num_list)
    print("over")
​
​
gl_num = 60
gl_num_list = [4, 5, 6]
demo(gl_num, gl_num_list)
print(gl_num)
print(gl_num_list)

如果在函数内部，使用方法来改变了可变类型数据的值，函数外面的值也会改变

def demo(num_list):
    # 如果函数内部对这个参数重新赋值，外面的数值就不会被改变
    # num_list = [7, 8] > 重新赋值对外面没作用
    num_list.append(9) > 外面值会变
    num_list.extend([4, 5, 6]) > 外面值会变
    print(num_list)
​
gl_list = [1, 2, 3]
demo(gl_list)
print(gl_list)
​
加等于操作产生的效果
​
def demo(num, num_list):
​
    print("action!")
    # 1. num = num + num  这个格式就等于给变量重新赋值了，外面变量值也会改变
    num += num  # 加等于是不会改变可变类型外部变量的值
    # num_list = num_list + num_list
    num_list += num_list # 本质上是在调用extend方法
​
    print(num)
    print(num_list)
    print("over!")
​
​
gl_num = 9
gl_list = [4, 5, 6]
demo(gl_num)
print(gl_num)

注意！！！

加等于“不可变变量 += 不可变变量”内部值会改变，但函数外部变量的值不会变

加等于中“可变变量 +=(+) 可变变量”本质上是调用extend/join，所以函数外部的可变变量值也会改变

*args作为一个参数表示能接收一个元组

* 函数名(正常参数， 缺省参数， 多值参数)**

​        正常参数 > nums          缺省参数 > gender= True       多值参数  >  *nums(元组）/**nums（字典）

多值参数求和

1.

def  sum_numbers(*num) >>  sum_numbers(1,2,3,4,5)

2

def  sum_numbers(num) >>  sum_numbers((1,2,3,4,5,6))

两种形式结果相同，但1可以处理多值，2要定义多个变量，不符合实际，太麻烦

递归

函数自己调用自己

必须规定一个出口，即终止条件，否则会出现死循环(最小或者最大）   

递归函数调用时，进去时执行调用函数上面的代码，出来时执行调用函数下面的代码

递归函数不擅长数字和的累和，积。会容易死机

递归的层数一般不会太多，常用于遍历文件目录结构

高级变量类型  

列表   元组   字典   字符串

索引(除了字典，所有索引都是从零开始，最大索引=len()-1, 逆向索引从-1开始)

针对查的操作：[]是知道索引查值， ()是知道值查索引

列表 list

增删改查统计排序

增：append(末尾追加)，insert(根据索引插入指定位置)，extend(继承，把一个列表追加到原列表)

删：remove(指定值删除)，pop()(默认末尾删除，索引指定位置删除),  del(内存中删除), clear(清空列表)

改：list[索引] = 新值

查：list[索引] > 查值            list.index(值) > 查索引

统计： len(list)  > 查列表长度           list.count(值)  >  值出现的次数

排序：list.sort()  从小到大     list.sort(reverse=True)    从大到小         list.reverse()     逆序

for  in   迭次循环    while 循环

name_list = ["小明", "小花", "小芳", "小雨", "小白"]
​
# 使用循环遍历
# 在高级变量类型中，一般使用for + 变量 + in+ 列表，而不用while ,当然while也可以用。
​
for my_name in name_list:
    print("某的名字是 %s " % my_name)
​
# 使用while循环
# 第一步，先查询列表索引列表的位数， 用len查询 n-1 为最后一位元素的位置编号
b = len(name_list)
print(b)
​
# 定义计数器变量i
# 下面循环是反方向的
i = 4
​
while i >= 0:
    # 定义一个变量来接收i对应的值
    # my_name = name_list
​
    print("某的名字是 %s " % name_list)
​
    i -= 1

元组  tuple

元组不能进行增删改操作， 保护数据

循环迭历

info_tuple = ("zhangsan", 18, 1.75)
for my_age in info_tuple:
    print(info_tuple)
# 格式化字符串输出
# 格式化字符串后面的“（）”本质上都是元组
print("%s 的年龄是 %d 身高是 %.2f \n" % info_tuple * 10)

字典  dict

1.字典无序

2.一个key对应一个值value，值唯一

3.只能对key进行操作

4.key不能为可变数据类型(list, dict)

增删改查统计

增: dict.update({键值对})，dict_1.update(dict_2) 字典合并

删：dict.pop("key") ,dict.clear( )

改：dict["key"] = 新值

查：dict["key"]

统计：len(dict )

# 把字典根据值的大小进行排序
b = {"key": 9,
     "key1": 5,
     "key2": -1}
c = list(b.values())
c.sort()
# d = dict(c)
print(c)
e = {}
i = 0
for v in c:
    if i == 0:
        e.update({"key": v})
    elif i == 1:
        e.update({"key1": v})
    else:
        e.update({"key2": v})
    i += 1
print(e)

字符串：

判断

str.isspace  只有空白返回True

str.isalnum 全数字或者字母返回True

str.isalpha   只有字母返回True

str.isdecimal 只有数字返回True

str.islower 只有小写返回True

str.isupper 只有大写返回True

大小写替换：

str.upper() 全转大写

str.lower()  全转小写

str.swapcase()  翻转大小写

str.title()  每个单词首字母大写

去空白字符

str.lstrip() 去左边        str.rstrip()去右边        str.strip()去左右

拆分和拼接

str.split(str="", num)          以str为分隔符拆分，分隔成num个子字符串

str.join()                合并所有子字符串

切片

[起点:终点:步数]   左闭右开   取到终点前一位

步数为负则反着数

函数

max() 取大  min()取小  

面向对象

面向过程

1.面向过程和面向对象都是一种编程方式

2.特点 >>>>注重步骤和过程，需求复杂时代码也会很复杂，开发复杂项目时难度极大

面向对象(简称oop)

1.把不同的职能分给不同的人来处理

2.确定职责>>确定不同对象>>对象有多个方法>>完成最后总结,建立主框架顺序的让

   不同对象 调用 不同方法

3.面向对象是更大的封装，一个对象封装多个方法

4.类与对象

   类>>模板，一个类可以有多个对象，对象属性多样，类中定义的属性(变量)和方法(函数)，

​           对象中不能多也不能少

​           类的命名 >> 满足大驼峰命名法(每个单词的首字母都要大写)

​           类的三要素 >>> 类名(根据项目确定类名)、属性(对象的特征描述)、方法(对象具有的行为>动词)

   对象>>类创建出来的一个具体存在，调用类中的方法和属性

   print输出对象变量，会显示出十六进制的id地址(%x)

   self默认为调用类的对象id地址， 对象调用之后print对象的名字就可以在控制台看到内存地址

   初始化方法__ init__(), 又是内置方法  创建新对象后会自动调用初始化方法 >> 给类添加初始的属性

   把希望设置的属性值，定义成into的参数

   末置方法  ——del——(), del方法触发时机：删除对象时会先自动调用del方法执行最后代码，然后对

   象才被删除

​    ——“ ”——等方法不用指定可以自动调用

   同一个类创建出来的各个对象的属性是互不干扰的

• 面向对象的语法
  
  

class 派生类名（基类）:

类属性

​    def 方法1(self, 参数列表):

​        pass

​    def 方法2(self, 参数列表):

​        pass

@staticmethod

def 静态方法():

​        pass

@classmethod

def 类方法(cls, 参数列表):

​        pass

对象 = 类名（属性参数）

对象.实例方法

对象.实例属性

• 面向对象的三大特性
  
  

(1) 封装

(2) 继承

子类继承父类的所有属性和方法（包括私有属性和私有方法），但是子类无法

(3) 多态

• 异常捕获
  
  

(1) 完整语法格式：

try:

​    # 尝试执行的代码

​    pass

except 错误类型1:

​    # 针对错误类型1，对应的代码处理

​    pass

except 错误类型2:

​    # 针对错误类型2，对应的代码处理

​    pass

except (错误类型3, 错误类型4):

​    # 针对错误类型3 和 4，对应的代码处理

​    pass

except Exception as result:

​    # 打印错误信息

​    print(result)

else:

​    # 没有异常才会执行的代码

​    pass

finally:

​    # 无论是否有异常，都会执行的代码

print("无论是否有异常，都会执行的代码")

（2）异常抛出

重写函数，设置判断条件，通过Exception定义错误类型对象ex，并用raise抛出

• 模块
  
  

(1) import 模块名 as 别名

(2) from模块名import 工具名

(3) from模块名import* （导入模块下所有方法，可以直接引用）

一般代码页格式

# 导入模块

# 定义全局变量

# 定义类

# 定义函数

# 在代码的最下方

def main():

​    # ...

​    pass

# 根据 name 判断是否执行下方代码

if name == "main":

​    main()

• 文件
  
  

访问方式

说明

r以只读方式打开文件。文件的指针将会放在文件的开头，这是默认模式。如果文件不存在，抛出异常
w以只写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a以追加方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入
r+以读写方式打开文件。文件的指针将会放在文件的开头。如果文件不存在，抛出异常
w+以读写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a+以读写方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入

File = open（文件名, 读取方式）

file.write()

Text = file.read()

File. Close()