第5课：内置函数、处理json、常用模块

1.　　内置函数

1）常用的内置函数

print(all([0, 2, 3, 4]))  # False,判断可迭代的对象里面的值是否都为真
print(any([0, 1, 2, 3, 4]))  # True 判断可迭代的对象里面的值是否有一个为真
print(bin(100), type(bin(100)))  # 0b1100100 <class 'str'> 十进制转二进制，二进制前有0b，如果想去掉，用如下方法：
ejz = bin(100)
print(ejz.replace('0b', ''), type(ejz.replace('0b', '')))  # 1100100 <class 'str'>
print(bool('s'))  # 把一个对象转换成布尔类型
print(bytearray('abcde', encoding='utf-8'))  # 把字符串变成一个可修改的bytes,什么情况下会用到呢？？？
'''
print(callable('aa'))
# 1. 判断传入的对象是否可被调用，可被调用是指能否使用()（括号）的方法调用
# 2. 可调用对象，在实际调用也可能调用失败；但是不可调用对象，调用肯定不成功。
# 3. 类对象都是可被调用对象，类的实例对象是否可调用对象，取决于类是否定义了__call__方法。
#       >>> callable(1)
#           False
#       >>> 1()
#           Traceback (most recent call last):
#           File "<pyshell#5>", line 1, in <module>
#           1()
#           TypeError: 'int' object is not callable
#       >>> class A:  # 定义类A
#               pass
#
#       >>> callable(A)  # 类A是可调用对象
#               True
#       >>> a = A()  # 调用类A
#       >>> callable(a)  # 实例a不可调用
#           False
#       >>> a()  # 调用实例a失败
#           Traceback(most recent call last): File "<pyshell#31>", line 1, in < module > a()
#           TypeError: 'A'
#           object is not callable
#
#      >>> class B:  # 定义类B
#       def __call__(self):
#           print('instances are callable now.')
#      >>> callable(B)  # 类B是可调用对象
#           True
#      >>> b = B()  # 调用类B
#      >>> callable(b)  # 实例b是可调用对象
#           True
#       >>> b()  # 调用实例b成功
#           instances are callable now.
'''

print(chr(65))  # A 打印数字对应的ascii
print(ord('A'))  # 65 打印字符对应的ascii码
print(dict(a=1, b=2))  # {'a': 1, 'b': 2} 转换字典
print(dir(1))  # 打印传入对象的可调用方法 ,一般只看不带__的方法，或属性

# print(eval('[]'))  # 执行python代码，只能执行简单的运算
# code = '1+1'
# print(eval(code))
# print(exec('def a():pass'))  # 执行python代码

code = '''
def a():
    print('aa')
a()'''
print(exec(code))  # 结果中有None是因为exec(code)没有返回值，所以输出None
# 结果是
# aa
# None
'''
# zip() # 把可迭代对象（如list）结合在一起,以短的list为准
ids = [1, 2, 3, 4]
names = ['小黑', '小白', '小黄']
# for idd, name in ids, names: # 这种写法会报错
for idd, name in zip(ids, names):
    print(idd, name)
结果：
1 小黑
2 小白
3 小黄

print(map(lambda x: x > 5, [1, 2, 3, 4, 5, 6]))
# map:循环调用函数，处理结果保存在map对象中，可以用list(map对象)查看返回结果
# 使用map高级些
# 同样的功能，代码越少越牛逼
def func(a):
    if a % 2 == 0:
        return a
        # return True
    else:
        return False
        # return True [0, True, 2, True, 4, True, 6, True, 8, True, 10]
nums = [x for x in range(11)]
res = map(func, nums)  # 参数只有这两个
print(list(res))
# 等价于
all_res = []
for num in nums:
    res = func(num)
    all_res.append(res)

print(filter(lambda x: x > 5, [12, 3, 12, 2, 1, 2, 35]))  # 把后面的迭代对象根据前面的方法筛选
# filter:循环调用函数，只保存返回结果为真的
res = filter(func, nums)
# print(list(res))  # return a时，[2, 4, 6, 8, 10] 没有0，是因为return 0 ，0也是假，所以未返回
print(list(res))  # return b时，[0, 2, 4, 6, 8, 10]
'''

