全国二级python考纲，全国等级考试二级

全国二级python考纲，全国等级考试二级安装PyDevEclipse PyDev源生态的【IDLE环境】

第1章 Python概述

【Python语言简介】

• Python是一种跨平台、开源、免费的解释型高级动态编程语言，是一种通用编程语言。
• Python支持命令式编程和函数式编程两种方式，并且完全支持面向对象程序设计。
• Python语法简捷、清晰，易学易用且功能强大，拥有大量的几乎支持所有领域应用开发的成熟扩展库，大幅提高了开发速度。
• 有人喜欢把Python 称为“胶水语言”，因为它可以把多种不同语言编写的程序融合到一起并实现无缝拼接，更好地发挥不同语言和工具的优势，满足不同应用领域的需求。

【搭建开发环境】

除了Python 官方标配的IDLE，还有大量的开发环境可以用来编写Python代 码， 如 Eclipse PyDev、Anaconda3、 Python(x y)、 zwPython、VisualStudio Code、 PythonWin等，微软公司从Visual Studio 2015 版本开始也支持Python 代码了。

源生态的

【IDLE环境】

Eclipse PyDev

安装PyDev

配置Python解释器

编写代码

PAGE

Anaconda3

JupyterNotebook

spyder

【Python 代码编写规范】

（1）严格使用缩进来体现代码的逻辑从属关系，相同级别的代码必须具有相同的缩进量。Python 对代码缩进量有是硬性要求的，这一点必须时刻注意。在选择结构、循环结构、异常处理结构、函数定义、类定义和with 块等结构中，都使用缩进表示代码的从属关系。如果某段代码的缩进量不对，那么整个程序就是错的。

（2）每条import 语句只导入一个模块，并且要按照标准库、扩展库、自定义库的顺序依次导入。

（3）让代码布局适当松散。最好在每个类、每个函数定义和一段完整的功能代码后增加一个空行，在运算符两侧（函数参数赋值时除外）各增加一个空格，在逗号后面增加一个空格。

（4）尽量不要写过长的语句。如果语句过长，那么可以考虑拆分成多条短一些的语句，以保证代码具有较好的可读性。如果语句确实太长而超出屏幕宽度，那么可以使用续行符“\”，或者使用圆括号将多行括起来表示是一条语句。

（5）虽然Python 运算符有明确的优先级，但对复杂的表达式，一般建议在适当的位置使用括号来明确各种运算的隶属关系和顺序。

（6）对关键代码和重要的业务逻辑代码应进行必要的注释，方便日后的维护和升级。在Python 中有两种常用的注释形式： # 号和三引号。# 号常用于单行注释，三引号常用于大段说明性文本的注释。

扩展库安装方法

•内置对象可以直接使用，而标准库和扩展库需要导入后才能使用其中的对象。

【导入整个模块库】

使用这种方式导入后，在使用时需要在对象之前加上模块名作为前缀，以“模块名. 对象名”的方式进行访问。如果模块名字很长，那么为方便记忆和代码编写，可以为导入的模块设置一个别名，即可用“别名. 对象名”的方式来使用其中的对象了。

>>> import math # 导入标准库 math

>>> math.pi # 查看圆周率的值

3.141592653589793

>>> math.sin(0.5) # 求 0.5（ 单位是弧度） 的正弦

0.479425538604203

>>> import random # 导入标准库 random

>>> n = random.random() # 获得 [0 1) 内的随机小数

>>> n = random.randrange(1 100) # 返回 [1 100) 内的随机整数

>>> import os.path as path # 导入标准库os.path，设置别名 path

>>> path.isfile(r'C:\windows\notepad.exe')

True

>>> import numpy as np # 导入扩展库numpy， 设置别名np

>>> a = np.array((1 2 3 4)) # 创建数组

【明确导入模块中的特定对象】

