内置函数

day25

# abs 求绝对值
print(abs(-5))  # 结果为5
print(abs(3))  # 结果为3

# all 判断真假，传入可迭代对象，判断每个元素，如果全部元素都为True就返回True，否则返回False
# 如果可迭代对象为空也返回True，为空不代表可以不传
# print(all())  # 会报错，不可不传入值
print(all(""))  # 返回True，传入了空字符串，可迭代对象为空
print(all((1, "", 2, None)))  # 返回False，因为"" 这个空字符串是传入迭代器的一个元素，会返回False. 空字符串，0，None都会返回False
print(all(i for i in range(10)))  # 返回False，因为元素有0
print(all(i for i in range(1, 10)))  # 返回True

# any 判断真假，传入可迭代对象，判断每个元素，如果任何一个元素为True就返回True，否则返回False
# 如果可迭代对象为空返回False，为空不代表可以不传
# print(any())  # 会报错，不可不传入值
print(any([]))  # 返回False，可迭代对象为空
print(any([None, 0, "", {}, 1]))  # 返回True，因为元素 1 为True

# sum 求和
print(sum((i for i in range(10))))

# bin 转为二进制
print(bin(10))  # 结果为 0b1010

# bool 判断真假，空字符串，0，None都会返回False
print(bool(0))  # 返回False
print(bool(None))  # 返回False
print(bool(""))  # 返回False
print(bool(1))  # 返回True

# bytes 把字符串转为字节
print(bytes("hello", encoding="utf-8"))  # 结果为 b'hello'

# callable 判断是否可调用
x = 2
print(callable(x))  # 返回False，不可调用


def test():
    pass


print(callable(test))  # 返回True，可被调用
print(callable(sum))  # 返回True，可被调用

# chr 根据传入的数字返回对应的ASCII编码表的值
print(chr(171))  # 返回«

# ord 根据传入的字符返回对应ASCII编码表的数字序号
print(ord("«"))  # 返回171

# dir 显示可以调用的方法
print(dir(sum))
mylist = []
print(dir(mylist))

# help 查看帮助文档
print(help(sum))
print(help(mylist))

# divmod 传入两个数字，返回一个元组，分别是两个数整除的结果和取余的结果，可用在分页
print(divmod(10, 3))  # 结果为 (3, 1)

# enumerate 返回的是一个迭代器，包含传入元素的索引以及值
for i in enumerate(["a", "b", "c", "d"]):
    print(i)  # 结果为 (0, 'a') (1, 'b')  (2, 'c')  (3, 'd')
for i in enumerate({"x": 1, "y": 2}):
    print(i)  # (0, 'x')  (1, 'y') 也有可能是 (0, 'y') (1, 'x') 因为字典是无序的

# hash算法，返回hash值，hash值不能逆推
print(hash("asfadfs"))  # 返回hash值为 7300869675203703379

# hex 十六进制转十进制
print(hex(10))  # 返回结果为0xa

# id 查看唯一标识身份
print(id("abcde"))  # 返回结果 3027805306080
a = 1
b = 2
print(id(a))  # id为1865244896
print(id(b))  # id为1865244928
print(a is b)  # 返回False，不一致
x = "a"
y = "a"
print(id(x))  # id为2108572640512
print(id(y))  # id为2108572640512
print(x is y)  # 返回True，一致

# max
print(max(1, 2, 3, 4, 5, 3, 2, 4, 34, 2, 1, 5))  # 返回最大值为34
print(min(1, 2, 3, 4, 5, 3, 2, 4, 34, 2, 1, 5))  # 返回最小值为1

# max，min应用：求下面字典中工资最高的人
salarries = {
    "alex": 230,
    "egon": 1000,
    "wanbadan": 300,
    "laowang": 400
}
print(max(salarries))  # 结果为 wanbadan 工资最高，不正确，是按照key来进行比较了，所以得到wangbadan
print(max(salarries.values()))  # 得到结果为 1000 ，但要求是要工资最高的人名，也不对，是按照value来比较了，但没有返回人名
# 实现方式1：
def get_value(k):
    return salarries[k]
