内置函数随笔及匿名函数

1. abs()　　获取绝对值

abs(-10)
--->10
 
abs(10)
--->10
 
abs(0)
--->0
 
a = -10
a.__abs__()
--->10

2. all()　　参数为可迭代对象，迭代对象为空时，返回True.如果迭代对象的所有元素都为真，那么返回True，否则返回False.

all(['python',123])
--->True
 
all([])
--->True
 
all([0])
--->False
 
all(" ")
--->True
 
all(1,' ',2,None)
--->False

3.any() 参数为可迭代对象，参数为空时返回True

print(any([None,0,' ',{},1]))
--->True
 
print(any(' '))
--->True

4.sum() 求和

res=sum(i for i in range(5))  #(i for i in range(5))为生成器表达式
print(res)
--->12

5.bin() 将参数转化为二进制

print(bin(3))
--->0b11

6.bool() 布尔函数，返回bool值，False或True

print(bool(0))
--->False
 
print(bool(None))
--->False
 
print(bool(' '))
--->False

7. ascii()　　调用对象的__repr__()方法，获得该方法的返回值.

8.bytes() 将一个字符串转化为字节类型

print(bytes('hello',encoding='utf8'))
--->b'hello'
 
s = 'python'
print(bytes(s, encoding='utf-8'))
--->b'python'
 
a = '王'
print(bytes(a, encoding='utf-8'))
--->b'xe7x8ex8b'

9.str()　　将字符类型/数值类型等转换为字符串类型

print(str(b'xe7x8ex8b', encoding='utf-8'))  # 字节转换为字符串
--->'王'
 
str(1)   # 整数转换为字符串
--->'1'

10.chr() 查看十进制数对应的ASCII字符

print(chr(67))
--->C
 
print(chr(65))
--->A

11.ord() 查看某个ASCII对应的十进制数

print(ord('A'))
--->65

12.callabe() 判断对象是否可以被调用，能被调用的对象就是一个callables对象，比如函数和带有__call__()的实例

def test():
    pass
print(callable(test))
--->True
 
print(callable(sum))
--->True

13. classmethod()　　用来指定一个方法为类的方法，由类直接调用执行，只有一个cls参数,执行雷的方法时，自动将调用该方法的类赋值给cls.没有此参数指定的类的方法为实例方法

class Province:
    country = "中国"
       
    def __init__(self, name):
        self.name = name
       
    @classmethod
    def show(cls):  # 类方法，由类调用，最少要有一个参数cls，调用的时候这个参数不用传值，自动将类名赋值给cls
        print(cls)
       
# 调用方法
Province.show()

14.complie()　　将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译

1 compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
2 将source编译为代码或者AST对象。代码对象能过通过exec语句来执行或者eval()进行求值。
3 参数source：字符串或者AST（abstract syntax trees）对象。
4 参数filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
5 参数model：指定编译代码的种类。可以指定'exec', 'eval', 'single'。
6 参数flag和dont_inherit：这两个参数为可选参数。

s  = "print('helloworld')"
print(compile(s, "<string>", "exec"))
---><code object <module> at 0x000001C648038390, file "<string>", line 1>

15.complex()　　

1 创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数是字符串，则不需要指定第二个参数。
2 参数real：int，long，float或字符串。
3 参数imag：int，long，float。

x=complex(1-2j)
print(x.real)
--->1.0
 
print(x.imag)
--->2.0

16. delattr()　　删除对象的属性　　

17.int() #数据类型，整型

int
num=1 #num=int(1)
print(type(num)) #查看num的类型
---> <class 'int'>
 
print(isinstance(num,int)) #判断num是否为int类型
 
print(num is 1) #is 是身份运算，根据id去判断身份

18. float()　　讲一个字符串或整数转换为浮点数

print(float())
--->0.0
 
print(float('123'))
--->123.0
 
print(float(1))
--->1.0
 
print(float('a'))
 
Traceback (most recent call last):
  File "<pyshell#45>", line 1, in <module>
    float('a')
ValueError: could not convert string to float: 'a'

19.list() 参数为可迭代对象

list
x=[]
x=list(i for i in range(10))  #生成器表达式，以元组的形式呈现
print(x)
--->[0,1,2,3,4,5,6,7,8,9]
 