使用这种方式仅导入明确指定的对象，并且可以为导入的对象起一个别名。这种导入方式可以减少查询次数，提高访问速度，减小打包后可执行文件的体积，同时也减少程序员需要输入的代码量，且不需要使用模块名作为前缀。

>>> from math importsin # 只导入模块中的指定对象

>>> sin(3)

0.1411200080598672

>>> from math import sinas f # 给导入的对象起别名

>>> f(3) # 等价于 sin(3)

0.1411200080598672

>>> from random importsample

>>> sample((1 2 3 4 5 6 7) 3) # 从 7 个元素中任选 3 个不重复元素

[6 5 1]

【一次导入特定模块中的所有对象】

>>> from math import* # 导入标准库 math 中所有对象

>>> gcd(36 18) # 最大公约数

18

>>> pi # 圆周率常数 π

3.141592653589793

>>> e # 常数 e

2.718281828459045

>>> log2(8) # 计算以 2 为底的对数函数值

3.0

>>> log10(100) # 计算以 10 为底的对数函数值

2.0

>>> radians(180) # 把角度转换为弧度

3.141592653589793

Python编程基础

常用内置对象(Built-in Object )

对象类型

类型名称

示例

简要说明

数字

int

float

complex

123456789

3.1415926

1e-63 4j

基本类型，不可变，大小没有限制

字符串

str

'swfu'

"I'm a student"

'''Python '''

容器类型，不可变，可以使用单引号、双引号、三引号作为定界符

列表

list

[1 2 3]

['a' 'b' ['c' 2]]

容器类型，可变，所有元素放在一对方括号中，元素之间使用逗号分隔，其中的元素可以是任意类型

元组

tuple

(2 -5 6)(3 )

容器类型，不可变，所有元素放在一对圆括号中，元素之间使用逗号分隔，如果元组中只有一个元素，后面必须多写一个逗号

集合

set

{'a' 'b' 'c'}

容器类型，可变，所有元素放在一对大括号中，元素之间使用逗号分隔，元素必须为不可变类型的数据，并且不允许重复

字典

dict

{1:'food' 2:'taste' 3:'import'}

容器类型，可变，所有元素放在一对大括号中，元素之间使用逗号分隔，元素形式为“键:值”，其中“键”不允许重复且必须不可变

对象类型

类型名称

示例

简要说明

布尔型

bool

TrueFalse

逻辑值，关系运算符、成员测试运算符、同一性测试运算符组成的表达式的值一般为True或False

空类型

NoneType

None

空值

其他可迭代对象

生成器对象、range对象、zip对象、enumerate对象、map对象、filter对象等等

具有惰性求值的特点，除range对象之外，其他几个对象中的元素只能使用一次

编程单元

函数（使用def定义）类（使用class定义）模块（类型为module）

类和函数都属于可调用对象，模块用来集中存放函数、类、常量或其他对象

常量与变量(Constant and Variable )

在Python 中，不仅变量的值是可变的，而且变量的类型也是可以随时发生改变的，这正是动态语言的特点。•另外，在Python 程序中不需要事先声明变量名及其类型，直接赋值即可创建任意类型的变量。

>>>x = 3 #凭空出现一个整型变量x

创建了整型变量x，并赋值为3，再例如语句

>>>x = 'Hello world.' #新的字符串变量，再也不是原来的x了

创建了字符串变量x，并赋值为'Helloworld.'。

在Python 中定义变量名、函数名或类名时，需要注意以下问题。

• 必须以汉字、字母或下画线开头。
• 不能包含空格或标点符号。
• 不能使用关键字。如if、else、for、while、return等不能作为变量名，也不能作为函数和类的名字。
• 对英文字母的大小写敏感，如score 和 Score 不是同一个变量。
• 不建议使用系统内置的模块名、类型名或函数名和已导入的模块名及其成员名，这会改变其类型和含义，甚至会导致其他代码无法正常执行。

数字类型(Numeric Type)

