Python 基础

Z时代
2024-01-10
分类：综合

python

print 打印关键字

注释

1注释 # ，可以用快捷键就是ctrl+/这是一个单行注释注释的内容不会被程序执行

python中用或者">多行注释，在Python中用\'\'\'或者"""

\'\'\' 多行注释多行注释多行注释 ‘’‘

提高代码可读性，提高开发效率，尤其是大型项目或者团队项目有重要的意义

变量（不需要指定数据类型）

1、什么是变量？

变量其实就是个盒子，里面可以装各种东西，装了苹果，箱子和其他的东西结合的时候就属于苹果，装了香蕉箱子和其他的东西结合的时候就属于香蕉

在python当中其实变量的概念和初中代数的方程变量是一致的

方程式y=x*3 X就是变量当X=2 结果其实就6 当X是不同的值的时候就是变量

只不过在计算机当中，写程序的时候变量不仅仅可以是数字，还可以是其他的任意类型

食材+食谱->厨师==美味的菜肴

变量+逻辑->python解释器-->软件的功能

其实变量就是原材料【就是数据了】

变量=存储的数据

顾名思义：变量是一段有名字的连续存储空间，我们可以通过定义变量来申请并命名这样的存储空间，并通过变量的名字来使用这段存储空间

变量是程序中临时存放数据的场所

2、变量如何来定义和使用

变量命名规范

变量必须以字母（a-z,A-Z）或下划线（_）开头

其他字符可以是字母，数字或_

变量分大小写

Python关键字不能用作变量名

变量不能以数字开头

查看Python关键字

见名知意，尽量使用有语义的单词命名。如使用password用作密码，username用户名。

小驼峰式命名法：第一个单词字母小写其他的单词字母大写，如userName

大驼峰式命名法：全部单词首字母大写，如UserName

下划线命名法：每个单词用_下划线链接，如user_name

数据类型

数字（num）

int（有符号整形）

long（长整形）（Python3取消）

float（浮点型）

complex（复数）adwd

布尔值（bool）

True

falsed

字符串（str）

字典（dict）高级数据结构

d={} #字典类型
print(type(d))
<class \'dict\'>

元组（Tuple）高级数据结构

b=() #元祖类型
print(type(b))
<class \'tuple\'>

列表（list）高级数据结构

c=[] #列表类型
print(type(c))
<class \'list\'>

Type函数可以查看数据类型

>>> a=1+1
>>> type(a)
<class \'int\'>
>>> b="你好"
>>> type(b)
<class \'str\'>
>>> b=6>2
>>> type(b)
<class \'bool\'>
>>>

算术运算符

+加法算术加法 a+b=10

-减法算术减法 a-b=4

乘法算术乘法 a b=21

**指数左边的数是底数,右边是指数 a * * b=343

%取余 x%y x处于y的余数 a%b=1

/除法 x/y结果包含小数点后面的数 a/b=2.3333333335

//地板除 x//y结果是忽略小数点后面的小数位,只保留整数位 a//b=2

比较运算符

== 等于 x==y 如果x恰好等于y,则为真

!=不等于 x!=y 如果x恰好不等于y,则为真

>大于 x>y 如果x(左侧参数)大于y(右侧参数),则为真

<小宇 x<y 如果x(左侧参数)小于y(右侧参数),则为真

>= x>=y 如果x(左侧参数)大于或等于y(右侧参数),则为真

<= x<=y 如果x(左侧参数)小于或等于y(右侧参数),则为真

逻辑运算符

and x and y x,y同为真,则结果为真.如果一个为假,则结果为假

or x or y x,y有一个为真,则结果为真,全部为假则结果为假

not not x 取反如果x为真则结果为假如果x为假则结果为真

例子