列表构造函数
list([iterable])
list的构造函数。参数iterable是可选的，它可以是序列，支持编译的容器对象，或iterator对象。
该函数创建一个元素值，顺序与参数iterable一致的列表。如果参数iterable是一个列表，将创建
列表的一个拷贝并返回，就像语句iterables[:]。　　

20.tuple() 元组

21.dict() 创建数据字典

d={'a':1}
d=dict(x=1,y=2,z=3)
print(d)
--->{'y':2,'x':1,'z':3}
 
print(dict()) 空字典
--->{}
 
print(dict(one = 1, two =2))
--->{'one': 1, 'two': 2}
 
print(dict({'one':1 ,'two':2}))
--->{'one': 1, 'two': 2}

22.set() 集合

s={1,2,3,4,4}
print(s)
--->{1,2,3,4}
 
s.add(5)
print(s)
--->{1,2,3,4,5}

23.frozenset() 不可变集合

frozenset([iterable])
set和frozenset最本质的区别是前者是可变的，后者是不可变的。当集合对象会被改变时（例如删除，添加元素），只能使用set，
一般来说使用fronzet的地方都可以使用set。
参数iterable：可迭代对象。
f=frozenset({1,2,3,4})
print(type(f))
---> <class 'frozenset'>

24.dir()　　不带参数时返回当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表

print(dir())
--->['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'li', 'li1', 'li2', 'li_1'] >>> dir(list) ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__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']
 
print(dir(sum))  #输出sum下有哪些可被sum调用的方法。（对象.方法），sum.方法

25.divmod()　　分别取商和余数.二个参数x和y，输出元组（x//y,x%y）

print(divmod(100,33))
--->(3,1)

26. enumerate()　　返回一个可以枚举的对象，该对象的next()方法将返回一个元组　

for i in enumerate(['a','b','c','d']):
    print(i)
--->(0, 'a')
    (1, 'b')
    (2, 'c')
    (3, 'd')
    (0, 'x')
    (1, 'y')
 
for i in enumerate({'x':1,'y':2}):
    print(i)   
---->(0, 'x')
     (1, 'y')

27.eval()　　将字符串str中的表达式提取出来并运行

s = "1+2*3"
print(type(s))
---> <class 'str'>
 
print(eval(s))
---> 7

28.exec()　　执行字符串或complie方法编译过的字符串，没有返回值

29.filter()　　过滤器，构造一个序列，等价于[ item for item in iterables if function(item)]，在函数中设定过滤条件，逐一循环迭代器中的元素，将返回值为True时的元素留下，形成一个filter类型数据

filter(function, iterable)
参数function：返回值为True或False的函数，可以为None。
参数iterable：序列或可迭代对象。
def bigerthan5(x):
    return x > 5
print(filter(bigerthan5, [3, 4, 5, 6, 7, 8]))
---> [6, 7, 8]

30.format()　　格式化输出字符串，format(value, format_spec)实质上是调用了value的__format__(format_spec)方法

print("I am {0}, I like {1}!".format("xu", "moon"))   
--->'I am xu, I like moon!'

31.getattr()　　获取对象的属性

getattr(object, name [, defalut])
获取对象object名为name的特性，如果object不包含名为name的特性，将会抛出AttributeError异常；如果不包含名为name的特性
且提供default参数，将返回default。
参数object：对象
参数name：对象的特性名
参数default：缺省返回值
 
print(getattr(list, 'append'))
---> <method 'append' of 'list' objects>
 
mylist = [3, 4, 5]
append(mylist, 6)
print(mylist)
--->[3, 4, 5, 6]
 
print(getattr(list, 'add'))
--->Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'list' has no attribute 'add'
 
print(getattr(list, 'add', 'NoMethod'))
---> 'NoMethod'

32.globals()　　返回一个描述当前全局变量的字典

a = 1
print(globals())
---> {'__loader__': <class '_frozen_importlib.BuiltinImporter'>, 'a': 1, '__builtins__': <module 'builtins' (built-in)>, '__doc__': None, '__name__': '__main__', '__package__': None, '__spec__': None}

33.hasattr()

