Python语言的特点

1 : Python是 最接近人类自然语言的计算机语言，语言的 简洁性、易读性及可扩展性常常作为 胶水语言 来组合其他语言编写功能模块，多用于 科学计算、大数据、人工智能、金融科技 等领域。

2 : Python具有 丰富且强大的支持库，通过Python编程采集、加工、整理和分析各种数据，构建人工智能算法从而实现各种智能化应用等。

Python语言的发展

1 : Python是由Guido van Rossum在20世纪80年代末和90年代初，在荷兰国家数学和计算机科学研究所设计出来。

2 : Python本身也由诸多其他语言发展而来，包括ABC、Modula-3、C、C++、ALGOL 68、SmallTalk、UNIX shell和其他脚本语言等。

3 : 像Perl语言一样，Python源代码同样遵循 GPL（GNU General Public License）协议。

4 : 现在Python由一个核心开发 团队在维护，Guido van Rossum仍然占据着至关重要的作用，并指导其发展。2020年，Python 2.7被确定为最后一个Python 2.X版本，它除了支持 Python 2.X语法外，还支持部分Python 3.1语法。

Python基本语法与数据类型

Python语言基本语法

引例：

<code># @Version : 12.1

# @Author : G.Sparrow

# @File : test1.py

# @Time : 2024-07-05 18:27

t = input('请输入带符号的温度值：') # 用键盘输入温度值

if t[-1] in ['F', 'f']:

c = ((eval(t[:-1]) - 32) / 1.8)

print('转换后的温度是{:.2f}C'.format(c))

elif t[-1] in ['C', 'c']:

f = eval(t[: -1]) * 1.8 + 32

print('转换后的温度是{:.2f}F'.format(f))

else:

print("输入格式错误")

其中关于[-1] 和 [: -1]的相关问题

# todo 引例

a='python'code>

b=a[::-1]

print(b) #nohtyp

c=a[::-2]

print(c) #nhy

#从后往前数的话，最后一个位置为-1

d=a[:-1] #从位置0到位置-1之前的数

print(d) #pytho

e=a[:-2] #从位置0到位置-2之前的数

print(e) #pyth

# todo 说明

b = a[i:j] # 表示复制a[i]到a[j-1]，以生成新的list对象

a = [0,1,2,3,4,5,6,7,8,9]

b = a[1:3] # [1,2]

# 当i缺省时，默认为0，即 a[:3]相当于 a[0:3]

# 当j缺省时，默认为len(alist), 即a[1:]相当于a[1:10]

# 当i,j都缺省时，a[:]就相当于完整复制一份a

b = a[i:j:s] # 表示：i,j与上面的一样，但s表示步进，缺省为1.

# 所以a[i:j:1]相当于a[i:j]

# 当s<0时，i缺省时，默认为-1. j缺省时，默认为-len(a)-1

# 所以a[::-1]相当于 a[-1:-len(a)-1:-1]，也就是从最后一个元素到第一个元素复制一遍，即倒序。

1 : 程序的格式框架

Python语言采用严格的“缩进”来表明程序的格式框架。缩进指每一行代码开始前的空白区域，用来表示代码之间的包含与层次关系。不需要缩进的代码顶行编写，不留空白。编写时可用Tab键实现，也可以用多个空格（一般是4个空格）实现，但两者不同混用。

缩进是Python语言中表明程序框架的唯一手段，缩进不正确会导致程序运行错误。

缩进也是表达代码间包含和层次关系的唯一手段。

2 : 注释

       注释就是程序员在代码中加入一行或多行信息，用来对语句、函数、 数据结构等进行说明，提升代码的可读性。注释是辅助说明的文字，会被解释器略去，不被计算机执行。

在Python中有以下两种注释方法。

（1）单行注释：以 # 开头。

<code> #这是单行注释,独占一行

（2）多行注释：以3个单引号开头和结尾。

'''

这是多行注释

不会被执行

print('hello world!')

'''

3 : 变量命名与保留字

Python程序设计中也使用特定的名称（即变量），来保存和表示具体的数据值。

为了更好地使用变量等其他程序元素，需要给它们关联一个标识符，关联标识符的过程称为命名。命名用于保证程序元素的唯一性。

Python的标识符由字母、数字、汉字和下划画线“_”组成，其命名方式需要遵守一定的规则：

（1）对大小写敏感，如Str和str是两个不同的变量名。

（2）变量的首字符不能是数字，变量中间不能出现空格。

（3）不能使用保留字。 保留字，也称为关键字，指被编程语言内部定义并保留的标识符。保留字是编程语言的基本单词，大小写敏感，Python 3.X中共有33个保留字.

4 : 赋值语句

程序中产生或计算新数据值的代码称为表达式，类似数学中的计算公式。

表达式以表达单一功能为目的。

运算后产生运算结果，运算结果的类型由操作符或运算符决定。

Python语言中，“=”表示赋值，可以同时给多个变量赋值，基本格式如下。

1 : 单个变量赋值：先运算右边的表达式，再将表达式的值赋给左侧变量。

<code>a = 5

2 : 多个变量同时赋值：按照顺序将右侧表达式的值赋给左侧变量。

a,b = 5,7

3 : 交换赋值：将两个表达式的值进行交换。

b,a = a,b

常用函数

1 : input ( ) 函数

无论用户在控制台输入什么内容，input（）函数都以字符串类型返回结果，一般将input（）函数的返回结果赋给一个变量。

t=input('请输入带符号的温度值:')

input（）函数中括号里的引号中的文字是一些提示性文字，如果无须提示，则可省略。

注意：无论用户在控制台输入的是数字还是字符，input（）函数统 一按照字符串类型返回。如输入：12.34，得到的是字符串＂12.34＂。如果想得到数值型，可用eval（）函数转换。

2 : eval( )函数

eval 函数能够以Python表达式的方式解释并执行字符串，得到的结果将去掉字符串前后的引号。

将字符串的数值前后的双引号去掉，使得数据类型变成数值型。

