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

本文纲要

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

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

输入输出	print() open()  input()
迭代相关	enmuerate()  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高效编程

这篇文章到此结束了，你们能够趁热打铁，多多练习。以为不过瘾的小伙伴，能够打开历史文章继续学下去。

-END-