#逻辑运算符  and or  not
#and 条件比较严格
#定义四个变量
a,b,c,d=23,18,10,3
print(a+b>c and  c<d)#True and False  返回false
print(c>d and a>b)#True and True 返回True
#  or 条件有一个为真 结果就为真
print(\'---------------or--------------------\')
print(a<b or b>d)#True  有一个满足
print(a<b or b<d)#False 都不满足
# not 取反 真假切换
print(\'-----------------not-----------------\')
print(not a>b)
#优先级
# ()-> not -> and -> or
#相同等级从左往右 ->->->->->->->->->->->->
print(2>1 and 1<4 or 2<3 and 9>6 or 2<4 and 3<2)
结果
False
True
---------------or--------------------
True
False
-----------------not-----------------
False
True
Process finished with exit code 0

赋值运算符

= 赋值运算符将=号右边的值赋值给左边的变量

+= 加法赋值运算符 c+=a 等效于 c=c+a

-= 加法赋值运算符 c-=a 等效于 c=c-a

= 加法赋值运算符 c =a 等效于 c=c * a

/= 加法赋值运算符 c/=a 等效于 c=c/a

%= 加法赋值运算符 c%=a 等效于 c=c%a

= 加法赋值运算符 c =a 等效于 c=c ** a

//= 加法赋值运算符 c//=a 等效于 c=c//a

例子

#赋值运算   算数运算的一个补充
# += -= *=  /= %= **=
a,b,c,d=23,18,10,3
a+=c #a=a+c  23+10
print(a)
a**=2 #a=a**2=23*23*23 等于几就相当于几次方
print(a)
结果
33
1089

Python格式化输出

python有一个简单的字符串格式化方法,使用%做占位符.%后面跟的是变量类型

例子 \n换行 \t空格

#输出 %占位符
name=\'张扬\'
classPro=\'清华附中一年3班\'
age=7
print(\'我的名字是:%s  来自[%s]今年%d岁\'%(name,classPro,age))
#%s 这里的s就是str类型
结果
我的名字是:张扬  来自[清华附中一年3班]今年7岁

常用的格式化符号,其中最常用的%s %d %f

%c 字符

%s 通过 str()字符串转换来的格式化

%i 有符号十进制整数

%d 有符号十进制整数

%u 无符号十进制整数

%o 八进制整数

%x 十六进制整数(小写字母)

%e 索引符号(小写E)

%E 索引符号(大写E)

%f 浮点实数

%g %f和%e的简写

%G %f和%E的简写

例子

name=\'老夫子\'
QQ=66666666
phone=5024193635
addr=\'河南省新乡市\'
print("姓名:%s"%name)
print("QQ:%s"%QQ)
print("手机号:%s"%phone)
print("地址:%s"%addr)
结果
姓名:老夫子
QQ:66666666
手机号:5024193635
地址:河南省新乡市

.format(变量1,变量2) 输出

grade=int(input("请输入你的成绩:"))
addr=input(\'家庭住址:\')
    print(\'成绩:{}\n地址:{}\'.format(grade,addr))

Python输入 input

Python中提供了input方法来获取键盘输入 (重点:input接受的键盘输入结果都是str类型的,如果需要接收数字类型需要将str转成int)

特殊注释

#！/usr/bin/eny.pyrhon3 这个是解释器的位置

#--coding=utf-8 中文编码

流程:

就是计算机执行代码的顺序

流程控制:

流程控制就是对计算机代码执行的顺序进行有效的管理,只有流程控制才能实现在开发当中的业务逻辑

流程控制的分类: if while

1顺序流程:就是代码一种自上而下的执行结构,也是Python默认的流程

2选择流程/分支流程:根据在某一步的判断,有选择的去执行相应的逻辑的一种结构

单分支

if 条件表达式: 一条条的python代码一条条的python代码一条条的python代码 ......

双分支

if 条件表达式: 一条条的python代码一条条的python代码一条条的python代码 ...... else: 一条条的python代码一条条的python代码一条条的python代码 ......

多分支

if 条件表达式: 一条条的python代码一条条的python代码一条条的python代码 ...... elif 条件表达式: 一条条的python代码一条条的python代码一条条的python代码 ...... elif 条件表达式: 一条条的python代码一条条的python代码一条条的python代码 ...... .... else: 一条条的python代码一条条的python代码一条条的python代码 ...... 条件表达式:比较运算符/逻辑运算符/复合的运算符

3循环流程:在一定的条件下,一直重复的去执行某段代码的逻辑[事情]

pass 占位符表示完整的代码块结束了退出结构

IF ELIF 可以嵌套但是要注意缩进

循环

while

#打印99乘法表
i=9
while i>=1:
    j=1
    while j<=i:
        print(\'{}*{}={}\'.format(j,i,j*i),end="丨")
        j+=1
    i-=1
    print()
结果
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
1*4=4 2*4=8 3*4=12 4*4=16 
1*3=3 2*3=6 3*3=9 
1*2=2 2*2=4 
1*1=1

end=""可以不换行

例子打印三角形

row=1
while row<=7:
    j=1
    while j<=row:
        print(\'*\',end=\' \')
        j+=1
        pass
    print()
    row+=1
    pass
方向相反的
row=7
while row>=1:
    j=1
    while j<=row:
        print(\'*\',end=\' \')
        j+=1
        pass
    print()
    row-=1
    pass
结果
* 
* * 
* * * 
* * * * 
* * * * * 
* * * * * * 
* * * * * * *

打印等腰三角形*3

# 等腰三角形
row=1
fan=10
while row<=10:
    A=1
    while A<=row:
        print(\' \',end=\'\')
        A+=1
        pass
    # Q = 1
    # while Q <= 2 * row - 1:
    #     print(\'*\', end="")
    #     Q += 1
    #     pass
    j=1
    while j<=fan*2-1:
        print(\'#\',end=\'\')
        j+=1
        pass
    fan-=1
    x=1
    while x<=2*row-1:
        print(\'*\',end="")
        x+=1
        pass
    print()
    row+=1
结果
 ###################*
  #################***
   ###############*****
    #############*******
     ###########*********
      #########***********
       #######*************
        #####***************
         ###*****************
          #*******************

for循环

for 临时变量 in 容器:

执行代码块

break 退出循环

for item in "I LOVE Python":
    if item ==\'E\':
        break #彻底中断循环
    print(item)
结果
I
L
O
V

continue 跳过本次循环

for item in "I LOVE Python":
    if item==\'o\':
        continue
    print(item)
结果
I
L
V
E
P
y
t
h
n

while使用 : 适用于对位置的循环次数

for使用: 适用于已知的循环次数[可迭代对象便利]

高级数据类型

序列:在python当中序列就是一组按照顺序排雷的值[数据集合]

在python中存在三种内置的序列类型:

字符串,列表,元组

优点:可以支持索引和切片的操作

特征:第一个正索引为0,指向的是左端,第一个索引为负数的时候,指向的是右端

切片: 是指截取字符串中的其中一段内容.切片使用语法:[起始下标: 结束下标: 步长]切片截取的内容不包含结束下标对应的数据,步长指的是隔几个下标获取一个字符

切片: [高级特性]可以根据下来获取序列对象的任意[部分]数据

语法结构: [start: end: step] step默认是1

字符串的常用方法.出来方法

capitalize()首字母大写

isalnum()判断是否字母和数字

islower()判断是否是小写

swapcase大写变小写,小写变大写

title()把每个单词的首字母变成大写

endswiht/starts with()是否x结束/开始

isalpha()判断是否是字母

join()循环去除所有值用xx去连接

lstrip/rstrip/strip 移除左/右/两侧空白

replace(old,new,count=None)old被换字符串,new替换字符串count还多少个.无count表示全部替换

find()检测x是否在字符串中

isdigit() 判断是否是数字"abc123",isdigit()

lower/upper 大小写转换

split()切割字符串

count()统计出现的次数

list 列表

list: python当中非常重要的数据结构,是一种有序的数据集合

特点:

1:支持增删改查

2:列表中的数据是可以变化的 [ 数据项可以变化,内存地址不会改变 ]

3:我们用中括号\'[]\' 来表示列表类型,数据之间用逗号 \' , \' 来分割 ,注意:数据项可以说任何类型的数据

4:支持索引和切片来进行操作

列表常用方法

append 在列表后面追加元素

count 统计元素出现的次数

extend 扩展,相当于批量添加

index 获取指定元素索引号

insert 在指定位置插入

pop 删除最后一个元素

remove 移除左边找到的第一个元素

reverse 反转列表

sort 列表排序 reverse=True 倒叙

列

# 怎么定义一个列表  li=[] 就定义好了
li = [1,2,3,4,5,\'你好\',7,8,9]  # 空列表
print(len(li))  # len函数可以获取到列表对象中的数据个数
strA=\'我喜欢python\'   # 汉字是一个字符一个字符来定义的和英语一样
print(len(strA))
print(type(li))
# 查找
listA = [\'abcd\',785,12.23,\'求职\',True]
print(listA)  # 输出完整的列表
print(listA[0])  # 输出第一个元素
print(listA[1:3])  # 从第二个开始到第三个元素
print(listA[2:])  # 从第三个开始一直到最后
print(listA[::-1])  # 倒叙输出 读书负数 从右向左开始输出
print(listA*3)  # 连着 多次都可以 [ 复制 ]
# 增加
print(\'---------------增加-------------\')
print("追加之前",listA)
listA.append([\'李豪\',\'a\',123,True])  # 追加操作
listA.append(999)   # 追加单个
print("追加之后",listA)
listA.insert(1,\'在第二个后面插入\')  # 插入操作,需要指定一个位置
print("追加之后",listA)
rsData = list(range(10))  # 强制转换为list对象
print(rsData)
listA.extend(rsData)  # 扩展  等于批量添加
listA.extend([1,2,3,4,5,6,7,8])  #一样的添加
print(listA)
# 修改
print(\'-------------------修改-----------------------------\')
print("修改之前",listA)
listA[0]=\'修改过了\'  # 用切片索引寻找修改目标并修改
print("修改之后",listA)
#删除
listB = list(range(10,50))
print(\'-------------------删除-----------------------------\')
print("删除之前",listB)
del listB[0]  # 单个删除
del listB[1:3]  # 批量删除数据  slice  批量之间用 \':\' 链接
listB.remove(20)  # 移除指定的元素   数据的具体值
listB.pop(1)  # 每次移除指定的项  参数索引值
print("删除之后",listB)
print(listB.index(31))  # 返回的是一个索引下表

下标从0开始

tuple 元组 :

是一种不可变的序列.在创建之后不能做任何的修改

1.不可变

2.用()创建元组类型,数据项用","来分割

3.可以说任何的类型

4.当元组中只有一个元素时,要加上逗号","不然解释器会当做整形来处理

5.同样可以支持切片操作

dict字典:

字典也是python中重要的数据类型,字典是有键值对组成的集合 , 通常使用键来访问数据,效率非常高,和list一样支持对数据的添加,修改,删除操作

特点:

1.不是一个序列类型没有下标的概念, 是一个无序的键值集合 . 是内置的高级数据类型

2.用哪个{}来表示字典对象,每个键值用逗号 "," 分割

3.键必须是不可变的类型 [元组 , 字符串 ] 值可以是任意的类型

4.每个键必定是唯一的,如果纯在重复的键,那么后者会覆盖前者

公用方法

字符串数组字典等都适用

1. + 连接

2. * 复制

3. in 查找返回bool 布尔值

函数

1.什么是函数: 一系列Python语句的组合,可以在程序中运行一次或者多次,

2. 一般是完成具体独立的功能

3.为什么要是用函数

4. 代码的附庸最大化以及最小化冗余代码, 整体代码结构清晰 , 问题局部化

函数的定义:

def + 关键字 +小括号 +冒号 + 换行缩进 + 代码块定义一个函数

def 函数名():

函数体[一系列的python语句,表示独立的功能]

函数的调用:

本质上就是去执行函数定义里面的代码块,在调用函数之前必须先定义

def 函数名():
	代码块

函数的调用:

函数名加()即可调用该函数

函数说明文档:

函数内容的第一行可以用字符串进行函数说明

函数的4中基本类型

1.无参数 ,无返回值 ,一般用于提示信息打印.

2.无参函数,有返回值,多用在数据采集中,比如获取系统信息.

3.有参数,无返回值,多用子啊设置某些不需要返回值的参数设置

4.有参数,有返回值,一般是计算型的,需要参数,最终也好返回结果.

局部变量 [优先使用]

就是在函数内部定义的变量.

作用于仅仅局限在函数的内部. 只在函数内生效互不干扰

不同的函数,可以定义相同的局部变量, 但是各自用各自的不回产生影响

局部变量的作用: 为了临时的保存数据需要在函数中定义来进行存储

全局变量

定义一个全局变量[作用于的范围不同]

在最外层定义的变量

但是如果全局变量遇到局部变量并相同的情况下,程序会优先使用函数内部变量

如果在函数内部项对全局变量进行修改的话, 必须用global 关键字进行声明

变量的关键字

global 修改全局变量

引用

小结

1. 在python当中万物皆对象,在函数调用的时候,实参传递的就是对象的引用

2. 了解了远离之后,就可以更好的去把控在函数内部的处理是否会影响到函数外部数据变化

3. 重要的事情说三遍↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓

参数的传递其实就是通过对象引用来完成,

参数传递是通过对象引用来完成,

参数传递是通过对象引用来完成

匿名函数

python中使用lambda关键字来创建匿名函数，所谓匿名即这个函数没有名字不用def关键字创建标准的函数

例1:

lambda 参数1,参数2,参数3:执行代码语句
# 使用lambda表达式计算两个数和:
test =lambda x,y:x+y
test(1,3)
test(4,5)
# 换成普通的韩式其实是这样的
def test(x,y):
    return x + y

例2:

# 匿名函数
# 语法:
# lambda 参数1,参数2,参数3:表达式
# 特点
# 1.使用lambda关键字去创建函数
# 2.不需要名字,没有名字
# 3.匿名函数冒号后面的表达式有且只有一个,
# ↑ 注意:是表达式,而不是语句
# 4.自带了一个retun, 而这个return的结果就是表达式计算后的结果
def 求和(x,y):
    \'\'\'
    计算两个数的和
    :param x:
    :param y:
    :return:
    \'\'\'
    return x+y
    pass
#对应的匿名函数
m = lambda x,y:x+y
# 通过变量去调匿名函数
print(m(23,19))
# print(求和(10,45))
c=lambda a,b,c:a*b*c
# 调用
print(c(1,2,3))
输出结果
42
6

例3: 里含标准双分支

# 双分支
age = 25
print(\'可以参军\'if age>18 else \'继续上学\')  # 可以替代窜通双分支写法
输出
\'可以参军\'
#比较最大值
b = lambda x,y:x if x>y else y
print(b(12,14))
输出
14
#还可以这么写 更简洁
b = (lambda x,y:x if x>y else y)(16,12) # 直接的调用
print(b)
输出
16

递归没看太懂有时间复习一下

代码块例子

# 递归条件的瞒足
# 自己调用自己
# 必须有一个明确的结束条件
# 优点: 逻辑简单,定义简单.
# 缺点: 容易,导致栈溢出,内存资源紧张, 甚至内存泄漏
# 求阶乘
# 循环的方式去实现
# def 阶乘(参数):
#     值=1
#     for item in range(1,参数+1):
#         值*=item
#         pass
#     return 值
# print(\'5的阶乘{}\'.format(阶乘(5)))
# 递归方式去实现
def 递归阶乘(参数):
    \'\'\'
    递归实现
    :param 参数: 阶乘参数
    :return:
    \'\'\'
    if 参数==1:
        return 1
    else:
        return 参数*递归阶乘(参数-1)
        pass
    pass
# 递归调用
print(\'5的递归阶乘{}\'.format(递归阶乘(5)))
# 递归案例 模拟实现 树形结构的便利
import os #引入文件操作模块 简称OS模块
def 查找文件(文件路径):
    listRs= os.listdir(文件路径) # 得到改路径下面所有的文件夹
    for 文件 in listRs:
        文件地址 =os.path.join(文件路径,文件) # 获取完整的文件路径
        if os.path.isdir(文件地址): # 判断是否是文件夹
            查找文件(文件)
        else:
            print(文件)
            pass
        pass
    else:
        return
    pass
# 调用搜索文件对象
查找文件(\'E:\\学习资料上课笔记\')

python 内部函数

也叫内嵌函数

就是python 在安装的时候就集成到python 中的函数直接调用就好

直接拿来用就行

数学运算你函数

abs() 求绝对值函数

round() 四舍五入求近似数的

注意 : 这里不是完全按照四舍五入或者四舍六入武城双来进行取值的,取值和python的版本有关系,还和浮点数的精度有关

pow() 求幂运算的

divmod() 求余和商的

max() 求最大值

min() 求最小值

sum() 求和

eval() 动态执行的

如果要给执行的赋值的话必须使用字典类型

例子

# abs() 取绝对值
print(abs(-123))
# round()  取近似的值
print(round(3.66)) #不保留小数位
print(round(3.66,1)) #保留1位小数
# pow() 求次方
print(3**3)  #也可以求出来3 的 3 次方
print(pow(3,3))  # 3 的 3 次方
# divmod() 求商和余数
print(divmod(10,2)) # 求商求余
# max() 求最大值
print(max([999,99999,1203105123,124])) #可以是列表 ,元组 等等
# min() 求最小值
print(min(12,1245,2156362,0.2))
# sum() 求和
print(sum([1,2,3,4,5,6,7,8,9]))
print(sum([1,2,3,4],10))
print(sum((1,2,3,4,5,6,7,8,9),1))
print(sum((1,1)))
# eval() 执行字符串表达式  动态执行
a,b,c=1,2,3
print(\'动态执行的函数={}\'.format(eval(\'a+b+c\')))
def tesaa():
    print(\'我执行了吗?\')
    pass
eval(\'tesaa()\')  # 可以调用函数执行

类型转换函数

int()

float()

str()

ord()

chr() # 将数字转换为阿斯克码

bool() # 布尔类型

bin() # 转换成刚二进制

hex() # 转换成刚十六进制

oct()

list() # 强制转换成列表模式

tuple()# 强制转换成元组模式

dict() # 声明一个字典或转换成一个字典

bytes() # 转为字节数

例子:

# 类型转换
# bin() # 转换成刚二进制
# bool() # 布尔类型
# chr() # 将数字转换为阿斯克码
# print(hex(23)) # 转换成16进制
# 元组转换成列表
tup = (1,2,3,4,5,6,7,8,9)
print(type(tup))
li = list(tup)
print(type(li))
tupli = tuple(li)
print(type(li))
字典的操作 dict()
dic = dict(name = \'小明\',age = 18)  # 创建一个字典
print(type(dic))
# dict[\'name\']=\'小明\'
# dict[\'age\']=18
print(dic)
# bytes 转换成字节数
print(bytes(\'我喜欢python\',encoding=\'utf-8\'))

序列操作函数序列包含(字符串元组列表)

all() #主要用来判断给定的可迭代参数 iterable 中的所有元素是否都为TRUE ,如果是返回True,否则返回False元素除了是0 空 FALSE 外都是 TRUE

注意: 空元组,空列表返回值为true

any() #用于判断给定的可迭代参数 iterable 是否全部为False,则返回False,如果有一个为True 则返回True

注意 : 除了是 0 空 False 外都算True

sorted() #函数对所有可迭代的对象进行排序操作,

","(逗号)reverse = True 或False 默认的是False 是升序

.key = str.lower #字符串于大小写无关

返回一个新的list 并不会修改原始值 sort 会修改

sort与sorted 区别 :

sort是应用在list上的方法,sorted可以对所有可迭代的队形进行排序操作

list的sort方法返回的是对已经存在的列表进行操作,而内建函数sorted 方法返回的是一个新的list,而不是在原来的基础上进行的操作

reverse() # 函数用于反向列表中元素

语法: list.reberse()

返回值: 该方法没有返回值 , 但是会对列表的元素进行反向排序

range() # 函数可创建一个整数列表, 一般用在for 循环中

语法 range(start,stop[, step])

参数:

start : 计数从 start 开始默认是从0开始列入 range(5)等价于range(0,5)

stop : 计数到stop结束 , 但不包括 stop 列如: reange(0,5)是[0,1,2,3,4]没有5

step: 步长,默认为1列如: range(0,5)等价于range(0,5,1)

zip() # 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表如果各个迭代器的元素个数不一致,则返回列表长度于最短对象相同,利用*号操作符,可以将元组解压为列表

语法: zip([iterable,...])

参数: iterabl -- 一个或多个迭代器:

返回值:返回元组列表

如果可迭代对象的元素个数不一样,name按照最少的那个迭代压缩最少元素进行可迭代对象结束后退出

enumerate()

导入OPENPYXL库

代码
import openpyxl
或者是
form openpyxl import Workbook
form openpyxl import load_wrokbook

以上是 Python 基础的全部内容，来源链接： utcz.com/z/389256.html