在Python 中，内置的数字类型有整数、实数和复数。•整数又分为二进制整数（以0b 开头，每位上的数字为0 或 1）、八进制整数（以0o 开头，每位上的数字在0～ 7 之间）、十进制整数（默认，每位上的数字在0～ 9之间）和十六进制整数（以 0x 开头，每位上的数字在0 ～ 9 之间或a ～ f之间）。

•在使用时，不必担心数值的大小问题，因为Python 支持任意大的数值。

>>>9999 ** 99 # 这里**是幂乘运算符， 表示9999的 99次方

990148353526723487602263124753282625570559528895791057324326529121794837894053513464422176826916433932586924386677766244032001623756821400432975051208820204980098735552703841362304669970510691243800218202840374329378800694920309791954185117798434329591212159106298699938669908067573374724331208942425544893910910073205049031656789220889560732962926226305865706593594917896276756396848514900989999

尽量避免在实数之间直接进行相等性测试，而是应该以二者之差的绝对值是否足够小作为两个实数是否相等的依据，或者使用标准库math中的isclose()进行测试。

>>>0.4 - 0.1 # 实数运算的结果可能会有一定的误差

0.30000000000000004

>>>0.4 - 0.1 == 0.3 # 避免直接比较两个实数是否相等

False

>>>abs(0.4-0.1 - 0.3) < 1e-6 # 这里 1e-6 表示 10 的 -6 次方

True

>>>math.isclose(0.4-0.1 0.3)

True

Python 支持复数及其运算

>>> x = 3 4j # 使用 j 或 J 表示复数虚部

>>> y = 5 6j

>>> x y # 复数之间的加、 减、 乘、 除运算

(8 10j)

>>> x - y

(-2-2j)

>>> x * y

(-9 38j)

>>> x / y

(0.6393442622950819 0.03278688524590165j)

>>> abs(x) # 内置函数 abs() 可以计算复数的模

5.0

>>> x.imag # 虚部

4.0

>>> x.real # 实部

3.0

>>> x.conjugate() # 共轭复数

(3-4j)

字符串(String)

在Python中，使用一对单引号、双引号、三单引号、三双引号作为定界符来表示字符串，并且不同的定界符之间可以互相嵌套。使用双引号限定的字符串中可以包含单引号，而使用单引号限定的字符串中可以包含双引号。

Python支持使用加法运算符连接字符串，支持乘法运算符对字符串进行复制。除此之外，Python 字符串自身还提供了大量的方法支持查找、替换、排版等操作，很多内置函数和标准库对象也支持对字符串的操作。

>>> x = 'Helloworld.' # 使用单引号作为定界符

>>> x = "Python is agreat language." # 使用双引号作为定界符

>>> x = '''Tom said "Let's go."''' # 最外层是三个单引号

# 在内层双引号中还嵌套了一个单引号

>>> print(x)

Tom said "Let's go."

>>> 'good ' 'morning' # 连接字符串

'goodmorning'

>>> 'good ' * 3 # 字符串复制

'goodgoodgood '

序列(Sequence)

>>> x_list = [1 2 3] # 创建列表对象

>>> x_tuple = (1 2 3) # 创建元组对象

>>> x_dict = {'a':97 'b':98 'c':99} # 创建字典对象

>>> x_set = {1 2 3} # 创建集合对象

>>> print(x_list[1]) # 使用下标访问列表中指定位置的元素

2

>>> print(x_tuple[1]) # 使用下标访问元组中指定位置的元素

2

>>> print(x_dict['a']) # 通过 " 键 " 访问字典中对应的 " 值 "

97

>>> 3 in x_set # 测试集合中是否包含某个元素

True

运算符与表达式( Expression )

•在Python 中很多运算符具有多种不同的含义，作用于不同类型的操作数时含义并不完全相同，使用非常灵活。

