小白IT：python的函数&内置方法&常用的模块详解-方法-使用-坚持就是胜利

Python 匿名函数&内置函数&常用模块

我们之前学过函数的知识，知道函数的调用方式：

函数名()

然后函数在调用之前需要定义，定以后我们就可以使用了，但是有没有发现有些很特别呢？

比如说print()，我们用的很频繁的一个函数，打印内容，我们再使用这个函数的时候，好像我们也没有定义这个函数啊，为什么就能直接拿来用了呢？

诸如此类的函数还有很多，如len()、input()等等

其实这些函数就是python中的内置函数，

python环境中已经为我们定义好的一些完成特定功能的函数，在python环境的任何地方我们可以直接调用。

一 内置函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B7eOwHXK-1588872144752)(/Users/xujiazeng/Library/Application Support/typora-user-images/image-20200508012116728.png)]

上面就是内置函数的表格（目前），68个内置函数，下面我们按照功能的类别归类成以下6大类，依次来学习。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eL57Mm1s-1588872144755)(/Users/xujiazeng/Library/Application Support/typora-user-images/image-20200508012134584.png)]

1.作用域相关

基于字典的方式获取局部变量和全局变量

globals(): 全局变量的字典

locals(): 获取执行本方法所在命名空间内的局部变量的字典

locals(): 打印局部变量，以字典形式返回，可以使用get方法

vars(): 如果没有参数，和locals()一样，返回本地变量名和值，放在字典中，如果有参数，则是查看某一个对象的所有方法，放在字典里面。

2.其他：

字符串类型代码的执行

eval()：将字符串类型的代码去掉引号并执行，不推荐使用

##将字符串转成相应的对象（如list、tuple、dict和string之间的转换）,打开字符串

a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
b = eval(a)
print(b)
#[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
a = "{1:'xx',2:'yy'}"
c = eval(a)
print(c)
#{1: 'xx', 2: 'yy'}
a = "(1,2,3,4)"
d = eval(a)
print(d)
#(1, 2, 3, 4)

##将字符串str当成有效的表达式来求值并返回计算结果。所以，结合math当成一个计算器很好用

print(eval('2''*''3')) # 加减乘除6

exec()：将字符串类型的代码去掉引号后并执行，eval升级版，不推荐使用

code = '''
import os 
print(os.path.abspath('.'))
'''

code = '''
print(123)
a = "20"
print(a)
'''
a = 10

exec(code)
print(code)

123  # exec 执行字符串中print 输出功能
20

print(123) # print 单纯打印
a = "20"
print(a)

**compile：**将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。

参数说明**：**

1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。

2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。

3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为’single’。

>>> #流程语句使用exec
>>> code1 = 'for i in range(0,10): print (i)'
>>> compile1 = compile(code1,'','exec')
>>> exec (compile1)
3
7


>>> #简单求值表达式用eval
>>> code2 = '1 + 2 + 3 + 4'
>>> compile2 = compile(code2,'','eval')
>>> eval(compile2)


>>> #交互语句用single
>>> code3 = 'name = input("please input your name:")'
>>> compile3 = compile(code3,'','single')
>>> name #执行前name变量不存在
Traceback (most recent call last):
  File "<pyshell#29>", line 1, in <module>
    name
NameError: name 'name' is not defined
>>> exec(compile3) #执行时显示交互命令，提示输入
please input your name:'pythoner'
>>> name #执行后name变量有值
"'pythoner'"

3 输出相关

**input()：**获取用户输入

