Python 内置函数与匿名函数

内置函数

python一共为我们提供了68个内置函数。它们是python提供给直接可以拿来使用的所有函数。

可以将这些函数分成6大类：

作用域相关

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

globals() 获取全局变量的字典

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

其他内置函数

字符串类型代码的执行

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

eval()

s = "5 + 6"
ret = eval(s) # 动态执行一个代码片段, 侧重点在返回上
print(ret)

a = "{'name':'汪峰', 'age':'48', 'wife':{'name':'国际章','age':'38'}}" # json. 像字典一样的东西
d = eval(a) # 还原回字典,列表.
print(d['name'])

s = "a = 10"
exec(s) # 执行代码
print(a) # pycharm里的报错信息. 不一定是对的

content = input("请输入你的代码:")
exec(content)
print(a)

compile() 编译

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

参数说明:
1. resource 要执⾏的代码, 动态代码⽚段
2. ⽂件名, 代码存放的⽂件名, 当传⼊了第⼀个参数的时候, 这个参数给空就可以了
3. 模式，取值有3种：
	exec：⼀般放⼀些流程语句的时候
	eval：resource只存放⼀个求值表达式.
	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) 

输入输出相关

input() 输入

s = input("请输入内容 ： ")  #输入的内容赋值给s变量
print(s)  #输入什么打印什么。数据类型是str

print() 输出

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

# file 关键字说明
f = open('tmp_file','w')
print(123,456,sep=',',file = f,flush=True)

>>>应用：打印进度条
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 可以把光标移动到行首但不换行

数据类型相关

type(o) 返回变量o的数据类型

内存相关

id(o) o是参数，返回一个变量的内存地址

---

hash(o) o是参数，返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错。

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

'''
结果：
TypeError: unhashable type: 'list'
'''
# hash函数会根据一个内部的算法对当前可hash变量进行处理，返回一个int数字。
# *每一次执行程序，内容相同的变量hash值在这一次执行过程中不会发生改变。

文件操作相关

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

操作文件的模式有r,w,a,r+,w+,a+ 共6种，
每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+)
可以用encoding指定编码.

模块操作相关

__import__导入一个模块

import time

os = __import__('os')
print(os.path.abspath('.'))

帮助方法

在控制台执行help()进入帮助模式。可以随意输入变量或者变量的类型。输入q退出

或者直接执行help(o)，o是参数，查看和变量o有关的操作

和调用相关

callable(o)，o是参数，看这个变量是不是可调用。

如果o是一个函数名，就会返回True

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

查看参数所属类型的所有内置方法

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

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

和数字相关

数据类型

# 数据类型：bool float int complex（复数）
# 根号下的内容都是正数
i**2 == -1 # i 叫虚数
复数 = 实数+虚数  3+2i
print(0.00125e3)

进制转换

# 进制转换：bin()  oct()  hex()
print(bin(3)) #  5的二进制  0b二进制
# 注册, 实名认证, 银行卡, 风险评估
# 01      01       01     01
# 1111
# 1101

print(oct(8)) # 0o八进制
print(hex(15)) # 0x十六进制 0123456789ABCDEF

数学运算

# 数学运算
print(abs(32)) # 绝对值 |绝对值| 取模
print(divmod(10, 3)) # 计算商和余数
print(round(4.51)) # 四舍五入
print(pow(2, 4, 3)) # 求次幂, 第三个参数, 计算余数
print(2**4)

print(sum([1,2,3,4,5], 3)) #第一个参数必须是可迭代对象，第二个参数是计算完前面的再相加

print(min([5,12,45,6,7,34])) # 最小值
print(max([5,12,45,6,7,34])) # 最大值

数据结构相关

序列

列表和元组相关的：list和tuple

# 序列：list  和 tuple 相关内置函数：reversed  slice 

lst = ["麻花藤", "马云", "马大帅", "马超"]
ll = reversed(lst)  # reversed()翻转，返回迭代器
print(list(ll))

lst = ["麻花藤", "马云", "马大帅", "马超"]
s = slice(1,3,2) #  切片
print(lst[s])
print(lst[1:3:2])

字符串相关的：str，format，bytes，bytearry，memoryview，ord，chr，ascii，repr

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

# memoryview
ret = memoryview(bytes('你好',encoding='utf-8'))
print(len(ret))
print(bytes(ret[:3]).decode('utf-8'))
print(bytes(ret[3:]).decode('utf-8'))


s = "你好啊. 不要睡了. 我也困"
print(memoryview(s.encode("utf-8"))) # 还不如id()，还只能看字符串


# 找到对应字符的编码位置
print(ord('a'))
print(ord('中'))

# 找到对应编码位置的字符
print(chr(97))
print(chr(20013))
ascii() 是ascii码中的返回该值 不是就返回\u 
# 在ascii中就返回这个值，如果不在就返回\u...
print(ascii('a'))
print(ascii('好')) 