•例如，加号在作用于整数、实数或复数时表示算术加法，而在作用于列表、字符串、元组时表示连接；乘号在作用于整数、实数或复数时表示算术乘法，而在列表、字符串或元组与整数相乘时表示序列复制；减号在作用于整数、实数或复数时表示算术减法，而在作用于集合时表示差集，在单个数字前面又表示负号。

运算符

功能说明

算术加法，列表、元组、字符串合并与连接，正号

-

算术减法，集合差集，负号

*

算术乘法，列表、元组或字符串与整数相乘时表示序列重复

/

真除法，结果为实数

//

求整商，向下取整，如果操作数中有实数的话，结果为实数形式的整数

%

求余数，结果的符号与除数相同

**

幂运算

<、<=、>、>=、==、!=

关系运算符

and

逻辑与

or

逻辑或

not

逻辑非

in

成员测试

is

同一性测试，测试两个对象是否引用同一个对象

&、|、^

集合交集、并集、对称差集

算术运算符

（1） 运算符除用于算术加法外，还可以用于列表、元组、字符串的连接。

>>> 3 5.0 # 实数相加

8.0

>>> (3 4j) (5 6j) # 复数相加

(8 10j)

>>> [1 2 3] [4 5 6] # 连接两个列表， 得到新列表

[1 2 3 4 5 6]

>>> (1 2 3) (4 ) # 连接两个元组， 得到新元组

(1 2 3 4)

>>> 'abcd' '1234' # 连接两个字符串， 得到新字符串

'abcd1234'

（2）* 运算符除了表示算术乘法，还可用于列表、元组、字符串与整数的乘法，表示序列元素的复制。

>>>3 * 5.0 # 实数乘法

15.0

>>>5 * (3 4j) # 实数与复数的乘法

(15 20j)

>>>(3 4j) * (5 6j) # 复数乘法

(-9 38j)

>>>[1 2 3] * 3 # 列表元素复制， 得到新列表

[1 2 3 1 2 3 1 2 3]

>>>(1 2 3) * 3 # 元组元素复制， 得到新元组

(1 2 3 1 2 3 1 2 3)

>>>'abc' * 3 # 字符串元素复制， 得到新字符串

'abcabcabc'

（3）运算符/ 和 // 分别表示算术除法和求整商。

>>>3 / 2 # 数学意义上的除法，结果为实数

1.5

>>>15 // 4 # 如果两个操作数都是整数，那么结果为整数

3

>>>15.0 // 4 # 操作数中有实数，得到实数形式的整数值

3.0

>>>-13 // 10 # 向下取整， 返回小于等于商的最大整数

-2

（4） % 运算符可以用于数字求余数运算。

>>> 789 % 23 # 求余数

7

>>> 36 % 12 # 余数为 0， 表示 36 能被 12 整除

0

（5）** 运算符表示幂乘。

>>>3 ** 2 # 3 的 2 次方

9

>>>9 ** 0.5 # 9 的 0.5 次方， 可以用来计算平方根

3.0

>>>(-9) ** 0.5 # 可以对负数计算平方根，得到复数

(1.8369701987210297e-16 3j)

>>>1.01 ** 365 # 每天多努力一点点，一年后的样子

37.78343433288728

>>>1.02 ** 365 # 每天再多努力一点点，一年后的样子

1377.4082919660768

>>>0.99 ** 365 # 每天少努力一点点，一年后的样子

0.025517964452291125

关系运算符

>>>1 < 3 < 5 # 等价于 1 < 3 and 3 < 5

True

>>>3 < 5 > 2

True

>>>1 > 6 < 8 # 注意， 这里实际上并不会计算 6<8 的值

False

>>>'Hello' > 'world' # 比较字符串大小

False

>>>[1 2 3] < [1 2 4] # 比较列表大小

True

>>>'Hello' > 3 # 字符串和数字不能比较，抛出异常

TypeError: unorderable types:str() >int()

成员测试运算符

