Python 学习笔记【1】

此笔记仅适用于有任一编程语言基础,且对面向对象有一定了解者观看

文章目录

  • 数据类型
    • 字面量
    • 数字类型
    • 数据容器
      • 字符串
      • 列表
      • 元组
    • type()方法
    • 数据类型强转
  • 注释
    • 单行注释
    • 多行注释
  • 输出
    • 基本输出
    • 连续输出,中间用“,”分隔
    • 更复杂的输出格式
  • 变量
    • 定义
    • del方法
  • 标识符
  • 运算符
    • 比较运算符
    • 逻辑运算符
  • 输入
    • input()
    • 正常输入
    • 连续输入
  • 控制语句
    • 自上而下的控制语句
    • if条件语句
    • 循环语句
      • for循环
        • range()
        • for循环临时变量作用域
      • while循环
      • break
      • continue
      • else
  • 函数
    • 定义函数
    • 调用函数
    • 传参
      • 位置参数
      • 关键字参数
      • 位置参数和关键字参数混用
      • 缺省参数
      • 可变参数(不定长)
        • 位置传递不定长
        • 关键字传递不定长
    • 多个返回值
    • 函数作为传参
    • 匿名函数
      • 介绍
      • 基本语法
      • 演示案例
  • 数据容器
    • 概述
    • 列表(list)
      • 介绍
      • 基本语法
      • 列表下标(索引)
      • 列表方法
        • 查询某元素下标
        • 修改对应下标的元素值
        • 在指定下标插入新元素
        • 追加元素
        • 删除指定下标元素
        • 删除某元素在列表的第一个匹配项
        • 清空列表
        • 统计某元素在列表中数量
        • 统计列表中所有元素数量
        • 排序
        • 列表拼接
    • 元组(tuple)
      • 介绍
      • 基本语法
        • 元组方法
    • 字符串(str)
      • 简介
      • 基本语法
      • 字符串方法
    • 数据容器的切片
      • 序列
      • 切片
    • 集合(set)
      • 介绍
      • 基本语法
      • 集合方法
      • 遍历集合
    • 字典(dict)
      • 介绍
      • 基本语法
      • 常用操作
      • 遍历字典
    • 容器通用函数
  • 迭代器和生成器
    • 迭代器
      • 简介
      • 创建迭代器
      • 迭代迭代器
    • 生成器
      • 简介
      • 创建生成器
      • 迭代生成器
  • Python3 内置函数
    • zip
    • enumerate
  • 文件操作
    • 文件编码
    • 文件基础操作
      • 打开文件
      • 关闭文件
      • 读操作
      • 写操作
    • CSV文件
  • 异常
    • 介绍
    • 捕获异常
      • 是什么
      • 为什么
      • 怎么做
      • 异常else
      • 异常finally
    • 异常传递
      • 介绍
  • 模块
    • 介绍
    • 导入模块
    • name变量
      • all变量
    • 自定义模块
      • 创建
      • 导入
    • 介绍
    • 创建包
    • 导入包
    • init.python文件
    • 第三方包
      • 如何安装第三方包
  • pyecharts模块
    • 介绍
    • 快速入门
      • 简单的画一个图
      • 全局配置
  • Numpy模块
    • 基础知识
    • 创建数组
    • 打印数组
    • 基本操作
    • 通函数
    • 索引、切片和迭代
  • datetime包
  • 类与对象
    • 基本操作
    • 构造方法(构造器)
    • 魔术方法
      • 介绍
      • str方法
      • lt方法
      • le方法
      • eq方法
    • 封装
      • 私有成员

数据类型

字面量

字面量就是非变量,直接以值的方式存在于程序中

数字类型

  • 整数
  • 浮点
  • 复数
  • 布尔

数据容器

字符串

三种定义方式

str1 = 'str1'
str2 = "str2"
str3 = """str3"""

列表

在后面列一个章节介绍

元组

在后面列一个章节介绍

type()方法

将变量 or 自变量放入“()”内,type()的返回值就是对应数据类型

数据类型强转

str = "123"# 这时str是字符串类型
str = (int)str# 这句话执行完str就成了int类型

注释

单行注释

# 这是单行注释
# #号和注释间一般用一个空格隔开

多行注释

"""
	这是多行注释
	这是多行注释
	这是多行注释
"""

输出

基本输出

连续输出,中间用“,”分隔

print(1,2,"3",4,5)#输出逗号默认为空格

更复杂的输出格式

  • 输出多个结果时,使用“,”分隔符

    print(1,2,3,sep=",")# 用分隔符“,”区分输出结果
    
  • 输出不换行

    print(x,end="")
    print(y)
    
  • %d、%s、%e的格式化输出

    print('%d'%3.1415926)# 仅输出整数部分
    print('%10s'%'Monday')# Monday右对齐,取十位,不够则补位
    print('%.3e'%3.1415926)# 3.1415926取3位小数,用科学计数法计数
    print('%.2f'%4.1415)# 保留两位小数
    
  • format的输出格式

    print('{}{}{}'.format
    ('Monday','Tuesday','Wednesday'))
    # 带关键字
    # "and"拼接
    
  • 自动格式化输出

    a = 180
    b = "roland"
    print(f"{b}的身高{a}")
    

变量

定义

变量名 = 变量值

bianliang = 1

del方法

使一个变量恢复到未定义状态

标识符

python中只支持:

  • 英文
  • 中文
  • 数字
  • 下划线 “_”

这四类元素

且,

  • 不推荐中文
  • 数字不能在开头
  • 区分大小写

运算符

加:+
减:-
乘:*
除:/ (计算完自动转化成浮点型)
整除://
取余:%
指数:**

比较运算符

运算符作用
>大于
<小于
==等于
!=不等于
>=大于等于
<=小于等于

逻辑运算符

逻辑运算符功能
and与运算
or或运算
not非运算

输入

input()

传参是字符串,此函数执行时会打印括号内的内容,并等待键盘的输入。接收完输入后会以字符串的形式返回程序

正常输入

x = int (input("请输入梯形的上底长度"))

连续输入

