Python常见内置函数与迭代器

常见内置函数

# 常见内置函数
# 什么是内置函数，提前定义好的且可以直接使用的函数
# 1.abs() 求绝对值
# print(abs(-88))       # 88
# 2.all()与any()        判断容器类型中所有的数据值对应的布尔值是否为True   这两个类似于我们之前学过的逻辑运算符里边的三种表达方式中的两种，即与and和或or
# all()                 所有的数据值为True的情况下，结果才是True
# print(all([11, 22, 33, 44, 55, 66, 0]))           # False
# print(all([11, 22, 33, 44, 55, 66]))              # True
# any()                 所有的数据值中，只要有一个数据值为True，结果就是True
# print(any([11, 22, 33, 44, 55, 66, 0]))           # True
# print(any([11, 22, 33, 44, 55, 66]))              # True
# 3.bin() oct() hex()  将十进制分别转换为二进制、八进制、十六进制
# print(bin(99))          # 0b1100011    十进制转二进制
# print(oct(99))          # 0o143        十进制转八进制
# print(hex(99))          # 0x63         十进制转十六进制
# 4.int() 类型转换  其他进制转换为十进制
# print(int(0b1100011))   # 99           二进制转十进制
# print(int(0o143))       # 99           二进制转八进制
# print(int(0x63))        # 99           二进制转十六进制
# 5.bytes()  类型转换  可以用于编码与解码
# line = ('大鹏一日同风起 扶摇直上九万里'.encode('utf8'))
# print(line)
# line1 = line.decode('utf8')
# print(line1)
# line = (bytes('大鹏一日同风起 扶摇直上九万里', 'utf8'))
# print(line)
# line2 = str(line, 'utf8')
# print(line2)
# 6.callable()   判断某个变量是否可以被加括号调用
# name = 'zs'
# def index():
#     print('111')
# print(callable(name))                # False
# print(callable(index))               # True
# 7.chr() ord()  两者互为反关系，一个是将数字转换为字母。一个是将字母转换为数字 依据ASCII码表实现字符与数字的转换，ASCII码表记录了英文字符与数字的对应关系
# print(chr(88))           # X        65~90
# print(chr(108))          # l        97~122
# print(ord('B'))          # 66
# print(ord('b'))          # 98
# 8.dir()        获取对象内部可以通过句点符获取的数据
# print(dir(str))
# 9.divmod       获取除法之后的整数和余数
"""
手上有很多数据 每页展示10条 需要多少页
    通过代码自动计算

总数据         每页展示            需要多少页
 100            10                  10
 99             10                  10
 101            10                  11
 898            10                  ???
"""
# real_number, more = divmod(898, 10)  # 解压赋值
# if more:
#     real_number += 1
# print('总页数:%s' % real_number)  # 总页数:90

# 10.enumerate()  枚举
# name_list = ['柳宗元', '韩愈', '欧阳修', '苏洵', '苏轼', '苏澈', '王安石', '曾巩']
# 需求:循环打印出上述列表里的数据值并且要有其对应的索引值
# count = 0
# for i in name_list:
#     print(count, i)
#     count += 1
# for i, j in enumerate(name_list, start=1):
#    将for循环出来的数据值交给前面的变量接收，然后使用解压赋值的方式把数据值依次赋值给变量名i和j  默认从0开始，但是可以自己设置
# print(i, j)   # 1 柳宗元 2 韩愈 3 欧阳修 4 苏洵 5 苏轼 6 苏澈 7 王安石 8 曾巩
# 11.eval() exec()   # 可以识别字符串中的python代码并执行
# chars = 'print(666)'
# print(chars)
# eval(chars)           # 666   只能识别最简单的python代码
# exec(chars)           # 666   能够识别复杂类的python代码
# chars = 'for i in range(10):print(i)'
# eval(chars)
# exec(chars)
# 12.hash 返回一串随机的数据值(哈希值)
# print(hash('666'))    # -4553508281048470705
# 13.help()  查看帮助
# help(input)
# 14.isinstance()   判断某个数据是否属于某个数据类型
# print(isinstance('lisa', int))      # False
# print(isinstance('123', str))       # True
# 15.pow()  幂指数
# print(pow(2, 4))              # 16
# 16.round()  四舍五入
# print(round(99.4))            # 99
# print(round(99.5))            # 100

可迭代对象

• 迭代：就是更新换代的意思，就好比我们手机的系统升级，软件更新，还有电脑有的时候会提示让你更新，并说明此次版本更新以后，增加了哪些内容，删除了哪些内容，优化了些什么东西，包括我们以后参加工作了，都会编写技术文档或者用户手册，这些输出的技术文档，你肯定不止是写一个版本，初始版本，测试版本，优化版本，最终版本，这就是一个简单的迭代的概念，它每次更新都会基于上一个版本进行改动。

