Python 内置函数 2018-08-02

Posted 2020-12-31 默写年华

1. abs():返回一个数的绝对值
2. divmod(a,b): 结合除法和取模运算，返回一个包含商和模的元祖(a//b, a%b), 在 python 2.3 版本之前不允许处理复数。

>>> divmod(7,2)
(3, 1)
>>> divmod(-7,2)
(-4, 1)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)

1. input()和raw_input()
   Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。
   Python2.x 中 input() 相等于 eval(raw_input(prompt)) ，用来获取控制台的输入。
   input() 和 raw_input() 这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。
   除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
   python3 里 input() 默认接收到的是 str 类型。
   input()在Python2.x中

>>> a = input("Please input:")
Please input:123
>>> a
123
>>> type(a)
<type ‘int‘>
>>> a = input("Please input:")
Please input:"Tom"
>>> a
‘Tom‘
>>> type(a)
<type ‘str‘>
>>> a = input("Please input:")
Please input:Tom
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name ‘Tom‘ is not defined
>>> a = input("Please input:")
Please input:1+2
>>> a
3

input()在Python3.x中

[email protected]:~/code$ python3.5
Python 3.5.2 (default, Nov 23 2017, 16:37:01) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> a = input("Please input:")
Please input:123
>>> type(a)
<class ‘str‘>
>>> a
‘123‘

>>> a = input("Please input:")
Please input:Tom
>>> a
‘Tom‘
>>> type(a)
<class ‘str‘>

>>> a = input("Please input:")
Please input:"Tom"
>>> type(a)
<class ‘str‘>
>>> a
‘"Tom"‘

raw_input()在Python3.x中未定义

>>> a = raw_input("input:")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name ‘raw_input‘ is not defined

raw_input()在Python2.x中将所有的输入当作字符串：

[email protected]:~/code$ python
Python 2.7.12 (default, Dec  4 2017, 14:50:18) 
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> a = raw_input("input:")
input:123
>>> a
‘123‘
>>> a = raw_input("input:")
input:‘Tom‘
>>> a
"‘Tom‘"

>>> a = raw_input("input:")
input:Tom
>>> a
‘Tom‘

>>> a = raw_input("input:")
input:1+2
>>> a
‘1+2‘

1. staticmethod返回函数的静态方法

# -*- coding: UTF-8 -*-                                                         
class C(object):
   @staticmethod
   def f():
       print "Hello World"

C.f() #静态方法无需实例化

cobj = C() #也可以实例化再调用
cobj.f()

1. all(iterable)：iterable为列表或者元祖，用于判断给定的可迭代参数中所有的参数是否都为True，如果是则返回Ture,否则返回False;等价于以下函数：

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True  

• 注意：如果iterable得所有元素不为0，"", False或者iterable为空，all(iterable)返回True，否则返回False; 空元组或者空列表返回值为True

print all([])
print all(())
print all((1,2,3,0))
print all((‘1‘,‘2‘,‘‘,‘4‘))
print all((1,2,3,4)) 

输出：

[email protected]:~/code$ python test.py 
True
True
False
False
True

1. enumerate(): 用于将一个可遍历的数据对象（如列表，元祖，字符串）组合成一个索引序列，同时列出数据和数据下标，一般用在for循环中

   enumerate(seq [, start=0)):
   seq: 一个序列，迭代器或其他支持迭代对象
   start: 下标起始位置

>>> seasons = [‘Spring‘, ‘Summer‘, ‘Fail‘, ‘Winter‘]
>>> seasons
[‘Spring‘, ‘Summer‘, ‘Fail‘, ‘Winter‘]
>>> enumerate(seasons)
<enumerate object at 0x7f5b24858870>
>>> list(enumerate(seasons))
[(0, ‘Spring‘), (1, ‘Summer‘), (2, ‘Fail‘), (3, ‘Winter‘)]
>>> list(enumerate(seasons,start = 1))
[(1, ‘Spring‘), (2, ‘Summer‘), (3, ‘Fail‘), (4, ‘Winter‘)]

普通的for循环

>>> i = 0
>>> seq = [‘one‘, ‘two‘, ‘three‘]
>>> for element in seq:
...     print i,seq[i]
...     i += 1
... 
0 one
1 two
2 three

使用enumerate的for循环

>>> for i, element in enumerate(seq):
...     print i,element
... 
0 one
1 two
2 three