print(max(salarries, key=get_value))  # 得到结果为egon，正确
# 上述说明：由于max传入salarries或salarries.values()都只能返回各自的比较值，所以同时传入两个值给max，
# 第一个值传入salarries用于获得人名，
# 第二个值key=get_value的作用是，由于salarries是可迭代对象，所以是可以next的，max内部将salarries的值一个个next出来得到了key，也就是得到了人名，
# 再将这个人名传给get_value函数返回得到这个人的工资，赋值给key作为比较值，salarries的值next完后就得到了所有人的工资，比较得到1000最大，同时也得到了对应的人名为egon

# 实现方式2：
print(max(salarries, key=lambda k: salarries[k]))  # 得到结果为egon，正确
# 上述说明：lambda用于定义匿名函数，也就是函数没有函数名。
# lambda k: salarries[k] 表示定义了一个匿名函数，需传入参数为k，返回值为salarries[k] ，和之前上面定义的get_value函数功能一致，但是更精简。

# 同样方式取到工资最少的人
print(min(salarries, key=lambda k: salarries[k]))  # 得到结果为 alex，正确


# zip 拉链
l1 = [1,4,3]
s = "hel"
for i in zip(l1,s):
    print(i)  # 输出结果为 (1, 'h')  (4, 'e')  (3, 'l')
# 上述说明：zip会将l1和s这两个迭代对象一一对应输出元组，无论哪个可迭代对象的元素多，结果中元组的数量都只会按照元素最少的那个对象来对应

print(salarries.keys(),salarries.values())
z = zip(salarries.keys(),salarries.values())
# for i in z:
#     print(i)  # 输出结果为：('alex', 230)  ('egon', 1000)  ('wanbadan', 300)  ('laowang', 400)
print(max(z))  # 输出结果为：('wanbadan', 300)  ，比较最大值却得到wanbadan，因为比较的是key

z = zip(salarries.values(),salarries.keys())
print(max(z))  # 输出结果为：(1000, 'egon') ，这里比较的是value，得到正确的工资最高的egon

print(max((2,"b"),(1,"a"),(3,"a")))   # 结果得到(3, 'a') 大，因为首先比的是第一位，如果一致再进行第二位的比较


# sorted 排序
l=[3,5,2,5,2,1,7,7,4,2,56,2]
print(sorted(l))  # 结果：[1, 2, 2, 2, 2, 3, 4, 5, 5, 7, 7, 56] ，返回值是列表，默认是升序
print(sorted(l,reverse=True))  # 结果：[56, 7, 7, 5, 5, 4, 3, 2, 2, 2, 2, 1] ，返回值是列表，reverse=True 表示按降序排列

s="hello abc"
print(sorted(s))  # 结果：[' ', 'a', 'b', 'c', 'e', 'h', 'l', 'l', 'o']

salarries = {
    "alex": 230,
    "egon": 1000,
    "wanbadan": 300,
    "laowang": 400
}
print(sorted(salarries))  # 结果：['alex', 'egon', 'laowang', 'wanbadan']  默认是按照字典的key去排序
print(sorted(salarries,key=lambda  k:salarries[k]))  # 结果：['alex', 'wanbadan', 'laowang', 'egon'] ，按照工资排升序
print(sorted(salarries,key=lambda  k:salarries[k],reverse=True))  # 结果：['egon', 'laowang', 'wanbadan', 'alex'] ，按照工资排降序


# 重要
# map，映射
# 例子1：给列表里每个值进行平方
nums = [1, 2, 3, 5, 4]
# 传统：
newlist = []
for i in nums:
    res = i ** 2
    newlist.append(res)
print(newlist)  # 结果为 [1, 4, 9, 25, 16]

# map方式
m = map(lambda item: item ** 2, nums)
print(m)  # 结果为 <map object at 0x000002753BB432B0>
print(list(m))  # 结果为 [1, 4, 9, 25, 16]