>>> 3 in [1 2 3] # 测试 3 是否为列表 [1 2 3] 的元素

True

>>> 'abc' in 'abcdefg' # 子字符串测试

True

逻辑运算符

>>> 3 and 5 # 最后一个计算的表达式的值作为整个表达式的值

5

>>> 3 or 5 # and 和 or 的结果不一定是 True 或 False

3

>>> 3 and 5>2 # 所有非 0 数值都等价于 True

True

>>> 3 not in [1 2 3] # 逻辑非运算 not

False

>>> 3 is not 5 # not 的计算结果只能是 True 或 False 之一

True

集合运算符

>>>{1 2 3} & {3 4 5} # 交集

{3}

>>>{1 2 3} | {3 4 5} # 并集

{1 2 3 4 5}

>>>{1 2 3} - {3 4 5} # 差集

{1 2}

>>>{1 2 3} ^ {3 4 5} # 对称差集

{1 2 4 5}

>>>{1 2 3} < {1 2 3 4} # 测试是否子集

True

>>>{1 2 3} == {3 2 1} # 测试两个集合是否相等

True

>>>{1 2 4} > {1 2 3} # 集合之间的包含测试

False

>>>{1 2 4} < {1 2 3}

False

常用内置函数

函数

功能简要说明

abs(x)

返回数字x的绝对值或复数x的模

bin(x)

返回整数x的二进制表示形式

complex(real [imag])

返回指定实部和虚部的复数

chr(x)

返回Unicode编码为x的字符

dir(obj)

返回指定对象或模块obj的成员列表，不带参数则返回包含当前作用域内所有标识符名字的列表

divmod(x y)

返回包含整商和余数的元组((x-x%y)/y x%y)

enumerate(iterable[ start])

返回包含元素形式为(start iterable[0]) (start 1 iterable[1]) (start 2 iterable[2]) ...的迭代器对象，start默认值为0，enumerate对象中的元素只能使用一次

eval(s[ globals[ locals]])

计算并返回字符串s中表达式的值

filter(func seq)

返回filter对象，其中包含序列seq中使得单参数函数func返回值等价于True的那些元素，如果函数func为None则返回包含seq中等价于True的元素的filter对象，filter对象中的元素只能使用一次

float(x)

返回把整数或字符串x转换成浮点数的结果

help(obj)

返回对象obj的帮助信息

hex(x)

返回整数x的十六进制表示形式

函数

功能简要说明

input([提示信息])

显示提示信息，接收键盘输入的内容，以字符串形式返回

int(x[ d])

返回数字x的整数部分，或把字符串x看做d进制数，将其转换为十进制返回，d默认为10

isinstance( class-or-type-or-tuple)

测试对象obj是否属于指定类型（如果有多个类型的话需要放到元组中），返回True或False

len(obj)

返回对象obj包含的元素个数，适用于列表、元组、集合、字典、字符串以及range对象，但不适用于zip、map、filter、enumerate或类似对象

list([x])、set([x])、tuple([x])、dict([x])

把可迭代对象x转换为列表、集合、元组或字典并返回，不带参数时用来生成空列表、空集合、空元组、空字典

map(func *iterables)

返回包含若干func函数值的map对象，函数func的参数分别来自于iterables指定的每个迭代对象，map对象中的元素只能使用一次

max(...)、 min(...)

返回多个值中或者包含有限个元素的可迭代对象中所有元素的最大值、最小值，要求所有元素之间可比较大小，允许使用key参数指定排序规则

next(iterator[ default])

返回迭代器对象x中的下一个元素，default参数表示迭代结束之后继续迭代时返回的默认值

oct(x)

返回整数x的八进制表示形式

ord(x)

返回单个字符x的Unicode编码

函数

功能简要说明

pow(x y z=None)

返回x的y次方或该结果对z的余数，等价于x ** y或(x ** y) % z

print(value ... sep=' ' end='\n' file=sys.stdout flush=False)