• 可迭代对象：可以对列表、字典、元组、字符串等类型的数据使用for循环的方式依次取值进行使用，并且提供了一种不依赖于索引取值的方式，因为字典和集合是不支持索引取值的，它们的内部是无序的

  表达关键字：iterable

代码实例：

n = 0
while n < 10:
    print(n)
    n += 1
    
    每一次打印n，都是基于n+1后得出的结果

• 如何判断是可迭代对象

内置有__iter__方法的都叫做可迭代对象

内置是能够通过句点符直接点出来的东西

__xxx__  针对双下划线开头双下划线结尾的方法，统一读作双下xxx

对象的概念：没有具体的表现形式，可以是数字、字符串、列表、字典、元组、函数名等等   在python中一切皆对象

# int    # 整型不是可迭代对象
# float  # 浮点型不是可迭代对象
# str.__iter__()   # 字符串是可迭代对象
# list.__iter__()  # 列表是可迭代对象
# dict.__iter__()  # 字典是可迭代对象
# tuple.__iter__() # 元组是可迭代对象
# set.__iter__()   # 集合是可迭代对象
# bool             # 布尔值不是可迭代对象
# def index():     # 函数名不是可迭代对象
#    pass
# f = open(r'01 常见内置函数.py', 'r', encoding='utf8')   文件是可迭代对象，同时也是迭代器对象
# f.__iter__()
# f.__next__()


"""

可迭代对象：
        字符串、列表、字典、元组、集合、文件
不可迭代对象：
        整型、浮点型、布尔值、函数名
"""

迭代器对象

作用：迭代器对象给我们提供了一种不依赖于索引取值的方式，所以我们才能够对字典、集合等无序数据类型循环取值  还可以节省内存

• 如何判断迭代器对象

内置有__iter__和__next__的对象都称为是迭代器对象

可迭代对象与迭代器对象的关系

		可迭代对象在调用__iter__方法之后就会变成迭代器对象

		迭代器对象调用__iter__方法无论多少次还是迭代器本身

迭代器对象的迭代取值

		迭代器对象执行__next__方法，就类似于循环取值
		
# name = '张三'.__iter__()           # name已经是迭代器对象
# print(name)      # <str_iterator object at 0x0000017E218C4B80>
# print(name.__next__())            # 张
# print(name.__next__())            # 三
# print(name.__next__())            # 报错

# dic = {'name': 'lisa', 'pwd': 666}
# dic1 = dic.__iter__()
# print(dic1.__next__())              # name
# print(dic1.__next__())              # pwd

# l1 = [777, 888, 99, 2, 3, 456, 66, 22]
# 需求：不使用for循环  依次打印出列表中所有的数据值
# 1.先将列表变成迭代器对象
# res = l1.__iter__()
# 2.定义一个计数器
# count = 0
# 3.编写while循环
# while count < len(l1):
#     print(res.__next__())
#     count += 1


# l1 = [66, 77, 88, 99]
# print(l1.__iter__().__next__())             # 66   把列表转换成迭代器对象  每次都是产生了一个新的迭代器对象
# print(l1.__iter__().__next__())             # 66   把列表转换成迭代器对象  每次都是产生了一个新的迭代器对象
# print(l1.__iter__().__next__())             # 66   把列表转换成迭代器对象  每次都是产生了一个新的迭代器对象
# print(l1.__iter__().__next__())             # 66   把列表转换成迭代器对象  每次都是产生了一个新的迭代器对象

# l2 = l1.__iter__()                            
# print(l2.__iter__().__next__())               # 66   每次使用的都是一个迭代器对象
# print(l2.__iter__().__next__())               # 77   每次使用的都是一个迭代器对象
# print(l2.__iter__().__next__())               # 88   每次使用的都是一个迭代器对象
# print(l2.__iter__().__next__())               # 99   每次使用的都是一个迭代器对象
		
针对双下方法

l1 = [1, 2, 3, 4, 5]
res = l1.__iter__()   # iter(l1)
res.__next__()        # next(res1)

迭代器对象特殊情况

	可迭代对象  迭代器对象  通过打印的方式无法直接看出内部数据的情况  这个时候它们都可以节省内存，可以把它当做哆啦A梦的口袋，你要什么就从里边拿什么就可以了
	
# res = range(10).__iter__()
# print(res.__next__())                  # 0
# print(res.__next__())                  # 1
# print(res.__next__())                  # 2
# print(res)                             # <range_iterator object at 0x000001E40A7379D0>
	

for循环本质

语法结构
	for 变量名 in 可迭代对象：
			循环体代码
1.for会自动将in后面的数据调用__iter__（）变成迭代器对象
2.之后每次循环调用__next__()进行取值
3.最后没有值调用__next__()就会报错，for循环会自动处理报错，并让循环正常结束