#多数据输入中间用空格间隔
x,y,z=map(int,input(“请输入梯形的上下底长和
高“).split())
#多数据输入中间用逗号间隔
x,y,z=map(int,input(“请输入梯形的上下底长和
高”).split(”,"))

控制语句

缩进为四个空格!!!

自上而下的控制语句

if条件语句

特点:if后条件不需要用空格包住,
用:代替{}
else if 变成elif

if 1>2:
    print("数学崩塌了")
elif 1>3:
    print("数学真崩塌了")
else:
    print("数学还是正常的")

循环语句

for循环

for 临时变量 in 序列类型:
执行语句

序列类型指,其内容可以一个个依次取出的一种类型,包括【字符串 列表 元组 ……】

Python的for循环是一个轮询的机制,轮询 in 后的列表

name = "Roland"
for x in name:
    print(x)
    
"""输出结果如下:
R
o
l
a
n
d
"""

理论上Python中的for循环无法构成无限循环(序列类型(被处理的数据集)不可能无限大)

range()
  • 语法1

    range(5)# 获得一个从0到5(不含5)的数字序列(0,1,2,3,4)
    
  • 语法2

    range(1,5)# 获得一个从1到5(不含5)的数字序列(1,2,3,4)
    
  • 语法3

    range(1,10,2)# 获得一个从1到10(不含10),步长为2的数字序列(1,3,5,7,9)
    

将range融合进for循环

for i in range(1,10,2):
    print (i)
for循环临时变量作用域

实际上可以在外部访问

但在编程规范上,不允许

while循环

i = 6
while(i > 0):
    print("i = ",i)
    i--

break

跳出循环

continue

中断本次循环,进入下次循环

如果没有下次了,那就跳出循环

else

在 python 中,while … else 在循环条件为 false 时执行 else 语句块:

count = 0
while count < 5:
   print count, " is  less than 5"
   count = count + 1
else:
   print count, " is not less than 5"

'''----------------------------------------------'''
# 注意,break退出循环不会触发else
count = 0
while count < 5:
   print count, " is  less than 5"
   count = count + 1
    break
else:
   print count, " is not less than 5"

函数

定义函数

def 函数名 (参数列表):
函数体
return 返回值

# 此函数根据传参大小,打印Hello n次,并返回"Over"
def SayHello(n):# 传参列表可以空着
    for i in range(n):
        print("Hello")
    return "Over" #可以不写return,不写return就是等于写了一个 return None

调用函数

print(SayHello(3))# 打印三次Hello

传参

位置参数

就是c语言的传参机制

关键字参数

即函数调用时通过 “键 = 值”形式传递参数

作用:可以让函数更加清晰、更容易使用,同时也清除了参数的顺序需求

def user_info(name,age,gender):
    print(f"您的名字为{name},年龄为{age},性别是{gender}")
    
user_info(name = "Roland", age = 3, gender = "男")
user_info(name = "Roland", gender = "男", age = 3)
user_info(age = 3, gender = "男", name = "Roland") 
#上面三次调用都是一样的传参效果

位置参数和关键字参数混用

def user_info(name,age,gender):
    print(f"您的名字为{name},年龄为{age},性别是{gender}")
 
user_info(name = "Roland", age = 3, gender = "男")
user_info("Roland", gender = "男", age = 3)
#上面三次调用都是一样的传参效果

缺省参数

也叫默认参数,意思就是为参数提供默认值,如果传参没有传该参数,则函数自己使用默认的参数,如果有传,则使用传参

def user_info(name,age,gender = "男"):
	print(f"您的名字为{name},年龄为{age},性别是{gender}")
    
user_info("Roland",age = 3)
user_info("Rose",18,"女")

可变参数(不定长)

位置传递不定长

def user_info(*args):# 这里注意下,args是一个默认的惯例,可以叫别的,但最好叫这个

传进的参数都会被 *args接收,作为一个元组存储,这也叫做位置传递

关键字传递不定长

def user_info(**kwargs):# 这里注意下,kwargs是一个默认的惯例,可以叫别的,但最好叫这个

传进的参数都会被 **kwargs接收,作为一个字典存储,这也叫做关键字传递,所以传递的参数得以字典的形式

多个返回值

# 此函数根据传参大小,打印Hello n次,并返回"Over"
def SayHello(n):# 传参列表可以空着
    for i in range(n):
        print("Hello")
    return "Over",6 # 多个返回值之间用逗号分隔

a,b = SayHello(3)# 接收多个返回值也是用逗号分隔
print(a,b)

函数作为传参

函数1作为参数传递给函数2,其实函数2写来就是为了让使用者传递一个函数1,然后有函数2来调用。

当然,函数1所赋予的传参是由函数2给的,并不是使用者

这算是传入计算逻辑,而非传入数据

挺绕的,自己写了就清楚了

# 对1和2进行计算,至于怎么计算,根据传入的函数决定
def calc_1_and_2(Handle):
    x = Handle(1,2)
    return x

#计算a+b
def math_plus(a,b):
    return a+b

#计算a-b
def math_minus(a,b):
    return a-b

print(calc_1_and_2(math_plus))
print(calc_1_and_2(math_minus))

匿名函数

介绍

函数的定义中

  • def关键字,可以定义带有名称的函数,可重复使用
  • lambda关键字,可以定义匿名函数(无名称),只可临时使用一次
  • 可以用来测试某个参数是函数的函数的功能

基本语法

lambda 传入参数:函数体 # 注意函数体内只能写一行

演示案例

def test_func(computer):
    result = computer(1,2)
    print(result)
    
test_func(lambda x,y: x + y)

# 在这里就是把新定义的匿名函数的逻辑传给了test_func

数据容器

概述

一种可以同时存储多个(种)元素的python数据类型

根据是否支持重复元素、是否可以修改、是否有序等,分为5类:

  • 列表(list)
  • 元组(tuple)
  • 字符串(str)
  • 集合(set)
  • 字典(dict)

数据容器变量名是指针:也就是先定义了list1,然后list2=list1,则修改list1后,list2内容也是同步变化的

列表(list)

介绍

列表内的每一个数据称为元素

列表中可以存储不同的数据类型

列表中可以存储相同的数据

说白了就是数组Pro

基本语法

# 字面量
# [元素1,元素2,元素……]

# 定义变量
# 第一种
myList = [1, 2, 3, 4, 5]
# 第二种
myList = [i for i in range(1, 6)]
# 上面两个结果一致

# 定义空列表
myList = []
myList = list()

# 列表嵌套
myList = [列表1,列表2]

案例演示

my_list = ["Roland", 3, True]
print(type(my_list))
print(my_list)
my_list_list = [my_list,["Roland", 3, False]]
print(my_list_list)

列表下标(索引)

my_list = ["Roland", 3, True]
# 正向索引
print(my_list[0],my_list[1],my_list[2])
# 反向索引(-1是倒数第一个,-2是倒数第二)
print(my_list[-1],my_list[-2],my_list[-3])

列表方法

查询某元素下标
列表对象.index(元素)

案例演示

my_list = ["Roland", 3, True]
print(my_list.index(3))
修改对应下标的元素值

同数组的修改元素方式,我觉得不应该叫方法

在指定下标插入新元素
列表对象.insert(下标,元素)

案例演示

my_list = ["Roland", 3, True]
my_list.insert(1,2)
print(my_list)
追加元素
列表对象.append(元素)# 将新元素追加到列表尾部
列表对象.extend(其他数据容器)# 将其他数据容器内容取出,依次追加到列表尾部

案例演示

my_list = ["Roland", 3, True]
my_list.append(2)
print(my_list)
my_list2 = ["Steve", 2, False]
my_list.extend(my_list2)
print(my_list)
删除指定下标元素
del 列表[下标]
列表对象.pop(下标)

案例演示

my_list = ["Roland", 3, True]
my_list.pop(2)
print(my_list)

my_list2 = ["Steve", 2, False]
del my_list2[0]
print(my_list2)
删除某元素在列表的第一个匹配项
列表对象.remove(元素)

案例演示

my_list = ["Roland", 3, True]
my_list.remove(3)
print(my_list)
清空列表
列表对象.clear()

案例演示

my_list = ["Roland", 3, True]
my_list.clear()
print(my_list)
统计某元素在列表中数量
列表对象.count(元素)

案例演示

my_list = ["Roland", 3, True]
print(my_list.count(True))
统计列表中所有元素数量
len(列表对象)

案例演示

my_list = ["Roland", 3, True]
print(len(my_list))
排序
list.sort(cmp=None, key=None, reverse=False) # reverse=true:降序
列表拼接

元组(tuple)

介绍

元组与列表的唯一区别——不可修改

基本语法

# 定义元组字面量
(元素,元素,……)

# 定义元组变量
变量名称 = (元组,元组,……)

# 定义单元素元组变量(要写个逗号)
变量名称 = (元组,)

# 定义空元组
变量名称 = ()
变量名称 = tuple() 

# 元组嵌套

元组方法
  • index
  • count
  • len

字符串(str)

简介

字符串时字符的数据容器,只能存字符

不可修改的

基本语法

# 通过下标取值
mystr = "Roland"
print(mystr[3])

字符串方法

  • .index 这里注意下,index不只是只能查单个字符的位置,也可以查一个小字符串出现的起始下标

  • .replace(字符串1,字符串2) 将调用此方法的字符串中的字符串1替换成字符串2,并以返回值的方式返回(需要一个新的变量来接收)

  • .split(“分隔符字符串”) 将调用此方法的字符串用分割字符串分割成多个元素,并存入一个列表,并以返回值的方式返回(需要一个新的变量来接收)

    # 这个方法不好描述,直接上代码
    myStr = "Hello this is Roland"
    mylist = myStr.split(" ")
    print(mylist)
    
  • .strip() 字符串规整操作,去除字符串的前后空格。传参还可以传入字符串,意思就是去除原字符串的前后被传入的字符串,当然还是将新字符串以返回值的方式返回

  • .count

  • len

数据容器的切片

序列

内容连续、有序,可使用下标索引的一类数据容器(列表、元组、字符串)

切片

从一个序列中取出一个子序列

语法:序列[起始下标:结束下标]
序列[起始下标:结束下标:步长]

arr[::-1] # 将数据容器内容倒序

注意:

  • 不含结束下标
  • 步长为负数表示反向取,呢么起始下标和结束下标也要反向标记
  • 是以返回值的方式返回新的序列
  • 传参不传步长的话就是默认步长为1

集合(set)

介绍

  • 无序、无下标
  • 不可重复
  • 可不同数据类型
  • 可修改
  • 支持for循环不支持while循环遍历

基本语法

# 定义集合字面量
{元素,元素,……}

# 定义集合变量
变量名称 = {元素,元素,……}

# 定义空集合
变量名称 = set()

集合方法

  • .add(元素) 将指定元素添加到自身集合内
  • .remove(元素) 删除指定元素
  • .pop()随机取一个元素通过返回值返回,同时删除此元素
  • .clear()
  • 集合1.difference(集合2) 取两个集合的差集,将新集合返回,原集合不发生变化
  • 集合1.difference_update(集合2) 在集合1内,删除和集合2相同的元素。集合1可能发生变化,集合2不变
  • 集合1.union(集合2) 将集合1和集合2合并,并以返回值的方式返回新集合
  • len(集合) 统计集合元素数量

遍历集合

由于集合没有下标,所以不能用while()遍历

可以用for循环遍历,但不能保证遍历顺序

myset = {1,2,5,6}
for i in myset:
    print(i)

字典(dict)

介绍

生活中的字典:【字】:含义

Python中的字典:【Key】:value

  • 无序、无下标
  • Key 不可重复(重复添加等于覆盖原有数据)
  • 值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。
  • 可修改
  • 支持for循环,不支持while循环遍历

基本语法

# 字面量
{key:value, key:value, ……}
# 变量
mydict = {key:value, key:value, ……}
# 空字典
my_dict = {}
my_dict = dict()

# 从字典中基于Key获取Value
my_dict = {"Roland":180,
          3:170,
          "Rola":160}
print(my_dict["Roland"])

# 字典的嵌套(Key不可为字典)
score = {"高数":100,
          "大英":99,
          "离散":100}
student = {"Roland":score}
print(student)
print(student["Roland"])
print(student["Roland"]["高数"])

常用操作

  • 新增/更新元素

    my_dict = {	"Roland":180,
              	"Steve":170}
    my_dict["Rola"] = 160 # 第一次使用表示新增Rola这个Key,Value为160
    print(my_dict)
    my_dict["Rola"] = 150 # 第二次使用表示修改Rola这个Key,Value为150 
    print(my_dict)
    
  • .pop(key) 获得指定Key的Value,通过返回值返回,同时删除这个key和对应的value

  • .clear() 清空字典

  • .keys() 获取所有的key(不含value)

  • len(字典) 获取字典中key的数量

  • .get(key) 获取key的值

遍历字典

my_dict = {	"Roland":180,
          	"Steve":170,
          	"Rola":160}
keys = my_dict.keys()
for key in keys:
    print(key)
for key in my_dict:# 其实这种写法和上面的的for一样,都是拿出my_dict中的所有key
    print(key)

容器通用函数

  • len
  • max
  • min

迭代器和生成器

迭代器

简介

迭代器(interation)是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退。

创建迭代器

# 使用iter方法创建
myList = [0, 1, 2, 3, 4]
myIter = iter(myList) # 等效下一行代码
myIter = iter([i for i in range(5)]) # 等效上一行代码

迭代迭代器

# 先创建一个迭代器
myIter = iter([i for i in range(5)])

# 使用next方法进行迭代,每执行一次next,迭代一次,当超出了迭代返回,会由一个 StopIteration 异常结束程序
print (next(myIter))
print (next(myIter))
print (next(myIter))
print (next(myIter))
print (next(myIter))
print (next(myIter))

生成器

简介

生成器(generator)是使用了 yield 的函数 或是 由循环表达式生成的。

没错,所有函数都能成为生成器,只需要在函数内部写到 yield 关键字

生成器函数还包括以下内容:

  • 通用生成器
  • 协程生成器
  • 委托生成器
  • 子生成器

创建生成器

生成器有两种创建方式表示:

  • 生成器表达式

    # 生成器表达式是用圆括号来创建生成器
    myGenerator = (i for i in range(5)) # 与列表的创建很想,是把方括号改成圆括号
    
  • 生成器函数

    # 创建 生成器函数
    def countdown(n):
        while n > 0:
            yield n
            n -= 1
     
    # 创建生成器对象
    generator = countdown(5)
    

迭代生成器

 # 创建 生成器函数
def countdown(n):
    while n > 0:
        yield n
        n -= 1
 
# 创建生成器对象
generator = countdown(5)


# 通过迭代生成器获取值
print(next(generator))  # 输出: 5
print(next(generator))  # 输出: 4
print(next(generator))  # 输出: 3
 
# 使用 for 循环迭代生成器
for value in generator:
    print(value)  # 输出: 2 1

Python3 内置函数

zip

zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象

我们可以使用 list() 转换来输出列表。

enumerate

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
print(list(enumerate(seasons, start=1)))# 下标从 1 开始

文件操作

文件编码

编码技术即翻译的规则

如:

  • UTF-8

  • GBK

  • Gig5

文件基础操作

打开文件

"""
	name:要打开的目标文件名的字符串
	mode:设置打开文件的模式(访问模式):只读、写入、追加等
		r:只读
		w:只写,清空文件,从头开始编辑;如果文件不存在,则创建新文件
		a:追加新内容写到已有内容之后;如果文件不存在,则创建新文件
	encoding:编码格式(字符串)
"""
open(name, mode, encoding)# 打开一个已存在的文件,或者创建一个新文件;并返回一个文件对象,可以理解成C语言中的FILE类型变量

#示例
f = open("F:\Pyworks\Demo1\demo.txt","r",encoding="UTF-8")# 这里要注意,encoding在函数定义处不是第三位传参,所以要用关键字传参

关闭文件

  • .close()方式

    f = open("F:\Pyworks\Demo1\demo.txt","r",encoding="UTF-8")
    f.close()# 解除文件占用
    
  • with open语法

    with open("F:\Pyworks\Demo1\demo.txt","r") as f:
        print(f.readlines())
    # 通过在with open的语句块中对文件进行操作
    # 可以在操作完成后自动close文件,避免遗忘掉close方法
    

读操作

  • 文件对象.read(num) 从文件对象中读取指定长度的内容(num的单位是字符个数,如果不写num,则效果等于readlines() )(这里注意,读取的时候是有个指针的概念的,一开始指针指向第一个字符,假设第一次读取到第4个字符(第4未读出),则下次读取是从第4个字符开始)
  • 文件对象.readline() # 按照行的方式对文件内容读取一行,并返回一个字符串
  • 文件对象.readlines() # 按照行的方式对文件内容进行一次性读取,并返回一个列表,文件中每行数据作为一个元素
# 示例1
f = open("F:\Pyworks\Demo1\demo.txt","r",encoding="UTF-8")
print(f.read(10))

# 示例2
f = open("F:\Pyworks\Demo1\demo.txt","r",encoding="UTF-8")
print(f.readlines())


for循环遍历文件内容

f = open("F:\Pyworks\Demo1\demo.txt","r",encoding="UTF-8")
for line in f: # 每次循环会从文件中拿一行数据以字符串形式给到line
    print(line)

写操作

# 只写的方式打开文件
f = open("F:\Pyworks\Demo1\demo.txt","w",encoding="UTF-8")
# 写入文件
f.write("你好世界")# 写入Python程序缓冲区
# 内容刷新(即Ctrl-S保存操作),可以不要这个内存刷新,当f.close被执行后或者程序关闭了,也是会自动刷新的
f.flush()# 真正写入文件中
# 追加的方式打开文件
f = open("F:\Pyworks\Demo1\demo.txt","a",encoding="UTF-8")
# 写入文件
f.write("你好世界")# 写入Python程序缓冲区
# 内容刷新(即Ctrl-S保存操作),可以不要这个内存刷新,当f.close被执行后或者程序关闭了,也是会自动刷新的
f.flush()# 真正写入文件中

CSV文件

import csv
 
filename='C:\\Users\\lenovo\\Desktop\\parttest.csv'
data = []
with open(filename) as csvfile:
    csv_reader = csv.reader(csvfile)  # 使用csv.reader读取csvfile中的文件
    #header = next(csv_reader)        # 读取第一行每一列的标题
    for row in csv_reader:            # 将csv 文件中的数据保存到data中
        data.append(row[5])           # 选择某一列加入到data数组中

异常

介绍

即bug,程序跑到某个位置时,编译器无法继续运行下去

捕获异常

是什么

世上没有完美的程序

我们要做的,不是力求程序完美运行,而是在力所能及的范围内,对可能出现的bug进行提前准备、提前处理

这种行为称为:异常处理:(捕获异常

为什么

当程序遇到BUG时,接下来有两种情况:

  1. 整个程序停止
  2. 对BUG进行提醒,整个程序继续运行

没有捕获异常的时候,程序是以 情况1 的方式处理bug的

但是在真实应用场景时,不可能因为一个bug就让程序停了,所以我们就需要捕获异常来实现 情况2

怎么做

  • 基本捕获语法

    try:
        可能发生错误的代码
    except:
        如果出现异常 执行的代码
    
  • 捕获指定的异常

    try:
        print(a)
    except NameError as e:# 这个e就是异常的对象,也就是系统自带的异常解释信息;可以不写as e,就是不接收异常对象罢了
        print("出现了变量未定义的异常")
        print(e)
    
  • 捕获多个异常

    try:
        print(1/0)
    except(NameError,ZeroDivisionError):
        print("ZeroDivision错误…")
    
  • 捕获所有异常并获取异常信息

    try:
        print(1/0)
    except Exception as e:
        print(e)
    

异常else

else表示没有异常的话要执行的代码

try:
    print(1/0)
except Exception as e:
    print(e)
else:
    print("没有异常~")

异常finally

finally表示无论有没有异常都要执行里面的代码

try:
    print(1/0)
except Exception as e:
    print(e)
else:
    print("没有异常~")
finally:
    print("离开异常判断区域")

异常传递

介绍

异常是具有传递性的

看看代码

def func1():
    return 1/0

def func2():
    return func1()

try:
    print(func2())
except:
    print("发现异常")

上述代码中func1中 0 作为除数会报异常,如果func1中没有处理这个异常的话,异常会传递到func2;如果func2也没有捕获异常的话,异常最终会传递到主程序中,如果主程序也没有捕获,那程序就停止了

模块

介绍

就是C语言的.c文件,在python中是一个.python文件,里面有定义好的函数,类,变量。

就是个工具包,直接拿过来用

导入模块

[from 模块名] import [模块 || 变量 | 函数 | *|] [as 别名][]”括起来的是可选的意思 “|” 是选其一的意思

常见的组合形式:

  • import 模块名
  • import 模块名1,模块名2
  • import 模块名 as 别名
  • from 模块名 import 类|变量|方法
  • form 模块名 import *
  • form 模块名 import 类|变量|方法 as 别名

使用import导入需要通过 . 才能使用全部功能,比如time.sleep()

使用from导入直接就能使用全部功能,比如sleep()

当导入不同模块的时候,如果有重名的函数之类的,程序会优先调用最后一次导入

name变量

如果导入的模块内有可立即执行代码,则程序运行import的时候就会直接执行模块内的代码,如下

"""这是模块文件.python"""
def test(a,b):
    return a+b

test(a+b)
"""主程序文件.python"""
import 这是模块文件

print("主程序")

如果不想执行模块内的代码呢?

这里就需要在模块内部的可执行代码前加东西了

"""这是模块文件.python"""
def test(a,b):
    return a+b

if __name__ == '__main__': # __name__ 是一个Python内置变量,当我们运行某个.python文件是,该.python文件内的 __name__ 就会被赋值为 '__main__' 可以理解成Python的入口文件,很类似c语言的int main(){}
	test(a+b)
"""主程序文件.python"""
import 这是模块文件

print("主程序")

all变量

如果一个模块文件中有 all 变量,当使用 from xxx import * 导入的时候,只能导入在这个列表中的元素

"""这是模块文件.python"""
__all__ = ['test_a'] # 这时候如果 from 这是模块文件 import * 的话,只能使用test_a函数,用其他导入语句的话就没关系,不用看这个all
def test_a(a,b):
    return a+b

def test_b(a,b):
    return a-b

"""主程序文件.python"""
import 这是模块文件

print("主程序")
test_a(1,2)
test_b(1,2)

自定义模块

创建

只需要新建.python文件,定义对应函数,就可以了

导入

在同一个文件夹直接import或者from文件名就可以

介绍

模块可以理解成文件,包就是文件夹

相较于文件夹,包还多了一个叫 __init__.python 的文件,有了这个文件,文件夹才叫做包

创建包

  1. 新建文件夹
  2. 新建文件 __init__.python
  3. 好了

导入包

  • 方式一

    import 包名.模块名# 导入
    包名.模块名.目标 # 使用
    
  • 方式二

    from 包名 import 模块名# 导入
    模块名.目标# 使用
    

init.python文件

 __all__  = ['my_module1']#此时如果使用import *这个包时,就只能使用my_module1这个模块

第三方包

如何安装第三方包

  1. 进入cmd
  2. 输入pip install 包名
    也可以pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名
    没有科学上网的话第二个可以改善下载速度

pyecharts模块

介绍

可以做出数据可视化效果图的一个模块

本体是 Echarts 框架,Echarts是百度开源的数据可视化框架,而pyecharts模块是专为Python设计的模块

官方网站

安装:pip install pyecharts

快速入门

简单的画一个图

# 导包,导入Line功能构建折线图对象
from pyecharts.charts import Line

# 得到折线图对象
line = Line()

# 添加x轴数据
line.add_xaxis(["中国","美国","日本"])

# 添加y轴数据
line.add_yaxis("GDP",[30,20,10])

#生成图标
line.render()

全局配置

set_global_opts()

该方法可配置的基础配置(所谓基础配置即无论是什么图都会有的配置)如下:

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

不学了,没用

Numpy模块

[官方链接](NumPy 介绍 | NumPy)

基础知识

NumPy的主要对象是同构多维数组。它是一个元素表(通常是数字),所有类型都相同,由非负整数元组索引。在NumPy维度中称为

NumPy的数组类ndarray被调用。它也被别名 array所知。请注意,numpy.array这与标准Python库array.array类不同,后者只处理一维数组并提供较少的功能。ndarray对象更重要的属性是:

  • ndarray.ndim - 数组的轴(维度)的个数。在Python世界中,维度的数量被称为rank
  • ndarray.shape - 数组的维度。这是一个整数的元组,表示每个维度中数组的大小。对于有 n 行和 m 列的矩阵,shape 将是 (n,m)。因此,shape 元组的长度就是rank或维度的个数 ndim
  • ndarray.size - 数组元素的总数。这等于 shape 的元素的乘积
  • ndarray.dtype - 一个描述数组中元素类型的对象。可以使用标准的Python类型创建或指定dtype。另外NumPy提供它自己的类型。例如numpy.int32、numpy.int16和numpy.float64。
  • ndarray.itemsize - 数组中每个元素的字节大小。例如,元素为 float64 类型的数组的 itemsize 为8(=64/8),而 complex32 类型的数组的 itemsize 为4(=32/8)。它等于 ndarray.dtype.itemsize
  • ndarray.data - 该缓冲区包含数组的实际元素。通常,我们不需要使用此属性,因为我们将使用索引访问数组中的元素

创建数组

# 使用array函数从常规Python列表或元组中创建数组
import numpy as npy

# 一维数组
a = npy.array([2,3,4]) 
print(a)

# 二维数组
b = npy.array([[1,2,3],[4,5,6],[7,8,9]])
print(b)

# 在创建时显示指定数组的类型
c = npy.array([6,6,6], dtype=complex)# complex是虚数
print(c)

# 创建一个全是0的数组
d = npy.zeros([3,4])
print(d)

# 创建一个全是1的数组
e = npy.ones([3,4], dtype=npy.int16)
print(e)

# 创建一个数组,其初始内容是随机的,取决于内存的状态。(dtype默认是float64)
f = npy.empty([3,4])
print(f)

# 创建整数组成的数组
g = npy.arange(10,100,20) #从10到100,步长为20
print(g)

# 创建浮点数组成的数组
h = npy.linspace(0,2,9) # 获取0到2之间的9个数

# 根据π做一些操作
from numpy import pi
i = npy.linspace(0,2*pi,100) # 获取0到2π间的100个数
print(i)
j = npy.sin(i) # 将数组i中的所有元素进行正弦转化
print(j)

打印数组

numpy中的数组有一定的固定布局:

  • 最后一个轴从左到右打印,
  • 倒数第二个轴从上到下打印,
  • 其余轴也从上到下打印,每个切片用空行分隔

[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]
 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]

如果数组太大而无法打印,NumPy会自动跳过数组的中心部分并仅打印角点:

>>> print(np.arange(10000))
[   0    1    2 ..., 9997 9998 9999]
>>>
>>> print(np.arange(10000).reshape(100,100))
[[   0    1    2 ...,   97   98   99]
 [ 100  101  102 ...,  197  198  199]
 [ 200  201  202 ...,  297  298  299]
 ...,
 [9700 9701 9702 ..., 9797 9798 9799]
 [9800 9801 9802 ..., 9897 9898 9899]
 [9900 9901 9902 ..., 9997 9998 9999]]

要禁用此行为并强制NumPy打印整个数组,可以使用更改打印选项set_printoptions

>>> np.set_printoptions(threshold=sys.maxsize)     

基本操作

数组上的算术运算符会应用到 元素 级别。即所有的元素都会收到运算符的影响

>>> a = np.array( [20,30,40,50] )
>>> b = np.arange( 4 )
>>> b
array([0, 1, 2, 3])
>>> c = a-b
>>> c
array([20, 29, 38, 47])
>>> b**2
array([0, 1, 4, 9])
>>> 10*np.sin(a)
array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])
>>> a < 35 # 比较运算符都可以
array([ True, True, False, False])

