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 + 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()