人工智能程序设计 课件 第2章 Python语法与面向对象程序设计

Python语法与面向对象程序设计Python基础语法·数据类型·控制语句·函数与模块PythonBasicSyntax·DataTypes·ControlStatements·FunctionsandModules

01

02

03

04Python基础语法基本数据类型复杂数据类型控制语句

05函数

06

07

08

09模块和包错误和异常类和对象文件读写

10PEP编码规范2.1.1标识符和变量2.1.2行和缩进2.1.3多行语句与单行多条语句2.1.4注释2.1.5引号2.1.6空行2.1

Python基础语法本节学习内容2.1.1标识符和变量在Python中，标识符是用于给变量、函数、类、模块等编程元素命名的字符序列。它由字母（大小写均可）、数字和下划线组成，不过不能以数字开头，且不能是Python的关键字。同时，Python对标识符大小写敏感，规范的命名有助于提升代码的可读性与可维护性。标识符的边界•标识符用于为变量、函数、类和模块命名。•可以由字母、数字和下划线组成，但不能以数字开头。•Python区分大小写，同一单词的大小写变化会形成不同名称。Code01student_name="Lin"02Student_name="Wang"关键字检查•标识符不能使用Python保留字。•

keyword.kwlist

可以查看当前版本的关键字集合。•输出页应把关键字列表视为程序运行结果，而不是新的代码。Code01fromkeywordimportkwlist02print(kwlist)Python中标识符的命名为：第一个字符必须是字母表中的字母或下画线（_），标识符的其他部分可以包含字母、数字和下画线。此外，需要注意：在Python中标识符对大小写敏感，且标识符的名称不能和系统的保留字相同。Python的标准库提供了一个keyword模块，可以输出当前版本中的所有保留字：这些保留字不能用作变量或任何其他标识符名称。输出01['False','None','True','and','as','assert','async','await','break','class','continue','def','del','elif','else','except','finally','for','from','global','if','import','in','is','lambda','nonlocal','not','or','pass','raise','return','try','while','with','yield']2.1.1标识符和变量在Python中，变量是存储在内存中的值，这就意味着在创建变量时会在内存中开辟一个空间。基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。因此，变量可以指定不同的数据类型，这些变量可以存储整数，浮点数或字符串。Python中的变量赋值不需要类型声明。每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。等号（=）用来给变量赋值。等号运算符左边是一个变量名，等号运算符右边是存储在变量中的值。变量与内存1变量名指向内存中的值。变量与内存2数据类型影响解释器分配的空间和可存储的数据。变量与内存3同一变量名可以在不同时间绑定不同类型的值。2.1.1标识符和变量下面示例中，18，100.0和"John"分别赋值给age，score，name变量。三种数据的赋值•整数、浮点数和字符串可以分别绑定到不同变量。•

print

按变量当前绑定的值输出。•代码与输出需要成组阅读。Code01age=18#整数02score=100.0#浮点数03name="John"#字符串04print(age)05print(score)输出011802100.003John06print(name)2.1.1标识符和变量赋值方式与错误•链式赋值让多个变量得到同一个值。•多变量赋值按位置把不同值绑定到不同变量。•未定义变量在使用时会触发

NameError

。Code01a=b=c=102d=e=a03name,age,score="John",18,100.004print(n)0506#运行结果07NameError:name'n'isnotdefinedPython允许同时为多个变量赋值。例如：第一行将变量a，b，c的值设置为1。第二行将变量d和e的值设置为变量a的值。此外，还可以同时为多个变量分别赋予不同的值。如果变量未被定义（分配值），直接使用它将会得到一个错误。语法2.1.1标识符和变量2.1.2行和缩进Python最具特色的一点，便是运用缩进来界定代码块，这与其他不少语言借助大括号({})的方式截然不同。在Python里，处于同一个代码块的语句，其缩进空格数必须保持一致。在右侧代码中，if条件成立时，后续的两条print语句都有相同的缩进，它们共同构成了if条件为真时要执行的代码块。由于条件永远为False，运行这段代码，程序不会输出任何结果。Code01ifFalse:02

print("Hello")03

print("Python")1缩进不是排版习惯，而是Python的语法2同一代码块中的语句必须保持缩进一致。这个示例中，if条件仍然不成立，因此缩进代码块不会执行。缩进对比•

ifFalse

不进入代码块，因此不会执行缩进后的语句。•同一代码块中的语句必须保持相同缩进。•输出结果要结合条件真假进行解释。Code01ifFalse:02

print("Hello")03print("Python")0405#运行结果06Python2.1.2行和缩进2.1.3多行语句与单行多条语句三种续写方式•反斜杠可以把一条长语句延续到下一行。•列表、字典和括号内的多行表达式通常不需要反斜杠。•分号可以在同一行分隔多条语句。Code01a=123456+\当以反斜杠结尾时，在下一行可以继续写这条语句。但是，在[]、{}或()中的多行语句，不需要使用反斜杠。例如：Python可以在同一行中使用多条语句，语句之间使用分号分割。语法02numbers=[030,1,2,3,4,045,6,7,8,9,05]06x=0;y=1;s=x+y0712345678902.1.4注释在Python中，有单行注释和多行注释。其中单行注释以#开头，可以单独一行，也可以写到代码之后。例如：多行注释用3个单引号（'''）或者三个双引号（"""）将注释引起来。例如：Code01#这是一个注释02print("Hello")#这句代码的作用是显示字符“Hello”03'''04这是第一行注释，使用单引号05这是第二行注释，使用单引号06'''071字符串用于表示文本数据2引号决定字符串边界，转义字符表示特殊含义2.1.5引号Python可以使用引号(')、双引号(")、三引号('''或""")来表示字符串，引号的开始与结束必须是相同类型的。其中三引号可以由多行组成，是编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。使用规则•字符串用于表示文本数据。•引号决定字符串边界，转义字符表示特殊含义。•下标、切片和格式化用于读取或组织字符串内容。Code01"""02这是第一行注释，使用双引号03这是第二行注释，使用双引号04"""05char='c'07paragraph="""这是一个段落。08包含了多个语句"""06sentence="这是一个句子。"2.1.6空行Code函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。空行也是程序代码的一部分。01deffunc1():#这是一个功能函数02

