【python基础】第22回 常见内置函数与迭代器

本章内容概要

1. 队列与堆栈

2. 用户权限讲解

3. 常见内置函数

4. 可迭代对象

5. 迭代器对象

6. for循环的本质

本章内容详解

1. 队列与堆栈

1.1 队列：先进先出，后进后出

1.2 堆栈：先进后出，后进先出

1.3 用列表实现队列与堆栈的效果

1. 队列

# 先定义一个空列表
new_list = []
# 先放数据
new_list.append(111)
new_list.append(222)
new_list.append(333)
# 再取数据
print(new_list.pop(0))  # 111
print(new_list.pop(0))  # 222
print(new_list.pop(0))  # 333

2. 堆栈

# 先定义一个空列表
new_list = []
# 先放数据
new_list.append(111)
new_list.append(222)
new_list.append(333)
# 在取数据
print(new_list.pop())  # 333
print(new_list.pop())  # 222
print(new_list.pop())  # 111

2. 用户权限题讲解

# 要求: 调用上述三个函数的时候需要从user_data中校验用户身份是否正确
# 并获取当前登录用户拥有的可执行函数功能编号即键access对应的功能编号列表
# func1是1、func2是2、func3是3
# 并且一旦用户登录成功之后后续函数的调用不再校验用户身份，请思考如何获取函数功能编号，如何校验用户身份。如何校验权限
user_data = {
    '1': {'name': 'jason', 'pwd': '123', 'access': ['1', '2', '3']},
    '2': {'name': 'kevin', 'pwd': '321', 'access': ['1', '2']},
    '3': {'name': 'oscar', 'pwd': '222', 'access': ['1']}
}

# 9.创建全局变量记录用户登录状态以及当前用户的执行权限
is_login = {
    'is_login': False,
    'access_list': []
}
def auth_user(func_id):
    def outer(func_name):
        def inner(*args,**kwargs):
            # 10.判断当前用户是否登录
            if is_login.get('is_login'):
                # 11.获取当前用户执行权限
                access = is_login.get('access_list')
                # 12.判断当前函数编号是否在用户权限内
                if func_id in access:
                    res = func_name(*args,**kwargs)
                    return res
                else:
                    print('你没有当前功能编号为:%s 的函数执行权限' % func_id)
            else:
                # 1.先判断用户的身份编号
                user_id = input("请输入您的身份编号：").strip()
                # 2.判断用户编号是否存在
                if user_id in user_data:
                    # 3.获取用户名和密码
                    username = input('username>>:').strip()
                    password = input('password>>:').strip()
                    # 4.根据用户编号获取真实用户字典数据
                    real_dict = user_data.get(user_id)
                    # 5.比较用户和密码是否正确
                    if username == real_dict.get('name') and password == real_dict.get('pwd'):
                        # 6.获取当前用户可执行的函数编号
                        access = real_dict.get('access')
                        # 10.保存用户登录状态并记录用户权限
                        is_login['is_login'] = True
                        is_login['access_list'] = access
                        # 7.判断当前用户是否含有当前被装饰函数的执行权限 假设当前被装饰函数功能编号是 func_id
                        if func_id in access:
                            # 8.用户拥有该函数的执行权限
                            res = func_name(*args, **kwargs)
                            return res
                        else:
                            print('你没有当前功能编号为：%s 的函数执行权限'% func_id)
        return inner
    return outer
@auth_user('1') # 被装饰的函数 提前传入该函数的功能编号
def func1():
    print('from func1')
@auth_user('2') # 被装饰的函数 提前传入该函数的功能编号
def func2():
    print('from func2')
@auth_user('3') # 被装饰的函数 提前传入该函数的功能编号
def func3():
    print('from func3')

func1()
func2()
func3()

3. 常见内置函数

3.1 什么是内置函数

提前定义好的，直接使用即可，很多内置函数的功能都非常的好用

3.2 abs() 求绝对值

print(abs(-99))  # 99

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

1. all() 所有的数据值都为True 结果才是True

print(all([1, 2, 3, 4, 5, 0]))  # False
print(all([1, 2, 3, 4, 5]))  # True

2. any 所有的函数值只要有一个Ture 结果就是Ture

print(any([1, 2, 3, 4, 5, 0]))  # True
print(any([1, 2, 3, 4, 5]))  # True

3.4 bin() oct() hex() 十进制转其他进制

