python学习笔记

今日内容概要

• 考试题讲解
• 常见内置函数
• 可迭代对象
• 迭代器对象
• for循环的本质

今日内容详细

考试题讲解

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

队列：先进先出

堆栈：先进后出

# 队列
list = []
# 先放数据
list.append(111)
list.append(222)
list.append(333)  # [111, 222, 333]
# 再取数据
print(list.pop(0))
print(list.pop(0))
print(list.pop(0))


# 堆栈
list = []
# 先放数据
list.append(111)
list.append(222)
list.append(333)  # [111, 222, 333]
# 再取数据
print(list.pop(0))
print(list.pop(0))
print(list.pop(0))

2.附加题

要求:调用上述三个函数的时候需要从user_data中校验用户身份是否正确
并获取当前登录用户拥有的可执行函数功能编号即键access对应的功能编号列表
func1是1、func2是2、func3是3
并且一旦用户登录成功之后后续函数的调用不再校验用户身份
请思考如何获取函数功能编号 如何校验用户身份 如何校验权限
ps:装饰器知识 附赠:实现上述主体功能即可 其他扩展优化功能可暂且不写

'''
1.先编写校验用户身份的装饰器
2.然后再考虑如何保存用户登录状态
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)
                #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')
                        #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 func1():
    print('from func2')

@auth_user('3')
def func1():
    print('from func3')
    
    
func1()
func2()
func3()

常见内置函数

内置函数：提前定义好的，直接使用即可

很多内置函数的功能都非常的好用

分类	函数	作用
数学运算	abs	求数值的绝对值
	divmod	返回两个数值的商和余数
	max	返回可迭代对象中元素的最大值
	min	返回可迭代对象中元素的最小值
	round	对浮点数进行四舍五入求值
	sum	对元素类型是数值的可迭代对象中每个元素求和
	pow	返回两个数值的幂运算
类型转换	bool	根据传入的参数逻辑值，创建一个新的布尔值
	int	将其他进制转换成十进制
	float	根据传入的参数，创建一个新的浮点数
	complex	根据传入的参数，创建一个新的复数
	bytes	根据传入的参数，创建一个新的不可变字节数组
	ord	返回ASCII码表字符对应的整数
	chr	返回整数所对应ASCII码表字符
	bin	将十进制转换成二进制字符串
	oct	将十进制转换成八进制字符串
	hex	将十进制转换成十六进制字符串
	list	根据传入的参数，创建一个新的列表
	dict	根据传入的参数，创建一个新的字典
	tuple	根据传入的参数，创建一个新的元组
	set	根据传入的参数，创建一个新的集合
	str	返回一个对象的字符串表现形式
	enumerate	根据可迭代对象创建枚举对象
	range	根据传入的参数，创建一个整数列表，一般用在 for 循环中
	iter	根据传入的参数，创建一个新的可迭代对象
	slice	根据传入的参数，创建一个新的切片对象
序列操作	all	判断可迭代对象的每个元素是否都为True值，都为True的情况下，结果才是True
	any	判断可迭代对象的元素是否有为True值的元素，有一个为True，结果就是True
	filter	用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新列表
	map	使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象
	next	返回可迭代对象中的下一个元素值
	reversed	反转序列生成新的可迭代对象
	sorted	对可迭代对象进行排序，返回一个新的列表
	zip	把 2 个或多个列表合并，并创建一个元组对的列表，元组对的数量以合并列表的最短长度为准
对象操作	help	返回对象的帮助信息
	dir	获取对象内部可以通过句点符获取的数据
	id	返回对象的唯一内存地址
	hash	返回一串随机的数字(哈希值)
	type	返回对象的类型，或者根据传入的参数，创建一个新的类型
	len	返回对象的长度
	format	格式化显示值
反射操作	isinstance	判断某个数据是否属于某个数据类型
	callable	判断某个变量是否可以加括号调用
变量操作	globals	返回当前作用域内的全局变量，和其值组成的字典
	locals	返回当前作用域内的局部变量，和其值组成的字典
交互操作	input	读取用户输入的内容
	print	打印输出对象
文件操作	open	使用指定的模式和编码打开文件，返回文件的读写对象
执行	eval	能够识别字符串中python代码并执行，不识别复杂结构的代码，只能识别最简单的
	exec	能够识别字符串中python代码并执行，能够识别复杂结构的代码

可迭代对象

1.迭代如何理解

迭代就是更新换代，每次迭代都需要基于上一次的成果

2.代码演示

# 不属于迭代
while True:
    print('嘿嘿嘿')

# 属于迭代
n = 0
while n < 10:
    print(n)
    n += 1

3.如何判断可迭代对象

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

3.1.内置是什么意思

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

3.2.__ XXX__ 针对双下划线开头双下划线结尾的方法 统一读作双下XXX

数据类型	是否可迭代对象
int	整型不是可迭代对象
float	浮点型不是可迭代对象
str	字符串是可迭代对象
list	列表是可迭代对象
dict	字典是可迭代对象
tuple	元组是可迭代对象
set	集合是可迭代对象
bool	布尔值不是可迭代对象
函数	函数名不是可迭代对象
文件	文件对象是可迭代对象

可迭代对象

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

不是可迭代对象

整型 浮点型 布尔值 函数名

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

迭代器对象

作用：

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

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

1.如何判断迭代器对象

内置有__ iter__ 和 __ next__的对象都称为迭代器对象

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

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

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

3.迭代器对象迭代取值

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

4.补充说明：

4.1.迭代器反复使用

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

4.2.针对双下方法

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

4.3.迭代器对象特殊的地方

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

这个时候他们都能够帮你节省内存

相当于是一个工厂 你要一个数据就临时给你造一个

for循环的本质

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