基本输出函数，默认输出到屏幕，多个数值之间使用空格分隔，以换行符结束所有数据的输出

range([start ] end [ step] )

返回range对象，其中包含左闭右开区间[start end)内以step为步长的整数

reduce(func sequence[ initial])

将双参数函数func以迭代的方式从左到右依次应用至序列seq中每个元素，每次的计算结果作为下一次计算的第一个操作数继续参与运算，最终返回单个值作为结果。在Python 3.x中需要从标准库functools中导入reduce()函数再使用

reversed(seq)

返回seq（可以是列表、元组、字符串、range等对象）中所有元素逆序后的迭代器对象，但不能作用于zip、filter、map、enumerate、reversed等对象，reversed对象中的元素只能使用一次

round(x [ 小数位数])

返回对x进行四舍五入的结果，若不指定小数位数，则返回整数

函数

功能简要说明

sorted( key=None reverse=False)

返回按指定规则对iterable排序后的列表，其中iterable表示要排序的序列或迭代对象，key用来指定排序规则，reverse用来指定升序（False）或降序（True）。该函数不对iterable做任何修改

str(obj)

返回把对象obj直接转换为字符串的结果

sum(x start=0)

返回序列x中所有元素之和，允许指定起始值start（默认为0），返回start sum(x)的结果

type(obj)

返回对象obj的类型

zip(seq1 [ seq2 [...]])

返回zip对象，其中元素为(seq1[i] seq2[i] ...)形式的元组，最终结果中包含的元素个数取决于所有参数序列或可迭代对象中最短的那个，zip对象中的元素只能使用一次

>>>x = input('Please input: ')

Pleaseinput: 345

>>>type(x) # 返回字符串

<class'str'>

>>>int(x) # 转换为整数

345

>>>x = input('Please input: ')

Pleaseinput: [1 2 3]

>>>type(x)

<class'str'>

>>>eval(x) # 对字符串进行求值，还原为列表

[1 2 3]

>>>x = input('Please input:') # 不论用户输入什么， 都返回字符串

Please input:'helloworld'

>>>x # 如果本来就想输入字符串，那么不用再输入引号

"'helloworld'"

>>>eval(x)

'helloworld'

基本输入输出函数

>>>x = input('Please input: ')

Please input: 345

>>>type(x) # 返回字符串

<class'str'>

>>>int(x) # 转换为整数

345

>>>x = input('Please input: ')

Please input: [1 2 3]

>>>type(x)

<class'str'>

>>>eval(x) # 对字符串进行求值，还原为列表

[1 2 3]

>>>x = input('Please input:') # 不论用户输入什么， 都返回字符串

Please input:'helloworld'

>>>x # 如果本来就想输入字符串，那么不用再输入引号

"'helloworld'"

>>>eval(x)

'helloworld'

>>> print(1 3 5 7 sep='\t') # 修改默认分隔符

1 35 7

>>> for i in range(10):

print(i end=' ') # 修改默认行尾结束符， 不换行

0 1 2 3 4 5 6 7 8 9

数字有关的函数

（1）函数bin()、 oct()和 hex() 分别用来将整数转换为二进制数、八进制数和十六进制数的数字字符串，要求参数必须为整数。

>>> bin(555) # 将十进制整数转换为二进制数字字符串

'0b1000101011'

>>> oct(555) # 将十进制整数转换为八进制数字字符串

'0o1053'

>>> hex(555) # 将十进制整数转换为十六进制数字字符串

'0x22b'

>>> bin(0x888) # 将十六进制整数直接转换为二进制数字字符

'0b100010001000'

（2）函数int()用来将其他形式的数字转换为整数，参数可以为整数、实数、分数或合法的数字字符串，语法格式有int([x])和 int(x base=10)两种。

>>>int(-3.2) # 将实数转换为整数

-3

>>>int('0x22b' 16) # 将十六进制数转换为十进制数

555