hasattr(object，name)
判断对象object是否包含名为name的特性（hasattr是通过调用getattr(object，name)）是否抛出异常来实现的。
参数object：对象
参数name：特性名称
 
print(hasattr(list, 'append'))
---> True
 
print(hasattr(list, 'add'))
---> False

34.hash()　　哈希值

hash(object)
hash是一种算法，二个数值相等hash值是确定的唯一的，常用来校验数据。<br>hash值不能逆推。
如果对象object为哈希表类型，返回对象object的哈希值。哈希值为整数，在字典查找中，哈希值用于快递比价字典的键。
两个数值如果相等，则哈希值也相等。

35.hex() 十进制转化为十六进制

print(hex(10))
---> 0xa

36. id() 查看唯一标识的身份

37. help()　　返回对象的帮助文档

38. input()　　获取用户输入内容

39. isinstance()　　检查对象是否是类的对象，返回True或False

isinstance(obj, cls)
检查obj是否是类cls的对象, 返回True 或 False
class Foo(object):
     pass
obj = Foo()
isinstance(obj, Foo)

40. issubclass()　　检查一个类是否是另一个类的子类。返回True或False

issubclass(sub, super)
检查sub类是否是super类的派生类（子类）。返回True 或 False
  
class Foo(object):
    pass
    
class Bar(Foo):
    pass
    
issubclass(Bar, Foo)

41. iter()

iter(o[, sentinel])
返回一个iterator对象。该函数对于第一个参数的解析依赖于第二个参数。
如果没有提供第二个参数，参数o必须是一个集合对象，支持遍历功能（__iter__()方法）或支持序列功能（__getitem__()方法），
参数为整数，从零开始。如果不支持这两种功能，将触发TypeError异常。
如果提供了第二个参数，参数o必须是一个可调用对象。在这种情况下创建一个iterator对象，每次调用iterator的next()方法来无
参数的调用o，如果返回值等于参数sentinel，触发StopIteration异常，否则将返回该值。

42. len()　　返回对象长度，参数可以是序列类型（字符串，元组或列表）或映射类型（如字典）

43. locals()　　打印当前可用的局部变量的字典

不要修改locals()返回的字典中的内容；改变可能不会影响解析器对局部变量的使用。
在函数体内调用locals()，返回的是自由变量。修改自由变量不会影响解析器对变量的使用。
不能在类区域内返回自由变量。

44. lambda匿名函数

因为lambda函数没有函数名，引用计数为0，内存会被清理，所有匿名函数常与内置函数一起使用。

求出工资最高的
salaries={'egon':3000,'alex':1000000,'wupeiqi':10000,'yuanhao':2500}
def get_value(k):
    return salaries[k]
print(max(salaries))  
---->yuanhao
 
print(max(salaries,key=get_value))  #迭代输出key,调用get_value函数，参数为key,得到每个人工资， max再进行比较工资，打印最大的人名key值
 --->alex  
 
使用匿名函数求出工资最高的
f=lambda k:salaries[k]  #匿名函数不写函数名，返回值为salaries[k]
print(f)  #f 相当于函数名  
-----> <function <lambda> at 0x0000000002823A60>
 
print(f('egon'))  
---->3000
 
print(max(salaries,key=lambda k:salaries[k]))   #求出最高工资的人
---->alex
 
print(min(salaries,key=lambda k:salaries[k]))   #求出最低工资的人
---->yuanhao

45. zip() ‘拉链’，一对一的

l1=[1,2,3]
s="hel"
for i in zip(l1,s):   #zip(l1,s)为可迭代的
    print(i)
---->(1, 'h')
     (2, 'e')
     (3, 'l')
 
l1=[1,2,3,4],s不变，输出结果也同上；l1不变，s="hell",输出结果也同上。
因为zip()函数为一一对应的

用zip函数求最高工资的人
salaries={'egon':3000,'alex':1000000,'wupeiqi':10000,'yuanhao':2500}
print(salaries.keys(),salaries.values())#dict_keys(['egon', 'alex', 'wupeiqi', 'yuanhao']) dict_values([3000, 1000000, 10000, 2500])
z=zip(salaries.keys(),salaries.values())
print(z) 
----> <zip object at 0x00000000027F3C08>
 