>>> A = np.array( [[1,1],
...             [0,1]] )
>>> B = np.array( [[2,0],
...             [3,4]] )
>>> A * B                       # 乘积运算符
array([[2, 0],
       [0, 4]])

与许多矩阵语言不同,乘积运算符*在NumPy数组中按元素进行运算。即 aij * bij

而矩阵乘积是使用@或者 dot函数

>>> A = np.array( [[1,1],
...             [0,1]] )
>>> B = np.array( [[2,0],
...             [3,4]] )

>>> A @ B                       # matrix product
array([[5, 4],
       [3, 4]])
>>> A.dot(B)                    # another matrix product
array([[5, 4],
       [3, 4]])                       

当使用不同类型的数组进行操作时,结果数组的类型对应于更一般或更精确的数组(称为向上转换的行为)。

许多一元操作,例如计算数组中所有元素的总和,都是作为ndarray类的方法实现的。

  • 注意,以下几个方法有个传参叫axis,axis = 0表示对列进行操作,axis = 1表示对行进行操作
  • .sum
  • .min
  • .cumsum
  • 等……

通函数

如sin,cos,exp……这些函数也都是在数组上按元素进行运算,产生一个数组作为输出

索引、切片和迭代

一维的数组可以进行索引、切片和迭代操作的,就像 列表 和其他Python数据容器类型一样