>>>int('22b' 16) # 与上一行代码等价

555

>>>int(bin(54321) 2) # 二进制数与十进制数之间的转换

54321

>>>int('0b111') # 非十进制数字字符串， 必须指定第二个参数

ValueError:invalid literal for int() withbase 10: '0b111'

>>>int('0b111' 0) # 第二个参数 0 表示使用字符串隐含的进制

7

>>>int('0b111' 6) # 第二个参数必须与隐含的进制一致

ValueError:invalid literal for int() withbase 6: '0b111'

>>>int('111' 6) # 字符串没有隐含进制

# 这时第二个参数可以为 2 ～ 36 之间的整数

（3）函数float() 用来将其他类型数据转换为实数，函数complex()用来生成复数。

>>>float(3) # 把整数转换为实数

3.0

>>>float('5.5') # 把数字字符串转换为实数

5.5

>>>float('inf') # 无穷大， 其中inf不区分大小写

inf

>>>complex(3) # 只指定实部， 虚部默认为 0

(3 0j)

>>>complex(4 5) # 同时指定实部和虚部

(4 5j)

（4）函数abs() 用来计算实数的绝对值或者复数的模，函数divmod()用来同时计算两个数的商和余数，函数pow() 用来计算幂乘，函数round()用来对数字进行四舍五入。

>>>abs(-3) # 绝对值

3

>>>abs(-3 4j) # 复数的模

5.0

>>>divmod(60 8) # 返回商和余数组成的元组

(7 4)

>>>pow(2 3) # 幂运算， 2 的3 次方，相当于 2**3

8

>>>pow(2 3 5) # 相当于 (2**3) % 5

3

>>>round(10/3 2) # 四舍五入， 保留 2 位小数

3.33

序列有关的函数

（1）函数list()、 tuple()、 dict()、 set() 和 str()

>>>list(range(5)) # 把 range 对象转换为列表

[0 1 2 3 4]

>>>tuple(_) # 一个下画线表示上一次正确输出结果

(0 1 2 3 4)

>>>dict( zip('1234' 'abcde')) # 创建字典

{'4':'d' '2': 'b' '3': 'c' '1': 'a'}

>>>set('1112234') # 创建集合

{'4' '2' '3' '1'}

>>>str(1234) # 直接转换为字符串

'1234'

>>>str([1 2 3 4]) # 直接转换为字符串

'[1 2 3 4]'

>>>list(str([1 2 3 4])) # 注意这里的转换结果

['[' '1' ' ' ' ' '2' ' ' ' ' '3' ' ' ' ' '4' ']']

（2）函数max()、 min()、 sum()

>>> from random import randint

>>> scores = [randint(1 100) for i in range(10)]

# 包含 10 个 [1 100] 之间随机数的列表

>>> scores

[15 100 59 88 74 58 56 48 74 86]

>>> print(max(scores) min(scores) sum(scores))

# 最大值、 最小值、 所有元素之和

10015 658

>>> sum(scores) / len(scores) # 平均值

65.8

（3）函数sorted()

>>>x = list(range(11))

>>>import random

>>>random.shuffle(x) # 随机打乱顺序

>>>x

[2 4 0 6 10 7 8 3 9 1 5]

>>>sorted(x) # 以默认规则排序

[0 1 2 3 4 5 6 7 8 9 10]

>>>sorted(x key=lambda item:len(str(item)) reverse=True)

# 按转换成字符串以后的长度降序排列

[10 2 4 0 6 7 8 3 9 1 5]

>>>sorted(x key=str) # 按转换为字符串以后的大小排序

[0 1 10 2 3 4 5 6 7 8 9]

>>>x # 不影响原来列表的元素顺序

[2 4 0 6 10 7 8 3 9 1 5]

>>>list(reversed(x)) # 逆序， 翻转

[5 1 9 3 8 7 10 6 0 4 2]

（4）函数enumerate()