repr() 返回⼀个对象的string形式
# repr 就是原封不动的输出, 引号和转义字符都不起作⽤
print(repr('⼤家好,\n \t我叫周杰伦'))
print('⼤家好我叫周杰伦')
# %r 原封不动的写出来
name = 'taibai'
print('我叫%r' % name) 

 
# 周杰伦说:"昆凌特别好看"
print('周杰伦说:"昆凌特别好看"')

print("周杰伦说:\"昆凌特别好看\"") # \" 转义. 不让"作为字符串的开头或者结尾
print("哈哈\\\呵呵") # \\ 表示的是一个\    \ 转义. \n换行 \t制表符 \", \', \\
print(repr("周杰伦说:\n\t昆凌特别好看\t"))  # 对象的规范字符串表示形式???????

print("")
C: \在字符串中是转义字符,
\n 换行
\t 制表符
\\ \
\"  "
\'  '

print("\\\\\哈哈")

# repr
# 原样输出字符串
print(repr("你好啊\n我不好")) # 还原回来了
#输出结果："你好啊\\n我不好"

今天吃\n什么 注入

print("你好. 我\\叫周润发") # 对用户是友好的，非正式的字符串

# 正式(官方)的字符串, 面向对象的时候
print(repr("你好, 我\'叫周润发")) # 程序中内部存储的内容, 这个是给程序员看的

print("我叫%r" % "周润发") # %r 实际上调用的是repr()
# 输出结果：我叫‘周润发’

# 原样输出：
print(r"麻花说:\"哈哈哈, \" \n\t")

print("你好") # 用户看着舒服
print(repr("你好")) # 真实的字符串表示形式(正式的)

__str__()
__repr__()

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

# 字符串
print(format('test', '<20')) # 左对⻬
print(format('test', '>20')) # 右对⻬
print(format('test', '^20')) # 居中

# 数值
print(format(3, 'b')) # ⼆进制
print(format(97, 'c')) # 转换成unicode字符
print(format(11, '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')) # 1.234568e+08 科学计数法. 默认保留6位⼩数
print(format(123456789, '0.2e')) # 1.23e+08 科学计数法. 保留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')) # INF无穷大，⼩数点计数法.  

数据集合

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

s = {"爱情公寓", "爵迹", "妖猫传", "煎饼侠", "郭德纲的电影"}

s.add("空天猎") # 可变, 不可哈希
print(s)
print(hash(s)) # 可变

s = frozenset({"战狼2", "我不是药神", "西虹市首富", "捉妖记"})
print(hash(s)) # 不可变，可哈希


lst = ["张国荣", "黄渤", "郭达森", "泰森", "甄子丹"]
for el in lst:
    print(el)

for i in range(len(lst)):
    print(i, lst[i])

for i, el in enumerate(lst):
    print(i, el)

all() 和 any()  里面放可迭代对象

all() # and
print(all([True, 1, 1, 1]))

any() # or
print(any([1, 1, 0, 0]))

# 所有的空 都是False: None,空字典，空集合，空元组，空列表...

zip()

lst1 = ["甜蜜蜜", "往事只能回味", "难忘今宵", "粉红的回忆", "十年"]
lst2 = ["邓丽君", "韩宝仪", "李谷一", "王宝强", "陈奕迅"]
lst3 = ["2000","3000","5","120","50000"]
a = zip(lst1, lst2,lst3) # 水桶效应，看最短的，然后都满足最短的
# a 是一个对象
print("__iter__" in dir(a)) # 可迭代的
for el in a:
    print(el)

>>>难题：实现一个滑动数列，定义一个函数，根据参数n变成对应元素的容器

def get_toghter(lst, n):
     '''
     :param lst: 传入一个列表
     :param n: 需要分几个一组
     :return: 结果
     '''
     return zip(*[lst[i::n] for i in range(n)])


#print(get_toghter([1, 2, 3, 4, 5, 6, 7, 8, 9], 3))
res=get_toghter([1, 2, 3, 4, 5, 6, 7, 8, 9], 3)
print(list(map(list,res)))

# 升级，应用所有函数知识点：
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
ret = lambda lst, n: zip(*[lst[i::n] for i in range(n)])
print(list(map(list, ret(lst, 3))))

过程分析：

sorted() 排序

lst = [16, 18, 32, 54, 12, 9]
lst.sort() # list的方法
print(lst)

# 内置函数中提供了一个通用的排序方案, sorted()
s = sorted(lst) # 内置函数都需要接收
print(s)

      0       1          0          1         1        0      0
lst = ["聊斋", "西游记", "三国演义", "葫芦娃", "水浒传", "年轮", "亮剑"]

def func(s):
     return len(s)%2 # 排序方案
     return 

ll = sorted(lst, key=func,reverse=True) # key直接接函数名
print(ll)

# key参数: 排序方案...过程sorted函数内部会把可迭代对象中的每一个元素拿出来交给后面的key
# --后面的key计算出一个数字. 作为当前这个元素的权重, 整个函数根据权重进行排序

lst = [
     {'name':"汪峰","age":48},
     {"name":"章子怡",'age':38},
     {"name":"alex","age":39},
     {"name":"wusir","age":32},
     {"name":"赵一宁","age":28}
     ]