多维的数组每个轴可以有一个索引。这些索引以逗号分隔的元组给出:

array([[ 0,  1,  2,  3],
       [10, 11, 12, 13],
       [20, 21, 22, 23],
       [30, 31, 32, 33],
       [40, 41, 42, 43]])
>>> b[2,3]
23

当提供的索引少于轴的数量时,缺失的索引被认为是完整的切片 :

>>> b[-1]                                  # the last row. Equivalent to b[-1,:]
array([40, 41, 42, 43])

如果想要对数组中的每个元素执行操作,可以使用flat属性,该属性是数组的所有元素的迭代器

for element in b.flat:
    print(i)

datetime包

示例代码

import numpy as np
import pandas as pd
from datetime import *

# 输入2个日期
date1 = "2022.05.11 13:30:00"
date2 = "2022.05.10 12:00:00"

# 创建时间点对象(不能进行减法运算)
realTime = datetime.time(10, 30, 0) # 10:30:00

# 创建具体时间对象(可以进行减法运算)
realTime_dt = datetime.datetime(2021, 1, 1, realTime.hour, realTime.minute, realTime.second)

# 将输入的日期转换为“datetime.datetime”类型
# 由于日期的类型是字符串,因此不能直接进行计算,会报错
date1 = datetime.strptime(date1, "%Y.%m.%d %H:%M:%S")
date2 = datetime.strptime(date2, "%Y.%m.%d %H:%M:%S")
print(" date1:", date1, "\n" ,"date2:", date2)
print(" 2个日期的类型分别是:\n", type(date1), type(date2))

