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

参数说明:

  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
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():
    pass

print(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]]])

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

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

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
  1. ascii()返回一个字符串对象。
  2. ascii()的参数只能有一个。
  3. 如果参数中有非ascii字符,会用 \u,\U,\x 来替代。
  4. 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 False
    return True
    
# any
def any(iterable):
    for element in iterable:
        if element:
            return True
    return False   
l1 = [2, 12, ["xa", None], 22]
print(all(l1))  # True
l2 = [2, 12, 0, 22]
print(all(l2))  # False

l3 = [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 == 1


num_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 ==0

print(list(filter(sqrt_is_int,range(1,101))))
  • map   map(function, iterable, …)
    map() 会根据提供的函数对指定序列做映射。(把序列中的参数代入函数运算)

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

def square(x):
    return x * x

num_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]
  1. filter 执行了filter之后的结果集合 <= 执行之前的个数
      filter只管筛选,不会改变原来的值
  2. map 执行前后元素个数不变
      值可能发生改变
二、匿名函数 lambad

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

函数名 = lambad 参数:返回值

def add_two_num(x, y):
    return x + y
   
add_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
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值