（十三）内置函数

下面是68个内置方法，里面有一些以前用过，所以说起来就简单了。还有一些没看过的，来说一下它的作用。

abs()， dict()，help()， min()， setattr()

all()， dir()， hex()， next()， slice()

any()， divmod()， id()， object()， sorted()

ascii()， enumerate()， input()， oct()， staticmethod()

bin()， eval()， int()， open()， str()

bool()， exec()， isinstance()， ord()， sum()

bytearray() ，filter()， issubclass()， pow()，super()

bytes()， float()， iter()， print()， tuple()

callable()， format()， len()， property()， type()

chr()， frozenset()， list()， range()， vars()

classmethod()， getattr()， locals()， repr()， zip()

compile()， globals()， map()，reversed()， __import__()

complex()， hasattr()， max()， round()

delattr()， hash()， memoryview()， set()

作⽤域相关:

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

　　　　   globals() 返回全局作⽤域中的名字

迭代器相关:

　　　　range() ⽣成数据，从头循环到尾，这个也可以按照步长生成。所以也可以倒序输出数据。

　　　　next() 迭代器向下执⾏⼀次, 内部实际使⽤了__next__()⽅法返回迭代器的下⼀个项⽬

　　　　iter() 获取迭代器, 内部实际使⽤的是__iter__()⽅法来获取迭代器

字符串类型代码的执⾏：

 eval() 执⾏字符串类型的代码，并返回最终结果：

print(eval("2+2")) # 4
n = 8
print(eval("2+n")) # 10
def func():
 	print(666)
eval("func()") # 666
exec() 执⾏字符串类型的代码
exec("""
for i in range(10):
     print(i)
""")
exec("""
def func():
 	print("我是周杰伦")
func()
""")

compile() 将字符串类型的代码变异. 代码对象能够通过exec语句来执⾏或者eval()进⾏求值

'''
 参数说明:
 1. resource 要执⾏的代码, 动态代码⽚段
 2. ⽂件名, 代码存放的⽂件名, 当传⼊了第⼀个参数的时候, 这个参数给空就可以了
 3. 模式, 取值有3个,
 1. exec: ⼀般放⼀些流程语句的时候
 2. eval: resource只存放⼀个求值表达式.
 3. single: resource存放的代码有交互的时候. mode应为single
'''
code1 = "for i in range(10): print(i)"
c1 = compile(code1, "", mode="exec")
exec(c1)
code2 = "1+2+3"
c2 = compile(code2, "", mode="eval")
a = eval(c2)
print(a)
code3 = "name = input('请输⼊你的名字:')"
c3 = compile(code3, "", mode="single")
exec(c3)
print(name)

　　

有返回值的字符串形式的代码⽤eval(). 没有返回值的字符串形式的代码⽤exec(). ⼀般很少⽤到compile()

输入和输出相关:

　　　　 input() 获取⽤户输入的内容

 　　　　print() 打印输出

内存相关:

 　　　　hash() 获取到对象的哈希值(int, str, bool, tuple)

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

⽂件操作相关:

 　　　　open() ⽤于⼝打开⼀个⽂件, 创建⼀个⽂件句柄

模块相关:

 　　　　__import__() ⽤于动态加载类和函数

帮助:

 　　　　help() 函数⽤于查看函数或模块⽤途的详细说明

调⽤相关:

 　　　　callable() ⽤于检查⼀个对象是否是可调⽤的. 如果返回True, object有可能调⽤失败, 但如果返回False. 那调⽤绝对不会成功

查看内置属性:

 　　　　dir() 查看对象的内置属性, ⽅法. 访问的是对象中的__dir__()⽅法

基础数据类型相关:

数字相关:

 　　　　bool() 将给定的数据转换成bool值. 如果不给值. 返回False

　　　　 int() 将给定的数据转换成int值. 如果不给值, 返回0

 　　　　float() 将给定的数据转换成float值. 也就是⼩数