# 计算时间差:时间差的类型为“datetime.timedelta”类型
duration = date1 - date2
duration

# 对计算差值进行天数(days)和秒数(seconds)的提取,并将秒数转换为小时数
day = duration.days
hour = duration.seconds/3600
print("days:", day)
print("hours:", hour)

类与对象

基本操作

主要要了解self

"""设计类"""
class Student:
    """类的属性(变量)"""
    name = None
    age = None
    
    """类的行为(方法)"""
    def say_hi(self,myname):# self关键字必须存在,其余定义方式和普通的函数一样
        print(f"hi,大家好,我是{self.name}")# 如果成员方法要直接使用成员变量,也需要在变量前加上self.
        print(f"hi,大家好,主人也叫我{myname}")
    
"""创建对象"""    
stu1 = Student()
stu2 = Student()


"""为对象赋值"""
stu1.name = "Roland"
stu2.name = "Rola"


"""获取对象信息"""
print(stu1.name)


"""调用成员方法"""
stu1.say_hi("Steve")# self虽然是定义法时的形参,但是调用方法时完全可以忽略这个形参

构造方法(构造器)

类中如果有了构造方法,那么可以实现:

  • 在创建类对象 (构造类) 的时候,会自动执行
  • 在创建类对象(构造类) 的时候——new,将传入参数自动传递给构造方法使用