def fun(el): # 传入一个字典
    return el["age"] # 获取到字典的age 作为排序依据

res=sorted(lst,key=fun)
# 可以直接写成 lambda表达式
res=sorted(lst,key=lambda el:el["age"],reverse=True)

print(res)

filter()

>>>筛选出不是姓张的名字
lst = ["张无忌", "张铁林", "赵一宁", "石可心","马大帅"]

def func(el):
     if el[0]=="张":
          return False
     else:
          return True
res=filter(func,lst)

# filter将lst中的每一项传递给func, 所有返回True的都会保留, 所有返回False都会被过滤掉
# --得到的是一个可迭代对象

#res=filter(lambda el:False if el[0]=="张" else True,lst)
#res=filter(lambda el:el[0]!="张",lst)

# 返回值：我们只需要不是姓张的
print(list(res))
# 筛选出大于60分的人
lst = [
     {"name":"汪峰", "score":48},
     {"name":"章子怡", "score":39},
     {"name":"赵一宁","score":97},
     {"name":"石可心","score":90}
]

f = filter(lambda el: el['score'] >60 , lst) # return位置只要留下你想要判断的东西
print(list(f))

map() 映射

lst = [1,4,7,2,5,8]
>>>计算列表中每个数字的平方
ll = []
for el in lst:
     ll.append(el**2)

def func(el):
     return el**2
m = map(lambda el: el**2, lst) # 把后面的可迭代对象中的每一个元素传递给function, 结果就是function的返回值
#print("__iter__" in dir(m))
print(list(m))

# 分而治之
map(func1, map(func2, map(func3 , lst))) # 第二个参数是可迭代对象，map返回的就是可迭代对象

lst1 = [1, 3, 5, 7]
lst2 = [2, 4, 6, 8, 10]
# 水桶效应，和 zip() 一样
m = map(lambda x, y, z: x + y+ z, lst1, lst2, [5,1,2,3,6])
print(list(m))

迭代器、生成器相关

迭代器、生成器： iter()  next()  range()

lst = ["白蛇传","骷髅叹","庄周闲游"]

it = lst.__iter__()
print(it.__next__())
print(it.__next__())
print(it.__next__())
print(dir(str))
it = iter(lst) # 内部封装的就是__iter__()
print(it.__next__())
print(next(it)) # 内部封装的是__next__()

匿名函数lambda

匿名函数：为了解决那些功能很简单的需求而设计的一句话函数

# 普通的正常的函数
def func(n):
     return n * n

# ret = func(9)
# print(ret)

匿名函数, 语法: lambda 形式参数1,形式参数2 : 返回值
a = lambda n : n * n
# ret = a(9)
# print(ret)
b = lambda x: x+1

print(a(5)) # 函数的名字可以认为是a


print(func.__name__) # 结果是：func;__name__的作用是查看函数的名字
print(a.__name__) # __name__的值都是<lambda>
print(b.__name__)


# 多个返回值时的lambda的表示：

def func(x, y):
     return x, y # 正常函数，多个返回值，得到的是一个元组

print(func(1,2))

test=lambda x, y :x, y # 这是错误的写法，会默认将test=（x,y:x），y 当做元组处理，此时，y是没有被声明的
test=lambda x, y :（x, y）#正确写法
print（test(1,2)）


>>>练习：给函数传入两个值，返回较大的一个
test= lambda a,b :max(a,b)
#test= lambda a,b : a if a>b else b
print(test(1,2))

ret = lambda n: "偶数" if n % 2 == 0 else "奇数"
print(ret(50))

# 传入多个数：
test= lambda *args : max(args)
print(test(1,2,3,4,5))

>>>现有两个元组(('a'),('b')),(('c'),('d'))，
>请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]

# 解法一
test = lambda t1,t2 :[{i:j} for i,j in zip(t1,t2)]
print(test(t1,t2))

# 解法二
print(list(map(lambda t:{t[0]:t[1]},zip(t1,t2))))

# 还可以这样写
print([{i:j} for i,j in zip(t1,t2)])

>>>下面程序的输出结果是：
d = lambda p:p*2
t = lambda p:p*3
x = 2
x = d(x)
x = t(x)
x = d(x)
print x

>>>以下代码的输出是什么？请给出答案并解释。
def multipliers():
    return [lambda x:i*x for i in range(4)]
print([m(2) for m in multipliers()])
请修改multipliers的定义来产生期望的结果。

偏函数

# 默认是使用的十进制
print(int("10"))
>>>将一个字符串表示的二进制数转换成十进制
print(int("10",base=2))
print(int("1010",base=2))

def erjing(str): # 用函数的做法
     return int(str,base=2) # 将本身返回

print(erjing("1010"))
print(erjing("10")) # 直接调用好每次都自动换成二进制的函数


偏函数：参数1 需要修改的函数名,参数2 需要设置的默认值
import functools

func = functools.partial(int,base=2)
print(func("1010"))
print(func("10"))