print(frozenset({1, 2, 3, 3}))  # 定义一个不可修改的集合
print(globals())  # 返回程序内所有的全局变量，返回的是一个字典
print(locals())  # 返回局部变量
print(hash('aaa'))  # 把一个字符串哈希成一个数字
print(hex(111))  # 0x6f 数字转成16进制
print(max(111, 12))  # 111 取最大值
print(oct(111))  # 0o157 把数字转换成8进制
print(round(11.111111, 2))  # 11.11 取几位小数
print(format(11.11111, '0.2f'))  # 11.11
print(sorted([2, 31, 34, 6, 1, 23, 4], reverse=True))  # 排序，默认升序，把reverse的值赋为True，降序排列

'''
# 函数如果有多个return值，那么会把这几个return的值都放到一个元组里面，然后返回
def hello(a, b, c, d):
    return a, b, c, d
print(hello('1', '2', '3', '4'))  # ('1', '2', '3', '4')

# 列表推导式
nums = [0, 1, 2, 3, 4]
new_nums = [str(x) for x in nums]
print(new_nums)  # ['0', '1', '2', '3', '4']
'''

 

2.　　处理json

# json:一种通用的数据类型
import json
d = {
    'car': {'color': 'red', 'price': 100, 'count': 50},
    '挨粪叉': {'color': 'red', 'price': 100, 'count': 50},
    '挨粪叉1': {'color': 'red', 'price':  100, 'count': 50},
    '挨粪叉2': {'color': 'red', 'price': 100, 'count': 50},
    '挨粪叉3': {'color': 'red', 'price': 100, 'count': 50},
    '挨粪叉4': {'color': 'red', 'price': 100, 'count': 50},
}
# json.dumps()将list dict转化为json串
res = json.dumps(d, indent=4, ensure_ascii=False)
# fi = open('f.txt', 'w', encoding='utf-8')
# fi.write(res)
# json文件中必须用""，不能用''，否则会报错

# f1 = open('f.txt', 'w', encoding='utf-8')
# 自动将json串写入文件中
# json.dump(d, f1, indent=4, ensure_ascii=False)

f1 = open('f.txt', encoding='utf-8')
# 自动将从文件读取的json串转化为python对象
res = json.load(f1)
print(res, type(res))

　3. 模块

　　1） 常用模块

import os
# .代表当前路径，..代表上一级路径
# print(os.getcwd())  # 获取当前工作目录#
# os.chmod("/usr/local", 7)  # 给文件/目录加权限
# print(os.chdir("../"))  # 更改当前目录
# print(os.curdir)  # 当前目录
# print(os.pardir)  # 父目录
# print(os.makedirs("/usr/hehe/hehe1"))  # 递归创建文件夹，父目录不存在时创建父目录
# print(os.removedirs("/usr/hehe/hehe1"))  # 递归删除空目录
# print(os.mkdir("test1"))  # 创建文件夹
# print(os.rmdir("test1"))  # 删除指定的空文件夹
# print(os.remove("test"))  # 删除文件
# print(os.listdir('.'))  # 列出一个目录下的所有文件
# os.rename("test", "test1")  # 重命名
# print(os.stat("笔记"))  # 获取文件信息
# print(os.sep)  # 当前操作系统的路径分隔符
# print(os.linesep)  # 当前操作系统的换行符
# print(os.pathsep)  # 当前系统的环境变量中每个路径的分隔符，linux是:，windows是;
# print(os.environ)  # 当前系统的环境变量
# print(os.name)  # 当前系统名称
# print(__file__) # 获取当前文件的绝对路径 D:/PyCharmWorkspace/bcClassExercises/day5/常用模块.py
# print(os.path.abspath(__file__))  # 获取绝对路径 D:PyCharmWorkspacecClassExercisesday5常用模块.py
# print(os.path.split("/usr/hehe/hehe.txt"))  # 分割路径和文件名 ('/usr/hehe', 'hehe.txt')
# print(os.path.split(r'D:haha1.txt'))  # ('D:\haha', '1.txt')
# print(os.path.dirname("/usr/local"))  # 获取父目录
# print(os.path.basename("/usr/local"))  # 获取最后一级，如果是文件显示文件名，如果是目录显示目录名
# print(os.path.exists("/usr/local"))  # 判断目录/文件是否存在
# print(os.path.isabs("."))  # 判断是否是绝对路径
# print(os.path.isfile("/usr/local"))  # 判断是否是一个文件
# print(os.path.isdir("/usr/local"))  # 是否是一个路径
# print(os.path.join(r"
oot", 'hehe', 'a.sql'))  # 拼接为一个路径(自动加上),拼的个数没有限制
# os.system('notepad')  # 执行系统命令

# print(os.path.getatime("len_os.py"))  # 输出最近访问时间
# print(os.path.getmtime("len_os.py"))  # 输出最近访问时间