1. int()函数：用于将一个字符串或数字转换为整型

   int (x, base = 10)
   x: 字符串或者数字
   base: 进制数，默认十进制

>>> int() #不传入参数时，得到结果0
0
>>> int(3) #可以传入数字
3
>>> int(‘3‘) #也可以传入字符串
3
>>> int(‘12‘,16)  #如果是要带 base 的话，12要以字符串形式进行输入，12为16进制数
18
>>> int(‘0xa‘,16)
10
>>> int(‘10‘,8)
8

1. ord()函数，以一个字符（长度为1的字符串）作为参数，返回对应的ASCII数值，或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。

>>> ord(‘a‘)
97
>>> ord(‘b‘)
98

1. str():返回一个对象的string格式

>>> str(123)
‘123‘
>>> dict = {‘a‘:123,45:‘abc‘}
>>> str(dict)
"{‘a‘: 123, 45: ‘abc‘}"
>>> dict
{‘a‘: 123, 45: ‘abc‘}

1. any():any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True；元素除了0，空，False外都算True，等价于以下函数：

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False   

测试：

print any(())
print any([])
print any([‘a‘,‘‘])
print any([False])
print any((0,))

输出：

[email protected]:~/code$ python test.py 
False
False
True
False
False

1. eval()用来执行一个字符串表达式，并返回表达式的值

   eval(expression[, globals[, locals]])
   expression -- 表达式。
   globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
   locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

>>> x = 7
>>> eval(‘3*x‘)
21
>>> eval(‘x*x‘)
49
>>> eval(‘(1+2j)*x‘)
(7+14j)

1. isinstance()判断一个对象是否属于一个已知的类型，与type()的区别在于：

   type()认为子类不属于父类类型，不考虑继承关系
   isinstance()认为子类是一种父类类型，考虑继承关系
   如果要判断两个类型是否相同推荐使用isinstance

   • isinstance(object, classinfo)
     object: 实例对象
     classinfo: 可以直接或间接类名、基本类型或者由他们组成的元祖：

>>> a = 2
>>> isinstance(a,int)
True
>>> isinstance(a,str)
False
>>> isinstance(a,(str, int, list))
True

type()与isinstance()区别

# -*- coding: UTF-8 -*-                                                         
class father(object):
    pass
class son(father):
    pass
if __name__==‘__main__‘:
    print type(son())==father
    print isinstance(son(),father)
    print type(son())
    print type(son)

输出：

[email protected]:~/code$ python test.py 
False
True
<class ‘__main__.son‘>
<type ‘type‘>

• type()主要用来获取未知变量的类型
• isinstance()主要用于判断A类是否属于B类

1. pow(x, y[, z])与math.pow(): 计算 x 的 y 次方,分别相当于x ** y % z、x**y

• 通过内置的方法直接调用，内置方法会把参数作为整型，如果有 z，再对z取模
• 而 math 模块则会把参数转换为 float

