python中一些内置函数实例

时间:2022-11-15 12:07:15

lambda表达式

简单函数可用lambda表达式
1.

      def f1()
return(123)
r1=f1()
print()

2.

      f2=lambda:123
r2=f2()
print()

以上两个的功能是一样的

1.

        def f1(a1,a2)
return(a1+a2)

2.

        f2=lambda a1,a2:a1+a2        

以上两个的功能是一样

python的内置函数

abs()

i=abs(-123)
print(i)
结果为123

abs()的作用是绝对值

all()
循环参数,如果每个元素都为真,那么all的返回值为真
0、None、空字符串(有空格不算)、空列表、空字典、空元组==>0、None、空值这些为假

i=all(1,0)

any()
循环参数,只要有一个为真,就为真

i=any(1,0)

ascii()
去对象的类(列表list,字典dict)中找__repr__,获取期返回值
ascii(对象)
例如
1、

        class foo:#创建了一种新的数据类型(?)
def __repr__(self):
return "hello" obj=foo()#创建了一个foo类的变量(就像list,dict一样)
r=ascii(obj)执行ascii()这个函数以后就去它的类中寻找__repr__,并获取其返回值
print(r)#在这里输出的是hello

2、

        li=list()
r=ascii(li)
print(r) #结果是:[]

进制

bin()#二进制
r=bin(11)
print(r) #0b1011
oct()#八进制
r = oct(11)
print(r) #0o13
int()#十进制
hex()#十六进制
r = hex(20)
print(r) #0x14

进制转换

二进制转十进制

i=int("0b111",base=2)
print(i) #结果是:7

八进制转十进制

i=int("0o120",base=8)
print(i) #结果是:80

十六进制转十进制

i=int("0x100",base=16)
print(i) #结果是:256

bool()
判断换真假,把一个对象转换成布尔值(之前说的空值,None)假的False,真的True

bytes 字节
字节和字符转的转换
bytes("xxxx",encoding="utf-8")
bytearray 字节列表(字节数组)

chr()
接收一个数字,找到这个数字对应ascii的元素

x=chr(66)

print(x)#输出ascii值为66对应的字符 结果为 B

ord()
接收一个字符找到这个字符所对应的ascii码

i=ord("B")
print(i)#输出这个字符所对应的ascii码
#ascii码 一个字节 8位 2**8 256个

生成随机数

import random
i=random.randrange(65,9)#生成一个在65到90之间(65<=x<90)的随机数
print(i)
c=chr(i)
print(c)

随机数生成一个6位的验证码

1、

    temp=""
for i in range(6) 0<= <6
num=random.randrange(0,4)
if num==3 or num==1:
rad2 = random.randrange(0,10)
temp=temp+str(rad2)#把数字类型转换为字符类型然后再用"+"
#添加到temp字符串里
else
rad1 = random.randrange(65,91)
c1=chr(rad1)
temp=temp+c1

2、

    import random
temp = ""
for i in range(6):
num = random.randrange(0, 4)
if num == 3 or num == 1:
rad2 = random.randrange(0, 10)
temp = temp + str(rad2)
else:
rad1 = random.randrange(65, 91)
c1 = chr(rad1)
temp = temp + c1
print(temp)

callable()
对象是否可以被执行

def f1():
return 123
f1()
r=callable(f1)
print(r)
#结果为 True

classmethod()
#暂无解释

compile
接收一个字符串把这个字符串编译成python可以执行的代码

complex() #!
complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
如果第一个参数为字符串,则不需要指定第二个参数。
#复数??
#网上实例

>>>complex(1, 2)
(1 + 2j) >>> complex(1) # 数字
(1 + 0j) >>> complex("") # 当做字符串处理
(1 + 0j) # 注意:这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错
>>> complex("1+2j")
(1 + 2j)

delattr()
getattr()
hasattr()
setattr()
反射

dict()
字典

dir()
查询某个类提供了什么功能

li=[]
print(dir(li))

