python-函数学习笔记

常见内置函数

内置函数：提前定义好的 直接使用即可
1.abs() 求绝对值
    print(abs(-100))  # 100
2.all()与any() 判断容器类型中的所有数据值对应的布尔值是否为True
    all()  所有的数据值都为True的情况下  结果才为True
    print(all([1,2,3,4,5,0]))  # False
    print(all([1,2,3,4,5]))  # True
    any()  所有的数据值只有一个为True 结果就是True
    print(any([1,2,3,4,5,0]))  # True
    print(any([1,2,3,4,5]))  # True
3.bin() oct() hex()  十进制转其他进制
    print(bin(10))  # 0b1010
    print(oct(10))  # 0o12
    print(hex(10))  # 0xa
4.int() 类型转换 其他进制转十进制
    print(int(0b1010))  # 10
    print(int(0o12))  # 10
    print(int(0xa))  # 10
5.bytes() 类型转换
    res = '帅帅的大男孩 完美的身材'.encode('utf8')
    print(res)
    res1 = res.decode('utf8')
    print(res1)
    res = bytes('帅帅的大男孩 完美的身材','utf8')
    print(res)
    res1 = str(res,'utf8')
    print(res1)
6.callable() #call在IT专业名词中翻译成 调用>>>:加括号执行
    判断某个变量是否可以加括号调用
    name = 'curry'
    def index():
        print('from index')
    print(callable(name))  # False
    print(callable(index))  # False
7.chr() ord() 依据ASCII码
    print(chr(65))  # A
    print(chr(97))  # a
    print(ord('A'))  # 65
    print(ord('a'))  # 97
8.dir()  # 获取对象内部可以通过句点符获取的数据
    print(dir(str))
9.divmod()  # 获取除法之后的整数和余数
    real_num, more = divmod(199,10)
    if more:
        real_num += 1
    print('总数:%s' % real_num)
10.enumerate() # 枚举
    name_list = ['curry','jason','oscar','jerry']
    for i,j in enumerate(name_list,100):  # 默认是从0开始 可以自定义
        print(i,j)
11.eval() exec() # 能够识别字符串python代码并执行
    res = 'print(123)'
    eval(res)  # 不能识别复杂结构的代码 只能识别最简单的
    exec(res)  # 能够识别复杂结构的代码
    res1 = "for i in range(10):print(i)"
    eval(res1)
    exec(res1)
12.hash() # 返回一串随机的数字(哈希值)
    print(hash('curry'))  # -7241956875149484275
    print(hash('123'))  # 689483870838391509
13.help()  # 查看帮助信息
    help()  # help(len)  # Return the number of items in a 	    	container.(返回容器中项目的数量。）
14.isinstance() # 判断某个数据是否属于某个数据类型
    print(isinstance(123,int))  # True 
    print(isinstance(123,str))  # False
15.pow()  # 幂指数
	print(pow(2,3))  # 8
16.round()  # 大致：四舍五入  并不太精准
    print(round(98.3))  # 98
    print(round(98.9))  # 99

可迭代对象

1.迭代如何理解？
	迭代就是更新换代 每次迭代都需要基于上一次的成果
    	eg：手机上面的软件更新其实专业名词>>>:软件版本迭代
2.代码演示
	#不属于迭代
    while True：
    	print（'好好学习'）
    #属于迭代
    n = 0
    while n < 10:
        print(n)
        n += 1
3.如何判断可迭代对象？
'''
内置有__iter__方法的都叫做可迭代对象
	1.内置是什么意思  通过句点符直接能够点出来的东西都叫内置
	2.__XXX__ 针对下划线开头双下划线结尾的方法 统一叫:双下XXX
'''
int # 整形不是可迭代对象
float # 浮点型不是可迭代对象
str # 字符串是可迭代对象
list # 列表是可迭代对象
dict # 字典是可迭代对象
tuple # 元组是可迭代对象
set # 集合是可迭代对象
bool # 布尔值不是可迭代对象
def index()； # 函数名不是可迭代对象
	print
f = open（r'01 考题讲解.py','r',encoding='utf8'） # 文件对象是可迭代对象
"""
可迭代对象
	字符串 列表 字典 元组 集合 文件对象（本身就是迭代器对象）
不是可迭代对象
	整型 浮点型 布尔值 函数名
可迭代对象能够支持for循环取值
"""        

迭代器对象

"""
作用:
	迭代器对象给我们提供了一种不依赖于索引取值的方式
	正是因为有迭代器对象的存在 我们才能对字典、集合这些无序类型循环取值
"""
1.如何判断迭代器对象
	内置有__iter__和__next__的对象都成为迭代器对象
2.可迭代器对象与迭代器对象的关系
	可迭代对象调用__iter__方法之后就会变成迭代器对象
    迭代器对象调用__iter__方法无论多少次还是迭代器对象本身
3.迭代器对象迭代取值
    res = 'curry'.__iter__()   # res已经是迭代器对象
    print(res.__next__())  # c
    print(res.__next__())  # u
    print(res.__next__())  # r
    print(res.__next__())  # r
    print(res.__next__())  # y
    print(res.__next__())  # 没有了直接报错
    
    d1 = {'name':'curry','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
4.补充说明
	4.1 迭代器反复使用
        l = [11,22,33,44]
        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（res1）
4.3 迭代器对象特殊的地方
	可迭代对象 迭代器对象 通过打印操作无法直接看出内部数据的情况
    但是可以节省内存:类似于一个工厂 想要数据会临时造一个

fotr循环的本质

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

练习题

# 附加题有下列用户数据
# 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']}
# }
# 并有三个函数
# def func1():
#     pass
# def func2():
#     pass
# def func3():
#     pass
# 要求: 调用上述三个函数的时候需要从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']}
}
# 创建全局变量记录用户登录状态以及当前用户的执行权限
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、获取当前用户执行权限
                acess = is_login.get('access_list')
                # 12、判断当前函数编号是否在用户权限内
                if func_id in acess:
                    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') # ['1','2']
                      # 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 的函数执行权限')
        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()