内置函数

什么是内置函数?就是python帮我们提供的一个工具,拿过直接用就行,比如我们的print,input,type,id等等.截止到python3.6.2版本

中一共提供了68个内置函数.他们就是python直接提供给我们的,有一些我们已经用过了.有一些还没有用过.还有一我们需要学完面向对象才能继续学习.今天我们认识一下python的内置函数

作用域相关

　　locals()返回当前作用域中的名字

　　gloabls()返回全局作用域中的名字

 

 迭代器相关

 range()范围

iter()获取迭代器,内部实际使用的是iter()方法来获取迭代器

next()迭代器向下执行一次,内部实际使用了next()方法返回迭代器的下一个项目

 

 字符窜类型的代码的执行

eval()执行字符串类型的代码,并返回最终结果

print(eval('2+3'))

exec()执行字符串类型的代码.(输入字符串也可以执行)

exec("""
print('你好')
""")

里面也可以是函数...

 

输入和输出相关

 print里的sep

print('啊啊啊','是是是')
print('啊啊啊','是是是',sep=',')
结果:
啊啊啊 是是是
啊啊啊|是是是

打印出来的东西是以空格分开的,sep可以指定以什么分开

print里的end

 print 默认end是一个\n,打印出来的效果是有换行功能,咱们改成空字符串,打印出来的效果就是一行显示

 内存相关

 hash()获取对象的哈希值

print(hash((1,2,3)))

 id()获取到对象的内存地址

 

帮助

help()函数用于查看函数或模块的用途

 

调用相关

 callable()用于检查一个对象是否可调用的,True,object有可能调用失败,要是返回False,绝对失败

 

 查看内存属性

 dir()查看对象的内置属性,方法

 dir(input)

 

 数字相关:

bool()将给定的数据转换成bool值,返回False

float()将给定的数据转换成float值,也就上次小数

compilex()创建一个复数,第一个参数为实部,第二个参数为虚部,或者第一个参数直接用字符串来描述复数

进制转换:

bin()将给的参数转换成二进制

otc()将给的参数转换成八进制

hex() 将给的参数转换成十六进制

 

 数字运算

abs()求绝对值

divmod(20,6)返回商和余数     结果(3,2)

第一个参数是商,第二个参数是余数

round(2.33,1)四舍五入

后边的参数是指定小数点后边的数字进行四舍五入,咱们指定的数字要小于咱们小时候点后边的位数

pow(a,b)求a的b次幂,如果有个三次参数,则求万次幂后对第三个余数取余

print(pow(2,4))
结果:
16
print(pow(2,4,3))
结果:
1
三个参数 前来个参数是求2的3次幂,第三个参数是这个总和去除3然后获取的是余数

sum()求和

min()求最小值

max()求最大值

这三个求:和,大,小的参数必须是可迭代对象

 

数据结构相关

列表和元祖

list() 将一个可迭代对象转换成列表

tuple() 将一个可迭代对象转换成元祖

reversed() 将一个序列反转,返回反转序列的迭代器

 

字符串相关

str() 将数据转化成字符串

format() 与具体数相关,用于计算各种小数,精算等

字符串

# 字符串
# print(format('meet','<20'))   #左对齐
# print(format('meet','>20'))   #右对齐
# print(format('meet','^20'))   #居中
​
结果:
meet               
                meet
        meet

数值

#数值
print(format(3,'b'))    # 二进制
print(format(97,'c'))   # 转换成unicodezif
print(format(11,'d'))   #十进制
print(format(56))       #和d一样
print(format(11,'n'))   #十进制
print(format(11,'o'))   #八进制
​
print(format(11,'x'))  # 十六进制(小写字母)
print(format(11,'X'))  # 十六进制(大写字母)
​
# 浮点数
​
print(format(1234567890,'e'))  #科学计算法,默认使用6位
print(format(123456789,'0.2e'))# 科学计算,保留2位小数(小写)
print(format(123456789,'0.2E'))# 科学计算,保留2位小数(大写)
print(format(1.23456789,'f')) #小数点计数法,保留6位小数
print(format(1.23456789,'0.2f')) # 小数点计数法,保留2位数
print(format(1.23456789,'0.10f')) # 小数点计数法,保留2位数
print(format(1.23456789e+1000,'F')) # 小数点计数法

 

 