>>> import math
>>> math.pow(2,1,2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pow expected 2 arguments, got 3
>>> math.pow(2,1)
2.0
>>> pow(2,1)
2
>>> pow(2,1,2)
0

1. sum()函数：求序列的和

   sum(iterable[, start])
   iterable: 可迭代对象，如：列表，元祖，集合
   start: 在前面序列和的基础上再加上 start, 如果没有这个值，则默认为0

>>> sum((1,2,3))
6
>>> sum([1,2,3])
6
>>> sum([1,2,3],4)
10

1. basestring()是str和unicode的父类，也是抽象类，因此不能被调用和实例化，但是可以用来判断一个对象是否是str或者unicode的实例

• isinstance(obj, basestring) 等价于 isinstance(obj, (str, unicode))。

>>> isinstance(‘Hello world‘,basestring)
True
>>> isinstance(‘Hello world‘,str)
True

1. execfile()：用来执行一个文件

   execfile(filename[, globals[, locals]])
   filename -- 文件名。
   globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
   locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
   返回值：返回表达式的执行结果

>>> execfile(‘test.py‘)
False
True
<class ‘__main__.son‘>
<type ‘type‘>

• Python 3 中删去了execfile()，代替如下：

with open(‘test.py‘,‘r‘) as f: 
    exec(f.read())

1. issubclass()函数：用于判断参数 class 是否是类型参数 classinfo 的子类。

   issubclass(class, classinfo)

# -*- coding: UTF-8 -*-                                                         
class father(object):
    pass
class son(father):
    pass

print(issubclass(son,father))

输出：

[email protected]:~/code$ python test.py 
True

1. print: print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。
   print(*object, sep=‘ ‘, end=‘ ‘, file=sys.stdout)

   *object-----表示一次性可以接收多个对象，输出多个对象时，需要用,隔开
   sep-----用来间隔多个对象，默认是一个空格
   end-----用来设定以什么结尾，默认是一个换行符 ,可以更改换成其它字符
   file-----要写入的文字对象

python 3下的测试

>>> print("aaa""bbb")
aaabbb
>>> print("aaa","bbb")
aaa bbb
>>> print("aaa","bbb",sep=‘---‘) #设置间隔符
aaa---bbb

1. super()函数：用于调用父类的方法，super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表

• Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :

# -*- coding: UTF-8 -*-                                                         
class FooParent(object):
    def __init__(self):
        self.parent=‘I‘m the parent‘
        print(‘Parent‘)
    def bar(self,message):
        print("%s from parent"%message)

class FooChild(FooParent):
    def __init__(self):
        super(FooChild,self).__init__()
        print(‘Child‘)

    def bar(self,message):
        super(FooChild,self).bar(message)
        print (‘Child bar function‘)
        print(self.parent)

if __name__==‘__main__‘:
    fooChild = FooChild()
    fooChild.bar(‘Hello World‘)

输出：先调用父类，再调用自己的子类

[email protected]:~/code$ python test.py 
Parent
Child
Hello World from parent
Child bar function
I‘m the parent

• __init__方法的第一参数永远是self，表示创建的类实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。（2）有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器会自己把实例变量传进去

• 如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问

• 在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名。

• 参考：self的用法详解

1. bin()函数：返回一个整数 int 或一个长整型 long int的二进制表示

>>> bin(10)
‘0b1010‘
>>> bin(8)
‘0b1000‘

1. file()用于创建一个对象，与open()类似

   file(name[, mode[, buffering]])
   name-----文件
   mode-----打开模式
   buffering-----0表示不缓冲，如果为1则表示进行缓冲，大于1为缓冲大小

>>> f = file(‘b.txt‘,‘r+‘)
>>> f.read()
‘Hello world!!!‘

1. iter()用来生成一个迭代器

   iter(object[, sentinel])
   object-----支持迭代的集合对象
   sentinel-----如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object

>>> lst = [1,2,3]
>>> for x in iter(lst):
...     print x
... 
1
2
3

1. tuple()将列表转换为元祖

>>> tuple([1,2,3,4])
(1, 2, 3, 4)
>>> tuple({1:2,3:4,‘xsd‘:7}) #针对字典，会返回字典的 key 组成的 tuple
(1, 3, ‘xsd‘)
>>> tuple((1,2,3,4)) #元祖则会返回元祖本身
(1, 2, 3, 4)

1. bool()用于将给定参数转换为bool类型，如果没有参数，则 返回False

>>> bool(0)
False
>>> bool(1)
True
>>> bool(19)
True
>>> bool(-1)
True
>>> issubclass(bool,int)
True
>>> isinstance(False,bool)
True

1. filter()函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表

   filter(function, iterable)
   该函数接收两个参数，第一个为函数，第二个为序列；序列的每个元素分别作为函数的参数进行判断，然后返回 True 或者 False ，最后将返回 True的元素放在新列表中

Python 2 实例1. 滤出列表中所有的奇数

# -*- coding: UTF-8 -*-                                                         
def is_odd(n):
    return n%2==1

list = [1,2,3,4,5,6]
newlist = filter(is_odd, list)
print newlist

输出：

[email protected]:~/code$ python test.py 
[1, 3, 5]

Python 2 实例2. 滤出1-100中平方根是整数的数

# -*- coding: UTF-8 -*-
import math
def is_sqrt(x):
    return math.sqrt(x)%1==0
newlist = filter(is_sqrt, range(1,101))

print newlist 

输出：

[email protected]:~/code$ python test.py 
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

---

Python 2.x中filter()返回的是过滤后的列表，而Python3返回的是一个filter类

Python 3 运行输出：

[email protected]:~/code$ python3.5 test.py 
<filter object at 0x7f1cbecf3b00>
[0, 2, 4, 6, 8]

Python 2.5 运行输出：

[email protected]:~/code$ python test.py 
[0, 2, 4, 6, 8]
[0, 2, 4, 6, 8]

1. len()返回对象（元祖，列表，字符、字典等）的长度或者项目个数

>>> str = "Hello World"
>>> len(str)
11
>>> list = [1,2,3,4]
>>> len(list)
4
>>> tuple = (1,2,3,4)
>>> len(tuple)
4
>>> dict = {1:2,3:4}
>>> len(dict)
2

1. range(start, stop[, step])：创建一个整数列表，一般用在 for 循环中

   start: 计数从start开始，默认值为0，因此，range(5)等价于range(0,5)
   stop: 计数到stop结束，但不包括stop
   step: 步长，默认值为1，因此，range(3,2,1)等价于range(3,2)

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(0,10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1,10,2)
[1, 3, 5, 7, 9]
>>> range(0)
[]
>>> range(10,1)
[]
>>> range(0,-10,-1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

1. callable():检查一个函数是否是可调用的
   函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。
2. format()格式化函数
   通过{}和:来代替以前的%
   实例1.

>>> "{} {}".format("Hello","World")
‘Hello World‘
>>> "{0} {1}".format("Hello","World")
‘Hello World‘
>>> "{1} {0} {1}".format("Hello","World")
‘World Hello World‘

实例2.也可以设置参数：

>>> print ("Name:{name} Age:{age}".format(name="Tom",age=6))
Name:Tom Age:6

>>> info = {"name":"Jack","age":12} #通过设置元祖 但是要加双星号
>>> print ("Name:{name} Age:{age}".format(**info)) 
Name:Jack Age:12

>>> list = ["Rose",20] #对于列表，要加 0
>>> print ("Name:{0[0]} Age:{0[1]}".format(list)) # 0 是必须的，代表括号中的列表名
Name:Rose Age:20

>>> print ("Name:{[0]} Age:{[1]}".format(list)) # 不带 0 就会出错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range

实例3. 也可传入对象

# -*- coding: UTF-8 -*-
class AssignValue(object):
    def __init__(self,value):
        self.value = value

my_value = AssignValue(7)
 
print ("value is :{0.value}".format(my_value))   #这里的 0 则是可选的
print ("value is :{.value}".format(my_value))      # 这里的 0 则是可选的，但是点 . 要留着

输出：

[email protected]:~/code$ python test.py 
value is :7
value is :7

• 数字格式化

  ^ > < 　分别代表居中对齐，右对齐，左对齐，后面跟 宽度
  :　后面带填充的字符，只能是一个字符，不指定则默认用空格填充
  + 　表示在正数面前显示 +，在负数面前显示 -，` `(空格)在正数面前加空格
  b, d, o, x 分别表示二进制， 十进制，八进制，十六进制

数字	格式	输出	描述
3.14159265	{:.2f}	3.14	保留2位小数
3.14159265	{:+.2f}}	+3.14	带符号保留2位小数
-1	{:+.2f}	-1.00	带符号保留2位小数
3.14159265	{:.0f}	3	不带小数
5	{:0>2d}	05	数字往右对齐，不足左边补零
5	{:x<2d}	5x	数字往左对齐，不足的右边补0
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.23	:.2%	23%	百分比表示
1000000	:.2e	1.00e6	指数计数法
13	{:10d}	13	右对齐(默认右对齐，空缺补空格)
	"{:b}".format(11)	1101	二进制
	"{:d}".format(11)	11	十进制
	"{:o}".format(11)	13	八进制
	"{:x}".format(11)	b	十六进制
	"{:#x}".format(11)	0xb	十六进制
	"{:#X}".format(11)	0XB	十进制

• 使用大括号{}来转义大括号{}

>>> print("{}对应的位置是{{0}}".format("Hello"))
Hello对应的位置是{0}

>>> print("{0}对应的位置是{1}{{0}}".format("Hello","World"))
Hello对应的位置是World{0}

1. locals()以字典类型返回当前位置的全部局部变量

# -*- coding: UTF-8 -*-
def f(x):
    z = 1
    print(locals())

f(6)     

输出：

[email protected]:~/code$ python test.py 
{‘x‘: 6, ‘z‘: 1}

1. reduce(function, iterable[, initializer])

   function----- 函数，有2个参数
   iterable-----可迭代对象
   initializer-----可选，初始参数
   功能： 先用集合 iterable 中的第 1, 2 两个元素传入给函数 function 的两个参数进行操作，得到的结果再与第三个数据继续传入给 function 的两个参数进行操作，直到得到最后一个结果

>>> def add(x, y):
...     return x+y
... 
>>> reduce(add, [1,2,3,4])
10
>>> reduce(lambda x, y: x + y, [1,2,3,4])
10

• 在Python 3中reduce()函数已经从全局名字空间中移除，被放置在functools模块

# -*- coding: UTF-8 -*-                                                         
from functools import reduce
def add(x, y):
    return x+y

print (reduce(add, [1,2,3,4]))

输出：

[email protected]:~/code$ python test.py 
10

实例2. 统计某字符串的重复次数

from functools import reduce
sentences = [‘The Deep Learning textbook is a resource intended to help students 
and practitioners enter the field of machine learning in general 
and deep learning in particular. ‘] 
word_count =reduce(lambda a,x:a+x.count("learning"),sentences,0)
print(word_count)

分析：
reduce()的源码如下：

def reduce(function, iterable, initializer = None):
    it = iter(iterable)
    if initializer is None:
        value = next(it)
    else:
        value = initializer
    for element in it:
        value = function(value,element)
    return value

上面首先value=initializer=0,然后value=function(0, element)，即lambda匿名函数中的参数a = 0, x=序列的元素，因此不能互换 a 和 x的位置，因为只有序列有count方法，而 int 没有，互换之后就会报错，
File "test.py", line 16, in <lambda> word_count = reduce_1(lambda x,a:x.count(‘learning‘)+a,sentences,0) AttributeError: ‘int‘ object has no attribute ‘count‘
输出：

[email protected]:~/code$ python test.py 
2

1. next()返回迭代器的下一个项目

   next(iterator[, default])
   iterator -- 可迭代对象
   default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

# -*- coding: UTF-8 -*-
 
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

输出：

1
2
3
4
5

1. chr()用一个范围在 range(256) 即0-255的整数（可以是十进制，也可以是十六进制,二进制等）做参数，返回一个对应的字符

>>> print chr(48), chr(49), chr(97)
0 1 a
>>> print chr(0x30),chr(0x31),chr(0x61)
0 1 a

1. frozenset()返回一个冻结的集合，冻结后集合不能再添加或删除任何元素

   frozenset([iterable])
   iterable-------可迭代的对象，比如列表，字典，元祖等
   返回新的 frozenset 对象，如果不提供任何参数，默认生成空集合。

>>> a = frozenset(range(10))
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset("Hello World")
>>> b
frozenset([‘ ‘, ‘e‘, ‘d‘, ‘H‘, ‘l‘, ‘o‘, ‘r‘, ‘W‘])
>>> b[0]=1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: ‘frozenset‘ object does not support item assignment

1. long()将数字或字符串转换为一个长整型

   long(x, base = 10)
   x -------- 字符串或者数字，当指定进制后，x 只能是字符串
   base --------可选，进制数，默认十进制

>>> long(123)
123L

>>> long(123,base = 10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: long() can‘t convert non-string with explicit base

>>> long(‘123‘,base = 10)
123L
>>> long(‘0b100‘,base = 2)
4L
>>> long(‘0x10‘,base = 16)
16L

1. reload()用于重新载入之前载入的模块
   reload()会重新加载已加载的模块，但原来使用的实例还是会使用旧的模块，而新的实例会使用新的模块
   reload()后还是使用原来的内存地址
   reload()不支持from xxx import xxx格式的模块进行重新加载

2. vars()返回对象 object的属性和属性值的字典对象，如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。

>>> print(vars())
{‘__builtins__‘: <module ‘__builtin__‘ (built-in)>, ‘__package__‘: None, ‘__name__‘: ‘__main__‘, ‘__doc__‘: None}

>>> class Name:
...     x = 1
... 
>>> print(vars(Name))
{‘x‘: 1, ‘__module__‘: ‘__main__‘, ‘__doc__‘: None}

• 对于 x = 1，这样一个赋值语句，在执行后，名称 x 引用到值 1，这就像字典一样，键引用值，当然，变量和所对应的值是个"不可见的"字典，可以使用vars()来返回这个字典

x = 2
>>> x = 2
>>> vars()[‘x‘] #vars()相当于返回当前变量的字典，其中就存在键值对应的(‘x‘: 1)，因此像字典一样可以通过键取值
2

1. classmethod()修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls参数，可以调用类的属性，类的方法，实例化对象等

# -*- coding: UTF-8 -*-
class A(object):
    bar = 1
    def fun1(self):
        print("fun1")
    @classmethod
    def fun2(cls):
        print ("fun2")
        print (cls.bar)
        cls().fun1()
A.fun2() #不需实例化

输出：

[email protected]:~/code$ python test.py 
fun2
1

1. getattr()用于获取对象的属性值

   getattr(object, name[, default])
   object------对象
   name-----字符串，对象属性
   default------默认返回值，如果不提供该参数，在没有对应属性时，将触发AttributeError

>>> class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a,‘bar‘)
1
>>> getattr(a, ‘bar2‘)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: ‘A‘ object has no attribute ‘bar2‘
>>> getattr(a, ‘bar2‘,3)
3

1. map()根据提供的函数对指定序列映射,Python2返回列表，Python3返回迭代对象

   map(function, iterable, ...)
   function ------函数，有两个参数
   iterable ------一个或者多个序列
   函数function 调用序列中的每一个参数，最后返回包含每个function返回值的新列表

>>> map(square, [1,2,3,4])
[1, 4, 9, 16]
>>> map(lambda x, y: x**2, [1,2,3,4])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: <lambda>() takes exactly 2 arguments (1 given)
>>> map(lambda x: x**2, [1,2,3,4])
[1, 4, 9, 16]
>>> map(lambda x, y: x*y, [1,2,3,4],[1,2,3,4])
[1, 4, 9, 16]
>>> map(lambda x, y, z: x*y*z, [1,2,3,4],[1,2,3,4],[1,2,3,4])
[1, 8, 27, 64]

• 在Python3.x 如果函数含有多个参数，但每个参数序列的元素数量不一样，会根据最少的序列进行，Python2.X中报错

Python 3.5.2 (default, Nov 23 2017, 16:37:01) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.

>>> x = [1,2,3]
>>> y = [1,2]
>>> z = [1,2,3,4]
>>> print(map(lambda x,y,z:x+y+z,x,y,z))
<map object at 0x7f0e926c0d68>
>>> print(list(map(lambda x,y,z:x+y+z,x,y,z)))
[3, 6]

• map完成规范名字格式

# -*- coding: UTF-8 -*-                                                         
name_list = [‘tom‘,‘tony‘,‘jack‘]

def format_name(s):
    ss = s[:1].upper() + s[1:].lower()
    return ss

print(list(map(format_name, name_list)))

输出：

[email protected]:~/code$ python test.py 
[‘Tom‘, ‘Tony‘, ‘Jack‘]

1. repr()将对象转化为供解释器读取的形式,返回一个对象的string格式

>>> s = ‘Hello world‘
>>> str(s)
‘Hello world‘
>>> repr(s)
"‘Hello world‘"
>>> s = {‘1‘:1,‘2‘:2}
>>> str(s)
"{‘1‘: 1, ‘2‘: 2}"
>>> repr(s)
"{‘1‘: 1, ‘2‘: 2}"

1. xrange()与range()相似,不同的是range生成的是一个数组，而xrange是一个生成器

>>> xrange(8)
xrange(8)
>>> list(xrange(8))
[0, 1, 2, 3, 4, 5, 6, 7]
>>> range(8)
[0, 1, 2, 3, 4, 5, 6, 7]
>>> xrange(0,6,2)
xrange(0, 6, 2)
>>> list(xrange(0,6,2))
[0, 2, 4]

1. cmp(x, y)用与比较两个对象。
   如果 x<y, 则返回 -1；如果 x==y, 则返回0；如果 x>y, 则返回1

>>> cmp(80,9)
1
>>> cmp(8,9)
-1
>>> cmp(‘a‘,‘b‘)
-1
>>> cmp(‘a‘,‘ac‘)
-1
>>> cmp(‘x‘,‘bcd‘)
1

• Python3.X 已经没有cmp()函数，若需实现比较功能，需引入operator模块

operator.lt(a, b)  # less than 
operator.le(a, b) # less equal
operator.eq(a, b)  # equal
operator.ne(a, b)  # not equal 
operator.ge(a, b)   # greater equal
operator.gt(a, b)  # greater than
operator.__lt__(a, b)
operator.__le__(a, b)
operator.__eq__(a, b)
operator.__ne__(a, b)
operator.__ge__(a, b)
operator.__gt__(a, b)

1. globals()以字典类型返回当前位置的全部全局变量

>>> a = ‘Hello‘
>>> globals()
{‘__builtins__‘: <module ‘__builtin__‘ (built-in)>, ‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘a‘: ‘Hello‘, ‘__package__‘: None}
>>> locals()
{‘__builtins__‘: <module ‘__builtin__‘ (built-in)>, ‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘a‘: ‘Hello‘, ‘__package__‘: None}

1. max()返回当前参数的最大值

>>> max(1,2,3,4)
4
>>> max(‘a‘,‘b‘,‘c‘)
‘c‘
>>> max((1,2,3),(4,1,2)) #一个一个元素地进行对比，从左往右
(4, 1, 2)
>>> max({1:10,2:8,3:7}) #字典则先比较键值，键值相同再比较后面的 value
3
>>> max({1:10,1:8,1:7})
1

1. reverse()用于反向列表中的元素

>>> a = [1,2,3,4]
>>> a.reverse()
>>> a
[4, 3, 2, 1]

1. zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元祖，然后返回由这些元祖组成的列表

• 如果各个迭代器的元素个数不一样，则返回列表长度与最短的对象相同
• 利用*操作，可以将元祖解压为列表
• 在Python3中返回的是一个对象，需要手动list()转换

>>> a = [1,2,3,4]
>>> b=[5,6,7]
>>> c = [7,8,9]
>>> ac = zip(a,c)
>>> ac
[(1, 7), (2, 8), (3, 9)]
>>> bc = zip(b,c)
>>> bc
[(5, 7), (6, 8), (7, 9)]

>>> bc = zip(*bc)
>>> bc
[(5, 6, 7), (7, 8, 9)]

1. compile()将一个字符串编译为字节代码

   compile(source, filename, mode[, flags[, dont_inherit]])
   source -- 字符串或者AST（Abstract Syntax Trees）对象。。
   filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
   mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
   flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
   flags和dont_inherit是用来控制编译源码时的标志

>>> str = "for i in range(0,10):print i,"
>>> exec(str)
0 1 2 3 4 5 6 7 8 9
>>> c = compile(str,‘‘,‘exec‘)
>>> c
<code object <module> at 0x7f9328f04db0, file "", line 1>
>>> exec(c)
0 1 2 3 4 5 6 7 8 9

1. hasattr()判断对象是否包含对应的属性

   hasattr(object, name)
   object------对象
   name-----字符串，属性名
   如果对象有该属性则返回 True, 否则返回 False

>>> class coordinate:
...     x = 10
...     y = -5
...     z = 0
... 
>>> point1 = coordinate()
>>> hasattr(point1, ‘x‘)
True
>>> hasattr(point1, ‘y‘)
True
>>> hasattr(point1, ‘no‘)
False

1. round()返回浮点数 x 的四舍五入值

   round(x[, n])

>>> round(10.0044,3)
10.004
>>> round(10.0045,3)
10.005

1. complex(real[, imag])用于创建一个值为real + imag * j的复数或者转化一个字符串或数为复数，如果第一个参数为字符串，则不需要指定第二个参数

>>> complex(1,2)
(1+2j)
>>> complex(1.1,2.2)
(1.1+2.2j)
>>> complex("1+2j")
(1+2j)

>>> complex("1 + 2j")  # + 两侧不能有空格
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: complex() arg is a malformed string

>>> complex("1")
(1+0j)
>>> complex("2j")
2j

1. hash()返回对象的哈希值

• 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。

>>> hash(1)
1
>>> hash(2)
2
>>> hash(‘hello‘)
840651671246116861
>>> hash(str([1,2,3]))
1335416675971793195

>>> hash([1,2,3]) 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: ‘list‘

1. min()返回多个参数的最小值

>>> min(1,2,3)
1
>>> min(‘a‘,‘b‘)
‘a‘
>>> min({1:10,2:8,3:7})
1
>>> min({1:10,1:8,1:7})
1

1. set(iterable)创建一个无序不重复元素集

• 可进行关系测试，删除重复数据，还可以计算交集，并集等

>>> x = set(‘hello‘)
>>> y = set(‘google‘)
>>> x,y
(set([‘h‘, ‘e‘, ‘l‘, ‘o‘]), set([‘e‘, ‘o‘, ‘g‘, ‘l‘]))
>>> x
set([‘h‘, ‘e‘, ‘l‘, ‘o‘])
>>> y
set([‘e‘, ‘o‘, ‘g‘, ‘l‘])
>>> x & y  # 交集
set([‘e‘, ‘l‘, ‘o‘])
>>> x | y   # 并集
set([‘e‘, ‘g‘, ‘h‘, ‘l‘, ‘o‘])
>>> x -y   # 差集
set([‘h‘])

1. delattr(object, name)用于删除属性

>>> class coordinate:
...     x = 10
...     y = -5
...     z = 0
... 
>>> point1 = coordinate()
>>> point1.x
10

>>> delattr(point1,‘x‘)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: coordinate instance has no attribute ‘x‘

>>> delattr(coordinate,‘x‘)
>>> point1.x
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: coordinate instance has no attribute ‘x‘

1. help()返回对象的帮助信息

>>>help(‘sys‘)             # 查看 sys 模块的帮助
……显示帮助信息……
 
>>>help(‘str‘)             # 查看 str 数据类型的帮助
……显示帮助信息……
>>>a = [1,2,3]
>>>help(a)                 # 查看列表 list 帮助信息
……显示帮助信息……
 
>>>help(a.append)          # 显示list的append方法的帮助
……显示帮助信息……

1. setattr()对应于函数getattr()用于设置属性值，可以增加属性

   setattr(object, name, value)

>>> class coordinate:
...     x = 10
...     y = -5
...     z = 0
... 
>>> point1 = coordinate()
>>> point1.x
10
>>> setattr(point1,‘x‘,20)
>>> point1.x
20

>>> point1.m
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: coordinate instance has no attribute ‘m‘
>>> setattr(coordinate,‘m‘,9) #当以类名为参数时，实例的值也会修改
>>> point1.m
9
>>> setattr(point1,‘m‘,90) #当以实例为参数时，再以类名为参数，则不会改变
>>> point1.m
90
>>> setattr(coordinate,‘m‘,9)
>>> point1.m
90

1. dict()函数用于创建一个字典

>>> dict()  #创建一个空字典
{}
>>> dict(a=‘a‘,b=‘b‘,c=3) #传入关键字
{‘a‘: ‘a‘, ‘c‘: 3, ‘b‘: ‘b‘}

>>> dict(zip([‘one‘,‘two‘,‘three‘],[1,2,3])) #映射函数方式来构造字典
{‘three‘: 3, ‘one‘: 1, ‘two‘: 2}

>>> dict([(‘one‘,1),(‘two‘,2),(3,‘three‘)])  # 可迭代对象来构造字典
{‘one‘: 1, 3: ‘three‘, ‘two‘: 2}

1. slice()实现切片，

   slice(start, stop[, step])
   返回一个切片对象

>>> myslice = slice(5)
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
range(0, 10)
>>> arr[myslice]
range(0, 5)
>>> list(arr[myslice])
[0, 1, 2, 3, 4]
>>> list(arr[slice(6,10,1)])
[6, 7, 8, 9]

1. dir()函数

• 不带参数时，返回当前范围内的变量、方法和定义的类型列表；
• 带参数时，返回参数的属性、方法列表
  • 如果参数包含方法__dir__()，该方法被调用；如果参数不包含__dir__()，该方法将最大限度地收集参数信息

>>> dir()
[‘__builtins__‘, ‘__doc__‘, ‘__loader__‘, ‘__name__‘, ‘__package__‘, 
‘__spec__‘, ‘arr‘, ‘coordinate‘, ‘myslice‘, ‘p2‘, ‘point1‘]
>>> dir([])
[‘__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‘]

1. id()获取对象的内存地址

>>> a = ‘Hello‘
>>> id(a)
140540780793224
>>> b = ‘Hello‘
>>> id(b)
140540780793224
>>> c = a
>>> id(c)
140540780793224

• 可以看到，对于同一个字符串对象，可以有多个引用 a,b,c但是其地址都是相同的

1. oct()将一个整数转换为 8 进制字符串

>>> oct(0b1000)
‘0o10‘
>>> oct(8)
‘0o10‘
>>> oct(0x8)
‘0o10‘
>>> oct(0x10)
‘0o20‘

1. sorted()