使用eval（）函数处理字符串时需要注意使用场合，如果函数中的字符串是字母组合，如eval（'hello'），去掉两个单引号，得到的hello将作为一个变量，由于之前并未定义这个变量，将会导致程序报错。

故 eval（）函数中的字符串只能是纯数字型的。如eval（'12.3'）的结果就 是得到数字：12.3。 如果用户想要同时输入数值（小数或负数），并将数值用于计算，则需要使用eval（）函数与input（）函数结合。

如果同时输入两个数值并赋值给两个变量，注意输入时要将数字以英文状态的逗号隔开。代码如下：

3 : print( )函数

用于将信 息输出到控制台，即在控制台窗口打印信息。

1 : 直接输出字符串

将要输出的字符串或变量直接放在print（）函数 中

<code>print('hello world!') #直接输出字符串

a='Life is too short to learn Python!' #定义变量 code>

print(a) #输出变量对应的值

2 : 格式化输出

print（）函数可以将变量与字符串组合起来，按照一 定的格式输出组合后的字符串。常用的组合方式有两种，一种是参照C语言的%，另一种是与字符串函数format（）结合。

temp=23.6 #字义变量

print('当前温度为%.1f度'%temp) # 用%号将变量与字符串组

合输出

print('当前温度为{:.1f}度'.format(temp)) #用format()函数将变量与

字符串组合输出

3 : 不换行输出

print（）函数在输出内容到控制台后会自动换行，因 为print（）函数在打印字符串时还会打印结束标志：换行符“\n”，光标会自动出现在输出信息的下一行。如果要控制输出时不换行，则可以使 用参数end=''来修改结束标志  

<code>print('hello world!') #直接输出字符串

a='Life is too short to learn Python!' #定义变量 code>

b='Hello Python!' code>

print(a,end=' ') code>

print(b)

Python 基本数据类型

Python语言提供了3种数字类型：整数、浮点数、复数，以及一种字符串类型。

1 : 整数

整型数据的长度不受机器字长的影响，它的取值范围只与计算机的内存有关。

只要计算机的内存足够大，无论整型的长度为多少，都不用担心溢出问题。

在计算机中，经常用4种进制来表示整型：二进制、八进制、十进制、十六进制。默认的是十进制，如果想要用其他进制表示，需要加上引导符号。

二进制：以0B或0b开头；

八进制：以 0O或0o开头；

十六进制：以0X或0x开头

a=0b101

print('a的十进制表示:%d'%a)

b=0o101

print('a的十进制表示:%d'%b)

c=0x101

print('a的十进制表示:%d'%c)

d=101

print('d的十进制表示:%d'%d)

输出结果为：

a的十进制表示:5

b的十进制表示:65

c的十进制表示:257

d的十进制表示:101

不同的进制之间还可以通过不同的函数实现相互转换：

bin（x）：将数值x转换为二进制。

oct（x）：将数值x转换为八进制。

hex（x）：将数值x转换为十六进制。

int（x）：将字符串x转换为整数。

a=10

print('a的二进制为', bin(a))

print('a的八进制为', oct(a))

print('a的十六进制为', hex(a))

print('二进制101的整数值为', int('101',2))

a的二进制为0b1010

a的八进制为0o12

a的十六进制为0xa

二进制101的整数值为5

2  :  浮点数

Python的浮点数一般以十进制表示，由整数和小数部分组成，如 0.0，2.34，0.00000051，3.14159都是浮点数。

对于非常大或者非常小的浮点数可以用科学记数法表示。如： 0.00000051可以表示成5.1E-7，314000可以表示成3.14E5。

Python中的浮点数是双精度的，每个浮点数占8个字节（64位），52 位存储尾数，11位存储阶码，1位存储符号，故浮点数的取值范围 为-1.8E308～1.8E308。

超出这个范围将视为无穷大（inf）或者无穷小 （-inf）。

Python中最长可以输出浮点数的17位数字，但是计算机只能保证15位 数字的精度，对于超出17位的浮点数会产生截断。一旦产生截断，结果就 会产生误差。如平时我们都会认为0.1+0.2的结果是0.3，但是实际执行的 结果却是0.30000000000000004

3 : 复数

一个复数由“实部”和 “虚部”两部分组成，实部是一个实数，虚部是一个实数后加j或J组成， 虚部不能单独存在。

获取一个复数实部的方法是调用属性real，获取虚部的方法是调用属性imag。 将一个数据转换为复数的函数是complex（）

<code>a=complex(2,4)

b=6

print(a)

print('a的实部是:',a.real, 'a的虚部是:',a.imag)

print(complex(b))

(2+4j)

a的实部是:2.0 a的虚部是:4.0

(6+0j)

4 : 布尔型

布尔型只有True和False两个值，本质上来说，布尔型其实是一种特殊的整数，True对应1，False对应0。

任何对象都具有布尔属性，在Python中，以下数据的值均为False：

（1）None。

（2）False。

（3）任何为0的数字类型：0、0.0、0j。

（4）任何空字符、空列表、空字典：＂＂、（）、[ ]、{}。

（5）用户定义的类实例，如果类中定义了__bool__（）或者 __len__（）方法，并且方法返回0，或者布尔值False。

以下代码结果均为 False

bool()

bool('')

bool(0)

bool([ ])

5 : 运算符

数值运算符是一类对数值型操作数有效的运算符。按照不同的功能， 又可以分成算术运算符、赋值运算符、比较运算符、逻辑运算符等。

1）算术运算符

（1）一元操作符。

以x=2，y=9为例，对以下算术运算符进行说明， 一元运算符描述如表

（2）二元运算符

Python中的算术运算符既支持对相同类型的数值进行运算，也支持对不同类型的数值进行混合运算。在混合运算时，Python会强制将数值进行临时类型转换。遵循原则是将简单的数据类型转换为相对复杂的那一种数据类型。

布尔类型进行算术运算时，会将值视为0或1。

