python入门之 python内置函数

函数就是以功能为导向，一个函数封装一个功能，那么python将一些常用的功能（比如len）给我们封装成了一个一个的函数，供我们使用，他们不仅效率高（底层都是用c语言写的），而且是拿来即用，避免重复早*，那么这些函数就称为内置函数，到目前为止python给我们提供的内置函数一共是68个。

1、内置函数一

（1）eval() : 执行字符串类型的代码，并返回最终结果 神器一

a = "88 + 99"
print(eval(a))

eval("n + 4")  # 85
eval('print(666)')  # 666

注意：千万记住禁止使用

（2）exec() : 执行字符串类型的代码 神器二

def func():
    print(111)
func()

exec(func())

注意：千万记住禁止使用

（3）hash() :作用就是区分可变数据类型和不可变数据类型

print(hash("123"))
print(hash(12))
print(hash(-1))
print(hash(-10))
print(hash((2,1)))

dic = {[1,2,3]:2}
print(hash([1,2,3]))

（4）help() :查看帮助信息，用于查看函数或模块用途的详细说明

help(list) 

（5）callable() :查看对象是否可调用

def func():
    print(1)
lst = [1,23,4,]
print(callable(lst))

（6）int() :将一个字符串或数字转换为整型

print(int())  
print(int('12'))  
print(int(3.6))  

（7）float() :将整数和字符串转换成浮点型

print(float(3))
print(int(3))

（8）complex() :复数

print(complex(20))

（9）bin() :十进制转二进制 0b

print(bin(100))

（10）oct() :十进制转八进制 0o

print(oct(10)) 

（11）hex() :十进制转十六进制 0x

print(hex(17))

（12）divmod() :求商和余数 （商，余）

print(divmod(5,2))

（13）round() :保留小数位

print(round(3.534232,2)) 

（14）pow() :幂运算pow 当是两个参数时是求幂，三个参数时就是求幂取余

print(pow(2,2))  #幂 pow 两个参数是求幂
print(pow(2,2,3))  #幂 pow 两个参数是求幂后的余

（15）bytes() :将字符串进行编码，用于不同编码之间的转化

s = "你好"
s1 = bytes(s,encoding="utf-8")
print("s1")

（16）ord() :通过元素获取当前表位的序号

print(ord("你"))

（17）chr() :通过表位序号查找元素

print(chr(20320))

（18）repr() :查看数据的源生态 ，给程序员使用的

a = 'alex'
print(repr(a))   #查看你数据的原生态  -- 给程序员使用的
print(a)         # 给用户使用的

（19）all() :判断容器中的元素是否都为真 (and)

lst = [1,2,0,4,5]
print(all(lst)) 

（20）any() :判断容器中的元素是否有一个为真

lst = [1,2,3,0,1,23]  
print(any(lst))

（21）globals() :查看全局变量

print(globals()) 

（22）locals() :查看当前空间变量

a = 10
def func():
    a = 1
    print(locals())     #  查看当前空间变量
    print(1)

func()

（23）frozenset() :冻结集合

2、内置函数二

（1）普通函数：

<1> print() 屏幕输出

''' 源码分析
def print(self, *args, sep=' ', end='\n', file=none): # known special case of print
    """
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=false)
    file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
    sep:   打印多个值之间的分隔符，默认为空格
    end:   每一次打印的结尾，默认为换行符
    flush: 立即把内容输出到流文件，不作缓存
    """
'''

sep : 每一个元素之间分割的方法 默认 " "    ****
print(1,2,3,sep="|")

end :print执行完后的结束语句 默认\n        ****
print(1,2,3,end="")
print(4,5,6,end="")

file : 文件句柄 默认是显示到屏幕
print(1,2,3,4,file=open("test","w",encoding="utf-8"))

print()  # flush 刷新

print(111,222,333,sep='*')  # 111*222*333

print(111,end='')
print(222)  #两行的结果 111222

