重要内置函数

1.map映射

map映射就是根据途共的函数对指定的序列做映射
l1 = [12,23,28,34,65]
需求:元素全部自增6
方法1:利用列表生成式
def index(n):
    return n + 6
res = map(index,l1)
print(list(res))  # [18, 30, 34, 40, 71]

方法2:内置函数
res = map(lambda x: x+6,l1)
print(list(res)) # [18, 30, 34, 40, 71]

2.zip拉链

从多个数据集中取出元素组合成一个新的数据集，返回一个列表
a = [1,2,3]
b = [4,5,6]
res = zip(a,b)
print(list(res)) # 因为直接打印res出来的是迭代器，所以把它装化成列表打印出来
# [(1,4),(2,5),(3,6)]

zip(*)与zip相反，可理解为解压，返回原始的数据集
a1, a2 = zip(*zip(a,b))
print(list(a1)) # [1,2,3]
print(list(a2)) # [4,5,6]

'''zip可以整合多个数据集'''
a = [1,2,3]
b = [4,5,6]
c = ['蜘蛛侠','钢铁侠','绿箭侠']
d = [123,456,789]
res = zip(a,b,c,d)
print(list(res))
# [(1, 4, '蜘蛛侠',123),(2, 5, '钢铁侠',456),(3, 6, '绿箭侠',789)]

不使用zip拉链
a = [1,2,3]
b = [4,5,6]
c = ['蜘蛛侠','钢铁侠','绿箭侠']
d = [123,456,789]
res = [(a[i], b[i], c[i], d[i])for i in range(len(a))]
print(res)

'''zip在整合多个数据集时，当数据集之间个数不一致，那么依据短的'''
b = [4, 5]
c = ['蜘蛛侠','钢铁侠','绿箭侠']
res = zip(b, c)
print(list(res)) #[(4, '蜘蛛侠'), (5, '钢铁侠')]

3.filter过滤

filter过滤函数接收两个参数,第一个为判断函数,第二个为判断对象,第二个的每个元素作为参数传递给判断函数,然后返回 True 或 False,最后将返回 True 的元素放到新列表中

l1 = [4, 5, 6, 7, 12, 14]
# 取出大于10的数字
方法1:利用列表生成式
def index(x):
    return x > 10
res = filter(index,l1)
print(list(res))  # [12, 14]

方法2:内置函数
res = filter(lambda x:x>10, l1)
print(list(res))  # [12, 14]

4.reduce归总

from dunctools import reduce # 固定
作用就是对序列中的元素进行积累


from functools import reduce
l1 = [1, 2, 3, 4, 5]
res = reduce(lambda x,y: x+y, [1, 2, 3, 4, 5])
print(res)
计算的流程就是((((1+2)+3)+4)+5) # 15

5.sorted排序

l1 = [21, 12, 53, 64, 76, 32, 11, 22]
res = sorted(l1)
print(res)  # 默认升序

常见的内置函数补充

1、获取绝对值(不考虑绝对值)
print(abs(-123))  # 123
print(abs(123))  # 123

2.all()与any()   一个是全部，一个是任一
l1 = [2, 0, 1, 1, True]
print(all(l1))  # False  数据集中必须所有的元素对应的布尔值为True返回的结果才是True
print(any(l1))  # True   数据集中只要所有的元素对应的布尔值有一个为True 返回的结果就是True

3.bin() oct() hex()  # 产生对应的进制数
print(bin(100))  # 0b1100100  二进制
print(oct(100))  # 0o144  八进制
print(hex(100))  # 0x64  十六进制

4.bytes()   # 类型转换
s = '锄禾日当午'
print(s.encode('utf8'))  # b'\xe9\x94\x84\xe7\xa6\xbe\xe6\x97\xa5\xe5\xbd\x93\xe5\x8d\x88'
print(bytes(s, 'utf8'))  # b'\xe9\x94\x84\xe7\xa6\xbe\xe6\x97\xa5\xe5\xbd\x93\xe5\x8d\x88'
'''针对编码解码 可以使用关键字encode与decode  也可以使用bytes和str  ，bytes为编码、str为解码'''

5.callable()   判断当前对象是否可以加括号调用
name = 'owen'
def index():pass
print(callable(name))  # False  变量名不能加括号调用
print(callable(index))  # True  函数名可以加括号调用

6.chr()、ord()  # 字符与数字的对应转换
print(chr(71))  # G 根据数字转字符  使用ASCII码
print(ord('d'))  # 100 根据字符转数字  使用ASCII码

7.dir() 
# 返回数据类型可以调用的内置方法(查看对象内部可调用的属性)
print(dir(52))
print(dir('owen'))  
# 结果太长，不打印了，可以自己使用上面代码试试

8.divmod()
"""
可以使用在网站的分页制作上
      总共250条数据 每页展示25条 需要多少页   10页
       总共300条数据 每页展示25条 需要多少页   12页
        总共234条数据 每页展示25条 需要多少页   9页
"""
print(divmod(250,25))  # (10, 0)  第一个参数是整数部分 第二个是余数部分
print(divmod(300,25))  # (12, 0)
print(divmod(234,25))  # (9, 9)

def get_page_num(total_num,page_num):  #django分页器使用
    more,others = divmod(total_num, page_num)
    if others:
       more += 1
       print('需要%s页'%more)
