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 高效编程

分隔符为'*':

>>> print('Python'


    
, '高效编程', sep = '*')
Python*高效编程

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

name = 'Python高效编程'
fmt1 = f'公众号：{name}'
fmt2 = '公众号：{}'.format(name)
fmt3 = '公众号：%s' %name
print(fmt1)
print(fmt2)
print(fmt3)
# 公众号：Python高效编程

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() 读取一行内容。

with open('test.txt', 'r') as f:
    text1 = f.read()

with open('test.txt', 'r') as f:
    text2 = ''
    line = f.readline()
    while line:
        text2 += line
        line = f.readline()

assert text1 == text2
print(text1)

###############
输出内容：
Python 高效编程
Python 高效编程
Python 高效编程
Python 高效编程
###############

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

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

with open('test.txt', 'r',
       encoding='utf-8') as


    
 f:
    text1 = f.read()

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

with open('test.txt', 'r',
       encoding='gb2312') as f:
    text1 = f.read()

with open('test.txt', 'w',
       encoding='gbk') as f:
    f.write('Python高效编程')

input 函数获取控制台输入

input([prompt])

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

>>> s = input('请输入公众号名称：')
请输入公众号名称：Python高效编程
>>> s
'Python高效编程'

迭代相关

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




    
enumerate(iterable, start=0)

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

enumerate 函数的等价形式如下：

def enumerate(sequence, start=0):
  n = start
  for elem in sequence:
      yield n, elem
      n += 1

seq = ['P', 'y', 't', 'h', 'o', 'n']
for i, elem in enumerate(seq):
   print(i, elem)

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

zip(*iterables)

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

a = ["**", '**', '**']
b = ['微信公众号', '关注', 'Python高效编程']
c = a



    
print('#'*20)
for i, j, k in zip(a, b, c):
    print(i, j, k)
print('#'*20)

####################
** 微信公众号 **
** 关注 **
** Python高效编程 **
####################

序列属性

序列最大值：max

序列最小值：min

序列的和： sum

序列长度： len

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

import random
random.seed(21)
seq = [random.randint(0, 100) for i in range(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

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

import random
random.seed(21)
num = max(random.randint(0, 100) for i in


    
 range(10))
print(num)
# 88

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

def foo(x):
    return 1. / x
max(seq, key = foo)
# 21

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

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

class foo:
    def __init__(self, num, seq):
        self.num = num
        self.seq = seq
        
    def __len__(self):
        return len(self.seq)
        
    def __eq__(self, other):
        return self.num == other.num
        
    def __lt__(self, other):
        return self.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 _ in range(3):
  print('Python高效编程')

reversed 函数可以将序列逆置

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

import random
random.seed(21)
seq = [random.randint(0, 100) for i in range(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]
'程编效高nohtyP'
>>> ''.join(reversed('Python高效编程'))
'程编效高nohtyP'

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 返回对象的类型

class foo:
    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(lambda x: 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]
微信公众号 
>>> content = slice(6, 16)
>>> text[content]
Python高效编程

这篇文章到此结束了，大家可以趁热打铁，多多练习。觉得不过瘾的小伙伴，可以继续学习我们公众号中的python教程。

作者：flywind

来源：Python高效编程