整型与浮点型进行混合运算时，会将整型转换为浮点型。

其他类型与复数运算时，会将其他类型转换为复数。

<code>1+True #结果为2

1*2.0 #结果为2.0

1+(2+3j) #结果为(3+3j)

（2）比较运算符

比较运算符是比较符号左右两边的操作数，运算结果是一个布尔值。

（3）逻辑运算符

逻辑运算符可以把多个条件表达式连接起来，形成更为复杂的条件

（4）运算符优先级

常见运算符优先级由高到低的顺序如下

 一般来说，同一优先级的运算符在运算时是按照从左往右的顺序执行，

如2+3-4的运算顺序是：解释器先运算2+3，得到结果5再与运算符结合执行5-4。 而赋值运算符的结合则相反，按照从右往左的顺序，如x=y=z，会先 将z的值赋给y，再将y的值赋给x。

6 : 字符串

1）字符串表示

Python中的字符串是由一对单引号（''）、一对双引号（＂＂）或一 对三引号（''''''）括起来的字符序列。

单引号：单引号括起来的单行，可以使用双引号作为字符串的一部 分。

双引号：双引号括起来的单行，可以用单引号作为字符串的一部分。

三引号：三引号括起来的多行，可以用单引号、双引号作为字符串的 一部分，也可以换行。

如果非要在单引号（或双引号）括起来的字符串中包含单引号（或双 引号），可使用转义字符反斜杠（\）对字符串中的单引号（或双引号） 进行转义处理，使得转义字符与特殊字符组成新的含义。

在字符串定义时需要遵守以下几条规则：

（1）字符串可以使用单引号或双引号来定义，但是最好在一个文件中统一使用同一种，避免混合使用的情况。

（2）如果在字符串中可能包含某种引号时，那么优先使用另一种形式的引号来定义字符串，尽量不使用转义字符。

2）字符索引

字符串中的多个字符都会按顺序给出一个编号，这个编号就是索引。 如s='Python'，字母'P'的编号为0。

Python中的字符串，我们可以通过索引取出其中的一个字符或一段字符子串，但是不支持动态修改。如s[1]可取出字符'y'。但是如果通过 s[1]='a'将'y'修改成'a'，则是非法操作。

在字符串中通过索引取出一个或一段字符子串的操作非常灵活，我们 把取其中一段的操作称为切片。切片的操作非常多样，具体如下：

s[n：m]：表示从字符串s中取索引号从n到m-1的字符子串，其中不包含索引号m的字符。

s[n：]：省略结束索引号，表示切取索引号从n到最后一个字符的子串。

s[：m]：省略开始索引号，表示切取索引号从0到索引号为m-1的子串。

s[-n：-m]：表示从字符串s中切取索引号从倒数n到倒数m-1的字符子串。

s[：：]：省略开始和结束索引号，表示切取整个字符串。 s[：：-1]：获得整个字符串的逆序。

3）字符串的处理函数

Python提供了许多内置函数，其中有6个与字符串处理相关的函数

4）字符串的处理方法

在Python的解释器内部，所有数据类型都采用面向对象的方式实现， 封装成一个类。

字符串就是其中的一个类。

每一个类里面都有许多自己的方法和属性，想要使用类的方法和属性，需要用 a . b （）的方式进行调用，其中a指明相应类创建的对象，例如我们创建一个字符串变量s='Python'，变量s就是一个字符串类的实例化对象。b（）指的是这个 类中相应的方法。类里的方法其实就是根据特定功能创建的函数，对外调用时我们一般称为“方法”。

5）字符串的格式化方法

字符串可以通过format（）方法进行格式化处理。

例如小明同学想用一个程序输出他每天的运动量：2019-12-12：跑步 1小时，行程9.85千米。标识中的内容每天都会发生改变，我们可以用特定的函数运算得到结果，填充到指定的位置，最终形成格式化的字符串。

Python提供了两种字符串格式化方法，一种是类C语言中printf（） 函数的格式化方法，另一种采用专门的format（）格式化方法。

（1）使用%符号进行格式化

使用%符号对字符串格式化的形式：'%[对齐][正号][0][宽度][.精 度]指定类型'%变量。

基本思想是：第一个%号表示格式开始标志，单引号外面的%后面跟待 格式化的变量。

[对齐]：-：左对齐，+：右对齐

（2）使用format（）方法进行格式化

模板字符串由一系列槽组成，用来控制修改字符串中嵌入值出现的位置，其基本思想是将format（）方法中逗号分隔的参数按照逗号关系替换到模板字符串的槽中。槽用大括号{}表示，如果大括号中没有序号，则按照出现的顺序替换

format（）方法中的槽除了包含参数序号，还可以包含格式控制的信息，具体格式信息如下

参数的序号是从0开始编号的，调用format（）方法后会得到一个新的字符串。想输出小明同学的运动量，可用变量来存储具体数值，代码如下：

<code>day= '2024-7-9'

hours=1

dis=9.85

print('{}:跑步{}小时,行程{}千米'.format(day,hours,dis))

print('{0}:跑步{1}小时,行程{2}千米'.format(day,hours,dis))

import time

scale = 10

for i in range(scale + 1):

a = '**' * i

b = '..' * (scale - i)

c = (i / scale) * 100

print('{:<3.0f} % [{} - > {}]'.format(c, a, b))

time.sleep(0.1)

进度条例：

0 % [ - > ....................]

10 % [** - > ..................]

20 % [**** - > ................]

30 % [****** - > ..............]

40 % [******** - > ............]

50 % [********** - > ..........]

60 % [************ - > ........]

70 % [************** - > ......]

80 % [**************** - > ....]

90 % [****************** - > ..]

100 % [******************** - > ]

Python组合数据类型

计算机中不仅可对单个变量表示的数据进行处理，更多的情况是对一 组数据进行批量处理。

Python中有3种数字类型：整数、浮点数、复数，一种字符串类型。

这种被组合成一个整体的数据集合称为组合数据类型。