get_page_num(1688,30)  # 需要57页


9.enumerate()  枚举
name_list = ['owen', 'kevin', 'wuxidixi', 'mary']
for i,j in enumerate(name_list):
    print(i,j)  # i类似于是计数 默认从0开始
0 owen
1 kevin
2 wuxidixi
3 mary

for i,j in enumerate(name_list,start=1):
    print(i,j)  # 还可以控制起始位置
1 owen
2 kevin
3 wuxidixi
4 mary
    
10.eval() exec()  识别字符串中的python代码,不常用
print('print("不错不错")')  # 不错不错
eval('print("不错不错123")')  # 不错不错123
exec('print("不错不错234")')  # 不错不错234
res = """
for i in range(10):
    print(i)
"""
eval(res)  # 报错  只能识别简单逻辑的python代码
exec(res)  # 0~9  能够识别具有与一定逻辑的python代码
exec可以执行动态Python代码
eval函数可以计算Python表达式，并返回结果（exec不返回结果）

可迭代对象

1.迭代

迭代的含义:
    迭代其实就是更新换代,并且在更新换代时,要更新的内容还要依靠上一次更新的结果
    
迭代代码是什么样子？
a = 1
while Ture:
    print(a)
    a +=1 # 每次都要借助+=1, 符合迭代条件
    
使用迭代取值:
l1 = [11, 12, 13, 14, 15, 16]
n = 0
while n < len(l1):
    print(l1[n])
    n += 1 # 11 12 13 14 15 16

2.可迭代对象

1.含义:
内置中有__iter__方法的都成为可迭代对象
"""
1.内置方法 通过点的方式能够调用的方法
2.__iter__ 双下iter方法
"""

2.可迭代对象的范围
	不是可迭代对象
    	int float bool 函数对象
    是可迭代对象
    	str list dict tuple set 文件对象
        
3.可迭代的含义
	"""
	迭代:更新换代(每次更新都必须依赖上一次的结果)
		eg:手机app更新
	"""
	可迭代在python中可以理解为是否支持for循环

迭代器对象

1.含义
	可迭代对象调用__iter__,生成的结果就是迭代器对象

2.特征
	含有__iter__的方法和__next__方法

3.如何理解迭代器对象
  迭代器对象可以很大程度上节省存储空间
  也就是你想要什么，要哪个可以给你拿出来，当你不需要的时候，它就是一个很小的东西，很节省空间

4.迭代器对象取值
  调用__next__方法，当值被取完时会发生报错
  
5、迭代器对象补充说明

5.1、有些双下方法有简单写法：
   """ 
   __方法名__ = 方法名()
   例如：
    __iter__ = iter()
    __next__ = next()
    __len__ = len()
   """
l = [1, 2, 3, 4]
print(l.__iter__())  # <list_iterator object at 0x0000012915BC5FA0>
print(iter(l))  # <list_iterator object at 0x0000012915BC5FA0>  
# 产生的结果是一样的

5.2、有一些可迭代对象本身也是迭代器对象>>>:文件对象  # 既有__iter__方法也有__next__方法
    
5.3、当迭代器对象调用一次__iter__方法编辑迭代器对象，当再调用时，结果还是迭代器本身
l = [1, 2, 3, 4]
res = l.__iter__()
res1 = l.__iter__().__iter__().__iter__()
print(res, res1)
# <list_iterator object at 0x000001F877675FA0> 
# <list_iterator object at 0x000001F87767A130>

5.4、迭代取值的要求
 当直接调用一个数据时，如果被调用对象不是迭代器对象，那么每次调用的结果都一样
    eg:
l = [1, 2, 3, 4]
print(l.__iter__().__next__())
print(l.__iter__().__next__())
print(l.__iter__().__next__())
print(l.__iter__().__next__())
# 1
# 1
# 1
# 1


如何让它取里面一个一个的值
把l变成迭代器对象
l = [1, 2, 3, 4]
res = l.__iter__()
当l成为迭代器对象时再次调用
print(res.__iter__().__next__())
print(res.__iter__().__next__())
print(res.__iter__().__next__())
print(res.__iter__().__next__())
# 1
# 2
# 3
# 4

3.迭代取值与索引取值的对比

1.索引取值:
    优势:可以反复的获取相同的元素,且没有固定的方向
    劣势:只能支持有序的容器类型,无序无法取值
2.迭代取值:
    优势:兼容所有容器类型
    劣势:取值的顺序永远是从左到右,但是没法重复获取

for循环的本质

for 变量名 in 可迭代对象:
    循环体代码
    
 """
 1.先将in后面的数据调用__iter__转变成迭代器对象
 2.依次让迭代器对象调用__next__取值
 3.一旦__next__取不到的值报错 for循环会自动捕获并处理
 """

异常捕获/处理

1.异常
	异常就是代码运行报错 行业俗语叫bug 
    代码运行中一旦遇到异常会直接结束整个程序的运行 我们在编码代码的过程中药尽可能避免
2.异常分类
	语法错误
    	不允许出现 一旦出现立刻改正 否则提桶跑路
    逻辑错误
    	允许出现的 因为它一眼发现不了 代码运行之后才可能会出现
3.异常结构
	错误位置
    错误类型
    错误详情

原文地址：http://www.cnblogs.com/super-xz/p/16792903.html