f = open('log','w',encoding='utf-8')
print('写入文件',fle=f,flush=true

<2> dir() 查看当前对象的所有方法 返回的是列表

print(dir(list))  # 查看当前对象所有方法  返回的是列表print(dir(str))  # 查看当前对象所有方法

<3> format() 格式转换

# 对齐方式
print(format("alex",">20"))  # 右对齐
print(format("alex","<20"))  # 左对齐
print(format("alex","^20"))  # 居中

# 进制转换
print(format(10,"b"))      # bin  二进制
print(format(10,"08b"))
print(format(10,"08o"))    # oct  八进制
print(format(10,"08x"))    # hex  十六进制
print(format(0b1010,"d"))  # digit 十进制

<4> str() 将字节转换成字符串

byte_str = bytes("你好",encoding="utf")
print(byte_str)
print(str(byte_str,encoding="utf-8"))

<5> list() 将一个可迭代的对象转换为列表

print(list("alex"))

<6> tuple() 讲一个可迭代的对象转换成元组

print(tuple([1,2,3,4]))

<7>set() 将可迭代对象转换成一个集合

print(set("alex"))

<8> dict() 通过相应的方式创建字典

print(dict([(1,2),(3,4)]))

print(dict(k=1,v=2,c=3))

dic1 = {"key1":1,"key2":2}
dic2 = {"a":1,"b":2}
dic2.update(dic1)
print(dic2)

print(dict(**dic1,**dic2))

<9> abs() 返回绝对值

i = -5
print(abs(i))  # 5

<10> sum() 求和

print(sum([1,2,3]))
print(sum((1,2,3),100))     # 从100开始加

<11> reversed() 将一个序列翻转，返回翻转序列的迭代器

print(list(reversed("alex")))

lst = [1,2,3,4,5]
print(list(reversed(lst)))  反转
print(lst)

<12> zip() 拉链

用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组，然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回。

lst1 = [1,2,3]

lst2 = ['a','b','c','d']

lst3 = (11,12,13,14,15)

for i in zip(lst1,lst2,lst3):

    print(i)
    

结果:

(1, 'a', 11)

(2, 'b', 12)

(3, 'c', 13)

（2）高阶函数：

<1> min() 求最小值

rint(min([1,2,3]))  # 返回此序列最小值

ret = min([1,2,-5,],key=abs)  # 按照绝对值的大小，返回此序列最小值
print(ret)
# 加key是可以加函数名，min自动会获取传入函数中的参数的每个元素，然后通过你设定的返回值比较大小，返回最小的传入的那个参数。
print(min(1,2,-5,6,-3,key=lambda x:abs(x)))  # 可以设置很多参数比较大小
dic = {'a':3,'b':2,'c':1}
print(min(dic,key=lambda x:dic[x]))

# x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键

<2> max() 求最大值

print(max(10,12,13,15,16))
print(max([10,12,13,15,-16],key=abs))

<3> sorted() 排序函数

语法:sorted(iterable,key=none,reverse=false)

iterable : 可迭代对象

key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序

reverse :是否是倒序,true 倒序 false 正序

lst = [1,3,2,5,4]
lst2 = sorted(lst)
print(lst)    #原列表不会改变
print(lst2)   #返回的新列表是经过排序的


lst3 = sorted(lst,reverse=true)
print(lst3)   #倒叙

结果:
[1, 3, 2, 5, 4]
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]

字典使用sorted排序

dic = {1:'a',3:'c',2:'b'}
print(sorted(dic))   # 字典排序返回的就是排序后的key

结果:
[1,2,3]




和函数组合使用

# 定义一个列表,然后根据一元素的长度排序
lst = ['天龙八部','西游记','红楼梦','三国演义']

# 计算字符串的长度
def func(s):
    return len(s)
print(sorted(lst,key=func))

# 结果:
# ['西游记', '红楼梦', '天龙八部', '三国演义']


和lambda组合使用

lst = ['天龙八部','西游记','红楼梦','三国演义']

print(sorted(lst,key=lambda s:len(s)))

结果:
['西游记', '红楼梦', '天龙八部', '三国演义']


lst = [{'id':1,'name':'alex','age':18},
    {'id':2,'name':'wusir','age':17},
    {'id':3,'name':'taibai','age':16},]

# 按照年龄对学生信息进行排序

print(sorted(lst,key=lambda e:e['age']))

