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']

'''

# 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))

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:\PyCharmWorkspace\bcClassExercises\day5\常用模块.py

# print(os.path.split("/usr/hehe/hehe.txt"))  # 分割路径和文件名 ('/usr/hehe', 'hehe.txt')

# print(os.path.split(r'D:\haha\1.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"\root", '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]  # 获取输入的值

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

# 通过时间戳的加减可以获取几天前几天后的时间

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)

'''

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())