常见的内置函数及迭代

使用列表实现队列和堆栈的效果
常见的内置函数
可迭代对象
迭代器对象
补充知识点——for循环的本质

使用列表实现队列和堆栈的效果

队列和堆栈的含

队列：先进先出

堆栈: 先进后出
用列表举例

new_list = []

1. 队列
存放数据
new_list.append(111)
new_list.append(222)
new_list.append(333)   # [111, 222, 333]

取出数据
print(new_list.pop(0))  # 111
print(new_list.pop(0))  # 222
print(new_list.pop(0))  # 333


2. 堆栈
存放数据
new_list.append(111)
new_list.append(222)
new_list.append(333)  # [111, 222, 333]

取出数据
print(new_list.pop())  # 333
print(new_list.pop())  # 222
print(new_list.pop())  # 111

常见的内置函数

abs( )

使用 abs( ) 能够直接计算出绝对值
all ( ) 与 any( )

all( ) 与 any( ) 能够判断容器类型种的所有数据值对应的布尔值是否为 True

all( ) 是在说有数据全部为 True 的时候结果才为True

any( ) 是数据种只要有一个为True , 结果就为True
bin () oct( ) hex( )

十进制转其他进制

bin( ) 十进制转二进制

oct( ) 十进制转八进制

hex( ) 十进制转十六进制
int()

类型转换（转换成整型）

将其他进制数转换成十进制
bytes()

类型转换（转换成字节形式）
callable() # call在IT专业名词中翻译成调用>>>:加括号执行

判断某个变量是否可以加括号调用
chr() 和 ord ( )

依据ASCII码表实现字符与数字的转换

chr( ) 是将数字转换成字符

ord( ) 是将字符转换成数字
dir( )

获取对象内部可以通过句点符获取的数据
divmod( )

获取除法之后的整数和余数

enumerate( )

枚举

name_list = ['jason', 'kevin', 'oscar', 'jerry']
需求:循环打印出数据值并且对应的索引值
for i, j in enumerate(name_list, 100):  # 默认是从0开始 可以自定义
    print(i, j)

eval( ) exec（）

能够识别字符串中python代码并执行

eval( ) 不能识别复杂的代码，智能识别最简单的

exec( ) 能识别所有复杂结构的代码
hash( )

返回一串随机的数字(哈希值)
help( )

查看帮助信息
isinstance( )

判断某个数据是否属于某个数据类型
pow( )

幂指数
round( )

大致:四舍五入

由于python计算的原因有时候五舍六入

常见的内置函数表

数学相关

函数	作用	函数	作用
abs(a )	求取绝对值	max(list )	求取最大值
min(list )	求取最小值	sum(list )	求取元素的和
sorted(list )	排序，返回排序后的list	len( list)	list的长度
divmod(a, b )	获取商和余数	pow( a, b)	获取幂方数
round(a,b )	获取指定位数的小数。a代表浮点数，b代表要保留的位数	range(a, [b] )	生成一个a到b的数组,左闭右开

类型转换

函数	作用	函数	作用
int( str)	转换为int型	float(int/str )	将int型或字符型转换为浮点型
str(int )	转换为字符型	bool(int )	转换为布尔类型
bytes(str,code )	接收一个字符串，与所要编码的格式，返回一个字节流类型	list(iterable)	转换为list
iter(iterable)	返回一个可迭代的对象	dict(iterable)	转换为dict
enumerate(iterable)	返回一个枚举对象	tuple(iterable)	转换为tuple
set(iterable)	转换为set	hex(int)	转换为16进制
oct(int)	转换为8进制	bin(int)	转换为2进制
chr(int)	转换数字为相应ASCI码字符	ord(int)	转换ASCI字符为相应的数字

功能相关

