六.Python函数编程_内置函数

最新推荐文章于 2023-06-01 20:25:00 发布

木瞳

最新推荐文章于 2023-06-01 20:25:00 发布

阅读量181

点赞数

分类专栏： # Python

本文链接：https://blog.csdn.net/qq_39663113/article/details/85058619

版权

Python 专栏收录该内容

42 篇文章 0 订阅

订阅专栏

Python函数编程

#13.函数编程
#   lambda lambda是对函数的简写

    #fun=lambda x:2*x+1
    #print(fun(20))
    #相当于
    # def test(x):
    #     return 2*x+1
    # print(test(20))

li=[1,2,4,8,12]
#map函数  列表里的值的顺序和位置不发生改变，对单个值进行操作并依次进行输出

# li1=map(lambda x:x**2,li)
# print(list(li1))
# 相当于
# def li1(fun,x):
#     res=[]
#     for i in x:
#         res.append(fun(i))
#     return res
#print(list(li1(lambda x:x**2,li)))



#filter函数  对列表里的元素进行筛选，满足条件留下

# li={1000,18,12}
# liFilter=filter(lambda x:x<=18,li)
# print(list(liFilter))
# 相当于
# def liFil(fun,x):
#     res=[]
#     for i in x:
#         if fun(i):
#             res.append(i)
#     return res
# print(list(liFil(lambda x:x<=18,li)))


#reduce函数 将集合元素整合成一个元素的操作

# from functools import reduce #导入reduce
#
# y=reduce(lambda x,y:x+y,li)
# print(y)
# 相当于
# def red(fun,li,num=None):
#     if num==None:
#         num=li.pop()
#     for i in li:
#         num=fun(num,i)
#     return num
# print(red(lambda x,y:x+y,li))

内置函数

#14.内置函数

#abs() 获取绝对值
    #print(abs(-12))
#bin() 十进制转换为二进制
    #print(bin(20))
#oct() 十进制转换为八进制
    #print(oct(20))
#hex() 十进制转换为十六进制
    #print(hex(40))
#dir() 获取函数的方法名
    #print(dir(str))
#help() 获取函数详细的方法注释
    #print(help(str))
#all() 进行bool的and运算    全部为True才为True
    #print(all([1,"sss",13]))
#any 进行bool的or运算    一个为True就为True
    #print(any([1,""]))
#ascii()  返回字符串
    #print(ascii('1'))
#bool() 将元素转换为bool值
    #print(bool([])) #将空列表转换为bool值
#bytes()  将元素通过格式转换为二进制字节，可用于网络数据传输
    # print(bytes("你好",encoding="utf-8"))
    # print(bytes("你好",encoding="gbk").decode("gbk"))#将二进制数据通过转码格式转化为元素
#chr()  通过ascii码将数字转换为ascii字母
    #print(chr(65))
#ord() 将字母转换为ascii码
    #print(ord("A"))
#divmod()  通过运算，获取两个数的商和余数到集合里
    #print(divmod(20,3))
#enumerate() 用于将一个可循环元素转换为可索引的序列
    #print(list(enumerate(["tom","tom1","tom2"])))
#eval() 用于提取字符串中的函数，或者将字符串表达式进行运算
    # print(eval("print(1)"))
    # print(eval("1+3**2"))
#exec() 可以执行存储在字符串中的python语句
    #exec("for i in 'Hello': print(i)")
#getattr() 获取类的属性值
    # class people:
    #     count="china"
    # print("获取people类中count的属性值：",getattr(people,"count"))
#setattr() 为类的属性值赋值
    # class people:
    #     count="china"
    # setattr(people,"count","american")

#hasattr()  判断类中是否存在此属性
    # class people:
    #     age=18
    # print("people类是否存在age属性：",hasattr(people,"age"))
#globals()返回所有全局变量的字典
    #print(globals())