>>> list(enumerate('abcd')) # 枚举字符串中的元素

[(0 'a') (1 'b') (2 'c') (3 'd')]

>>>list(enumerate(['Python' 'Greate'])) # 枚举列表中的元素

[(0 'Python') (1 'Greate')]

>>> for index value inenumerate(range(10 15)):

print((index value) end=' ')

(0 10) (1 11) (2 12) (3 13) (4 14)

（5）函数zip()

>>>list(zip('abcd' [1 2 3])) # 压缩字符串和列表

[('a' 1) ('b' 2) ('c' 3)]

>>>list(zip('abcd')) # 对一个序列也可以压缩

[('a' ) ('b' ) ('c' ) ('d' )]

>>>list(zip('123' 'abc' ' .!')) # 压缩三个序列

[('1' 'a' ' ') ('2' 'b' '.') ('3' 'c' '!')]

>>>for item in zip('abcd' range(3)): # zip 对象是可迭代的

print(item)

('a' 0)

('b' 1)

('c' 2)

>>>x = zip('abcd' '1234')

>>>list(x)

[('a' '1') ('b' '2') ('c' '3') ('d' '4')]

>>>list(x) #zip 对象中的元素只能使用一次

[]

函数map()、 reduce()、 filter()

（1）函数map()

>>>list(map(str range(5))) # 把列表中元素转换为字符串

['0' '1' '2' '3' '4']

>>>def add5(v): # 单参数函数， 把参数加 5 后返回

return v 5

>>>list(map(add5 range(10))) # 把单参数函数映射到序列的所有元素上

[5 6 7 8 9 10 11 12 13 14]

>>>def add(x y): # 返回两个参数之和的函数

return x y

>>>list(map(add range(5) range(5 10))) # 把双参数函数映射到两个序列上

[5 7 9 11 13]

>>>import random

>>>x = random.randint(1 1e30) # 生成指定范围内的随机整数

>>>x

839746558215897242220046223150

>>>list(map(int str(x))) # 提取大整数每位上的数字

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

>>>sum(map(int str(x))) # 大整数各位数字之和

122

（2）标准库functools中的函数reduce()

>>> from functools import reduce

>>> seq = list(range(1 10)) # range(1 10) 包含从 1 到 9 的整数

>>> reduce(add seq) # add 是上一段代码中定义的函数

45

（3）函数filter()

>>>seq = ['foo' 'x41' '?!' '***']

>>>deffunc(x):

return x.isalnum() # 测试是否为字母或数字

>>>filter(func seq) # 返回可迭代的 filter 对象

<filterobject at 0x000000000305D898>

>>>list(filter(func seq)) # 把 filter 对象转换为列表

['foo' 'x41']

>>>seq #filter() 不对原列表做任何修改

['foo' 'x41' '?!' '***']

>>>list(filter(None [1 2 3 0 0 4 0 5])) # 指定函数为 None

[1 2 3 4 5]

函数range()

函数 range() 是 Python 中非常有用的一个函数，其语法格式为range([start ]stop[ step] )，有range(stop)、 range(start stop) 和 range(start stop step) 三种用法，参数 start 默认为 0， step 默认为 1。该函数返回具有惰性求值特点的 range 对象，其中包含左闭右开区间 [start end) 内以step为步长的整数。

>>>range(5) # start 默认为 0， step 默认为 1

range(0 5)

>>>list(range(1 10 2)) # 指定步长， 并转换为列表查看其中的内容

[1 3 5 7 9]

>>>list(range(9 0 -2)) # 步长可以为负数

[9 7 5 3 1]

精彩例题分析与解答

1、编写程序，输入一个包含若干自然数的列表，输出一个新列表，要求新列表中只包含原来列表中各位数字之和等于9 的自然数。

x = eval(input(' 请输入包含若干自然数的列表：'))

result = list(filter(lambda num:sum(map(int str(num)))==9 x))

print(result)