内置函数

Posted 2020-11-10 森森2017

# 内置函数
# print(all(‘ ‘))

# 一定要传可迭代对象，例如元组
# print(all((1,2,None,‘r‘)))
#
# print(all((1,2,3,‘r‘)))
#
# print(all(i for i in range(1,10)))
# print(all((i for i in range(1,10))))
#
# print(all(i for i in range(10)))
#
# print(sum((i for i in range(10))))
#
# print(any(i for i in range(10)))
# print(any((0,0)))

# 二进制
# print(bin(9))
# 十六进制
# print(hex(10))
# print(hex(17))



# 布尔值
# print(bool(0))
# print(bool(‘‘))
# print(bool(None))

# 把字符串表示成字节格式
# print(bytes(‘hello‘,encoding=‘utf-8‘))
# print(bytes(‘中国‘,encoding=‘utf-8‘))

# 是不是内置函数
# def test():
#     pass
# print(callable(test))
# print(callable(sum))

# aciica码相互转化
# print(chr(67))
# print(ord(‘a‘))
# print(chr(97))

# complie() 很少用
# complex() 很少用
# x=complex(1-2j)
# print(x.real)
# print(x.imag)

# 数据类型
# int
# num=1
# print(type(num))
# print(num is int) # is不是用来判断数字类型的
# print(num is 1)
# print(num == 1)

# str，变字符
# s="fwee" # s=str("fwee")
# print(str(2))
# print(str({‘a‘:1}))

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

# tuple 元组


# # dict 字典
# d={‘a‘:1}
# print(d)
#
# d=dict(x=1,y=2,z=3)
# print(d)

# set集合：无序，去重
# s={1,1,2,3,4,"q"}
# print(s)
# s.add(5)
# print(s)
# print(type(s))

# frozenset # 不可变类型
# set和frozenset皆为无序唯一值序列。set和frozenset最本质的区别是前者是可变的、后者是不可变的 。
# 当集合对象会被改变时（例如添加、删除元素等），只能使用set ，一般来说使用fronzet的地方都可以使用set 。
# f=frozenset({1,2,3,4})
# print(type(f))
# print(f)

# dir就是看看l可以调用什么方法
# l=[]
# print(dir(l))

# 取除了的商对应的整数和余数
# print(divmod(10,3))
# 这个函数方便用来计算数据分几页显示
# 100条数据，一页33条，于是得到4页
# print(divmod(100,3))
# print(divmod(100,3)[0])

# 能输出列表的索引值（列表有序，所以输出的索引值多次结果一样）
# for i in enumerate([‘a‘,‘b‘,‘c‘,‘d‘]):
#     print(i)

# 字典是无序的，所以每次结果不一定排序一样，一般不用字典
# for i in enumerate({‘a‘:3,‘b‘:6,‘c‘:8,‘d‘:9}):
#     print(i)

# 得到hash值，用来校验数据
# print(hash(‘sfe‘))
# print(hash(‘sfe‘))

# 下载时得到hash值
# s=‘hello‘
# print(hash(s))
# # 程序运行时可能不小心修改了，例如木马
# s=‘h‘
# print(hash(s))
# 如果下载某软件时，前后两个hash值比较是否相等，不等就要重新下载
# hash值与文件长度无关，固定的
# hash值不能内推，是固定的

# 查id号(同样的数，每次运行的ID值都不一样)
# print(id(‘dagege‘))
# a=1
# b=2
# print(id(a))
# print(id(b))
# print(a is b)
# a=2
# print(id(a))
# print(a is b)

# # 如果数值变大，就明明相同的两个数，python的ID是不同的
# x=123123456456789099999
# y=123123456456789099999
# print(id(x))
# print(id(y))
# print(x is y)

# 变字符型
# print(type(str(1)))
# print(type(1))

# 最大值最小值
# print(max(1,2,3,4,5,10))
# print(min(1,2,3,4,5,10))

# salaries={
#     ‘egon‘:3000,
#     ‘alex‘:1000000,
#     ‘yuanhao‘:2500
# }
# for i in salaries:
#     print(i)
#     print(salaries[i])

# 这样得到关键字最大的那个
# print(max(salaries))
# 应该是比较工资，把记录全部列出来
# print(max(salaries.values()))
# def get_value(sa):
#     k=max(sa.values())
#     for i in sa:
#         if sa[i]==k:
#             print(i,k)
#
# get_value(salaries)
#
# ee=(i,max(salaries.values()) for i in salaries if salaries[i]==max(salaries.values()))

# 也可以：
# ee=((i,max(salaries.values())) for i in salaries if salaries[i]==max(salaries.values()))
# print(next(ee))

# 也可以比较参数从关键字变为别的字段 
# def rr(j):
#     return salaries[j]
#
# print(max(salaries,key=rr))


# 匿名函数：
# def rr(j):
#     return salaries[j]

# lambda k:salaries[k]
# f=lambda k:salaries[k]
# print(f)
# print(f("egon"))