函数	作用	函数	作用
eval()	识别并执行简单的python语句	exec()	识别并执行全部复杂的python语句
filter(func,iterable)	通过判断函数fun，筛选符合条件的元素	map(func,*iterable)	将func用于每个iterable对象
zip(*iterable)	将iterable分组合并。返回一个zip对象	type()	返回一个对象的类型。
id()	返回一个对象的唯一标识值	hash(object)	返回一个对象的hash值，具有相同值的object具有相同的hash值
help()	调用系统内置的帮助系统	isinstance()	判断一个对象是否为该类的一个实例
issubclass()	判断一个类是否为另一个类的子类	globals()	返回当前全局变量的字典
next(iterator[, default])	接收一个迭代器，返回迭代器中的数值，如果设置了default，则当迭代器中的元素遍历后，输出default内容	reversed(sequence)	生成一个反转序列的迭代器

可迭代对象

什么是迭代

迭代就是更新换代每次迭代都需要基于上一次的成果
如何判断可迭代对象

内置有__iter__方法的都叫做可迭代对象
1.内置是什么意思通过句点符直接能够点出来的东西都叫内置
2. __ xxx __ 针对双下划线开头双下划线结尾的方法统一读作双下XXX
可迭代对象和不可迭代对象的类型

1.可迭代对象

字符串, 列表 ,字典 ,元组 ,集合 ,文件对象(本身就是迭代器对象)

可迭代对象能够支持for循环取值

2.不可迭代对象

整型 ,浮点型, 布尔值, 函数名

迭代器对象

迭代器对象的作用

迭代器对象给我们提供了一种不依赖于索引取值的方式
正是因为有迭代器对象的存在我们才能对字典、集合这些无序类型循环取值
如何判断迭代器对象

内置有__iter__和__next__的对象都称为迭代器对象
可迭代对象与迭代器对象之间的关系

可迭代对象调用__iter__方法之后就会变成迭代器对象
迭代器对象调用__iter__方法无论多少次还是迭代器对象本身
迭代器对象迭代取值

  res = 'jason'.__iter__()  # res已经是迭代器对象
     print(res.__next__())  # j
     print(res.__next__())  # a
     print(res.__next__())  # s
     print(res.__next__())  # o
     print(res.__next__())  # n
     print(res.__next__())  # 没有了直接报错


     d1 = {'name':'jason','pwd':123}
     res = d1.__iter__()
     print(res.__next__())
     print(res.__next__())


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

迭代器对象的优缺点
优点
1. 为序列和非序列类型提供了一种统一的迭代取值方式。
2. 迭代器对象表示的是一个数据流，可以只在需要时才去调用__next__来计算出一个值，迭代器对象在同一时刻的内存中只有一个值，因而可以存放无限大的数据流
缺点
1. 除非取尽，否则无法获取迭代器的长度
2. 只能取一个值，像是一次性的取值，迭代器产生后的唯一目标就是重复执行next方法直到值取尽，否则就会停留在某个位置，等待下一次调用__next__

补充说明

迭代器的反复使用

l = [11, 22, 33, 44]
        # print(l.__iter__().__next__())  # 11  每次都是产生了一个新的迭代器对象
        # print(l.__iter__().__next__())  # 11
        # print(l.__iter__().__next__())  # 11
        # print(l.__iter__().__next__())  # 11
        
res = l.__iter__()
        print(res.__iter__().__next__())  # 11  每次使用的都是一个迭代器对象
        print(res.__iter__().__next__())  # 22
        print(res.__iter__().__next__())  # 33
        print(res.__iter__().__next__())  # 44

当不给迭代器对象赋值时，每一次使用都会产生一个新的迭代器

给迭代器对象赋值时，每一次使用都是用的同一个迭代器对象

针对双下方法

res = l.__iter__()  # 可以简写iter(l)
res.__next__()  # 可以简写next(res)

迭代器对象的特殊
可迭代对象迭代器对象通过打印操作无法直接看出内部数据的情况

这个时候他们都能够帮你节省内存
for 循环的本质
Python的for循环本质上就是通过调用Iterable可迭代对象的__iter()__方法获得一个Iterator迭代器对象,然后不断调用Iterator迭代器对象 __ next() __ 方法实现的。