Python 初学者必备的常用内置函数

本文纲要

Python 作为一门高级编程语言，为我们提供了许多方便易用的内置函数，节省了不少开发应用的时间。目前，Python 3.7 共有 69 个内置函数，一些是我们耳熟能详的函数，另一些却不是很常见，这里主要介绍一些新手必备函数及其用法。

为了便于说明，我把这些内置函数粗略地分为六大类：

输入输出print() open() input()

迭代相关enumerate() zip()

序列属性sum() max() min() len()

操作序列sorted() reversed() range()

对象属性dir() id() isinstance() type()

映射类型eval() map() slice()

输入输出

print 函数将对象输出至控制台

print(*objects, sep=' ', end='\n',file=
sys.stdout, flush=False)

*objects 为可变参数，可以接受任意多个对象。sep 参数表示输出对象之

间的分隔符，默认为空格。

>>> print('Python','Python')
Python Python

分隔符为'*':

>>> print('Python','Python', sep ='*')
Python*Python

格式化输出字符串的三种方式：

name ='Python'
fmt1 =f'Python：{name}'
fmt2 ='Python：{}'.format(name)
fmt3 ='Python：%s'%name
print(fmt1)
print(fmt2)
print(fmt3)

open 函数打开文件并返回文件对象

open(file, mode='r', buffering=-1,encoding=None, errors=None, newline=None, closefd=True, opener=None)

file 为文件地址，mode 为打开文件的模式，默认为 'r'，表示读取文件，常用的还有：'w' 表示写入文件、'b' 表示以二进制形式打开。

常用上下文管理器 with 打开文件，f.read( ) 读取全部内容，f.readline() 读取一行内容。

withopen('test.txt','r')PythonPythonPythonPythonPythonPythonPythonPythonasf:
 text1 = f.read()
withopen('test.txt','r')asf:
 text2 =''
 line = f.readline()
 whileline:
   text2 += line
   line = f.readline()

asserttext1 == text2
print(text1)

有时候，我们读取文件还会遇到乱码问题，可以指定编码格式：

当文件中有中文的时候，使用 'utf-8' 编码会导致异常：UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb8 in position 7: invalid start byte

withopen('test.txt','r',
   encoding='utf-8')asf:
 text1 =f.read()

这时候，我们可以尝试 'gb2312' 或者 'gbk' 编码来打开含有中文字符的文件。这时，便可以成功打开文件。

withopen('test.txt','r',
   encoding='gb2312')asf:
 text1 =f.read()

withopen('test.txt','w',
   encoding='gbk')asf:
 f.write('Python')

input 函数获取控制台输入

input([prompt])

input 可接受字符串为参数，提示用户输入。

>>>s = input('Python：')
Python：Python
>>>s
'Python'

迭代相关

enumerate 函数返回元素的序号与对应值

enumerate(iterable, start=0)

iterable 参数表示可迭代对象，start 参数是元素序号的起点，默认为 0。

enumerate 函数的等价形式如下：

defenumerate(sequence, start=0):
n = start
foreleminsequence:
  yieldn, elem
  n +=1

seq =['P','y','t','h','o','n']fori, eleminenumerate(seq):
 print(i, elem)

zip 函数用于同时迭代多个对象

zip(*iterables)

*iterable 可以接受任意多个可迭代对象

a = ["**",'**','**']
b = ['Python','Python','Python']
c = a
print('#'*20)
fori, j, kinzip(a, b, c):
 print(i, j, k)
print('#'*20)

序列属性

序列最大值：max

序列最小值：min

序列的和： sum

序列长度： len

基本用法：向这四个函数中传入序列，可以得到对应属性。

importrandom
random.seed(21)
seq = [random.randint(0,100)foriinrange(10)]
print(seq)
# [21, 53, 88, 53, 81, 36, 61, 27, 60, 65]
print(max(seq))
# 88
print(min(seq))
# 21
print(sum(seq))
# 545
print(len(seq))
# 10

作为内置函数，可以直接传入生成器（不需要括号）作为参数：

importrandom
random.seed(21)
num = max(random.randint(0,100)foriinrange(10))
print(num)
# 88

可传入 key 参数，作为比较大小的依据，相当于把序列中每一个元素 item 先传入函数 key 中，将函数返回的数值作为判断对象大小的依据。

deffoo(x):
 return1./ x