结果:['__add__', '__class__', '__contains__'等很多
查看详细功能信息
help
help(dict)

divmod()

r=divmod(10,3)
print(r)#结果为(3, 1)

元组形式显示商和余数

eval()
eval() 函数用来执行一个字符串表达式,并返回表达式的值,有返回值

a="1+3"
print(a)
ret=eval("1+3")#把字符串转换为表达式
print(ret) #结果为 4

实例

>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> eval("n + 4")
85

exec
执行一个字符串内的代码,无返回值(返回值为None)

exec("print(123)")

comple
编译py代码

filter() 150 11.20
循环可迭代的对象,获取每一个参数,在函数里执行参数
函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,
然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
filter(函数,可迭代的对象)
实例
1、

        def f1(x):
if x>22:
return True
else:
return False ret = filter(f1,[11,22,33,44]) #把返回True的放到ret中
for i in ret: #用循环输出ret
print(i)

2、

        def f1(x):
return x>22 #当着个为真就返回True,由于该函数可以在简单化所以看 3、 ret = filter(f1,[11,22,33,44])
for i in ret:
print(i)

3、

ret=filter(lambda x: x>22,[11,22,33,44])
for i in ret :
  print(i)

结果为 33 44

4、filter()函数详情

    def myfilter(func,seq):
#func函数名
result = []
for i in seq:
#func = f1
#func(x)执行f1函数,并获取返回值,将其赋给ret
ret = func(i)
if ret:
result.append(i)
return result def f1(x)
if x>22:
return True
else:
return False r = myfilter(f1,[11,22,33,44])
print(r)

map()
map() 会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数,
返回包含每次 function 函数返回值的新列表。
map(函数,可迭代的对象)

        def f1(x):
return x+100 ret = map(f1, [1,2,3,4,5])
for i in ret:
print(i)

结果为101
102
103
104
105

        ret = map(lambda x:x+100, [1,2,3,4,5])
for i in ret:
print(i)

#lambda是用于简单函数的所以可以用于上面的函数,尽管lambda只
能用于简单函数但其可使用三元运算

        ret = map(lambda x:x+100 if x%2 == 1 else x, [1,2,3,4,5])
for i in ret:
print(i)

mymap()函数详解

        def mymap(fun,arg):
#fun=>x函数
#arg=>li列表
result = []
for i in arg:
ret = fun(i)
result.append(ret)
return result
#这个只能说和map类似

format()
字符串格式化

frozenset
不能添加元素的set格式

globals()
获取当前代码里的所有的全局变量

local()
获取当前代码里的所有的局部变量

hash()
hash() 用于获取取一个对象(字符串或者数值等)的哈希值
一般用于字典key的优化

id()
内存地址

isinstance()
判断某个对象是否由某一个类创建的

li=[11,22,33]
t=isinstance(li,list)
print(t) 结果 True
a=isinstance(li,dict)
print(a) 结果 False

如果某个类是当前类的父类也是支持的

issubclass()
看看是不是子类

iter()
创建一个可以迭代的对象

next()
上面那个可迭代的对象运行一个next就去一个值,取下一个值

a=iter([11,22,33,44])
print(a)
r1=next(a)
print(r1) #结果 11
r2=next(a)
print(r2) #结果 22

max()
找到最大值
min()
找到最小值

li=[11,22,33,44]
t=max(li)
print(t) #结果 44
z=max(li)
print(z)# 结果 11

memoryview()
根据索引判断某个对象的的地址是多少
函数返回给定参数的内存查看对象(Momory view)。
所谓内存查看对象,是指对支持缓冲区协议的数据进行包装,在不需要
复制对象基础上允许Python代码访问。

object()

open()
文件操作

pow()

i=pow(2,10) #2的10次方
print(i) #结果 1024

property()

repr()
返回__repr__的值
repr() 函数将对象转化为供解释器读取的形式

reversed()
反转 倒置

round()
四舍五入

e=round(3.6) #

slice()
slice() 函数实现切片对象,主要用在切片操作函数里的参数传递
li[0:2]==>特殊的方法 __sliceitem__

sorted()
排序

    li = [1, 22, 33, 222, 3, 1]
print(li)
le = sorted(li)# 生成新的值,不对原来的变量进行改变
print(le) #这个只能对同一个类型的进行排序
print(li)
li.sort() # 不生成新的值,对原来的变量进行改变
print(li)

结果
[1, 22, 33, 222, 3, 1]
[1, 1, 3, 22, 33, 222]
[1, 22, 33, 222, 3, 1]
[1, 1, 3, 22, 33, 222]

实例

        li = ["","","张","a","","c","you","鈾","---","_","A","b","","你","王",]
print(li)
le = sorted(li)# 生成新的值,不对原来的变量进行改变
print(le)
for i in le:
print(bytes(i,encoding="utf-8"))

结果:
['123', '1', '张', 'a', '99', 'c', 'you', '鈾', '---', '_', 'A', 'b', '0', '你', '王']
['---', '0', '1', '123', '99', 'A', '_', 'a', 'b', 'c', 'you', '你', '张', '王', '鈾']
b'---'
b'0'
b'1'
b'123'#数字是先比较第一个元素,谁小谁在前面,第一个样就比第二个
b'99'
b'A'
b'_' #字母比较ascii码,先比较第一个元素,谁小谁在前面,第一个
b'a' #一样就比第二个
b'b'
b'c'
b'you'
b'\xe4\xbd\xa0'#汉字比十六进制的大小
b'\xe5\xbc\xa0'
b'\xe7\x8e\x8b'
b'\xe9\x88\xbe'

staticmethod()

sum()
t=sum([11,22,33])
print()

super()
找到父类

tuple()
查看类型

vars()
查看当前对象有多少变量

zip()

li=[11,22,33,44]
li2=["a","VV","c","aa"]
r=zip(li,li2)
print(r)
for i in r :
print(i)

结果为 :

<zip object at 0x00000059C0191748>
(11, 'a')
(22, 'VV')
(33, 'c')
(44, 'aa')

__import__
导入一个模块
import random
random.randrange()

下面那个相当于做了一个别名

r=__import__(random)
r.randrange()