python 内置函数、匿名函数

一、部分内置函数

输入输出

input 　　获取输入，获取的输入为str类型
output　　输出，可指定地方

i_str = input("请输入内容：")  # 输入的内容赋值给i_str
print(i_str)  # 用input 获得的内容为str数据类型

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print"""print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)Prints the values to a stream, or to sys.stdout by default.Optional keyword arguments:file:  a file-like object (stream); defaults to the current sys.stdout.sep:   string inserted between values, default a space.end:   string appended after the last value, default a newline.flush: whether to forcibly flush the stream."""
sep  分隔符，默认为空格
end  打印行尾，默认为\n
file 默认为屏幕，可以指定文件对象
flush = True 立即把内容输出到流文件，不做缓存。f = open('hhh','w', encoding='utf-8')
print(1, 2, 3, sep='', file=f, flush=True)
f.close()

作用域相关

locals　　获取全局变量的字典
globals　　获取当前命名空间的局部变量的字典

内存相关

hash 　　返回变量的内存地址
id　　返回一个可hash变量的哈希值，不可变变量hash后会报错

文件操作

open 用于打开文件


open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True):

字符串类型代码的执行

eval　　将字符串类型的代码执行并返回结果
exec　　将字符串类型代码执行（无返回值）

exec('print(123)')  # 123
eval('print(123)')  # 123
print(eval('1+2+3+4'))   # 有返回值  10
print(exec('1+2+3+4'))   # 没有返回值  None

compile　　将字符串类型代码编译。代码对象能够被exec( )来执行或者eval( )来进行求值。
compile(source, filename, mode[, flags[, dont_inherit]])

参数说明：

参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。
参数filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。
参数model：指定编译代码的种类，可以指定为‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为’single’。

流程语句使用exec

my_code = "for i in range(0,10): print (i, end='')"
compile1 = compile(my_code, '', 'exec')
exec(compile1)  # # 0123456789

简单求值用eval

my_code2 = '1 + 2 + 3 + 4'
compile2 = compile(my_code2, '', 'eval')
print(eval(compile2))  # 10

交互语句用signal

my_code3 = 'name = input("please input your name:")'
compile3 = compile(my_code3, '', 'single')
# 执行exec(compile3) 后会把 name 变量加载进来
exec(compile3)  # 执行时显示交互命令，提示输入
print(name)  # 不会报错，num变量已经存在

调用相关

callable　　查看变量是否可调用，如果是一个函数名，就会返回True

a = 1
def my_func():passprint(callable(print))  # True
print(callable(a))  # False
print(callable(my_func))  # True

查看内置属性

dir 查看内置的属性，返回一个列表

print(dir([1, 2]))
print(dir(int))
# ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
# ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

进制转换

bin　　10进制转二进制
oct　　10进制转八进制
hex　 10进制转十六进制

print(bin(10))  # 0b1010
print(oct(10))  # 0o12
print(hex(10))  # 0xa

数学运算

abs　　取绝对值
divmod　　取模取余
round　　指定小数个数
pow　　两参数：取幂　　三参数：取幂后再取余
sum　　求和
min　　取最小值
max　　取最大值

print(divmod(7, 2))  # (3, 1)
print(round(3.14159, 3))  # 3.142
print(pow(2, 3))  # pow幂运算  == 2**3   8
print(pow(2, 3, 3))  # 幂运算之后再取余   2
print(sum([1, 2, 3]))  # 6
print(max(1,2,-3,-4,key = abs)) # -4

序列-字符串相关

format
bytes（）　　用于转换成bytes类型

print(bytes("hello, 小杰", encoding='gbk'))  # unicode转换成gbk的bytes
print(bytes("hello, 小杰", encoding='utf-8'))  # unicode转换成utf-8的bytes
print(bytes("hello, 小杰", encoding='gbk').decode('gbk'))  # 之后再解码回去
# output
b'hello, \xd0\xa1\xbd\xdc'  # gbk简单汉字每个占两个字节
b'hello, \xe5\xb0\x8f\xe6\x9d\xb0'  # utf-8中汉字每个占三个字节
hello, 小杰

bytearry（）　　方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。

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

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

返回值：返回一个新的字节数组

b_array = bytearray('hello, 小杰', encoding='utf-8')
print(b_array)
print(b_array[0])  # 获取字节数组的第一个
# output
bytearray(b'hello, \xe5\xb0\x8f\xe6\x9d\xb0')
104  # h的ASCII码为104

切片 —— 字节类型不占内存
切片 —— 字符串占内存

memoryview　　暂时跳过 https://www.jianshu.com/p/f30d14424d3b

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

ord 　　返回单个字符对应的十进制整数。
chr　　　返回是当前指定进制下整数对应的 ASCII 字符。

print(ord('a'))  # 97
print(chr(97), chr(0b01100001), chr(0o141), chr(0x61))  # a a a a

ascii

ascii()返回一个字符串对象。
ascii()的参数只能有一个。
如果参数中有非ascii字符，会用 \u,\U,\x 来替代。
ascii()和Python2中repr()等效

print(ascii('hello, 小杰'))
str_1 = ascii(1)
print(str_1, type(str_1))# output
'hello, \u5c0f\u6770'
1 <class 'str'>

repr　　repr() 函数将对象转化为供解释器读取的形式，返回一个对象的 string 格式。

# 终端下
>>> repr(1)
'1'
>>> repr('1')
"'1'"# pycahrm下
print(repr(1))
print(repr('1'))# output
1
'1'

序列相关

reversed()　　函数返回一个反转的迭代器

l1 = [1, 2, 3, 4, 5]
l2 = reversed(l1)  # 返回一个反转的迭代器
print('l2:%s' % l2)
print(list(l2))# output
l2:<list_reverseiterator object at 0x0000019A9AFCC288>
[5, 4, 3, 2, 1]