print("Hello")0304deffunc2():#

这是另一个功能函数05print(“world")2.2.1基本数据类型简介2.2.2运算符2.2.3键盘输入2.2.4浮点算数的限制2.2

基本数据类型本节学习内容2.2.1基本数据类型简介Python定义了一些基本数据类型，用于存储各种类型的数据，包括整数（int）、浮点数（float）、布尔（bool）、复数（complex）。此外，还有一种特殊的类型，为None。例如，学生的年龄可以用整数来存储，成绩可以用浮点数（小数）来存储，考试是否合格可以用布尔值（是或否）来存储。整数为不具有小数部分的数字，例如2、4、20。具有小数部分的数为浮点数，例如5.0，1.6。复数由实数部分和虚数部分构成，可以用a+bj，或者complex(a,b)表示。复数的实部a和虚部b都是浮点型。布尔仅包含True和False，分别表示真和假。像大多数语言一样，数值类型的赋值和计算都是很直观的。Python3中内置的type()函数可以用来查询变量所指的数据类型。Code01a,b,c,d=18,99.5,True,4+3j02print(type(a))03print(type(b))04print(type(c))05输出01print(type(d))02<class'int'>03<class'float'>04<class'bool'><class'complex'>2.2.2运算符在Python中，运算符是一种特殊的符号，用于对操作数进行特定的运算操作。它允许程序执行各种数学、逻辑、比较等运算，以实现对数据的处理和操作。例如，通过算术运算符可以进行基本的数学运算，如加法、减法、乘法、除法等；通过比较运算符可以比较两个值的大小关系，如大于、小于、等于、不等于等；通过逻辑运算符可以对布尔值进行逻辑运算，如与、或、非等。不同类型的运算符具有不同的功能和优先级，合理使用运算符能够让程序员灵活地处理各种数据和控制程序的流程。2.2.2运算符Python语言支持以下类型的运算符：算术运算符、比较（关系）运算符、赋值运算符、逻辑运算符、位运算符、成员运算符、身份运算符。Code01a=2+202print(a)#输出403b=50-5*604print(b)#输出200506c=5+5**207print(c)#输出3008d=(c-b)*a09print(d)#输出402.2.2运算符从最高到最低优先级的所有运算符运算符作用**指数运算~，+，-按位取反，正号和负号*，/，%，//乘，除，取余和整除+，-加法，减法>>，<<向右移位，向左移位&按位与^，|异或，按位或<=，<，>，>=小于等于，严格小于，严格大于，大于等于==，!=等于、不等于=，%=，/=，//=，+=，-=，*=，**=赋值运算符is，isnot身份运算符in，notin成员运算符not，or，and逻辑运算符2.2.2运算符运算说明表达式运算结果x+yx和y的和x-yx和y的差x*yx和y的乘积x/yx和y的商（浮点数）x//yx和y的商（整数）x%yx/y的余数-xx取反+xx不变2.2.2运算符运算说明abs(x)x的绝对值或大小int(x)将x转换为整数float(x)将x转换为浮点数complex(re,im)一个带有实部re和虚部im（默认为0）的复数c.conjugate()复数c的共轭divmod(x,y)(x//y,x%y)pow(x,y)x的y次幂x**yx的y次幂2.2.2运算符Code0102030405e=(50-5*6)/406print(e)#输出5.007f=1+1!=2#判断1+1的结果是否不等于2，由于!=的优先级大于=，所以先比较结果再赋值08print(f)#输出False09g=2**4==4**2#判断2的4次方和4的2次方是否相等，==的优先级大于=，先比较结果后赋值1011print(g)#输出True1213h=2>=3-1>1#判断是否2大于等于3-1且3-1大于11415print(h)#输出True2.2.2运算符除法（/）总是返回浮点数。如果要得到整数结果，可以使用//运算符；如果要计算余数，可以使用%运算符：Code01a=17/302print(a)#输出5.66666666666666703b=17//3#整除将丢弃小数部分04print(b)#输出505c=17%3#将得到17对3的余数06print(c)#输出2三种除法结果

/

总是返回浮点数，即使两个操作数都是整数。

//

保留整除结果的商，

%

保留除法余数。观察一组代码时，应同时比较商、余数和数据类型。2.2.2运算符Code0102a=4*3.75-103print(a)#输出14.004a=305a+=4#等价于a=a+406print(a)#输出707a-=5#等价于a=a-5当整数和浮点数进行运算时，得到的结果为浮点数赋值运算符可以与这些算数运算符结合a**=4#等价于a=a**4print(a)#输出1608092.2.2运算符布尔类型是整数的子类，True和False可以和数字进行运算，运算时，True被视为1，False被视为0：Code010203a=True+104print(a)#输出205b=False==006print(b)#输出True07c=(1+2==3)+(False<=0)08print(c)#输出2#说明：1+2==3的结果为True，表达式False<=0中，False被当作0来运算，因此结果也为True#最终，c的值为True+True，其中True被当作1来运算，所以c的值为22.2.2运算符not运算符用于将bool值取反，例如notTrue的结果为False，notFalse的结果为True。当数据参与逻辑运算时（包括not，or和and）会被视为布尔值进行运算。具体的，程序会将以下值视为False：None、False、0、0.0、0j、空序列（如''、()、[]、{}、set()、range(0)），其他值一律视为True。Code010203a=notnotTrue04print(a)#输出True05b=not(3>=2)#判断3是否不大于等于2print(b)#输出Falsec=not1#1被视为True进行运算print(c)#输出False062.2.2运算符Code0102030405a=TrueandFalse06print(a)#输出False07b=TrueorFalseand运算符用于计算两个布尔值的逻辑与。只有当两个布尔值都为True时，计算结果才为True，否则计算结果为False。or运算符用于计算两个布尔值的逻辑或。只有当两个布尔值都为False时，计算结果才为False，否则计算结果为True。c=(1+1>2)or(1+1<=2)print(c)#输出True，相当于FalseorTrue2.2.2运算符在Python中，对于表达式xandy，如果x的值为True，则计算结果为y的值；如果x的值为False，则计算结果为x的值，程序不会再计算y的值；对于表达式xory，如果x的值为False，则计算结果为y的值；如果x的值为True，则计算结果为x的值，程序不会再计算y的值。Code010203a=0and2**1000000004print(a)#输出005b=1and3+406print(b)#输出7c=1+1or1print(c)#输出2课外知识点•计算2的10000000次方是一个极其消耗计算资源和内存的操作，如果真去计算，程序可能会卡死甚至内存溢出。但由于and运算符遇到了0（视为False），触发了短路求值，程序根本没有去执行后面的庞大计算，而是瞬间把0赋给了a2.2.2运算符Python支持连续的运算符比较对于下面的连续比较语句，如果a<b的结果为False，那么程序将不会继续比较后面的b==c<d，而是直接给出结果为FalseCode0102a<b==c<d03a<bandb==candc<d04课外知识点•

在连续比较中，中间的表达式只会被计算一次•“如果a<b的结果为False，程序将不会继续比较...”，这在计算机科学中被称为短路求值2.2.2运算符位运算只对整数有意义。计算按位运算的结果，就相当于使用无穷多个二进制符号位对二的补码执行操作。二进制按位运算的优先级全都低于数字运算，但又高于比较运算；一元运算~具有与其他一元算术运算(+and-)相同的优先级。下表是以优先级升序排序的按位运算列表:可以使用input函数从键盘获取输入，这样就可以计算用户想要的内容了。下面的代码实现了计算用户输入的两个数的和的功能。注意，input函数获取的输入是字符串，需要转换为int或float才能进行数字运算。优先级升序排序的按位运算列表运算结果x|yx和y按位或x^yx和y按位异或x&yx和y按与x<<nx左移n位，相当于x*pow(2,n)x>>nx右移n位，相当于x//pow(2,n)~xx按位取反2.2.3键盘输入Code01a=input("输入第一个数：")02b=input("输入第二个数：")03c=float(a)+float(b)04print("两数之和为：",c)05可以使用input函数从键盘获取输入，这样就可以计算用户想要的内容了。下面的代码实现了计算用户输入的两个数的和的功能。注意，input函数获取的输入是字符串，需要转换为int或float才能进行数字运算。如果忘记转换类型，会发生什么？•

如果在代码第03行，没有使用float()，而是直接写成c=a+b程序并不会报错，但结果会出乎意料。如果你输入了1和2，因为它们是字符串，Python会执行字符串拼接操作，而不是数学加法，最后会打印12。2.2.4浮点算数的限制浮点数在计算机硬件中是以基数为2的小数来表示的，即二进制表示。例如，十进制小数0.625的值为6×10-1+2×10-2+5×10-3，而同样的二进制小数0.101的值为1×2-1+0×2-2+1×2-3。这两个小数具有相同的值，唯一的区别在于第一个写成了基数为10的小数形式，而第二个则写成的基数为2的小数形式。不幸的是，大多数的十进制小数都不能精确地表示为二进制小数。这导致在大多数情况下，十进制浮点数都只能近似地以二进制浮点数形式储存在计算机中。用十进制来理解这个问题显得更加容易一些。考虑分数1/3，它在十进制下的一个近似值为0.3，更近似的值为0.33，或者可以使用更加近似的值0.33。以此类推，无论写下多少小数，它都永远不会等于1/3，只是更加接近1/3。同理，无论使用多少位以2为基数的数码，十进制的0.1都无法精确地表示为一个以2为基数的小数。在以2为基数的情况下，十进制分数1/10是一个无限循环小数Code010.0001100110011001100110011001100110011001100110011...022.2.4浮点算数的限制无论在哪一个位置停下，都只能得到一个近似值。因此，在今天的大部分架构上，浮点数都只能近似地使用二进制小数表示，对应分数的分子使用每8字节的前53位表示，分母则表示为2的幂次。在1/10这个例子中，相应的二进制分数是3602879701896397/2**55，它很接近1/10，但并不是1/10。由于值的显示方式大多数用户都不会意识到这个差异的存在。Python只会打印计算机中存储的二进制值的十进制近似值。在大部分计算机中，如果Python要把0.1的二进制值对应的准确的十进制值打印出来，将会显示成这样：Code01020.10000000000000000555111512312578270211815834…2.2.4浮点算数的限制有趣的是，有许多不同的十进制数共享相同的最接近的近似二进制小数。例如，右侧的小数全都近似于3602879701896397/2**55。Code0102a=0.103b=0.1000000000000000104c=0.1000000000000000055511151231257827021181…print(a==b==c)#输出True2.2.4浮点算数的限制因此，在计算机中，0.1并非真正的1/10，所以将三个0.1的值相加也无法恰好得到0.3。此外，由于这个0.1无法精确表示1/10，而0.3也无法精确表示3/10的值，因此使用round函数进行预先舍入也是没用的：Code01print(0.1+0.1+0.1==0.3)#输出False02print(round(0.1,1)+round(0.1,1)+round(0.1,1)==round(0.3,1))#输出False03小结三个近似的0.1相加，结果可能不等于近似的0.3。对显示结果做round()不会消除底层二进制表示误差。浮点数比较不能简单依赖==判断数学上的相等。2.2.4浮点算数的限制Code0102frommathimportisclose03print(isclose(0.1+0.1+0.1,0.3))#输出True04虽然这些数字无法精确表示其所要代表的实际值，但是可以使用math库中的isclose函数来进行不精确的值比较使用isclose比较浮点数math.isclose()用容差判断两个浮点数是否足够接近。它表达的是工程上的“可接受误差内相等”，不是改变浮点数存储值。对计算结果进行比较时，应根据问题场景选择合适的容差。round()仍有误差isclose()2.3.1字符串2.3.2列表2.3.3元组2.3.4集合2.3.5字典2.3.6序列比较2.3

复杂数据类型本节学习内容2.3.1字符串Python可以操作文本，包括字符、单词、句子等。在Python中处理文本数据是使用字符串类型。字符串是由Unicode码位构成的不可变序列。字符串需要用单引号（'...'）或双引号（"..."）括起来，单引号和双引号的效果是相同的，没有区别。如果要在字符串中表示引号，可以使用转义字符，常见的转义字符有：\'：表示单引号Code01a='Python'02b="Helloworld!"03c='123456789'04print(a,b,c)05#输出PythonHelloworld!123456789字符串的基本属性字符串是由Unicode码位组成的不可变序列。单引号和双引号都可以界定字符串，二者基本作用相同。反斜杠引出转义字符，用于表示引号等特殊字符。2.3.1字符串Code01a='doesn\'t'#注意：如果不使用转义字符将会报错02print(a)#输出doesn't03b="doesn't"04print(b)#输出doesn't05\"：表示双引号\n：表示换行符\t：表示制表符当字符串使用两个单引号括起来时，字符串中的单引号需要使用转义字符表达，字符串中的双引号则可以直接表达。同样，当字符串使用两个双引号括起来时，字符串中的双引号需要使用转义字符表达，字符串中的单引号则可以直接表达。转义字符的语境\n表示换行，\t表示制表，'和\"用于在字符串中保留引号。外层使用单引号时，内部双引号通常可以直接写入；反之亦然。转义规则取决于字符串边界和反斜杠的位置。\n\t\"/\'2.3.1字符串如果不希望前缀为\的字符被解释为转义字符，可以通过在第一个引号前添加r来使用原始字符串：Code01020304print('C:\dlut\name')#输出两行，第一行为C:\some第二行为ameprint(r'C:\dlut\name')#输出一行，为C:\some\name原始字符串前缀r让反斜杠按普通字符处理，不主动解释为转义序列。原始字符串适合表示路径、正则表达式等包含大量反斜杠的文本。r只改变字符串字面量的解析方式，不改变字符串仍然是不可变序列这一属性。2.3.1字符串字符串可以用+运算符拼接，并用*运算符重复：两个或多个相邻的用引号表示的字符串会自动连接：Code01a=3*'un'+"itm"02print(a)#unununitm03a='Py'"thon"04print(a)#输出Python05b=("Hello""world")print(b)#输出Helloworld0607字符串拼接与重复+按顺序连接两个字符串，*按次数重复字符串。相邻的字符串字面量可以自动连接，适合拆分长文本。拼接操作要求参与运算的对象都是字符串，不能直接把数字与字符串相加。2.3.1字符串Code01word="Python"02print(word[0])#输出P03print(word[-1])#输出n04print(word[5])#输出n05print(word[6])#报错：IndexError:stringindexoutofrange字符串是一个字符的序列，可以通过索引访问其中的每一个字符。索引可以分为正向索引和反向索引。索引的语法为str[index]，其中str为字符串变量，index为整数，表示索引（下标）。当index为非负整数时，表示正向索引。在正向索引中，第一个字符的索引为0。例如，假设字符串s的值为"Python"，则s[0]的值为'P'，s[5]的值为'n'。当index为负整数时，str[index]的值为str中倒数第-index个字符。例如，s[-1]的值为'n'，s[-6]的值为'P'。值得注意的是，当索引超出范围时，会抛出IndexError错误。字符串索引正向索引从0开始，负向索引从-1表示最后一个字符。索引一次取得一个字符，越界会引发IndexError。通过索引读取字符不会改变原字符串。2.3.1字符串字符串可以被截取（切片），字符串截取是通过索引从字符串中提取子字符串。截取的语法为str[start:stop:step]，其中str为字符串变量，start，stop，step均为整数，分别表示起始索引（含）、终止索引（不含）和步长。其中，索引为stop的字符不会被包含在截取的字符串中，且:step可以被省略。如果:step被省略，则step的值为默认值1。下面的示例演示了字符串的基本截取操作，截取出的字符串从索引start开始，直到索引stop（不包含stop），截取的步长为step。当step为负数时，表示从右向左截取。Code01text="Hello,World!"02print(text[0:9:2])#输出Hloo03print(text[7:12])#输出World04print(text[12:7:-1])#输出dlro05print(text[::-1])#输出!dlroW,olleH字符串切片切片使用start:stop:step，包含start，不包含stop。省略step时默认按1递增；负step表示反向截取。切片得到新的子字符串，不会修改原字符串。2.3.1字符串另外，如果制定的start或stop超出字符串的范围，Python不会报错，而是取实际范围。Python字符串不能被更改，因此，通过索引为字符串赋值会导致错误。例如，对于上面的字符串text，如果运行语句text[0]=‘h’，将会报错TypeError。不可变性与越界start或stop超出范围时，切片会自动取实际可用范围。字符串不能通过索引位置直接赋值。text[0]='h'的失败原因是字符串不可变，而不是索引语法错误。Code01text="Hello,World!"02print(text[-50:5])#输出Hello03print(text[5:50])#输出,World!04#text[0]="h"#TypeError：字符串不可变2.3.1字符串使用内置函数len可以返回字符串的长度：标注了f或F前缀的字符串被称为格式字符串字面值（f-string），这种字符串可以包含以{}标注的表达式。称被{}标注的表达式为替换表达式。格式字符串字面值是可以在运行时求值的表达式。长度与f-stringlen()返回字符串包含的字符数量。f-string用{}标出运行时求值的替换表达式。长度计算和格式化分别解决“有多少字符”和“如何呈现”的问题。Code01text="Hello,World!"02print(len(text))#输出1303s=f"2024isthe{2024-1949}thanniversaryofthePRC."04print(s)#输出2024isthe75thanniversaryofthePRC.2.3.1字符串替换表达式的计算花括号中的year-1949会在构造字符串时先计算，再替换到对应位置。f-string可以把变量值和计算结果直接嵌入同一段文本。print(s)输出的是已经完成替换后的新字符串。Code01year=202402s=f"{year}isthe{year-1949}thanniversaryofthePRC."03print(s)04#输出2024isthe75thanniversaryofthePRC.2.3.1字符串替换表达式中可以包含注释，替换表达式内#后面的所有内容都是注释（包括结尾花括号和引号）。在这种情况下，替换字段必须在另一行中结束。注意：在Python3.12之前，不允许在格式字符串字面值中使用注释。Code01s=f"2024isthe{2024#这里是注释}"02-1949}thanniversaryofthefoundingofthePRC."03print(s)04#输出2024isthe75thanniversaryofthefoundingofthePRC.05替换字段中的注释Python3.12起，替换表达式内可以使用#添加注释。#后的内容会一直注释到该物理行结束，因此右花括号必须另起一行。Python3.12之前的f-string不支持在替换字段中写注释。2.3.1字符串格式说明符的作用.3f表示以固定小数形式显示，并保留小数点后三位。:10和:10d为字段设置最小宽度，便于把多行输出排成整齐的列。格式说明符只影响显示结果，不会改变变量pi、year1等保存的原始值。Code01pi=3.141592602print(f'Thevalueofpiisapproximately{pi:.3f}.')03#Thevalueofpiisapproximately3.142.04name1,year1='HongKong',199705name2,year2='Macau',199906可以在表达式后面增加格式说明符，从而更好地控制格式化值的方式。下例将小数舍入到小数点后三位：在

:

后传递整数，为该字段设置最小字符宽度，常用于列对齐：print(f'{name1:10}==>{year1:10d}')print(f'{name2:10}==>{year2:10d}')HongKong==>1997Macau==>19990708092.3.1字符串等号说明符（=）可被用于将一个表达式扩展为表达式文本、等号再加表达式求值结果的形式，但仅限于Python3.8及以上版本。Code010203print(f'Info:{country=}{area=}{unit=}')#输出Info:country='China'area=9.6unit='millionsquarekilometers'country,area,unit='China',9.6,"millionsquarekilometers"等号说明符{表达式=}同时展示表达式文本和表达式求值结果。该写法适用于Python3.8及以上版本。它便于调试变量值，但不等同于普通赋值语句中的等号。2.3.1字符串除了使用f-string之外，也可以使用str.format()方法实现格式字符串。调用此方法的字符串可以包含字符串字面值或者以花括号{}括起来的替换域。每个替换域可以包含一个位置参数的数字索引，或者一个关键字参数的名称。返回的字符串副本中每个替换域都会被替换为对应参数的字符串值。当替换域中的参数被省略时，将以出现的顺序依次默认从0开始填充str.format的替换域str.format()使用花括号标记替换域，再由位置参数或关键字参数提供值。省略参数索引时，替换域按出现顺序从0开始匹配。该方法与f-string都能格式化文本，但表达式写法和求值时机不同。Code01print("2024isthe{}thanniversaryofthePRC.".format(2024-1949))02#输出2024isthe75thanniversaryofthePRC.03year=202404age=year-194905print("{}isthe{}thanniversaryofthePRC.".format(year,age))06#输出2024isthe75thanniversaryofthePRC.2.3.1字符串编号参数的映射{0}读取format()的第一个位置参数，{1}读取第二个位置参数。编号写在替换域中，可以让文本中的显示顺序与实参传入顺序不同。本例把age传在第一位、year传在第二位，再通过{1}、{0}调换显示顺序。Code01year=202402age=year-194903print("{1}isthe{0}thanniversaryofthePRC.".format(age,year))04#输出2024isthe75thanniversaryofthePRC.2.3.1字符串位置参数编号{0}对应format()的第一个位置参数，{1}对应第二个位置参数。通过编号可以改变参数填入文本的顺序，而不必改变format()中实参的顺序。本例中age填入{0}，year填入{1}，所以输出仍先显示年份。Code01year=202402age=year-194903print("{1}isthe{0}thanniversaryofthePRC.".format(age,year))04#{0}取第一个实参age；{1}取第二个实参year05#输出2024isthe75thanniversaryofthePRC.2.3.1字符串位置参数和关键字参数可以组合使用：混合使用参数位置参数依次填入未指定名称的替换域。关键字参数通过名称定位替换域，名称必须与字段一致。组合使用时应先检查参数顺序，再检查关键字名称。Code01year=202402age=year-194903print("{y}isthe{n}thanniversaryofthePRC.".format(y=year,n=age))04#输出2024isthe75thanniversaryofthePRC.2.3.1字符串允许有多个位置使用同一个参数：Code01year=202402age=year-194903print("{0}isthe{n}thanniversaryofthePRC.".format(year,n=age))04#输出2024isthe75thanniversaryofthePRC.2.3.1字符串同一参数可重复使用一个位置参数可在多个替换域中重复引用，例如{1}可以出现两次。重复引用不会要求重复传入实参，两个{1}都读取同一个age值。关键字参数同样可以重复使用，并能直接传入计算表达式的结果。Code01year,age=2024,7502print("{0}marksthe{1}thanniversaryofthePRC"03"andthe{1}thanniversaryofDUT.".format(year,age))04print("{y}marksthe{n}thanniversaryofthePRC"05"andthe{n}thanniversaryofDUT.".format(y=year+1,n=age+1))2.3.1字符串两个输出的含义第一行使用year=2024、age=75，两个{1}都显示第75周年。第二行传入year+1、age+1，因此年份和周年数同时增加1。对照两行结果可验证：同一替换域可以在一句文本中重复出现。Code01year,age=2024,7502print("{0}marksthe{1}thanniversaryofthePRC"03"andthe{1}thanniversaryofDUT.".format(year,age))04#2024isthe75thanniversaryofthePRCandthe75thanniversaryofDUT.05print("{y}marksthe{n}thanniversaryofthePRC"06"andthe{n}thanniversaryofDUT.".format(y=year+1,n=age+1))07#2025isthe76thanniversaryofthePRCandthe76thanniversaryofDUT.2.3.1字符串字符串具有一种特殊的内置操作，即%(取余)运算符。这也被称为字符串的格式化运算符或插值运算符。对于给定的string%values，在string中的%转换标记符将被替换为零个或多个values中的元素（其效果类似于在C语言中使用printf函数）。如果string要求一个单独参数，则values可以为一个非元组对象。否则，values必须是一个包含项数与格式字符串中指定的转换符项数相同的元组，或者是一个单独映射对象。Code01age=2024-194902print("2024isthe%dthanniversaryofthePRC."%age)03#输出2024isthe75thanniversaryofthePRC.百分号格式化%左侧是格式字符串，右侧提供要替换的值。单个值可以直接传入，多个转换标记通常需要元组或映射对象。格式标记的数量和右侧参数数量必须匹配。2.3.1字符串当右边的参数为一个字典（或其他映射类型）时，字符串中的格式必须包含加圆括号的映射键，对应'%'字符之后字典中的每一项。映射键将从映射中选取要格式化的值。Code01data={"country":"PRC","year":2024,"age":2024-1949}02print("%(year)disthe%(age)dthanniversaryofthe%(country)s."%data)03#输出2024isthe75thanniversaryofthePRC.映射键与转换符映射格式使用%(键名)转换符，例如%(year)d、%(country)s。右侧字典必须提供对应键，格式化时按键名取值而不是按位置取值。d用于整数、s用于字符串，键名或类型不匹配都会导致格式化失败。2.3.1字符串转换符含义%d有符号十进制整数%i有符号十进制整数%o有符号八进制整数%x有符号十六进制整数（小写）%X有符号十六进制整数（大写）%e浮点指数格式（小写）%E浮点指数格式（大写）%f浮点十进制格式%F浮点十进制格式%s字符串按数据类型选择转换符整数进制浮点文本2.3.1字符串%o形式会在第一个数码之前插入标示八进制数的前缀('0o')；%x形式会在第一个数码之前插入'0x'前缀；%X形式会在第一个数码之前插入'0X'前缀；%f或%F形式总是会在结果中包含一个小数点，即使其后并没有数码，小数点后的数码位数由精度决定，默认为6；由于Python字符串显式指明长度，%s转换不会将'\0'视为字符串的结束。小结%o、%x、%X分别用于八进制和两种大小写的十六进制表示。%f总是保留小数点，并可通过精度控制小数位数。%s按字符串形式转换内容，不把\0当作结束标记。2.3.1字符串使用%d形式转换整数时，可以指定整数的长度，例如%02d表示将转换的整数长度为2，不足2的部分将使用0补齐。使用%f形式转换浮点数时，可以指定浮点数的小数位数，例如%.2f表示保留2位小数。这种方式同样适用于format方法：Code01time=48502print("time:%02d:%02d"%(time//60,time%60))#输出time:08:0503print("time:{:02d}:{:02d}".format(time//60,time%60))#输出time:08:0504格式化宽度与精度%02d把整数显示为至少两位，不足部分用0补齐。%.2f把浮点数显示为两位小数。宽度控制对齐，精度控制小数位数；二者都影响显示而不改变原值。2.3.2列表字符串实现了所有一般的序列操作，还额外提供了一些附加方法。下表列出了一些常用的字符串方法，调用时，被方括号括起来的参数可以省略。列表是Python中使用最频繁的数据类型之一，它可以写成方括号之间逗号分隔的值的组合。列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，可以是数字，字符串甚至可以包含列表（即嵌套列表）。列表与字符串的共同点列表和字符串都属于序列，支持索引和切片等一般序列操作。列表用方括号和逗号分隔元素，元素类型可以不同。列表还能嵌套列表，适合表达更复杂的数据结构。2.3.2列表查找/判断str.capitalize()：首字符大写str.center(width[,fillchar])：居中填充str.count(sub[,start[,end]])：统计出现次数str.endswith(suffix[,start[,end]])：判断后缀str.find(sub[,start[,end]])：查找，失败返回-1str.format(*args,**kwargs)：返回格式化字符串str.index(sub[,start[,end]])：查找，失败报错str.isalpha()：判断字母大小写/拆分str.islower()：判断小写str.isnumeric()：判断数值字符str.isspace()：判断空白str.isupper()：判断大写str.join(iterable)：连接字符串序列str.lower()：转小写str.partition(sep)：按分隔符拆成三段str.removeprefix(perfix)：移除前缀替换/清理str.removesuffix(suffix)：移除后缀str.replace(old,new[,count])：替换子串str.split([sep[,maxsplit]])：判断空白str.splitlines([keepends])：按行拆分str.startswith(suffix[,start[,end]])：判断前缀str.strip([chars])：去除首尾字符str.swapcase()：转小写str.upper()：转大写2.3.2列表下面的代码用于定义一个列表，里面包含了11个元素。和字符串（以及所有其他内置序列类型）一样，列表可以被索引和切片。Code01squares=[0,1,4,9,16,25,36,49,64,81,100]02print(squares[1])#输出103print(squares[-1])#输出10004print(squares[4::5])#输出[16,81]05列表的序列操作列表可以像字符串一样按索引访问元素，也可以进行切片。+可以连接列表，结果仍然是列表。索引定位单个元素，切片取得一个新的子列表。2.3.2列表列表还支持拼接操作：Code01squares=[0,1,4,9,16,25]+[36,49,64]02print(squares)#输出[0,1,4,9,16,25,36,49,64]03squares+=[81,100]04print(squares)#输出[0,1,4,9,16,25,36,49,64,81,100]05拼接与嵌套入口+会生成拼接后的新列表，+=会把右侧元素追加到原列表末尾。列表中的元素类型不要求一致，可以同时包含数字、字符串和列表。当元素本身也是列表时，就形成了嵌套列表结构。2.3.2列表列表中元素的数据类型可以不同，甚至可以包含列表：与不可变的字符串不同，列表是一种可变类型，可以更改其内容。Code01x=[[1,2,3],4,5,'678']02print(x[0])#输出[1,2,3]03print(x[1])#输出404print(x[-1])#输出67805print(x[0][1])#输出206print(x[3][:-1])#输出6707squares=[0,1,2,9,16,25,36,49,64,81,100]08squares[3]=409print(squares)#输出[0,1,2,4,16,25,36,49,64,81,100]嵌套访问与可变性嵌套列表需要连续下标访问，例如x[0][1]先取子列表再取元素。字符串元素也可以继续切片，例如x[3][:-1]得到'67'。列表是可变对象，可通过索引赋值直接修改指定位置的值。2.3.2列表除了使用+=，还可以使用list.append方法在列表末尾添加新项目。两者的区别是，+=是添加列表中所有的元素，而append方法的参数是需要添加的一个元素。+=与append的区别+=把右侧列表中的多个元素逐个加入左侧列表。append()把参数作为一个整体元素追加到列表末尾。当参数本身是列表时，两种写法产生的嵌套结构不同。Code01items=[1,2]02items+=[3,4]03print(items)#输出[1,2,3,4]04items.append([5,6])05print(items)#输出[1,2,3,4,[5,6]]06cubes=[0,1,2,9,16,25,36,49,64,81,100]07cubes.append(11**2)08print(cubes)#输出[...,100,121]2.3.2列表对列表的简单赋值不会拷贝数据。把列表分配给变量时，该变量会引用现有列表。而切片操作会对列表进行拷贝。引用与复制简单赋值只建立新的列表引用，不会复制元素。切片会产生一个新的列表副本。修改原列表时，应先判断另一个变量保存的是引用还是切片副本。Code01squares1=[0,1,2,9,16,25,36,49,64,81]02squares2=squares103squares2.append(100)04print(squares2)#输出[0,1,2,9,16,25,36,49,64,81,100]05print(squares1)#

输出[0,1,2,9,16,25,36,49,64,81,100]2.3.2列表列表引用的观察方法对照赋值前后的两个变量，观察它们是否指向同一列表。对照切片产生的新列表，观察修改是否相互影响。运行结果应重点验证“共享引用”和“独立副本”的区别。Code01squares1=[0,1,2,9,16,25,36,49,64,81,100]02squares3=squares1[:]03squares3.append(11**2)04print(squares3)#输出[0,1,2,9,16,25,36,49,64,81,100,121]05print(squares1)#

输出[0,1,2,9,16,25,36,49,64,81,100]2.3.2列表为切片赋值可以改变列表大小，甚至清空整个列表：切片赋值切片赋值可以一次替换一段元素。右侧元素数量与被替换片段数量不必相同，因此列表长度可以变化。使用空切片赋值可以插入元素，使用空列表可以删除片段。Code01squares=[0,1,2,9,16,25,36,49,64,81,100]02print(len(squares))#输出1103squares[5:]=[25,36]04print(squares)#输出[0,1,2,9,16,25,36]05squares[1:3]=[]06print(squares)#输出[0,9,16,25,36]07squares[:]=[]08print(squares)#输出[]2.3.2列表如果要根据索引删除列表中的值，可以使用del语句。del语句还可用于从列表中删除切片或清除整个列表。Code01squares=[0,1,2,9,16,25,36,49,64,81,100]02delsquares[0]#删除索引为0的元素03print(squares)#输出[1,2,9,16,25,36,49,64,81,100]04delsquares[-1]#删除最后一个元素05print(squares)#输出[1,2,9,16,25,36,49,64,81]del删除列表内容del可以删除单个索引位置，也可以删除一个切片。删除整个列表后，原变量名不再指向该列表。del修改的是列表结构，不返回被删除的元素。2.3.2列表列表删除操作的对照按索引删除适合已知位置的元素，按值删除适合已知内容的元素。删除切片可以一次移除连续范围。阅读输出时注意删除操作是否改变了原列表长度和剩余顺序。Code01squares=[0,1,2,9,16,25,36,49,64,81,100]02delsquares[0]#删除索引为0的元素03print(squares)#输出[1,2,9,16,25,36,49,64,81,100]04delsquares[-1]#删除索引为-1的元素05print(squares)#输出[1,2,9,16,25,36,49,64,81]06delsquares[5:8]#删除切片07print(squares)#输出[1,2,9,16,25,81]2.3.2列表列表支持很多方法，下一页列出了列表对象的常用方法，调用时，被方括号括起来的参数可以省略。注意：insert,remove或sort等仅修改列表的方法的返回值为None。并非所有列表都可以调用sort方法进行排序。例如，[None,'hello',10]就不可排序，因为整数不能与字符串比较而None不能与其他类型比较。此外，还存在一些没有定义顺序关系的类型，例如，3+4j<5+7j就不是一个合法的比较。列表方法示例：Code01delsquares[:]#删除所有元素02print(squares)#输出[]列表方法的返回值insert、remove、sort等方法直接修改列表，通常返回None。sort要求元素之间存在可比较的顺序。混合数字、字符串和None的列表不能直接按普通大小关系排序。2.3.2列表添加/扩展list.append(x)：

末尾追加单个元素list.extend(iterable)：

扩展多个元素list.insert(i,x)：

按位置插入元素list.remove(x)：

按值删除首个匹配项删除/查找list.pop([i])：

弹出并返回元素list.clear()：

清空列表list.index(x[,start[,end]])：

查找元素位置list.count(x)：

统计出现次数排序/复制list.sort([key[,reverse]])：

原地排序list.reverse()：

原地反转list.copy()：

生成浅拷贝2.3.2列表列表方法的观察方式先区分会改变列表的方法和返回新结果的函数或表达式。记录方法调用前后的列表内容，确认修改发生在原对象上。对排序、插入和删除，要同时观察位置变化和返回值。Code01majors=['CV','NLP','NLP','CV','Robotics','CV','CV']02print(majors.count('CV'))#输出403print(majors.count('CS'))#输出004print(majors.index('CV'))#输出005print(majors.index('CV',2))#输出306print(majors.reverse())#输出None07print(majors)#输出['CV','CV','Robotics','CV','NLP','NLP','CV']2.3.2列表列表方法案例本页代码应按方法名称分别观察其输入、对列表的修改和返回值。对同一列表连续调用方法时，后一步使用的是前一步修改后的状态。运行结果既要看列表内容，也要看方法调用表达式本身的输出。Code01majors.sort()02print(majors)03#输出['CV','CV','CV','CV','NLP','NLP','Robotics']04print(majors.pop())#输出Robotics05print(majors)06#输出['CV','CV','CV','CV','NLP','NLP']2.3.3元组列表和字符串有很多共性，例如索引和切片操作。事实上，这两种数据类型都是序列类型。本章将介绍Python中的另一种标准序列类型——元组。元组由多个用逗号隔开的值组成。下面的代码演示了如何定义元组，以及使用索引和切片访问元组中的元素：元组与序列元组和列表、字符串一样属于序列，都支持索引和切片。元组由逗号分隔的多个值组成，通常使用圆括号表示。元组适合表达创建后不希望改变的序列数据。Code01t=1978,'helloworld'02print(t[0])#输出197803print(t)#输出(1978,'helloworld')04u=t,(1,9,4,9)05print(u[1])#输出(1,9,4,9)06print(u[0][1])#输出helloworld2.3.3元组输出时，元组都要由圆括号标注，这样才能正确地解释嵌套元组。输入时，圆括号可有可无，不过经常是必须的（如果元组是更大的表达式的一部分）。不允许为元组中的单个元素赋值，例如对于元组a=(1,2)，语句a[0]=0是不允许的，会触发TypeError。不过，可以创建含列表等可变对象的元组，例如对于元组a=([1,2,3],[3,2,1])，语句a[0][0]=0是合法的，因为这是对列表中的单个元素赋值，而不是元组，语句a[0][:]=[0,1,2]也是合法的，因为这是对列表的切片赋值，而语句a[0]=[0,1,2]是不允许的，因为这是对元组中的单个元素赋值，会触发TypeError。Code01a=([1,2,3],[3,2,1])02#a[0]=[0,1,2]#TypeError：不能改元组元素03a[0][0]=0#合法：修改的是列表内部元素04a[0][:]=[0,1,2]#合法：列表切片赋值05print(a)#输出([0,1,2],[3,2,1])2.3.3元组构造0个或1个元素的元组比较特殊，为了适应这种情况，对语法有一些额外的改变。用一对空圆括号就可以创建空元组；只有一