# 在Python中,__init__()就是构造方法也就是java中的构造器
class Student:
    """类的属性(变量)"""
    name = None
    age = None
    
    """构造方法"""
    def __init__(self,name,age):
        self.name = name
        self.age = age

    """类的行为(方法)"""
    def say_hi(self,myname):# self关键字必须存在,其余定义方式和普通的函数一样
        print(f"hi,大家好,我是{self.name}")# 如果成员方法要直接使用成员变量,也需要在变量前加上self.
        print(f"hi,大家好,主人也叫我{myname}")
        
        

"""创建对象"""    
stu1 = Student("Roland",18)
# stu2 = Student()


"""获取对象信息"""
print(stu1.name)
stu1.say_hi("Steve")

魔术方法

介绍

Python类中有很多内置方法,即无论是什么类,都会有的方法,上面所说的 init 构造方法就是魔术方法

魔术方法的命名规范:方法单词前后都有两个 “_”

有:

  • init——构造方法
  • str——字符串方法
  • lt——小于、大于符号比较
  • le——小于等于、大于等于符号比较
  • eq——==符号比较
  • 等等……

str方法

字符串方法

当类对象需要被转换为字符串时,会调用str方法,而str方法实际上就是返回一串字符串。

如果没有重写方法的话,Python内置的是返回对象的内存地址,如果重写了,那么会返回重写方法中return 的值