组合数据类型能够将多个同类型或不同类型的数据组织起来，通过单一的表示并根据数据之间的关系，可将它们分为3类：序列类型、集合类型、映射类型。

序列类型是一个元素向量，元素之间存在先后关系，通过序号访问， 元素之间不排他，即可出现相同值的元素。如前面介绍过的字符串其实就是一个序列类型。序列类型就像一个编号的“数据收纳盒”，能以一种规则的下标索引方式（收纳盒名字+数字序号）访问每个数据。 集合类型是一个元素的集合，元素之间无序，集合中每个元素值都具 有唯一性。序列类型是一维元素向量，元素之间存在先后关系，通过序号访问。 序列的基本思想与表示方法均来源于数学概念。在数学中，会给每个序列 一个名字，用下标来表示对应的元素。如：S=s0，s1，s2，…，sn-1。Python中很多数据类型都是序列类型，其中比较重要的是字符串 （str）、元组（tuple）、列表（list）。字符串可以看成一个单字符的有序组合，属于序列类型，同时也是一种基本数据类型。元组是包含0个或多个数据项的不可变序列类型，即元组一旦生成，任何数据项都不可替换或删除。列表则是一个可以修改数据项的序列类型，使用非常灵活。

集合类型就像一个带有标签的容器。 映射类型是“键-值”数据项的集合，每个元素都是一个键-值对，表 示为（key，value），其中key具有唯一性。

映射类型就像一个“标签收 纳盒”，给每个数据贴上唯一的标签，可以通过具有特定意义的名字或记号来获得数据。如现实生活中的字典，可以通过标签（即关键字）来索引数据。

只要是序列类型，都可以使用相同的索引体系，Python中的序列支持双向索引，即正向递增序号和反向递减序号。

正向递增索引从左到右依次递增，第1个元素的索引号为0，第2个元素的索引号为1，以此类推。反向递减索引从右到左依次递减，最后一个元素的索引号为-1，倒数第二个为-2，以此类推。 序列类型有12个通用的操作符和函数。

1.元组类型

元组一旦创建就不能被修改。一般用于表达固定数据项、函数返回值、多变量同时赋值、循环遍历等情况。

Python构建元组的方式非常简单，可以用tuple（）函数构建， tuple（）函数中的参数是一个可迭代的数据，若没有传入参数，则创建空元组。也可以直接用圆括号包含多个使用逗号隔开的元素来创建元组。 非空元组的括号可以省略。

利用tuple（）创建非空元组。

2.列表类型

列表（list）是包含0个或多个对象引用的有序序列，与元组不同， 列表的长度和内容都是可变的，可自由对列表中的数据项进行增加、删除 或替换。列表没有长度限制，元素的类型可以各不相同，使用非常灵活。

1）列表创建

可以通过list（）函数将已有的元组字符串转换为列表。也可以直接用[ ]号创建

2）列表操作

与整数及字符串不同，列表要处理一组数据，因此，列表必须通过显 式的数据赋值才能生成，简单将一个列表赋值给另一个列表是不会生成新的列表对象的，而是将两个变量指向了同一个列表。只有通过list（）或 [ ]创建才会生成新列表。

如果非要将一个列表的值赋给另一个变量，可通过复制的方式实现

处理列表的增加、删除、修改

示例：

3）列表元素遍历

对列表进行遍历使用for-in结构，可对列表中的元素按序访问。

如果对元素访问时不需要删除操作，则可直接遍历列表。

如果对元素访问时涉及删除或改变元素位置等操作，则应先对原列表进行复制，在复制的列表中遍历，而在原列表中操作，这样可以保证每个元素都能被遍历并进行操作。

3.集合类型

集合类型与数学中的集合概念一致，即包含0个或多个数据项的无序组合。集合中的元素不可重复，元素类型只能是固定数据类型，不能是可变数据类型。如整数、浮点数、字符串、元组等可以作为集合的数据项， 而列表、字典和集合类型则不能作为集合的元素出现。集合是无序的组合，没有索引和位置的概念，不能分片，集合中的元素可以动态增加或删除。

集合用大括号{}表示，各元素之间用逗号隔开， 可以用赋值语句生成一个大集合。也可以用set（）函数进行集合的创建，输入的参数可以是任何组合数据类型，返回结果是一个无重复且排序 任意的集合。由于集合中的元素都是唯一的，可以使用集合类型过滤重复元素。

注意：空集合只能由set（）函数创建。空{}创建的集合默认为字典类型。 集合的操作符有10个

4.映射类型

映射类型是键-值数据项的组合，每一个元素都是一个键-值对，即元素是（key，value），元素之间是无序的。键-值对（key，value）是一种二元关系，源于属性和值的映射关系。 键（key）表示一个属性，也可理解为一个类别或项目，值（value） 是属性的内容，键-值对刻画了一个属性和它的值。键-值对将映射关系结 构化，用于存储和表达。

在列表中，存储和检索数据可以通过整数的索引实现，但是在很多应用中需要更灵活的信息查找方式，例如在检索学生或员工信息时，经常基于学号或身份证号码进行查找，而不是基于信息存储的序号进行查找。在编程术语中，根据一个信息查找另一个信息的方式构成了键-值对，它表示索引用的键和对应的值构成的成对关系，即通过一个特定的键（学号或 身份证号）访问值（学生信息）。 在实际应用中有很多键-值对的案例，如通信录中姓名和电话号码、 用户信息中用户名与密码、邮政编码与运输成本、国家名称与首都等。 这种通过任意键信息查找一组数据中值信息的过程称为映射，在 Python中，映射类型主要以字典（dict）进行体现。

1）字典创建

字典是包含0个或多个键-值对的无序集合，没有长度限制，可以根据 键索引值的内容，且键具有唯一性。 Python中可以通过函数dict（）来创建空字典，也可以通过大括号{} 来创建。