#locals() 返回局部变量
    # def testa():
    #     a=12
    #     b=16
    #     print(locals()) #返回当前函数局部变量的字典
    # testa()

#hash() 将元素转换为hash码
    #print(hash("Hello"))
#id() 获取元素内存地址
    #print(id("你好"))
#isinstance()  判断是否是对象
    # b=16
    # print(isinstance(b,int)) #判断b是否是int对象实例
#iter 迭代可迭代的对象
    # dic=[12,123,44,55]
    # print(list(iter(dic)))
#list() 将元素转换为列表
    # tu=("tom",18,"add")
    # print(list(tu))#将元组转换为列表
#zip 将两个可迭代对象生成字典元素
    # a=[18,19,20,21]
    # b=["18","19","20","21"]
    # print(dict(zip(a,b)))
#max() 输出列表里的最大值
    # print("最大值",max([12,500,600,20]))
    #输出字典里的最大数值
        # c={"age1":18,"age2":20,"age3":40,"age4":100}
        # d=dict(zip(c.values(),c.keys()))
        # print(d[max(d)],max(d))
#min()  输出列表里的最小值
    # print("最小值",min([12,500,600,20]))
#open()  打开文件
    #fo=open("d.run.txt")
#获取文件名
    #print(fo.name)
#next() 循环到文件的下一行
    #print(next(fo))
#object() 初始化object对象
    #print(object())
#pow() 获取数的几次方
    #print(pow(2,3))
#property()     将函数封装成对象的属性
    # def a():
    #     return 12
    # v=property(fget=a)
    # print("v的get属性为",v.fget())
#reversed()  将列表顺序反转
    # li=[1,2,3,4,5,6,7,8,9]
    # print(list(reversed(li)))
#sorted() 将列表进行排序
    # li=[1,3,2,4,9,5,4,77,12]
    # print(list(sorted(li)))
#range() 生成某个范围内的数字
    # print(list(range(10)))
#sclice() 对元素进行切片
    # lis=list(range(10))
    # msli=slice(1,10,2) #1起始位置  10最终位置  2间隔距离
    # print(lis[msli])
#sum() 对所有元素进行加操作
    #print(sum([1,5,6,9,23]))
#type() 获取元素的类型
    # print(type("H"))
#super() 调用父类
    # class A:
    #     pass
    # class B(A):
    #     def add(self,x):
    #         super().add(self,1)
#vars() 返回对象内的局部变量
    # class person:
    #     name="tom"
    #     age=19
    # print(vars(person))
#__import__()  动态加载函数
    # import sys
    # __import__("a")#导入a.py模块

abs() 对传入参数取绝对值

bool() 对传入参数取布尔值， None, 0, "",[],{},() 这些参数传入bool后，返回False

all() 所有传入参数为真，才为真

any() 任何一个传入参数为真，才为真

ascii() 自动执行传入参数的_repr_方法（将对象转换为字符串）

bin() 接收一个十进制，转换成二进制

oct() 接收一个十进制，转换成八进制

hex() 接收一个十进制，转换成十六进制

bytes() 字符串转换成字节。第一个传入参数是要转换的字符串，第二个参数按什么编码转换为字节 eg. bytes(s,encoding = 'utf-8') , bytes(s,encoding = 'gbk')    1个字节占8位；utf-8编码格式下，一个汉字占3个字节；gbk编码格式下，一个汉字占2个字节

str() 字节转换成字符串。第一个传入参数是要转换的字节，第二个参数是按什么编码转换成字符串

chr(65)  # 数字转字母，查看ASCII码表

ord('A')  # 字母转数字，查看ASCII码表

compile()  # 接收.py文件或字符串作为传入参数，将其编译成python字节码

eval()    # 执行python代码，并返回其执行结果。 e.g. eval("1+2+3")   eval("print(123)").   在接收用户输入时应避免使用eval，因为别有用心的用户可能借此注入恶意代码