结果:
[{'id': 3, 'name': 'taibai', 'age': 16}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}]

<4> filter() 筛选过滤

def func(a):
    return a == 1

print(list(filter(func,[1,2,3,4,6])))
1,指定过滤规则(函数名[函数的内存地址])  2,要过滤的数据

自己模拟

def filter(func,argv):
    lst = []
    for i in argv:
        ret = func(i)
        if ret:
            lst.append(i)
    return lst

def foo(a):
    return a>2

print(filter(foo,[1,2,3,4])) # filter(foo,[1,2,3,4])

def func(a):
    return a>1
print(list(filter(func,[1,2,3,4,5])))

print(list(filter(lambda a:a>1,[1,2,3,4,5])))

语法: filter(function,iterable)

function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的true或者false来判断是否保留此项数据

iterable:可迭代对象

lst = [{'id':1,'name':'alex','age':18},
        {'id':1,'name':'wusir','age':17},
        {'id':1,'name':'taibai','age':16},]

ls = filter(lambda e:e['age'] > 16,lst)

print(list(ls))

结果:
[{'id': 1, 'name': 'alex', 'age': 18},
 {'id': 1, 'name': 'wusir', 'age': 17}]

<5> map() 映射（将可迭代对象中的每个元素执行到指定的函数）

def func(a,b):
    return a+b
print(list(map(func,[1,2,3,4,5],[33,22,44,55])))


def map(argv,args):
    lst = []
    num = len(args) if len(args) < len(argv) else len(argv)
    for i in range(num):
        lst.append(argv[i] + args[i])
    return lst
print(map([1,2,3,4],[3,4,5,6,7,8,9,0]))

print(list(map(lambda x,y:x+y,[1,2,3,4,5],[33,22,44,55])))

语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function

计算列表中每个元素的平方,返回新列表

lst = [1,2,3,4,5]

def func(s):

    return  s*s

mp = map(func,lst)

print(mp)

print(list(mp))




改写成lambda

lst = [1,2,3,4,5]

print(list(map(lambda s:s*s,lst)))




计算两个列表中相同位置的数据的和

lst1 = [1, 2, 3, 4, 5]

lst2 = [2, 4, 6, 8, 10]

print(list(map(lambda x, y: x+y, lst1, lst2)))

结果:

[3, 6, 9, 12, 15]

高阶函数内部帮我们做了一个for循环

3、reduce 累计算

from functools import reduce   # 累计算
从 functools工具箱中拿来了reduce工具
def func(x,y):
    return x+y
print(reduce(func,[1,2,3,4,5]))
print(reduce(lambda x,y:x+y,[1,2,3,4,5]))

from functools import reduce
def func(x,y):
    return x + y

# reduce 的使用方式:
# reduce(函数名,可迭代对象)  # 这两个参数必须都要有,缺一个不行

ret = reduce(func,[3,4,5,6,7])
print(ret)  # 结果 25
reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,
接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始
临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推

注意:我们放进去的可迭代对象没有更改
以上这个例子我们使用sum就可以完全的实现了.我现在有[1,2,3,4]想让列表中的数变成1234,就要用到reduce了.
普通函数版
from functools import reduce

def func(x,y):

    return x * 10 + y
    # 第一次的时候 x是1 y是2  x乘以10就是10,然后加上y也就是2最终结果是12然后临时存储起来了
    # 第二次的时候x是临时存储的值12 x乘以10就是 120 然后加上y也就是3最终结果是123临时存储起来了
    # 第三次的时候x是临时存储的值123 x乘以10就是 1230 然后加上y也就是4最终结果是1234然后返回了

l = reduce(func,[1,2,3,4])
print(l)


匿名函数版
l = reduce(lambda x,y:x*10+y,[1,2,3,4])
print(l)


在python2.x版本中recude是直接 import就可以的, python3.x版本中需要从functools这个包中导入

龟叔本打算将 lambda 和 reduce 都从全局名字空间都移除, 舆论说龟叔不喜欢lambda 和 reduce

最后lambda没删除是因为和一个人给龟叔写了好多封,进行交流然后把lambda保住了.