注意：字典输出数据的顺序可能与创建之初的顺序不一致。其原因是字典是集合类型的延续，所以各元素之间没有顺序之分，如果想保持一个 集合中各元素的顺序，需要使用列表。 如果要访问元素的值，则可使用“字典变量[key]”的形式

字典中的元素是可以动态修改的，添加元素和修改元素都是通过对 “字典变量[key]”赋值方式实现：字典变量[key]=值。如添加一个元 素。

总体来说，字典是存储可变数量键-值对的数据结构，键和值可以是任意数据类型，包括程序自定义的类型。Python字典效率非常高，甚至可以存储几十万项内容。

2）字典操作

字典在Python内容中已采用面向对象方式实现，因此使用对应的方法 时，采用a.b（）格式。

如果希望以keys（）、values（）、items（）方法返回列表类型， 可用list（）函数进行转换。

3）字典遍历

与其他组合类型一样，字典的遍历可以使用for-in语句

Python程序结构

程序有3种基本结构：顺序结构、分支结构和循环结构。

这些结构都只有一个入口和一个出口。

顺序结构 ：程序按照线性顺序依次执行的一种方式。

分支结构：程序根据条件判断结果而选择不同向前执行路径的一种运行方式。

循环结构：程序根据条件判断向后反复执行的一种运行方式。

分支结构

1 ： 单分支结构 ：If 语句

2 : 二分支结构 :  If - else 语句

3 : 多分支结构 ： if-elif-else语句

循环结构

Python的循环结构分为for循环和while循环两种。

for循环 确定循环次数，称为“遍历循环”，循环次数采用遍历结构中的元素个数来体现。

while循环 不确定循环次数，称为“无限循环”，不能明确循环体可能的执行次数，而是通过条件判断是否继续执行循环体。

1 : 遍历循环  for循环

1）遍历元素

使用for循环遍历字符串、列表等组合类型

<code>#遍历字符串

s= 'ABCD'

for c in s:

print(c)

2）range（）函数

range（）函数可以创建一个整数列表，range（）函数的语法格式如下：

range([start,] stop [,step]) 函数说明如下。

start：表示列表的起始位置，该参数可以缺省，缺省则表示列表默认从0开始。

stop：表示列表的结束位置，开区间，即不包含stop的值，如 range（6），range（0，6）表示结束的值为5，即产生的列表为[0，1， 2，3，4，5]。

step：表示列表中元素的增幅，该参数可以缺省，缺省则表示元素默认步长为1，如range（0，6）相当于range（0，6，1）。

range（）函数一般与for循环搭配使用，以控制for循环中代码段的执行次数。例如对上面的字符串、列表的遍历也可以由range（）函数来 控制，range（）函数的结束值为字符串、列表的长度。

s= 'ABCD'

for i in range(len(s)):

print(s[i])

3）for-else

for循环还能与保留字else搭配使用

<code>for c in 'ABC':

print('循环进行中:'+c)

else:

print('循环正常结束:')

2 : 无限循环 ： while循环

3 : 循环保留字

在一些特殊情况下，程序需要终止循环，跳出循环结构。Python中提供了两个保留字：break和continue，用它们来辅助控制循环执行。

1） break

break跳出它所属的循环结构，脱离循环后程序从循环代码后继续执行。

该语句通常与if结构结合使用，两种循环的语法格式。

<code>for c in'Python':

if c== 't':

break

print(c,end='') code>

这段代码在字符串中遍历，从字符串'Python'中逐一取出字符并进行输出，当取出的字符为't'时，满足了判断条件，则会从循环中跳出，故输出结果如下：

P y

2）continue

continue与break的区别在于，continue是结束本次循环，继续下一轮循环判断，而不是终止整个循环的执行；

break语句则会结束整个循环过程，不再判断循环的条件是否成立。

<code>for c in'Python':

if c== 't':

continue

print(c,end='') code>

这段代码在字符串中遍历，从字符串'Python'中逐一取出字符并进行输出，当取出的字符为't'时，满足了判断条件，则会跳过判断条件后面的语句“print（c，end=''）”，继续下轮循环的判断，故字符't'不会被输出。运行结果如下：

<code>P y h o n

异常处理

异常处理采用try-except语句。

Python异常信息中最重要的部分是异常类型，它表明异常产生的原因，也是程序处理异常的依据。

Python中使用try-except语句实现异常处理。

在程序数据输入时，经常将输入的数字用于计算，但如果用户输入的不是数字，则会报错，为避免这种输入类型的错误，可以采用异常处理，代码如下：

<code>try:

num=eval(input('请输入一个整数:'))

print(num*num)

except:

print('输入错误,请输入整数')

运行结果如下：

请输入一个整数:s123

输入错误,请输入整数

Python函数与模块化编程

函数能将代码划分为若干模块，每一模块可相对独立地实现某一功能。

将经常被使用的部分功能封装起来，每次需要使用这个功能时，通过调用函数就可实现。

函数的两个主要目的：降低编程难度和实现代码复用。

函数是一种功能抽象，复用它可以将一个复杂的大问题分解成一系列简单的小问题，同时，小问题还可以继续划分成更小的问题，是一种分而治之的思想应用。当 每个小问题都细化到足够简单时，为每个小问题编写程序，并通过函数封装，由小问题的解决到整个大问题的解决。这就是一种自顶向下的程序设计思想。

函数的基本使用

1 : 函数的定义 

函数的定义即函数功能的实现过程，包含函数头与函数体两部分。为提高程序的可读性，函数定义之前，一般以注释形式标明函数接口信息。 从上面的案例中，我们可以看出函数的定义格式：

def 函数名(参数1,参数2,…):

      函数体

      return返回值列表

def：关键字，标志着函数的开始。

函数名：函数唯一的标识，可以是任何有效的Python标识符，命名方式遵循变量的命名规则。

参数：参数列表中的参数是形式参数，简称为“形参”，是调用该函数时传递给它的值，可以是0个，也可以是一个或多个。当传递多个参数时，各参数由逗号分隔。没有参数也需要保留括号。形参只在函数体中有效。