"""这是没有重写str方法时"""
class Student:
    """类的属性(变量)"""
    name = None
    age = None
    
    """构造方法"""
    def __init__(self,name,age):
        self.name = name
        self.age = age


"""创建对象"""    
stu1 = Student("Roland",18)


"""输出对象信息(两个语句等价)"""
print(stu1)
print(str(stu1))
"""这是重写str方法时"""
class Student:
    """类的属性(变量)"""
    name = None
    age = None
    
    """构造方法"""
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"这个对象的name={self.name},age={self.age}"
"""创建对象"""    
stu1 = Student("Roland",18)


"""输出对象信息"""
print(stu1)
print(str(stu1))

lt方法

支持小于或大于符号( “<、>” )比较方法

即使两个对象可以进行比较,这个是需要我们自己写的,程序内没有内置。如果没有写这个方法,但是还是使用小于号比较了两个对象,则会报错

"""案例演示"""
class Student:
    """类的属性(变量)"""
    name = None
    age = None
    
    """构造方法"""
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __lt__(self,other):# 这里other代表着另一个对象
        return self.age < other.age
    
stu1 = Student("Roland",18)
stu2 = Student("Steve",19)

print(stu1 < stu2)

le方法

将我对lt方法的描述中的“小于或大于”替换成“小于等于或大于等于”

eq方法

将我对lt方法的描述中的“小于或大于”替换成“等于”

封装

封装是一个思想,就是下列代码

class Student:
    """类的属性(变量)"""
    name = None
    age = None
    
    """构造方法"""
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __lt__(self,other):# 这里other代表着另一个对象
        return self.age < other.age

私有成员

封装一个类时,有时会有一些变量,不公开给外部使用,只给内部的方法自己调用,这时就需要私有成员的形式

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/668219.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

LeetCode84:柱形图中最大的矩形

题目描述 给定 n 个非负整数&#xff0c;用来表示柱状图中各个柱子的高度。每个柱子彼此相邻&#xff0c;且宽度为 1 。 求在该柱状图中&#xff0c;能够勾勒出来的矩形的最大面积。 代码 单调栈 class Solution { public:int largestRectangleArea(vector<int>& h…

【数据结构】链表与顺序表的比较

不同点&#xff1a; 顺序表和链表是两种常见的数据结构&#xff0c;他们的不同点在于存储方式和插入、删除操作、随机访问、cpu缓存利用率等方面。 一、存储方式不同: 顺序表&#xff1a; 顺序表的存储方式是顺序存储&#xff0c;在内存中申请一块连续的空间&#xff0c;通…

文明互鉴促发展——2024“国际山地旅游日”主题活动在法国启幕

5月29日&#xff0c;2024“国际山地旅游日”主题活动在法国尼斯市成功举办。中国驻法国使领馆、法国文化旅游部门、地方政府、国际组织、国际山地旅游联盟会员代表、旅游机构、企业、专家、媒体等围绕“文明互鉴的山地旅游”大会主题和“气候变化与山地旅游应对之策”论坛主题展…

字符串-最长回文子串

一、题目描述 二、解题思路 设置双指针&#xff0c;定位连续子串&#xff0c;这里提供暴力解法&#xff0c;枚举各种子串并判断子串是否符合回文特征&#xff0c;符合则更新最长子串长度。 主要是注意一下java相关的语法API&#xff1a; 1.使用 (new StringBuilder(substr))…

MongoDB~存储引擎了解