**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: 立即把内容输出到流文件，不作缓存
    """

print源码剖析

import time
for i in range(0,101,2):  
     time.sleep(0.1)
     char_num = i//2      #打印多少个'*'
     per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)
     print(per_str,end='', flush=True)
#小越越  ： \r 可以把光标移动到行首但不换行

打印进度条

4 数据类型相关

**type(a)：**返回变量a的数据类型

5 内存相关

**id(a)😗*返回参数a的内存地址

**hash(a)：**a是参数，返回一个可hash变量的哈希值，不可hash的变量会报错

hash函数会根据一个内部的算法对当前可hash变量进行处理，返回一个int数字。

*每一次执行程序，内容相同的变量hash值在这一次执行过程中不会发生改变。

t = (1,2,3)
l = [1,2,3]
print(hash(t))  #可hash
print(hash(l))  #会报错

'''
结果：
TypeError: unhashable type: 'list'
'''

hash实例

6 文件操作相关

**open()：**打开一个文件，返回一个文件操作符（文件句柄）

7 模块操作相关

**import😗*导入一个模块

# 第一种直接导入
import time

# 第二种导入字符串名字
os = __import__('os')
print(os.path.abspath('.'))

# 实际是通过sys模块找到'os'文件的路径，再导入使用

help(): 在控制台执行help()进入帮助模式，查看任意变量或者变量类型的有关操作

8 调用相关

callable(a): a是参数，查看这个参数是否可调用

如果a是一个函数名，则返回True

def func():pass
print(callable(func))  #参数是函数名，可调用，返回True
print(callable(123))   #参数是数字，不可调用，返回False

dir(): 默认查看全局空间内的属性，也可以接受一个参数查看这个参数内的方法或变量

print(dir(list))  #查看列表的内置方法
print(dir(int))  #查看整数的内置方法

9 数字相关

数字——数据类型相关：bool, int, float, complex

数字——进制转换：bin, oct, hex

数字——数学运算：abs, divmod, min, max, sum, round, pow

min和max高级用法

'''
max比较字典类型的大小
'''

l = [1, 3, 100, -1, 2]

print(max(l))
dic = {
   'age1': 18, 'age2': 12}
print(max(dic))  # 比较的是字典的key
print(max(dic.values())) # 比较的是字典的值，但是不是对应那个键

# 结合zip函数比较
print(max(zip(dic.values(), dic.keys()))) # 比较字典的值，并显示对应的键

100
age2
18
(18, 'age1')

'''
最终的使用方法。
'''

people = [
    {'name': 'alex', 'age': 1000},
    {'name': 'wupeiqi', 'age': 10000},
    {'name': 'alex', 'age': 9000},
    {'name': 'alex', 'age': 18},
]

print(max(people, key=lambda dic:dic['age']))
# max()对可迭代对象的每一个元素比较，key接收元素的获取函数（匿名函数）

# min()和max()一样。

10 数据结构相关

序列——列表与元组相关：强转类型：list和tuple

序列——字符串相关：str, format, bytes, bytearray, memoryview, ord, chr, ascii, repr

format(str,格式化范式):格式化函数，

# format('a','>10')  # 格式化字符a的输出 
#         a

bytes():将字符根据编码方式转化成对应编码方式的字节

​ bytearray() 法为python内置函数，其用于返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。其语法如下：

class bytearray([source[, encoding[, errors]]])

'''如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。'''

>>> s = 'xyz'
>>> b = bytearray(str(s),'utf8')
>>> print b
xyz
>>> print b[1]
121
>>> print b[0]
120
>>> print b[2]
122

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9phJqdeg-1588872144758)(C:\Users\v_xjzxu\AppData\Roaming\Typora\typora-user-images\1588837754248.png)]

chr():返回数字序号在Ascii中对应的字符，65–>A, 97–>a, 122–>z

ord():返回字符在Ascii中对应的数字序号*

ascii():判断内容是否ascii字符集中，在的话返回，不在返回\u…一堆数字

repr():显示的原本的数据，没有任何处理

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

bytearray(b'alex')
97
bytearray(b'Alex')
1976654977712

11 数据集合

数据集合：——字典和集合：dict, set, frozenset

len(): 计算可迭代类型的长度

enumerate(iter[,x]): 枚举，遍历可迭代对象，返回每个对象并为其加上序号,x为序号起始数，默认为0

li = [1,2,3,4]
for index,element in enumerate(li,0):
    print(index,element)
    
0 1
1 2
2 3
3 4

all(): 判断可迭代类型中的所有元素是否都为真，是返回True，任意为假返回false

any(): 判断可迭代类型中元素是否有一个为真，是返回True，全为假返回false

zip(拉链):跟拉链一样，将两个可迭代类型中的元素一一对应，包裹在元组里，放在列表中

print(list(zip(('q', 'b', 'c'), (1, 2, 3)))) # [('q', 1), ('b', 2), ('c', 3)]
print(list(zip(('abcd'), ('123')))) # [('a', '1'), ('b', '2'), ('c', '3')]
# 可以拼接多个可迭代对象。不止两个

slice(): 切片

l = 'hello'
s1 = slice(3, 5)  # l[s1] = l[3, 5]
s2 = slice(1, 4, 2)  # l[s2] = l[1, 4, 2]

print(l[s1])
print(l[s2])

12 sorted方法

给列表排序的两个方法（前提，列表中元素可比较）

方法1.用List的成员函数sort进行排序，在本地进行排序，不返回副本
　　　　方法2.用built-in函数sorted进行排序（从2.4开始），返回副本，原始输入不变

参数说明：
　　iterable：是可迭代类型;
　　key：传入一个函数名，函数的参数是可迭代类型中的每一项，根据函数的返回值大小排序;
　　reverse：排序规则. reverse = True 降序 或者 reverse = False 升序，有默认值。
　　返回值：有序列表

people = [
    {
   'name': 'alex', 'age': 1000},
    {
   'name': 'wupeiqi', 'age': 10000},
    {
   'name': 'alex', 'age': 9000},
    {
   'name': 'alex', 'age': 18},
]

print(sorted(people, key=lambda dic:dic['age']))

[{
   'name': 'alex', 'age': 18}, {
   'name': 'alex', 'age': 1000}, {
   'name': 'alex', 'age': 9000}, {
   'name': 'wupeiqi', 'age': 10000}]

二 匿名函数

#这段代码
def calc(n):
    return n**n
print(calc(10))
 
#换成匿名函数
calc = lambda n:n**n
print(calc(10))

上面是我们对calc这个匿名函数的分析，下面给出了一个关于匿名函数格式的说明

函数名 = lambda 参数 ：返回值

#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型

我们可以看出，匿名函数并不是真的不能有名字。

匿名函数的调用和正常的调用也没有什么分别。

除此之外，匿名函数也不是浪得虚名，它真的可以匿名。在和其他功能函数合作的时候

l=[3,2,100,999,213,1111,31121,333]
print(max(l))

dic={
   'k1':10,'k2':100,'k3':30}


print(max(dic))
print(dic[max(dic,key=lambda k:dic[k])])

# 31121
# k3
# 100

map(func, iter)

映射函数：

创建一个迭代器，使用可迭代对象的每个参数计算函数并返回。当最短的可迭代用尽时停止。

map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

注：map函数内部会的机制会自动遍历传进来的可迭代对象。然后对遍历后的元素指定比较规则。（这里理解很重要）

num = [1, 2, 4, 5, 2, 8]
# 第一步需求，将列表中的数字全部平方

# new_li = []
# def square(array):
#     for i in array:
#         new_li.append(i**2)
#     return new_li
#
# print(square(num))


# 第二步需求，将列表中的数字全部减一
# new_li = []
# def reduce(array):
#     for i in array:
#         new_li.append(i-1)
#     return new_li
#
# print(reduce(num))

# 当需求过于巨大，需要一个一个实现，此时我们可以定义一个可以使用不同函数作用的函数


def square(num):
    return num**2


def reduce(num):
    return num - 1


def map_test(func, array):
    ret = []
    for i in array:
        res = func(i)
        ret.append(res)
    return ret

print(map_test(square, num))
print(map_test(reduce, num))

li = [1, 2, 3, 4, 5]
'''def square(num):
    return num**2

# 传入有名函数
map(square, li)'''

# 传入匿名函数
map(lambda x:x**2, li)
print(list(map(lambda x:x**2, li)))

# 结果
[1, 4, 9