冒号：用于标记函数体的开始。

函数体：函数每次被调用时执行的代码，由一行或多行代码组成。

return：标志函数的结束，将返回值赋给函数的调用者。若是没有返回值，则无须保留return语句，在函数体结束位置将控制权返回给调用者。

2 ：函数的调用

调用函数的基本格式：

函数名(参数列表)

调用时，参数列表中给出实际要传入函数内部的参数，这类参数称为 实际参数，即“实参”。实参可以是变量、常量、表达式、函数等。 在程序执行过程中，调用函数其实分成了4个步骤：

（1）调用程序在调用处暂停执行。

（2）在调用时将实参复制给函数的形参。

（3）执行函数体语句。

（4）函数结束时给出返回值，程序回到调用前暂停处继续执行。

参数的传递

函数的参数传递是指将实参传递给形参的过程，例如 形参为a：fact（a），调用时实参为n：fact（n），这个过程就是将实参n的值传递给形参a。

Python中函数支持以多种方式传递参数，包括位置传递、关键字传递、默认值传递、包裹传递、解包裹传递及混合传递。

函数的返回值

        函数的返回值语句return是可选项，可以出现在函数体中的任何位 置，它的作用是结束并退出当前函数，将程序返回到函数被调用时的位置继续执行，同时将函数中的数据返回给主程序。

         return语句可以同时将0个、1个或多个函数运算后得到的结果返回给函数调用处的变量。当存在多个返回值时，会形成一个元组。

运行结果如下：

上例函数Mult（）有两个返回值s和m；调用函数时会得到两个数值。 可以用两个变量来接收返回值，也可以用一个变量来接收返回值，此时的变量将会是一个元组类型。

函数可以没有返回值，即没有return语句。如果没有return体语句， 则会在函数体语句运行完成后退出函数。

变量的作用域

Python中的变量不是在哪个位置都可以访问的，具体的访问权限取决于定义变量的位置。变量所处的有效范围称为变量的作用域。

根据变量作用域的不同，可以将变量分为两类：全局变量和局部变量。

全局变量是指在函数之外定义的变量，一般没有缩进，在程序执行的全过程有效。

局部变量是指在函数内部定义的变量，仅在函数内部有效，一旦退出函数，变量就不再有效。

想要在函数中使用全局变量，一般会使用global声明。

<code>n=1

def fun(a,b):

n=a*b #此处n是与全局变量同名的局部变量

return a+b

s=fun(10,12)

print(s,n)

运行结果如下：

22,1

从运行结果中可以看出，尽管调用了函数，但变量n的值并未发生改变。原因是：虽然在主程序中声明了全局变量n，但是在函数中并没有使用global关键字声明，而函数fun（）有自己的内存空间，它会将n=a∗b理解为生成一个局部变量n，并将两个参数之积赋给它。所以在函数中出现的变量n其实是一个局部变量，与全局变量n是两个完全不同的独立变量。

n=1

def fun(a,b):

global n #此处n是全局变量

n=a*b

return a+b

s=fun(10,12)

print(s,n)

运行结果如下：

22,120

从运行结果可以发现，变量n的值经过函数调用后发生了变化。这是由于在函数体中使用global关键字声明的变量n是全局变量，变量n在主程序和函数体中使用的是同一个内存空间。故而在调用函数时会改变内存空间中的值。

ls=[ ] #创建一个全局列表变量

def fun(a,b):

ls.append(a*b) #此处ls是全局变量

return a+b

s=fun(10,12)

print(s,ls)

运行结果如下：

22[120]

从这个运行结果可以发现出现了神奇的事件，没有使用global声明的 列表变量ls，它的值在函数调用后居然发生了改变。原因是列表是组合数据类型，会对多个数据进行操作，它的使用有创建和引用的区别。当列表被方括号（[ ]）赋值时，列表就会被真实地创建，否则就是对之前创建出来的列表进行引用，而普通的数据类型变量的赋值却没有创建和引用的区分。

在函数体中，虽然没有使用global声明的列表变量ls，但是出现 ls.append（a∗b）语句时，仅仅是对列表ls进行引用。而函数体中没有创 建过这个名称的列表，fun（）函数就会进一步寻找全局内存空间，当在 全局内存空间找到变量ls后，则会自动关联全局ls列表，并对其内容进行修改。 简而言之，对于列表类型，函数可以直接使用全局列表，而不需要采用global进行声明。

ls=[ ] #创建一个全局列表变量

def fun(a,b):

ls=[ ] #此处ls是局部变量

ls.append(a*b)

return a+b

s=fun(10,12)

print(s,ls)

运行结果如下：

22[ ]

由于在函数体中创建了一个局部变量ls，虽然名称与全局变量相同， 但是出现了方括号（[ ]）赋值，列表就会在真实的fun（）函数的内存空间中创建，语句ls.append（a∗b）所修改的就是fun（）函数内存空间的ls变量值，而不是全局变量ls的值。故全局变量ls的值仍然是空的。

Python函数对变量的作用要遵守的原则：

（1）简单数据类型变量无论是否与全局变量重名，仅在函数内部创建和使用。函数退出后，变量就会被释放，而同名的全局变量不受函数调用影响。

（2）简单数据类型变量在使用global保留字声明后，作为全局变量使用，函数退出后，该变量仍被保留，且数值被函数改变。

（3）对于组合数据类型的全局变量，如果在函数内部没有被真实地创建同名变量，则函数内部可以直接使用并修改全局变量的值。

（4）如果函数内部真实地创建了组合数据类型变量，无论是否与全局变量同名，函数仅对内部的局部变量进行操作，函数退出后局部变量被释放，而全局变量的值不受函数影响。

匿名函数

匿名函数是一类无须定义标识符的函数，它与普通函数一样可以在程序的任何位置使用，但是在定义时被严格限定为单一表达式。

Python中使用关键字lambda来定义匿名函数。

这个语句等价于如下正常函数的定义：

<code>def函数名(参数列表):