max(seq, key = foo)
# 21

对于我们自定义的类型，必须实现特殊方法，才能进行 len 等操作。

__len__ 代表：len 操作，__eq__ 代表：= 操作，__lt__ 代表 < 操作。

classfoo:
 def__init__(self, num, seq):
   self.num = num
   self.seq = seq
   
 def__len__(self):
   returnlen(self.seq)
   
 def__eq__(self, other):
   returnself.num == other.num
   
 def__lt__(self, other):
   returnself.num < other.num

>>> f1 = foo(18, [1,4,6])
>>> f2 = foo(21, [1,7,9,10])
>>> f1 < f2
True
>>> f1 > f2
False
>>> f1 == f2
False
>>> f3 = foo(18, [9,9,0,7])
>>> f1 == f3
True
>>> len(f1)
3
>>> len(f2)
4

操作序列

range 函数生成序列

range(start, stop[, step])

start 可选参数，默认为 0 ，表示序列起点stop 必选参数，表示序列终点，不包括终点step 可选参数，序列的步长，默认为 1

>>> range(6)
range(0,6)
>>> list(range(6))
[0,1,2,3,4,5]
>>> list(range(0,6,2))
[0,2,4]

range 函数生成的对象可以迭代，和列表很类似，_ 表示废弃变量（为了避免污染变量环境）：

for_ inrange(3):
print('Python')

reversed 函数可以将序列逆置

reversed 可以将序列逆置，包括元组、字符串、列表。对于列表和字符串的逆置，使用 list[::-1] 或者slice()更加方便。

importrandom
random.seed(21)
seq = [random.randint(0,100)foriinrange(10)]
print(seq)
# [21, 53, 88, 53, 81, 36, 61, 27, 60, 65]
reversed(seq)
print(list(reversed(seq)))
# [65, 60, 27, 61, 36, 81, 53, 88, 53, 21]

字符串逆置：

>>> a='Python'
>>> a[::-1]
'Python'
>>>''.join(reversed('Python'))
'Python'

sorted 函数可以对序列进行排序

sorted(iterable, *, key=None, reverse=False)

sorted 不同于 list.sort 操作（原地排序），返回一个新的有序序列，原序列保持不变。* 表示仅限关键字参数(keyword-only)，也就是说，key、reverse 参数只能通过关键字传参，而不能通过位置传参。reverve 参数表示逆置操作，key 与之前 len 中的 key 参数类似，是函数排序的依据。

>>> sorted([9,6,2,3,6])
[2, 3, 6, 6, 9]

对象属性

dir 函数返回属性列表

id 函数返回对象地址

isinstance 判断对象的类型

type 返回对象的类型

classfoo: pass>>> dir(foo)['__class__','__delattr__','__dict__','__dir__',......'__str__','__subclasshook__','__weakref__']# 创建实例>>> f = foo()>>> type(foo)__main__.foo>>> isinstance(f, foo)True>>> id(f)2135099584864

映射类型

eval 解除引号的束缚

map 应用函数于单个对象

slice 生成切片

eval 可以去除字符串的单引号，从而获取引号内部内容。下面的演示展示了，如何使用 eval 函数获取字符串中的字典：

>>> info ='{"name": "LiHua", "age": 12}'
>>> eval(info)
{'name':'LiHua','age':12}
>>> info_dict = eval(info)
>>> type(info_dict)
dict

map 将传进来的函数应用于序列中的每一个元素，并返回迭代器。

map(function,iterable, ...)

举例来说,map 就是对 seq 列表中的每一个元素 item 进行 int 操作(int(item))。匿名函数同理，就是对序列中的每一个元素进行加 2 的操作。

>>>seq = [1.5,4.5,9.1]
>>> list(map(int, seq))
[1, 4, 9]
>>> list(map(lambdax:x+2, seq))
[3.5, 6.5, 11.1]

slice 函数为切片操作命名，使得切片操作更加清晰明了。

slice(start,stop[, step])

start 为起点，stop 为终点，step 为步长。使用该操作，使得截取有规律的文本内容变得很轻松。特别是长文本，使用 slice 函数更加清晰易懂。

>>> text =' Python'
>>> name = slice(0,6)
>>> text[name]
Python
>>> content = slice(6,16)
>>> text[content]
Python

这篇文章到此结束了，大家可以趁热打铁，多多练习。