存储引擎 存储引擎是一个数据库的核心&#xff0c;主要负责内存、磁盘里数据的管理和维护。 MongoBD的优势&#xff0c;在于其数据模型定义的灵活性、以及可拓展性。但不要忽略&#xff0c;其存储引擎也是插件式的存在&#xff0c;支持不同类型的存储引擎&#xff0c;使用不同…

B-TREE教程(个人总结版)

背景 在计算机科学中&#xff0c;数据存储和检索的效率是一个重要的研究课题。B-树&#xff08;B-Tree&#xff09;作为一种自平衡树结构&#xff0c;特别适合于在磁盘存储中处理大规模数据。它通过保持树的高度平衡&#xff0c;使得搜索、插入和删除操作的时间复杂度保持在对…

docker查看容器目录挂载

查看命令 docker inspect --format{{ json .Mounts }} <container_id_or_name> | jq 示例 docker inspect --format{{ json .Mounts }} af656ae540af | jq输出

Linux远程连接失败(Linux与Windows相互可以ping)

Linux远程连接解决办法记录 目录 文章目录 Linux远程连接解决办法记录1.SSH没有开启1.1查询ssh进程 1.SSH没有开启 sudo apt install openssh-serversudo /etc/init.d/ssh resart1.1查询ssh进程 ps -e | grep ssh 重新尝试连接

USB - D+/D-信号介绍

USB &#xff08;通用串行总线&#xff09;信令包括两条数据线 D 和 D-&#xff0c;用于差分信令&#xff0c;以提高抗噪能力和数据完整性。这些线路的控制决定了 USB 通信中的数据传输、各种状态和信号协议。 USB 差分信号 差分信号是指数据由 D 和 D- 线路之间的电压差来表…

【C++进阶】深入STL之string:掌握高效字符串处理的关键

&#x1f4dd;个人主页&#x1f339;&#xff1a;Eternity._ ⏩收录专栏⏪&#xff1a;C “ 登神长阶 ” &#x1f921;往期回顾&#x1f921;&#xff1a;C模板入门 &#x1f339;&#x1f339;期待您的关注 &#x1f339;&#x1f339; ❀STL之string &#x1f4d2;1. STL基本…

Java版本家政上门系统源码,自主研发、安全可控,支持任意二次开发

家政上门系统源码&#xff0c;Java版本&#xff0c;自主研发、安全可控。支持任意二次开发、有丰富合作案例。多端管理&#xff1a;管理端、用户端、服务端。 技术参数&#xff1a; 技术架构&#xff1a;springboot、mysql 、Thymeleaf 开发语言&#xff1a;java1.8、vue 开…

【智能AI相机】基于AI的新型成像和照明技术

缩短检测时间 降低废品率和成本 更快捕捉更多缺陷 ” Trevista CI Dome将康耐视专利的计算成像算法与结构化漫射圆顶照明相结合&#xff0c;提供无与伦比的地形图像质量&#xff0c;为光泽和哑光表面检测提供创新解决方案。有助于&#xff1a;缩短检测时间、降低废品率和成本…

通俗易懂->哈希表详解

目录 一、什么是哈希表&#xff1f; 1.1哈希表长什么样&#xff1f; 1.2为什么会有哈希表&#xff1f; 1.3哈希表的特点 1.3.1 取余法、线性探测 1.3.2 映射 1.3.3负载因子 1.4哈希桶 1.5闲散列与开散列 1.6总结 二、设计hash表 1、哈希表的设计 1&#xff09;插入…

ChatGPT在工作中的使用案例

知识点提示 开发过程中&#xff0c;遇到某个知识点&#xff0c;忘记或者不清楚怎么使用了&#xff0c;通过ChatGPT快速生成使用提示和案例。代码库“字典” 比如C 11 判断数组所有元素为false 在 C11 中&#xff0c;可以使用标准库中的 all_of 算法来判断数组中的所有元素是…

RAG 之 Embedding 模型 (一)

本文主要对 RAG 常见的 Embedding 模型 M3E 进行介绍。 一、M3E 1.1 简介 M3E 是 Moka Massive Mixed Embedding 的缩写。 Moka&#xff0c;此模型由 MokaAI 训练&#xff0c;开源和评测&#xff0c;训练脚本使用 uniem &#xff0c;评测 BenchMark 使用 MTEB-zh Massive&…

【计算机视觉】数字图像处理基础知识(模拟和数字图像、采样量化、像素的基本关系、灰度直方图、图像的分类)

一、图像的基本概念 图像(image)&#xff1a;图像这个简单单词其实包含两方面含义&#xff1a; “图”&#xff1a;是指物体反射光or透射光的分布“像”&#xff1a;接收和记录其分布所得到的结果&#xff08;如&#xff1a;人的视觉系统所接收“图”在人脑中形成的映像或认识&…

从CSV到数据库(简易)

需求&#xff1a;客户上传CSV文档&#xff0c;要求CSV文档内容查重/插入/更新相关数据。 框架&#xff1a;jdbcTemplate、commons-io、 DB&#xff1a;oracle 相关依赖&#xff1a; 这里本来打算用的2.11.0&#xff0c;无奈正式项目那边用老版本1.3.1&#xff0c;新版本对类型…

整数之间的赋值问题

前言&#xff1a;我们在初学C语言的时候&#xff0c;总是避免不了一些数据类型的转换&#xff0c;例如int-->char&#xff0c;char-->int&#xff0c;如果我们仅仅只学习这些语法&#xff0c;而不去了解底层原理&#xff0c;对于这些输出的内容&#xff0c;我们可能会感觉…

集成建筑5G商城为建筑行业开拓新方向

集成建筑5G商城为建筑行业开拓新方向 建筑业在我国有着悠久的发展历史&#xff0c;近年来&#xff0c;伴随着我国经济的快速增长、城镇化步伐加快&#xff0c;我国房地产、建筑业持续增长&#xff0c;建筑业显现出巨大的发展潜力。建筑行业近年来始终保持较高的增长速度。根据…

拉格朗日插值法的推导

1、插值的基本定义   设函数 y f ( x ) yf(x) yf(x)在区间 [ a , b ] [a,b] [a,b]上有定义&#xff0c;且已知它在 n 1 n1 n1个互异点 a ≤ x 0 < x 1 < . . . < x n ≤ b a\leq x_0<x_1<...<x_n\leq b a≤x0​<x1​<...<xn​≤b上的函数值 y 0 …