# os.popen('cmd') 返回的是文件的对象（默认模式r,还可以是w），对其进行读取read()就可以看到输出内容了
# res = os.popen('ipconfig').read()  # 执行系统命令，并获取返回结果
# print(res)
# import sys
# print(sys.platform)  # 查看当前系统是什么 windows的话都是打印win32
# print(sys.version)  # 查看python的版本
# # 获取运行Python文件时，传入的参数
# print(sys.argv)           # 命令行参数List，第一个元素是程序本身路径

# sys.exit(n)        # 退出程序，正常退出时exit(0)
# quit("程序退出")
# sys.version        # 获取Python解释程序的版本信息
# sys.maxint         # 最大的Int值
# sys.path           # 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
# sys.platform       # 返回操作系统平台名称
# sys.stdout.write('please:')  # 向屏幕输出一句话
# val = sys.stdin.readline()[:-1]  # 获取输入的值

　　2） 时间模块

import time
# time.sleep(1)  # 等待几秒
# 1. 格式化好的时间 2018-1-14 16:42
# 2. 时间戳，是从unix元年到现在的所有秒数
# print(int(time.time()))  # 当前时间戳
# cur_time = time.strftime('%Y:%m:%d %H:%M:%S')  # 获取当前时间的格式化时间字符串
# print(cur_time)
#
#
# print(time.gmtime())  # # 默认获取标准时区的时间元组，如果传入了一个时间戳，那么把这个时间戳转化为时间元组
# print(time.gmtime(1516005840))  # 取的标准时区
# print(time.timezone)  # 和标准时间相差了几个小时
# print(time.localtime())  # 默认获取当前时区的时间元组，如果传入一个时间戳，那么把这个时间戳转化为时间元组
#
res = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(1515686400))
print(res)

# 把格式化好的时间转化为时间戳
t = time.strptime('20180112', '%Y%m%d')  # 将参数string按第二个参数format解析为时间元组
print(time.mktime(t))  # 将时间元组转化为时间戳

# 一天的秒数：86400s
# 32342 + 86400*3  or 32342 - 86400*3
# 通过时间戳的加减可以获取几天前几天后的时间

　　3） 随机数模块

import random
import string
'''
print(type(string.digits))  # 所有的数字0-9 字符串类型
print(string.ascii_lowercase)  # 所有的小写字母
print(string.ascii_uppercase)  # 所有的大写字母
print(string.ascii_letters)  # 所有的大写字母和小写字母
print(string.punctuation)  # 所有的特殊字符

print(random.randint(1, 999))  # 1-999随机取一个整数
print(random.choice(['1', '2', '3', '4']))  # 随机取一个元素，参数是可迭代对象
res = random.sample(string.digits, 3)
print(res)
print(''.join(res))
'''
# 回头查查资料,数字的格式化输出
# random.uniform(1, 9)
res = format(random.uniform(1, 9), '.2f')  # 取随机小数
# res = random.uniform(1, 9)  # 取随机小数
print(res)
'''
# 5.03203 保留几位小数，四舍五入，如果四舍五入后最后一位小数为0，不显示
# 1.9027236450716112
# 1.9
print(round(res, 2))
print(random.random())  # 取0-1之间的随机小数

s = ['a', 'b', 'c', 'd']
random.shuffle(s)  # 洗牌，打乱顺序，参数必须为list
print(s)
'''

　　4） 加密模块

import hashlib
# md5
pwd = 'b'
m = hashlib.md5()  # 新建一个md5对象
# print(dir(m))  # 打印对象所有的属性和方法
pwd.encode()  # 将字符串转成bytes类型
m.update(pwd.encode())  # update()  加密，不能传字符串，只能传二进制bytes类型
print(m.hexdigest())  # 加密后的结果


def md5_passwd(st:str):  # 限定入参类型，只能是string类型
    bytess = st.encode()
    m = hashlib.md5(bytess)
    return m.hexdigest()
res = md5_passwd('1')
print(res)

# md5加密是不可逆的，不能被解密的。
# MD5  md5AF
# 123456  f0dfb4c968
# 撞库

# 另外一种加密方式
sha_256 = hashlib.sha3_256()

import base64
# base64
s = 'hahaha'
bytes_s = s.encode()
res = base64.b64encode(bytes_s)
print(res)
print(res.decode())  # 把bytes类型转成字符串

jie_mi_res = base64.b64decode(res)
print(jie_mi_res.decode())