Python 内置函数 2018-08-02

  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

使用enumeratefor循环

>>> 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 % zx**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()strunicode的父类,也是抽象类,因此不能被调用和实例化,但是可以用来判断一个对象是否是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=‘\n‘, file=sys.stdout)

    *object-----表示一次性可以接收多个对象,输出多个对象时,需要用,隔开

    sep-----用来间隔多个对象,默认是一个空格

    end-----用来设定以什么结尾,默认是一个换行符\n,可以更改换成其它字符

    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]hine:~/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()

原文地址:https://www.cnblogs.com/qiulinzhang/p/9513571.html

时间: 2024-10-25 15:19:53

Python 内置函数 2018-08-02的相关文章

Python内置函数_数学运算类

本文和大家分享的主要是python内置函数数据运算类相关内容,一起来看看吧,希望对大家学习python 有所帮助. abs abs(x) 求绝对值 · X可以是整型,也可以是复数 · 若X是复数,则返回复数的模 >>> abs(-1)1>>> abs(-3+4j)5.0>>> bin bin(x) 将整数x转换为二进制字符串 >>> bin(2)'0b10'>>> bin(3)'0b11' bool bool([x]

Python内置函数进制转换的用法

使用Python内置函数:bin().oct().int().hex()可实现进制转换. 先看Python官方文档中对这几个内置函数的描述: bin(x)Convert an integer number to a binary string. The result is a valid Python expression. If x is not a Python int object, it has to define an __index__() method that returns a

Python补充--Python内置函数清单

Python内置函数 Python内置(built-in)函数随着python解释器的运行而创建.在Python的程序中,你可以随时调用这些函数,不需要定义.最常见的内置函数是: print("Hello World!") 在Python教程中,我们已经提到下面一些内置函数:基本数据类型 type()反过头来看看 dir()   help()    len()词典 len()文本文件的输入输出 open()循环设计 range()   enumerate()    zip()循环对象

python基础9 -----python内置函数

python内置函数1 一.python内所有的内置函数: 二.python内常用的内置函数: 三.python内内置函数详解: 1.数学运算函数: 2.集合类函数: 3.逻辑类函数: 4.映射类函数: 5.IO操作:

Python 内置函数sorted()有哪些高级用法?

本文和大家分享的主要是python内置函数sorted()的相关内容,一起来看看吧,希望对大家学习python http://www.maiziedu.com/land/python/有所帮助. 1.对于 Python 内置函数 sorted() ,先拿来跟list(列表)中的成员函数 list.sort() 进行下对比.在本质上,list的排序和内建函数sorted的排序是差不多的,连参数都基本上是一样的. 2.主要的区别在于, list.sort() 是对已经存在的列表进行操作,进而可以改变

[python基础知识]python内置函数map/reduce/filter

python内置函数map/reduce/filter 这三个函数用的顺手了,很cool. filter()函数:filter函数相当于过滤,调用一个bool_func(只返回bool类型数据的方法)来迭代遍历每个序列中的元素. 返回bool_func结果为true的元素的序列(注意弄清楚序列是什么意思)http://blog.csdn.net/bolike/article/details/19997465序列参考</a> 如果filter参数值为None,list参数中所有为假的元 素都将被

lambda 表达式+python内置函数

#函数 def f1(a,b): retrun  a+b #lambda方式,形参(a,b):返回值(a+b) f2=lambda a,b : a+b 在一些比较简单的过程计算就可以用lambda python内置函数 abc 获取绝对值 all 循环对象,都为真就返回真否则为假 >>> li[1, 2, 3]>>> all(li)True #0为假 >>> li=[0,1,2,3]>>> all(li)False bool 真假判断

python内置函数(三)

python内置函数目前需要知道的如下: 代码: #!/usr/bin/env python# -*- coding:utf-8 -*-# author by lh #map(函数,可迭代的对象)def f1(x): return x+100ret=map(f1,[1,2,3,4,5])for i in ret: print iprint '---------------------------------------'#hash转换成哈希值,节约内存dic={ 'dvfhsuicbfhascj

python学习系列--python内置函数(一)

先列出所有的python内置函数,可以看到还是挺多的. abs()        求给定数的绝对值. all()          传入一个列表,只有当列表中所有元素都是真时,该函数返回真. any()        传入一个列表,只要列表中有一个元素为真,该函数即返回真. ascii()       执行对象中的__repr__方法.该函数在python2.7中已弃用. bin()         将给定的值转换成二进制. bool()       判断真假. bytearray()     

Python基础篇【第2篇】: Python内置函数--map/reduce/filter/sorted

Python内置函数 lambda lambda表达式相当于函数体为单个return语句的普通函数的匿名函数.请注意,lambda语法并没有使用return关键字.开发者可以在任何可以使用函数引用的位置使用lambda表达式.在开发者想要使用一个简单函数作为参数或者返回值时,使用lambda表达式是很方便的.总结:处理简单逻辑,自动返回结果 语法格式: lambda parameters: expression 就相当于 def fun(args) return expression 并且lam