encode('utf-8')转换成指定的编码字符集

decode('utf-8')指定解码方式进行解码

bytes()把字符串转换成bytes类型

a='度扒鸡'
a = bytes(a,encoding='utf-8')
print(a)
结果:b'\xe5\xba\xa6\xe6\x89\x92\xe9\xb8\xa1'
把字符串编码成utf-8

bytearray() 返回一个新字节数组,每个元素的值的范围是0~256对应的是ascii码表

ret = bytearray('meet',encoding='utf-8')
print(ret)
print(ret[0])
​
结果:
bytearray(b'meet')
109

memoryview() 查看bytes的内存地址

s = memoryview('麻花藤'.encode('utf-8'))
print(s)
​
# 结果:
# <memory at 0x000001F332E0E288>

ord() 输入字符找带字符编码的位置

print(ord('a'))
print(ord('中'))
print(ord('国'))
​
结果:
97
20013
22269
​
对应的是当前编码

chr() 输入位置数字找出对应的字符

print(chr(97))  # 找到对应位置的字符
print(chr(20013))  # 找到对应位置的字符
​
# 结果:
a
中

 

ascii()　是ascii码中的返回值 不是就返回\u

print(ascii('a'))  判断字符串在不在ascii码表中
print(ascii('中')) 
​
结果:
'a'
'\u4e2d'     如果不存在就返回\u...

repr()返回一个对象本质的形式

name = 'alex'
print(repr(name))   #返回这个对象本质的表示形式
​
结果:
'alex'
​
name = '我叫%r'
print(name%'meet')   %r 用的就是repr
结果:
我叫'meet'

 

数据集合

dict()创建一个字典

set()创建一个集合

 

其他相关

len()返回一个对象的元素

enumerate()获取枚举对象

 all()可迭代对象中全部是True,结果才是True

lst = [1,2,3,4,True,0,False]
lst1 = [1,2,3,4,True]
print(any(lst))
print(any(lst1))
结果:
False
True

any()可迭代对象中有一个是True就是True

lst = [1,2,3,4,True,0,False]
lst1 = [1,2,3,4,True]
print(any(lst))
print(any(lst1))
结果:
True
True

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)

 

 

lambda

 匿名函数,为了解决一些简单的需求而设计的一句话函数

 

def func(n):
    return n**n
print(func(4))
  
f = lambda x: x**x
print(f(4))
  
结果:
256
256

 

 

lambda表示的是匿名函数,不需要用def来声明,一句话就可以声明出一个函数

语法:

　函数名 = lambda 参数:返回值

注意:

　　1.函数的参数可以有多个,多个参数之间用逗号隔开

　　2.匿名函数不管多复杂.只能写一行.且逻辑结束后直接返回数据

　　3.返回值和正常的函数一样,可以是任意数据类型,但是只能一个,不能返回多个.

匿名函数并不是说一定没有名字,这里前面的变量就是一个函数名,说他是匿名原因是我们通过

name查看的时候是没有名字的.统一都叫做lambda.在调用的时候没有什么特别之处像正常的函数调用既可

 

 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}]

 

 

 filter

筛选过滤

语法: 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}]

 

map

映射函数

语法: 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]

reduce

 

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保住了.

 

 

 

排列组合函数

product 笛卡尔积　　（有放回抽样排列）

permutations 排列　　（不放回抽样排列）

combinations 组合,没有重复　　（不放回抽样组合）

combinations_with_replacement 组合,有重复　　（有放回抽样组合）

 

12345随机其中3位小数,三位小数不能重复

import  itertools
a = list(itertools.permutations('12345',3))
print(a)
print(len(a))#60种

 

 

参考资料:

https://www.processon.com/view/link/5b4ee15be4b0edb750de96ac