exec()    #执行python代码（可以是编译过的，也可以是未编译的），没有返回结果（返回None） e.g. exec(compile("print(123)","<string>","exec"))   exec("print(123)")

dir()  # 接收对象作为参数，返回该对象的所有属性和方法

help()  # 接收对象作为参数，更详细地返回该对象的所有属性和方法

divmod(100,10)  # 返回一个元组（10,0），第一个元素的100/10的商，第二个元素的100/10的余数 

enumerate()  # 接收序列化类型的数据，返回一个迭代器（对象). e.g. for i,item in enumerate(['one','two','three']): print(i,item)  打印1 'one' 换行2 'two'换行 3 'three'

isinstance(object, class)  # 判断对象是否是某个类的实例. e.g. isinstance([1,2,3],list)

filter(函数或者lambda表达式，可迭代的对象)  # 对可迭代对象中的每一个元素，将其作为实参传入函数（或lambda表达式），如果函数返回False，将该元素丢弃，如果函数返回True，将该元素添加到filter的返回值中。注意filter返回的是一个filter对象，实际应用中往往需要用list或tuple将其转换为列表或元组类型. e.g. list(filter(lambda a:a>1,[1,2,3])) 返回[2,3]

map(函数或lambda表达式，可迭代的对象)  #对可迭代的每一个元素，将其作为实参传入函数，将每一次调用函数返回的结果都添加到map的返回值中。e.g. tuple(map(lambda a:a+1,(1,2,3))) 返回(2,3,4)

format()  #字符串格式化

frozenset()  #转换为不可变的集合

globals()  # 返回一个字典，包括所有的全局变量与它的值所组成的键值对

locals()  # 返回一个字典，包括所有的局部变量与它的值所组成的键值对

hash()  # 对传入参数取哈希值并返回

id() # 返回内存地址，可用于查看两个变量是否指向相同一块内存地址

input('please input:')  # 提示用户输入，返回用户输入的内容（不论输入什么，都转换成字符串类型）

issubclass(subclass,class) #查看这个类是否是另一个类的派生类，如果是返回True，否则返回False

len('string')  # 返回字符串长度，在python3中以字符为单位，在python2中以字节为单位

max()  #接收序列化类型数据，返回其中值最大的元素

min()  # ..... 返回其中值最小的元素

memoryview()  # 查看内存地址

next() 

iter()  

object() 

pow(x,y)  # 求次方，返回x**y的结果

pow(x,y,z) # 返回 x**y%z 的结果

property()  # 获取对象的所有属性

range()  # 获取随机数或随机字符 eg. range(10) 从0到10的随机数

repr()  # 执行传入对象中的_repr_方法

reversed()  #对序列化类型数据反向排序，返回一个新的对象。注意与对象的reverse方法区别，后者是就地改变对象

sorted() # 对序列化类型数据正向排序，返回一个新的对象。注意与对象的sort方法区别，后者是就地改变对象

slice()  #对序列化类型数据切片，返回一个新的对象。eg. slice(起始下标，终止下标，步长)，步长默认为1

round()  # 返回四舍五入后的结果

int() #转换为整型

list() # 转换为列表类型

set()  # 转换为集合类型

str() #转换为字符串类型

tuple() # 转换为元组类型

type() # 返回对象类型

staticmethod() # 返回静态方法

super()  # 返回基类

vars() #返回当前模块中的所有变量

zip() # 接收多个序列化类型的数据，对各序列化数据中的元素，按索引位置分类成一个个元组。

eg. myList = list(zip([1,2,3],['a','b','c'])) 创建myList列表[(1,'a'),(2,'b'),(3,'c')]    

mydic = dict(zip([1,2,3],['a','b','c'])) 创建mydic字典{1:'a',2:'b',3:'c'}

l1 = [1,2,3]

l2 = ['one','two','three']

list(zip(l1,l2))  返回[(1,'one'),(2,'two'),'(3,'three')]