# 上面也可以
# print(max(salaries,key=lambda k:salaries[k]))
#
# print(min(salaries,key=lambda k:salaries[k]))
# salaries={
#     ‘egon‘:3000,
#     ‘alex‘:1000000,
#     ‘yuanhao‘:2500
# }

# print(max(salaries,key=lambda k:salaries[k]))

# 拉链
# l=[1,2,3]
# s=‘hel‘
# e=zip(l,s)
# print(next(e))
# for i in e:
#     print(i)
#
# z=zip(salaries.values(),salaries.keys())
# for i in z:
#     print(i)
#
# z=zip(salaries.values(),salaries.keys())
# print(max(z)) #以第一个字符为排序依据
#
# z=zip(salaries.values(),salaries.keys())
# print(min(z)) #以第一个字符为排序依据
#
# l=[3,4,5,2,2]
# print(sorted(l))
#
# s=‘hello abc‘
# print(sorted(s))
# print(sorted(s,reverse=True)) # 返回值是列表，默认是升序
#
# salaries={
#     ‘egon‘:3000,
#     ‘alex‘:1000000,
#     ‘yuanhao‘:2500
# }
#
# print(sorted(zip(salaries.values(),salaries.keys()),reverse=True))
#
# print(sorted(salaries,key=lambda x:salaries[x]))
#
# salaries={
#     ‘egon‘:3000,
#     ‘alex‘:1000000,
#     ‘yuanhao‘:2500
# }
#
# print(sorted(salaries,key=lambda x:salaries[x],reverse=True))

# 映射函数map
# l=[1,2,3,4,5]
#
# x={i**2 for i in l}
# print(x)
#
#
# m=map(lambda item:item**2,l)
# print(m)
# for i in m:
#     print(i)
#
# m=map(lambda item:item**2,l)
# print(list(m))
#
# name_l=[‘alex‘,‘zhengjiang‘,‘yuanjie‘]
# m=map(lambda name:name+‘sb‘,name_l)
# print(list(m))

# 序列合并reduce
# from functools import reduce
# l=list(range(10))
# print(l)
# ee=reduce(lambda x,y:x+y,l,100) # 100是初始值
# print(ee)

# filter过滤函数
# name_l=[
#     {‘name‘:‘egon‘,‘age‘:18},
#     {‘name‘:‘dragonfire‘,‘age‘:1000},
#     {‘name‘:‘gao‘,‘age‘:9000},
#     {‘name‘: ‘fsw‘, ‘age‘: 10000},
# ]
#
# ee=filter(lambda d:d[‘age‘]>100 ,name_l)
# for i in ee:
#     print(i)

# 其他
# 十进制转八进制
# print(oct(10))
# # 3的2次方再跟2取余数
# print(pow(3,2,2))
# print(pow(3,2))
# # 反转
# print(reversed([1,2,3,4,5]))
# print(list(reversed([1,2,3,4,5])))
# # 四舍六入，五看情况，如果前面是双数就舍，如果前面是单数就进
# print(round(10.3))
# print(round(10.5))
# print(round(10.9))
# print(round(11.5))
#
# # 切片
# l=[1,2,3,4,5,6,7,8]
# print(l[2:4])
# # 同样可以
# s=slice(2,4)
# print(l[s])
#
# s=slice(2,4,3) # 步长为3
# print(l[s])
#
# # vars打印局部名称空间的名字
# print(vars()) # 字典形式
# print(vars() is locals())

# # 时间函数
# import time
# time.sleep(1)
# print("helfwen")
# print(time)

# # 可以把字符变成内置函数
# s=‘time‘
# m=__import__(s)
# m.sleep(2)
# print(m)
#
# # 匿名函数lambda,没有函数名，直接写参数
# lambda x,y:x+y #return x+y
#
# def test(x,y):
#     return x+y
#
# max(iter,key=lambda )
# map(lambda,iter)
# reduce(lambda,iter)
# reduce(lambda,iter)
# filter(lambda,iter)

# 内置函数
# # 16进制
# hex
# # 数字变ica码的字母
# chr
# 复数
# x=complex(1,-2)
# print(x.real)
#
# int(9)

# 前面有点的不叫函数，叫方法,方法只对调用它的对象有用
# l=[]
# l.append(‘efef‘)
# print(l)

def test(x,item):
    x.append(item)

a=[]
b=[]
test(a,-9)
test(a,2)
test(a,7)
test(a,97)

print(a)
test(b,1)
print(b)

# 看对象点后有什么方法
print(dir(a))
# 商和余数
print(divmod(10,3))
# 迭代器
enumerate(a)

# 过滤
filter(lambda x:x>0,a)
map(lambda x:x>0,a)
from functools import reduce
er=reduce(lambda x,y:x+y,a)
print(er)

isinstance(1,int)
print(type(1) is int)
# 幂运算
print(pow(10,2))
# 幂运算再取余数
print(pow(10,2,3))
# 3.5变4,10.5变10
print(round(3.5))
print(round(10.5))