return表达式

与普通的函数相比，lambda函数的体积更小、功能单一，用于定义简单的、能在一行内表示的函数，返回一个函数类型。

与普通函数的区别

（1）普通函数在定义时有名称，而lambda函数没有。

（2）普通函数的函数体中可以包含多条语句，而lambda函数只能是一个表达式。

（3）普通函数可以实现比较复杂的功能，而lambda函数功能简单。

（4）普通函数能被其他程序调用，而lambda函数不能被其他程序调用，经常用一个变量来保存它，以便后期可以随时使用这个函数。当匿名函数用变量来保存时，这个变量可以作为匿名函数的临时名称来调用。

lambda函数经常会用在多维列表的排序中。

如对二维列表按第二列排 序分别升序、降序排序

代码复用与模块化编程

函数是程序的一种抽象，可以通过封装实现代码复用，对程序进行模块化设计。

需要对代码进行抽象， 形成易于理解的结构。

当代编程语言从代码层面采用函数和对象两种抽象方式，分别对应面向过程和面向对象编程思想。

函数封装的直接好处是代码可复用。

更新函数功能时，所有被调用处的功能都被更新。

面向过程：是一种以过程描述为主要方法的编程方式，它要求程序员列出解决问题所需要的步骤，然后用函数将这些步骤一步一步地实现，使用时依次建立并调用函数或编写语句即可。

面向过程编程是一种基本且自然 的程序设计方法，函数通过封装步骤或子功能实现代码复用，并简化程序设计难度。

面向过程和面向对象只是编程方式不同，抽象级别不同，所有面向对象编程能实现的功能采用面向过程同样能实现。

当程序的长度较长，如超过百行以上，如果不划分模块，程序的可读性就会非常差。解决这一问题的最好方法就是将一个程序分隔成短小的程序段，每一段程序完成一个小的功能。无论面向过程还是面向对象编程， 对程序合理划分功能模块并基于模块设计程序是一种常用的方法，称为 “模块化程序设计”。

模块化程序设计是指通过函数或对象的封装功能将程序划分成主程序、子程序和子程序间关系的表达。

两个基本要求

 （1）高内聚

尽可能地合理划分功能块，功能块内部耦合紧密。

（2）低耦合

模块间尽可能简单，功能块之间耦合度低。

耦合是指两个实体相互依赖于对方的一个量度，在程序设计结构中是 指各模块之间相互关联的程序。也就是在设计系统的各个功能模块时，尽可能使模块具有较大的独立性，使得每个模块完成一个相对独立的特定子 功能，并且和其他模块之间的关系很简单，以便能方便地把不同场合下写 成的程序模块组合成软件系统。

衡量模块独立性的定性标准是内聚

（一个模块内各个元素彼此结合的 紧密程度）和耦合（一个软件结构内不同模块之间互连程度的度量）。高内聚、低耦合的模块是设计时追求的目标。尽量降低系统各个部分之间的耦合度，是应用服务层设计中需要重点考虑的问题。

步骤

（1）分析问题，明确需要解决的任务。

（2）对任务进行逐步分解和细化，分成若干个子任务，每个子任务只完成部分完整功能，并且可以通过函数实现。

（3）确定模块（函数）之间的调用关系。

（4）优化模块之间的调用关系。

（5）在主函数中进行调用实现。

模块与模块之间可以相互调用。

假设模块1、模块2的程序文件分别在同一个目录下保存为文件名 module1.py 、 module2.py ，则在模块2中调用模块1的形式有：

（1）import module1。

（2）from module1 import∗。

创建Python文件a.py，并在文件中定义函数sum

<code>def sum(a,b):

return a+b

创建Python文件b.py，并调用sum函数

from a import sum

print(sum(1,2))

Python 面向对象编程

面向对象

使用对象来映射现实中的事物，来描述事物之间的联系，这种思想就是面向对象。

通常将对象划分为两个部分，即静态部分与动态部分。

静态部分：被称为“属性”，任何对象都具备自身属性，这些属性不仅是客观存在的，而且是不能被忽视的，如人的性别。

动态部分：是对象的行为，即对象执行的动作， 如人的行走。

具有相同属性和行为的一类实体被称为类

在Python中，类是一种抽象概念，如定义一个大雁类（Geese），在该类中，可以定义每个对象共有的属性和方法，而一只要从北方飞往南方的大雁则是大雁类的一个对象，对象是类的实例。

面向对象程序设计具有三大基本特征：封装、继承、多态。

封装：是面向对象编程的核心思想，将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体就是类，类通常对客户隐藏其实现细节，这就是封装思想。

继承：是实现重复利用的重要手段，子类通过继承复 用了父类的属性和行为的同时，又添加了子类特有的属性和行为。

多态：是将父类对象应用于子类的特征。

面向过程：只考虑在函数中封装代码逻辑，而不考虑函数的归属关系。

面向对象：把解决问题的事物提取为多个对象，而建立对象的目的也不是为了完成一个个步骤，而是为了描述某个事物在解决问题的过程中所发生的行为。面向对象是一个更大的封装，根据对象职责明确函数的归属关系。

类的定义与使用

1：类的定义

类表示具有相同属性和方法的对象的集合，在使用类时，需要先定义类，然后再创建类的实例，类的定义使用class关键字实现

<code>class类名(父类):

属性名=属性值

def方法名():

方法体

定义一个冰箱类代码如下：

class Fridge():

def open(self):

print('打开冰箱门')

def pack(self,goods):

self.goods=goods

print('将%s装进冰箱'%self.goods)

def close(self):

print('关上冰箱门')

2 : 类的使用

对象是类的实例化，类是对象的抽象，即创建对象的模板。创建类之后，需要通过创建对象来使用类。

对象名=类名()

按上面的冰箱类来创建一个实际的冰箱对象

fridge1=Fridge()

属性和方法

1 : 属性

属性用于描述事物的特征，如颜色、大小、数量等。可以分为类属性和对象属性。