print(bin(10))  # 0b1010
print(oct(10))  # 0o12
print(hex(10))  # 0xa

4.5 int 类型转换 其他进制转十进制

res = '现在有多苦 将来就有多轻松'.encode('utf8')
print(res)
res1 = res.decode('utf8')
print(res1)

4.6 bytes() 类型转换

res = '解码编码'.encode('utf8')
print(res)  # b'\xe8\xa7\xa3\xe7\xa0\x81\xe7\xbc\x96\xe7\xa0\x81'
res1 = res.decode('utf8')
print(res1)  # 解码编码
res = bytes('解码编码','utf8')
print(res)  # b'\xe8\xa7\xa3\xe7\xa0\x81\xe7\xbc\x96\xe7\xa0\x81'
res1 = str(res,'utf8')
print(res1)  # 解码编码

4.7 callable() # call在IT专业名词中翻译成 调用，加括号执行

name = 'jason'
def index():
    print('from index')
print(callable(name))  # False
print(callable(index))  # True

4.8 chr()与ord() 依据ASCII码表实现字符与数字的转换

print(chr(65))  # A
print(chr(97))  # a
print(ord('A'))  # 65
print(ord('a'))  # 97

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

print(dir(str))
# ['__add__', '__class__',....]

4.10 divmod() 获取除法之外的整数和余数

real_num, more = divmod(898, 10)
if more:
    real_num += 1
print('总页数:%s' % real_num)  # 90

4.11 enumerate() 枚举

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

4.12 eval()与exec() 能够识别字符串中python代码并执行

# eval 不识别复杂结构的代码 只能识别最简单的  exec  能够识别复杂结构的代码
res = 'print(123)'
eval(res)  # 123
exec(res)  # 123
res1 = "for i in range(2):print(i)"
eval(res1)  # 报错
exec(res1)  # 0 1

4.13 hash()  返回一串随机数字

print(hash('jason'))  # -6166847871802287264
print(hash('123'))  # -9110945152760350255

4.14 help 查看帮助信息

help(len)

4.15 pow() 幂指数

print(pow(2, 3))  # 8

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

print(isinstance(123,int))  # True
print(isinstance(123,str))  # False

4. 17 round() 大致四舍五入  也有五舍六入

print(round(10.4))  # 10
print(round(10.5))  # 10
print(round(10.6))  # 11

4. 可迭代对象

4.1 迭代如何理解

迭代就是更新换代 每次迭代都需要基于上一次的成果 。 eg:手机上面的软件更新其实专业名字就是软件版本迭代

4.2 迭代器简介

迭代器即用来迭代取值的工具，而迭代是重复反馈过程的活动，其目的通常是为了逼近所需的目标或结果，每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值,单纯的重复并不是迭代。

4.2 代码演示

1. 不属于迭代

while True:
     print('哈哈哈')

2. 属于迭代

n = 0
    while n < 4:
        print(n)
        n += 1

4.3 如何判断可迭代对象

1. 内置函数__iter__方法的都叫做可迭代对象

2. 内置是什么意思 通过句号符直接能够点出东西的都叫内置

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

4.4 可迭代对象与不可迭代对象

1. 可迭代对象(能够支持for循环取值)

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

f = open(r'01 考题讲解.py','r',encoding='utf8')  # 文件对象是可迭代对象
f.__iter__()

2. 不可迭代对象

整形， 浮点型， 布尔值， 函数名

5. 迭代器对象

5.1 迭代器对象作用

1. 迭代器对象给我们提供了一种不依赖于索引取值的方式

2. 正是因为有迭代器对象的存在 我们才能对字典，集合这些无序类型循环取值

5.2 如何判断迭代器对象

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

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

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

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

5.4 迭代器对象迭代取值

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__())  # name
print(res.__next__())  # pwd

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

5.5 迭代器反复使用

# 每次都是产生了一个新的迭代器对象
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

5.6 针对双下的方法

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

5.7 迭代器对象特殊的地方  节省内存空间

可迭代对象 迭代器对象 通过打印操作无法直接看出内部数据的情况，这个时候他们都能够帮你节省内存，相当于是一个工厂 你要一个数据就临时给你造一个

6. for循环的本质

语法结构：
for 变量名 in 可迭代对象:
     for循环体代码

1. for 会自动将in后面的数据调用__iter__()变成迭代器对象

2. 之后每次循环调用__next__()取值

3. 最后没有值__next__()会报错 for能够自动处理该错误，让循环正常结束