# 例子2：给列表里每个值后面都加上“SB”
name = ["aaa", "bbb", "ccc", "ddd"]
m = map(lambda item: item + "SB", name)
print(list(m))  # 结果为 ['aaaSB', 'bbbSB', 'cccSB', 'dddSB']

# reduce，合并
from functools import reduce

nums = list(range(100))
print(reduce(lambda x, y: x + y, nums))  # 结果为 4950
# 上述说明：reduce每次会将nums next两次传给x和y，x+y之后会放到那里，然后再next和之前的结果相加，直到完成，结果为4950
print(reduce(lambda x, y: x + y, nums, 100))  # 结果为 5050
# 上述说明：100叫做初始值，reduce next两次后与100相加，得到101，然后再next和之前的101相加，直到完成，结果为5050


# filter，过滤
# 例子：过滤出age大于100的
name_l = [
    {"name": "alex", "age": 20},
    {"name": "alex22", "age": 340},
    {"name": "alex33", "age": 1000},
    {"name": "alex44", "age": 9000},
]
f = filter(lambda d: d["age"] > 100, name_l)
for i in f:
    print(i)

print("__________________")

# 很重要，在面向对象里讲
# classmethod
# staticmethod
# property
# delattr
# hasattr
# getattr
# setattr
# issubclass
# super

# 先不管，很少用
# compile
# complex
# eval
# exec

# 数据类型
# 与数字相关的数据类型：int, float, bool, complex
num = 1  # 相当于 num = int(1)
print(type(num))  # 查看num的类型
print(isinstance(num, int))  # 判断num是否为int类型，返回True
print(num is 1)  # is 是身份运算，根据id去判断身份，返回True

# str 字符串
x = "hello"  # 相当于 x = str("hello")
print(str(1))
print(str({"a": 1}))

# list 列表
x = []
x = list([i for i in range(10)])
print(x)

# tuple 元组

# dict 字典
d = {"a": 1}
d = dict(x=1, y=2, z=3)  # 相当于 d = {'x': 1, 'y': 2, 'z': 3}
print(d)  # 结果为 {'x': 1, 'y': 2, 'z': 3}

# set 集合，无序，去重，关系运算
s = {1, 2, 3, 4, 4, 4}
print(s)  # 结果为 {1, 2, 3, 4} ，去掉了重复的4
s.add(5)  # 添加5到集合中
print(s)  # 结果为 {1, 2, 3, 4, 5}

# frozenset 不可变集合，没有像集合add,remove这类的方法
f = {1, 2, 3, 4}
print(type(f))  # 结果为 <class 'set'> 类型
f2 = frozenset({1, 2, 3, 4})
print(type(f2))  # 结果为  <class 'frozenset'> 类型


# 其他：
# oct, 十进制转八进制
print(oct(10))  # 结果为0o12

# pow，
print(pow(3, 2))  # 3的2次方，结果为9
print(pow(3, 2, 2))  # 3的2次方，再取余，结果为1

# reversed # 反转
print(list(reversed([1, 3, 5, 7])))  # 结果为：[7, 5, 3, 1]

# round，四舍六入五留双
print(round(3.4))  # 结果为：3
print(round(11.3))  # 结果为：11
print(round(11.5))  # 结果为：12
print(round(12.5))  # 结果为：12
print(round(12.6))  # 结果为：13

# slice，切片
l = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l[2:4])  # 结果为 [3, 4]
print(l[1:7:2])  # 步长为2，结果为 [2, 4, 6]
s = slice(2, 4)
print(l[s])  # 结果为 [3, 4]
s2 = slice(1, 7, 2)
print(l[s2])  # 步长为2，结果为 [2, 4, 6]

# vars
vars()  # 不加参数和locals()一样

# __import__() , 导入字符串模块
# 常规：
import time
time.sleep(3)
print(time)

# __import__ 方式
m = __import__("time")
print(m)
m.sleep(3)