for i in z:
    print(i)  ---->('egon', 3000)
                   ('alex', 1000000)
                   ('wupeiqi', 10000)
                   ('yuanhao', 2500)
 
z=zip(salaries.values(),salaries.keys())  #工资value和人名key互换位置
print(max(z))  
---->(1000000, 'alex')
 
z=zip(salaries.values(),salaries.keys())   #因为已经迭代完成了，所以要重新迭代
print(min(z))  
---->(2500, 'yuanhao')

46.　sorted() 返回列表，列表包含所有的元素，按升序排列

l=[3,4,1,0,9,10]
print(sorted(l)) 
---->[0, 1, 3, 4, 9, 10]
 
s="hello abc"
print(sorted(s)) 
----->[' ', 'a', 'b', 'c', 'e', 'h', 'l', 'l', 'o']
 
#降序 reverse 反转
print(sorted(l,reverse=True))  
---->[10, 9, 4, 3, 1, 0]

salaries={'egon':3000,'alex':1000000,'wupeiqi':10000,'yuanhao':2500}
print(sorted(salaries)) #默认是按照字典salaries的key去排序的
----->['alex', 'egon', 'wupeiqi', 'yuanhao']

排序且修改
l=[3,2,0,10]
l=sorted(l)
print(l)
--->[0, 2, 3, 10]

47. map() 映射，第一个参数为函数，第二个参数为可迭代对象

l=[1,2,3,4,7,5]
x=[i**2 for i in l]
print(x)
---->[1, 4, 9, 16, 49, 25]
 
 
#上述用map函数实现
#迭代取l 的值，传递给lamba函数
m=map(lambda item:item**2,l)
print(m)
----><map object at 0x00000000021DC3C8>
 
for i in m:
    print(i)
--->1    4    9    16    49    25
 
for 循环也可用print(list(m))来实现，不过要重新迭代
m=map(lambda item:item**2,l)
print(list(m))  <br>---->[1, 4, 9, 16, 49, 25]

map(function, iterable,...)
对于参数iterable中的每个元素都应用fuction函数，并将结果作为列表返回。
如果有多个iterable参数，那么fuction函数必须接收多个参数，这些iterable中相同索引处的元素将并行的作为function函数的参数。
如果一个iterable中元素的个数比其他少，那么将用None来扩展改iterable使元素个数一致。
如果有多个iterable且function为None，map()将返回由元组组成的列表，每个元组包含所有iterable中对应索引处值。
参数iterable必须是一个序列或任何可遍历对象，函数返回的往往是一个列表(list)。
  
li = [1,2,3]
data = map(lambda x :x*100,li)
print(type(data))
data = list(data)
print(data)
  
运行结果：
  
<class 'map'>
[100, 200, 300]

48.max()　　返回给定元素里最大值　

max(iterable [,args...][, key])
如果只提供iterable参数，函数返回可遍历对象（如：字符串，元组或列表）中最大的非空元素。
如果提供多个参数，那么返回值最大的那个参数。
可选参数key是单参数的排序函数。
如果提供key参数，必须是以命名的形式，如：max(a, b, c, key = fun)

49.min()　　返回给定元素里最小值

min(iterable [,args...][, key])
如果只提供iterable参数，函数返回可遍历对象（如：字符串，元组或列表）中最小的非空元素。
如果提供多个参数，那么返回值最小的那个参数。
可选参数key是单参数的排序函数。
如果提供key参数，必须是以命名的形式，如：max(a, b, c, key = fun)

50.object()

1 获取一个新的，无特性(geatureless)对象。Object是所有类的基类。它提供的方法将在所有的类型实例中共享。
2 该函数时2.2.版本新增，2.3版本之后，该函数不接受任何参数。

51.open()　　打开文件