类的属性存储了类的各种数据，定义位置有类的内部和方法的外部， 由该类所有的对象共同拥有。类属性可以通过类名访问，也可以通过对象名访问，但只能通过类名修改。

对象属性是对象特征的描述，定义非常灵活，可在方法内部定义，也可在调用实例时添加。如给上面的冰箱类定义两个属性：冰箱编号、物品 编号，再定义一个对象属性：物品名称

class Fridge():

No=0 #类属性--冰箱编号

Num=0 #类属性--物品编号

def pack(self,goods):

self.Num+= 1

self.goods=goods # 对象属性--物品名称

在开发过程中经常会遇到不想让对象的某些属性不被外界访问和随意 修改的情况，这时可将这些属性定义为私有属性，再添加一个公有方法， 用于私有属性的操作。私有属性定义以“__”开头，如__age。

2 : 构造方法

  在类的方法中，有两种特殊方法，分别在类创建时和销毁时自动调用，分别是构造方法__init__（）和析构方法__del__（）。

使用类名（）可以创建对象，但实际上，每次创建对象后，系统会自动调用__init__（）方法。每个类都有一个默认的构造方法，如果在自定义类时显示已经定义了，则创建对象时调用定义的__init__（）方法。

__init__（）方法的第一个参数是self，即代表对象本身，不需要显式传递实参。但是在创建类时传入的参数实际上都传递给了__init__（） 方法。

class Fridge():

No=0

Num=0

def__init__(self): #自定义构造方法

Fridge.No+=1

3 : 对象方法

对象方法是在类中定义的，以关键字self作为第一个参数。在对象方 法中可以使用self关键字定义和访问对象属性，同时对象属性会覆盖类属性。

冰箱类中的开门、装物品、关门都是对象方法：

运行结果：

<code> 打开1号冰箱门

在1号冰箱装第1个物品大象

在1号冰箱装第2个物品小象

关上1号冰箱门

继承

继承描述类与类之间的关系，可以不重写类，而对原有类的功能进行扩展。

如冰箱类，有容量、颜色、功耗等属性，有开门、装东西、关门、 制冷等行为。各品牌的冰箱除拥有这些功能外，又有各自的型号、特点等。

再例如学生类，有学号、姓名、性别、年龄等属性，有上课、学习、 活动等方法。大学生则又可以增加如学院、专业、选修、社团、实习等新 属性和方法。

一个类可以继承自另一个类，并自动拥有另一个类的属性和方法，还可以添加自己新的特性和方法。继承类称为子类，被继承的类称为父类或超类。

子类定义格式如下：

class子类名(父类名):

子类不能继承父类的私有属性和方法，但能自动拥有父类其他的属性和方法。

如果子类对父类提供的属性和方法进行修改，叫重写。

如果子类重新定义了父类方法后，还需要访问父类的同名方法，可以使用super关键字。

结果：

<code> 这是一类冰箱

这是一类双开门冰箱

在冰箱中装大象

Python文件操作与图形化编程

文件的基本操作

文件是一个存储在辅助存储器上的数据序列，可以包含任何数据内容。 从概念上讲，前面学到的函数是程序的集合和抽象，而文件则是数据的集合和抽象。

一个文件需要有唯一确定的文件标识，以便用户找到确定的文件。

文件的标识包括3个部分：文件路径、文件名、文件扩展名。如：D： \Python\example.txt。

文件路径:D:\Python\

文件名:example

文件扩展名:.txt

文件的组织形式和表达数据的方式更有效、更灵活。

按编码方式一般分为两大类型：文本文件和二进制文件。

Python对文件采用统一的操作步骤：打开—操作—关闭。

1：打开文件的方式：open（）

Python采用解释器内置的open（）函数打开一个文件，并实现该文件与一个程序变量的关联。open（）函数

变量名=open(文件名,打开模式,文件编码)

f=open('example.txt','r',encoding='utf-8') code>

open（）函数中的参数文件名指是的文件的实际名字，可以是包含完整路径的名字。打开模式用于控制使用何种方式打开文件。

open（）函数 提供了7种基本的打开模式：

2．关闭文件的方法：close（）

文件使用结束后采用close（）方法关闭，释放文件的使用授权

<code>变量名.close()

f.close()

3．文件的读取

当文件被打开后，根据打开方式的不同可以对文件进行相应的读写操作。当文件以文本文件方式打开时，读写按照字符串方式进行操作，并采用当前计算机使用的编码或指定的编码。当文件以二进制文件方式打开时，读写按照字节流方式进行操作。

4．文件的写入

Python提供了两个与文件内容写入有关的方法

write（）方法中的参数s表示要写入文件中的字符串，在一次打开和关闭操作之间，每调用一次write（）方法，程序向文件中追加一行数据，并返回本次写入文件中的字节数。

writelines（lines）方法中的参 数lines是元素为字符串的列表。

图形化界面tkinter

作为Python特定的GUI界 面，它是一个图像的窗口，并且tkinter是Python自带的模块，可以编辑 GUI界面，并且可以用GUI实现很多直观的功能，例如开发一个计算器或者 开发一个有交互功能的小系统。

由于tkinter是Python内置的库，不用安装，所以只需在使用时导入 tkinter模块：import tkinter，或者from tkinter import∗。

需要说明的是，虽然tkinter很好用，但是如果要开发一些大型的应用，tkinter提供的功能还是太少了，需要使用wxPython、PyQt这些第三方库

1．主窗体创建与运行

图形用户界面程序都需要一个根窗口，也叫主窗口，它就好像绘画时需要的画纸一样，tkinter提供创建主窗口的构造函数Tk（）

<code>root=Tk()

窗口和组件都创建好后，需要运行，程序要不停地告诉窗口管理对象 GM（Geometry Manager）有一个组件产生。

root.mainloop()

2．tkinter的组件

3．组件属性

标准属性也是所有组件的共同属性，如大小、字体、颜色等，除此之外，还有各组件自己特有的属性，常用的组件属性