slice()　　切片函数　　 slice(start, stop[, step])

l = (1, 2, 3, 4, 5, 6, 7, 8)
sli = slice(1, 5, 2)
print(l[sli])  # (2, 4)
print(l[1:5:2])  # (2, 4)

数据集合相关

len　　返回对象的长度或者元素个数
all　　
all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True。
any
any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。元素除了是 0、空、FALSE 外都算 TRUE。

# all
def all(iterable):for element in iterable:if not element:return Falsereturn True# any
def any(iterable):for element in iterable:if element:return Truereturn False

l1 = [2, 12, ["xa", None], 22]
print(all(l1))  # True
l2 = [2, 12, 0, 22]
print(all(l2))  # Falsel3 = [0, '', ["xa", None], 22]
print(any(l3))  # True

sorted　对传入的可迭代对象进行排序操作
------------------------
sorted(iterable, /, *, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.

A custom key function can be supplied to customize the sort order, and the
reverse flag can be set to request the result in descending order.
----------------------------
参数：
1. iterable：可迭代对象
2. 传入一个函数名，函数的参数是可迭代类型中的每一项，根据函数的返回值大小排序.
3. 排序规则. reverse = True 降序或者 reverse = False 升序（默认）。

# 根据元素的长度排序
lis = ['   ', [1, 2], 'hello world']
my_lis = sorted(lis, key=len)
print(my_lis)  # [[1, 2], '   ', 'hello world']# 根据元祖第二个值排序
good_tuple = (('computer', 4000), ('apple', 5), ('health', 10000000))
new_tuple_list = sorted(good_tuple, key=lambda x: x[1], reverse= True)
print(new_tuple_list)  # [('health', 10000000), ('computer', 4000), ('apple', 5)]

enumerate 　enumerate(sequence, [start=0])
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

name = ['jack', 'hha', 'wei_zai']
print(list(enumerate(name)))
for i, element in enumerate(name, 1):  # 指定索引从1开始print(i, element)# output
[(0, 'jack'), (1, 'hha'), (2, 'wei_zai')]
1 jack
2 hha
3 wei_zai

zip　　python3，该函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象（长度由最短的决定），可以节省内存。
zip(*) 可理解为解压，返回二维矩阵式

name_list = ['jack', 'hha', 'wei_zai']
age_tuple = (20, 3)
my_zip = zip(range(3), name_list, age_tuple)
print(my_zip)
for each in my_zip:print(each)# output
<zip object at 0x00000202D3586248>
(0, 'jack', 20)
(1, 'hha', 3)

zip(*)

name_list = ['jack', 'hha', 'wei_zai']
age_tuple = (20, 3)
my_zip = zip(name_list, age_tuple)
a, b = zip(*my_zip)
print(a, b)
print(list(a), list(b))  # output
('jack', 'hha') (20, 3)
['jack', 'hha'] [20, 3]

filter　　filter(function, iterable)
filter接受两个参数，第一个为函数名，第二个一般为一个序列，序列的每一个元素当做参数传入给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到一个可迭代对象中返回。

过滤列表中的奇数

def is_odd(n):return n % 2 == 1num_list = list(range(10))
num_iterator = filter(is_odd, num_list)
print(num_iterator)
print(list(num_iterator))# output
<filter object at 0x000002377A6F4FC8>
[1, 3, 5, 7, 9]

利用filter(), 可以完成很多有用的功能，比如，删除 None或者空字符串。

def is_not_empty(s):return s and len(s.strip()) > 0  # 不为None且字符串有实际内容str_list = list(filter(is_not_empty, ['test', None, '', 'str', '  ', 'END']))
print(str_list)  # ['test', 'str', 'END']

注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。
当rm为空时，默认删除空白符（包括’\n’, ‘\r’, ‘\t’, ’ ')，如下：

str1 = '  9527 '
str2 = '\t\t113\r\n'
print(str1.strip())  # 9527
print(str2.strip())  # 113

利用filter过滤出1~100中平方根是整数的数。

import math
def sqrt_is_int(n):return math.sqrt(n) % 1 ==0print(list(filter(sqrt_is_int,range(1,101))))

map　　 map(function, iterable, …)
map() 会根据提供的函数对指定序列做映射。（把序列中的参数代入函数运算）

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表(py2)，python3中返回的是一个迭代器。

def square(x):return x * xnum_iterator = map(square, [1,2,3])
print(num_iterator)
print(list(num_iterator))# output
<map object at 0x000002845DB94F88>
[1, 4, 9]

提供了两个列表，对相同位置的列表数据进行相加

my_iterator = map(lambda x, y: x + y, [1, 3], [2, 4])
print(list(my_iterator))  # [3, 7]

filter 执行了filter之后的结果集合 <= 执行之前的个数
　　filter只管筛选，不会改变原来的值
map 执行前后元素个数不变
　　值可能发生改变

二、匿名函数 lambad

目的：快捷定义简单函数，还不用给它名字，就不用纠结给这么多小函数起什么名字了，另外，避免了众多小函数的名字污染命名空间。

函数名 = lambad 参数：返回值

def add_two_num(x, y):return x + yadd_two_num(2, 3)

以上函数内容使用匿名表达式为：

add_two_num = lambda x, y: x+y
add_two_num(2, 3)

匿名函数与其他函数合作的时候，才真正地实现了匿名。

#　根据键值取key
my_dict = {'jack': 21, 'weige': 22, 'haha': 8}
print(max(my_dict, key=lambda k: my_dict[k]))
# weige

把列表里面的数取平方

my_iterator = map(lambda x: x*x, [1, 3, 4])
for each in my_iterator:print(each)
# output
1
9
16