open(filename [, mode [, bufsize]])
打开一个文件，返回一个file对象。 如果文件无法打开，将处罚IOError异常。
应该使用open()来代替直接使用file类型的构造函数打开文件。
参数filename表示将要被打开的文件的路径字符串；
参数mode表示打开的模式，最常用的模式有：'r'表示读文本，'w'表示写文本文件，'a'表示在文件中追加。
Mode的默认值是'r'。
当操作的是二进制文件时，只要在模式值上添加'b'。这样提高了程序的可移植性。
可选参数bufsize定义了文件缓冲区的大小。0表示不缓冲；1表示行缓冲；任何其他正数表示使用该大小的缓冲区；
负数表示使用系统默认缓冲区大小，对于tty设备它往往是行缓冲，而对于其他文件往往完全缓冲。如果参数值被省却。
使用系统默认值。

52.print()　　输出函数

python2中的print语句被python3中的print()函数取代。
如何限制print的默认换行：
    1. python2版本下，在print输出的最后加一个逗号','
    2. python3.4以后，print(value, ...,sep='',end='
',file=sys.stdout,flush=False),将end设为空即可。

53.range()　　根据需要生成一个指定范围的数字，可以提供你需要的控制来迭代指定的次数

用于创建包含连续算术值的列表(list)。常用于for循环。参数必须是普通整数。
参数step默认值为1，参数start的默认值为0。
全参数调用该函数将返回一个普通整数列表。
step 可以是正整数或者负整数。不可以为0，否则将处罚ValueError异常。
range(3)代表0,1,2.等价于range(0,3)
print(range(0,10,2)) #第一个参数是起始数，第二个是终止数(不包含这个)，第三个数步数
---->[0,2,4,6,8]

55. repr()　　将任意值转换为字符串，供计时器读取的形式

返回一个对象的字符串表示。有时可以使用这个函数来访问操作。
对于许多类型来说，repr()尝试返回一个字符串，eval()方法可以使用该字符串产生对象；
否则用尖括号括起来的，包含类名称和其他二外信息的字符串被返回。

56.reversed()　　　反转，逆序对象，反着排序。

返回一个逆序的iterator对象。参数seq必须是一个包含__reversed__()方法的对象或支持序列操作(__len__()和__getitem__())
该函数是2.4中新增的

print(list(reversed([1,3,5,9])))
----->[9,5,3,1]

57.round()　　四舍六入五留双，五留双留离整数最近的偶数

print(round(10.3))
----> 10
 
print(round(10.5))
----> 10
 
print(round(10.6))
----> 11
 
print(round(10.9))
----> 11
 
print(round(11.5))
----> 12

58.pow()　　幂函数

print(pow(3,2))   #3**2
---->9
 
print(pow(3,2,2))   #3**2%2
---->1

59. reduce() 合并，第一个参数为函数，第二个参数为可迭代对象。第三个参数可有可无，默认初始值。

from functools import reduce #合并
l=list(range(100))
print(l)
---->[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
 
print(reduce(lambda x,y:x+y,l,100))
i=iter(l)
# 100 next(i) --->100,0----->x,y-x+y-->100
# 100 next(i)---->100,1----->x,y--x+y-->101
# 101 next(i)----->101,2
---->5050

60. filter 过滤

name_l=[
    {'name':'egon','age':18},
    {'name':'dragonFire','age':1000},
    {'name':'gaoluchuan','age':9000},
    {'name':'fsw','age':10000},
]
 
f=filter(lambda d:d['age'] > 100,name_l)
print(f)
-----><filter object at 0x00000000027DCCF8>
 
print(list(f))   #与map函数不同的是其返还的是查询的内容
---->[{'name': 'dragonFire', 'age': 1000},{'name': 'gaoluchuan', 'age': 9000},{'name': 'fsw', 'age': 10000}]
 
for i in f: print(i)
---->{'name': 'dragonFire', 'age': 1000}
 　　 {'name': 'gaoluchuan', 'age': 9000}
 　　 {'name': 'fsw', 'age': 10000}

61.oct() 十进制转化为八进制

print(oct(10))
---->0o12

62.slice 切片

l=[1,2,3,4,5]
print(l[2:4])
--->[3,4]
 
s=slice(2,4)
print(l[s])
---->[3,4]

63. vars 没有参数时和locals()一样，有参数得到字典

64. __import__

import time
#print(time)  ----><module 'time' (built-in)>
time.sleep(3)
上述代码等价于下面代码内容
m=__import__('time')
#print(m)  ----><module 'time' (built-in)>
m.sleep(3)