python中一些内置函数实例详解编程语言

 

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") # 当做字符串处理 
(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) #4

 

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 = ["123","1","","a","99","c","you","","---","_","A","b","0","","",] 
        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()

 

原创文章,作者:ItWorker,如若转载,请注明出处:https://blog.ytso.com/12374.html

(0)
上一篇 2021年7月19日
下一篇 2021年7月19日

相关推荐

发表回复

登录后才能评论