　　　　 complex() 创建⼀个复数. 第⼀个参数为实部, 第⼆个参数为虚部. 或者第⼀个参数直接⽤字符串来描述复数

 进制转换:

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

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

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

 数学运算:

 　　　　abs() 返回绝对值

 　　　　divmode() 返回商和余数

 　　　　round() 四舍五入

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

 　　　　sum() 求和

 　　　　min() 求最⼩值

 　　　　max() 求最⼤值

和数据结构相关:

 列表和元组:

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

　　　　 tuple() 将⼀个可迭代对象转换成元组

 　　　　reversed() 将⼀个序列翻转, 返回翻转序列的迭代器

 　　　　slice() 列表的切片

st = "⼤家好, 我是麻花藤"
s = slice(1, 5, 2)
print(st[s])

　　

字符串相关:

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

 　　　　format() 与具体数据相关, ⽤于计算各种⼩数, 精算等

# 字符串
print(format('test', '<20')) # 左对⻬
print(format('test', '>20')) # 右对⻬
print(format('test', '^20')) # 居中
# 数值
print(format(3, 'b')) # ⼆进制
print(format(97, 'c')) # 转换成unicode字符
print(format(111, 'd')) # ⼗进制
print(format(11, 'o')) # ⼋进制
print(format(11, 'x')) # ⼗六进制(⼩写字⺟)
print(format(11, 'X')) # ⼗六进制(⼤写字⺟)
print(format(11, 'n')) # 和d⼀样
print(format(11)) # 和d⼀样
# 浮点数
print(format(123456789, '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')) # ⼩数点计数法. 保留10位⼩数
print(format(1.23456789e+10000, 'F')) # ⼩数点计数法.
bytes() 把字符串转化成bytes类型
s = "你好"
bs = s.encode("UTF-8")
print(bs)
s1 = bs.decode("UTF-8")
print(s1)
bs = bytes(s, encoding="utf-8") # 把字符串编码成UTF-8
print(bs)

　　

　　　　bytearray() 返回⼀个新字节数组. 这个数字⾥的元素是可变的, 并且每个元素的值得范围是[0,256)

ret = bytearray('alex',encoding='utf-8')
print(ret[0])
print(ret)

　　

　　　　memoryview() 查看bytes在内存中的情况：

# 查看bytes字节在内存中的情况
s = memoryview("麻花藤".encode("utf-8"))
print(s)
ord() 输入字符找带字符编码的位置
 chr() 输入位置数字找出对应的字符
 ascii() 是ascii码中的返回该值 不是就返回u...
# 找到对应字符的编码位置
print(ord('a'))
print(ord('中'))
# 找到对应编码位置的字符
print(chr(97))
print(chr(20013))
# 在ascii中就返回这个值. 如果不在就返回u...
print(ascii('a'))
print(ascii('好'))
repr() 返回⼀个对象的string形式
# repr 就是原封不动的输出, 引号和转义字符都不起作⽤
print(repr('⼤家好,
 	我叫周杰伦'))
print('⼤家好我叫周杰伦')
# %r 原封不动的写出来
name = 'taibai'
print('我叫%r' % name)

　　

数据集合:

 　　　　dict() 创建⼀个字典

　　　　set() 创建⼀个集合

 　　　　frozenset() 创建⼀个冻结的集合. 冻结的集合不能进⾏添加和删除操作

 其他相关:

 　　　　len() 返回⼀个对象中的元素的个数

 　　　　sorted() 对可迭代对象进⾏排序操作(讲完lamda后再讲这个)

 　　　　enumerate() 获取集合的枚举对象

lst = ["alex", "wusir", "taibai"]
for index, el in enumerate(lst):
 	print(str(index)+"==>"+el)
all() 可迭代对象中全部是True, 结果才是True
 any() 可迭代对象中有⼀个是True, 结果就是True
print(all([1,2,True,0]))
print(any([1,'',0]))

　　

　　zip() 函数⽤于将可迭代的对象作为参数, 将对象中对应的元素打包成⼀个个元组, 然后返回由这些元组组成的开了表. 如果各个迭代器的元素个数不⼀致, 则返回列表⻓度与最短的对象相同.

l1 = [1,2,3,]
l2 = ['a','b','c',5]
l3 = ('*','**',(1,2,3))
for i in zip(l1,l2,l3):
 	print(i)

　　

　　 filter() 过滤(讲完lamda)

　　 map() 会根据提供的函数对指定序列做映射(lamda)

　　重点介绍几个函数。在介绍之前先看个lambda。 lamda匿名函数，为了解决⼀些简单的需求⽽设计的⼀句话函数。

# 计算n的n次⽅
def func(n):
 return n**n
print(func(10))
f = lambda n: n**n
print(f(10))

　　

　　lambda表⽰的是匿名函数. 不需要⽤def来声明, ⼀句话就可以声明出⼀个函数

　　语法:

 　　　　函数名 = lambda 参数: 返回值

　　注意:

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

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

　　　　3. 返回值和正常的函数⼀样, 可以是任意数据类型

　　匿名函数并不是说⼀定没有名字，这⾥前⾯的变量就是⼀个函数名， 说他是匿名原因是我们通过__name__查看的时候是没有名字的， 统⼀都叫lambda。 在调⽤的时候没有什么特别之处，像正常的函数调⽤即可。lambda还可以嵌套使用，看下面的代码：

#f = lambda n: n + 1
fn = lambda m: (lambda n: n + 1)(m) > 2
print(fn(3))

　　

　　第一行注释掉的lambda直接放到下面，这样就可以嵌套了。下面开始介绍，几个函数：

1. sorted( )

  　　作用是排序，语法：sorted(Iterable, key=None, reverse=False)

　　　　Iterable: 可迭代对象

　　　　key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每⼀个元素传递给这个函

　　　　　　数的参数. 根据函数运算的结果进⾏排序。其实，sorted就是想找一个依据，我要根据什么来排序。

　　　　reverse: 是否是倒叙. True: 倒叙, False: 正序

lst = [1,5,3,4,6]
lst2 = sorted(lst)
print(lst) # 原列表不会改变
print(lst2) # 返回的新列表是经过排序的
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 = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"]
# 计算字符串⻓度
def func(s):
 	return len(s)
print(sorted(lst, key=lambda s: len(s)))
lst = [{"id":1, "name":'alex', "age":18},
 {"id":2, "name":'wusir', " "age":16},
 {"id":3, "name":'taibai', "age":17}]
# 按照年龄对学⽣信息进⾏排序
print(sorted(lst, key=lambda e: e['age']))

　　

2.filter( )

　　筛选函数,语法: filter(function. Iterable)

 　　function: ⽤来筛选的函数. 在filter中会⾃动的把iterable中的元素传递给function. 然后

　　根据function返回的True或者False来判断是否保留此项数据

 　　Iterable: 可迭代对象

lst = [1,2,3,4,5,6,7]
ll = filter(lambda x: x%2==0, lst) # 筛选所有的偶数
print(ll)
print(list(ll))
lst = [{"id":1, "name":'alex', "age":18},
    {"id":2, "name":'wusir', "age":16},
    {"id":3, "name":'taibai', "age":17}]
fl = filter(lambda e: e['age'] > 16, lst) # 筛选年龄⼤于16的数据
print(list(fl))

　　

3.map( )

　　映射函数,语法: map(function, iterable) 可以对可迭代对象中的每⼀个元素进⾏映射,分别去执⾏function

def func(e):
  　　return e*e
mp = map(func, [1, 2, 3, 4, 5])
print(mp)
print(list(mp))

　　

最后，对内置函数做了一个总结，可以点击地址看看。