1.abs()

取数字的绝对值,参数可以是整数或浮点数。如果参数是一个复数，则返回其大小

>>> print(abs(-28))

28

>>> print(abs(-2.34))

2.34

>>> print(abs(1/3))

0.3333333333333333

2.dict()

用于创建字典

>>> dict()     #创建空字典

{}

>>> dict(a='who',b='while',c='whit')   #传入关键字创建字典

{'b': 'while', 'c': 'whit', 'a': 'who'}

>>> dict(zip([1,2,3],['one','two','three']))  #映射函数方式创建字典

{1: 'one', 2: 'two', 3: 'three'}

>>> dict([(1,'one'),(2,'two'),(3,'three')])  #可迭代对象方式创建字典

{1: 'one', 2: 'two', 3: 'three'}

3.help()

用于查看函数或模块用途的详细说明

>>> help('sys')   #查看sys模块的帮助

>>> help('str')   #查看str数据类型帮助信息

>>> a = [1,2,3]

>>> help(a)       #查看列表list帮助信息

>>> help(a.extend)   #显示list的extend方法的帮助信息

4.min()

返回给定参数的最小值，参数可以为列表，元组，字典和集合

>>> print(min(1,23,4))     #给定序列的最小值，这里实际上判断的元组类

1

>>> print(min([1,2,3,4]))   #列表

1

>>> print(min((3,4,5)))   #元组

3

>>> print(min({'a':3,'b':44,'c':22}))  #字典，对字符串按ascii码位置判断

a

>>> print(min({22,33,44}))   #集合判断

22

5.setattr()

对应函数 getatt()，用于设置属性值，该属性必须存在,参数是一个对象，一个字符串和一个任意值。该字符串可以命名现有的属性或新的属性。如果该对象允许，该函数将该值分配给该属性。

>>> class x(object):

...   def aa():

...     print('test is aa')

...

>>> setattr(x,'foo',123)

>>> print(x.foo)

123

6.all()

判断给定的可迭代参数中所有元素不为0，空，False,返回True,否则返回False

>>> all([1,2,3])   #列表元素不为空或0返回True

True

>>> all([0,2,3])  #列表元素为0返回False

False

>>> all([1,'',3])  #列表元素为空返回False

False

>>> all([1,False,3])  #列表元素为False返回False

False

>>> all([])    #注意：空列表返回True

True

>>> all((1,2,3))  #元组元素都不为空或0返回True

True

>>> all((0,2,3))  #为0返回False

False

>>> all((1,'',3))   #为空返回False

False

>>> all(())    #注意：空元组返回True

True

>>> all((1,False,3))   #为False返回False

False

7.dir()

获取当前范围内的变量，方法和定义的类型列表，带参数时返回参数的属性，方法列表

>>> dir()   #获取当前范围内的变量，方法和定义的类型列表，

['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'b', 'd1']

#带参数时返回参数的属性，方法列表

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

8.hex()

将数值转换成十六进制

>>> hex(16)   #将十进制转换成十六进制

'0x10'

>>> hex(-17)

'-0x11'

>>> hex(0o11)  #将八进制转换成十六进制

'0x9'

>>> hex(0b1100)  #将二进制转换成十六直接

'0xc'

>>> hex(0b10)

'0x2'

#说明：二进制表示（0b）,八进制表示（0o）,十六进制（0x）

9.next()

返回迭代器的下一个项目，可在没有下一个项目时返回设置的默认值

>>> it = iter([1,2,3,4,5])   #使用iter生成迭代器

>>> next(it)   #返回一个可迭代数据结构中的下一个元素

1

>>> next(it)

2

>>> next(it)

3

>>> next(it)

4

>>> next(it)

5

>>> next(it)   #在没有下一个元素则会触发 StopIteration 异常

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

StopIteration

>>> next(it,'no values')   #在没有下一个元素时返回指定默认值

'no values'

10.slice()

用来创建切片对象，可指定起始和结束位置，间隔

class slice(stop)

class slice(start,stop[,step])

>>> l1 = [1,2,3,4,5,6,7,8]

>>> slice1 = slice(5)   #定义一个切片对象，截取长度为5，不指定起始位置默认从索引0开始

>>> l1[slice1]    #列表引用切片对象

[1, 2, 3, 4, 5]

>>> slice3 = slice(1,6,1)   #定义一个切片对象，指定起始位置为1结束位置为6，间隔为1

>>> l1[slice3]    #当间隔为1时，相当于0间隔

[2, 3, 4, 5, 6]

>>> slice2 = slice(1,7,2)  #间隔为2时，相隔一个截取元素

>>> l1[slice2]

[2, 4, 6]

11.any()

判断可迭代参数是否全部为空或0或False则返回False，否则返回True。

>>> any([1,2,3])

True

>>> any([0,'',1])

True

>>> any([0,'',False])   #全部为空值才返回False

False

>>> any([])   #空列表返回False

False

>>> any((1,2,3))

True

>>> any((0,'',1))

True

>>> any((0,'',False))

False

>>> any(())   #空元组返回False

False

12.divmod(a,b)

返回a除以b的商和余数的元组(a//b,a%b)

>>> divmod(4,2)   #返回4除以2的商和余数

(2, 0)

>>> divmod(15,4)

(3, 3)

>>> divmod(2+0.2j,3+1.3j)   #不支持负数

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: can't take floor or mod of complex number.

>>> divmod(4,8)  #当不被整除时余数返回4，不解！

(0, 4)

>>> divmod(4,9)

(0, 4)

>>> divmod(4,100)

(0, 4)

13.id()

用于获取对象的内存地址

>>> id(1)

8956480

>>> id(2)

8956512

>>> id('b')

140349300904040

>>> a = 'python'

>>> id(a)

140349300975744

14.object()

获取一个新的，无特性(geatureless)对象。Object是所有类的基类。它提供的方法将在所有的类型实例中共享。

该函数时2.2.版本新增，2.3版本之后，该函数不接受任何参数。

15.sorted()

对所有可迭代的对象进行排序操作

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法：sorted(iterable, /, *, key=None, reverse=False)

iterable:可迭代对象

key:用来进行比较的元素，只有一个参数，指定可迭代对象中的一个元素来进行排序

reverse:排序规则，reverse=True为降序，reverse= False为升序（默认）

>>> sorted([-12,3,23,18])   #列表按数字排序

[-12, 3, 18, 23]

>>> sorted([-12,3,23,18],key=abs)  #列表数字按绝对值排序

[3, -12, 18, 23]

>>> sorted(['bc','aa','fd','cj'])   #列表字符按首字母的ASCII码排序

['aa', 'bc', 'cj', 'fd']

#如果是数字与字符混合，在python3需要指定key的函数对象

>>> l1 = [2,'a','b',4,-33,'python']

>>> l1

[2, 'a', 'b', 4, -33, 'python']

>>> sorted(l1,key=id)   #按内存地址排序

[2, 4, -33, 'a', 'b', 'python']

>>> sorted(l1,key=str)  #按字符串排序，对所有数据转换成字符串后首个字符按ASCII排序

[-33, 2, 4, 'a', 'b', 'python']

>>> ord('-')

45

>>> ord('')

50

>>> ord('')

52

>>> ord('a')

97

>>> ord('b')

98

>>> ord('p')

112

#如果需要排序的是一个列表嵌套元组，则需要使用参数key，指定关键字

>>> a = [('b',2),('a',1),('c',0)]

>>> sorted(a,key=lambda x:x[0])

[('a', 1), ('b', 2), ('c', 0)]

>>> sorted(a,key=lambda x:x[1])

[('c', 0), ('a', 1), ('b', 2)]

>>> tup1 = ('python','java','c++','bash','php','perl','c#')


>>> tup1


('python', 'java', 'c++', 'bash', 'php', 'perl', 'c#')


>>> sorted(tup1,key=str.lower)   #忽略大小写排序


['bash', 'c#', 'c++', 'java', 'perl', 'php', 'python']


>>> sorted(tup1,key=str.lower,reverse=True)  #反向排序


['python', 'php', 'perl', 'java', 'c++', 'c#', 'bash']

#嵌套字典，按某个键值排序

>>>alist = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]

>>>sorted(alist,key=lambda x:x['age'],reverse=False)   #False为升序，True降序





[{'age': 20, 'name': 'a'}, {'age': 25, 'name': 'c'}, {'age': 30, 'name': 'b'}]

16.ascii()

类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符

>>> ascii('bb')

"'bb'"

>>> ascii('+')

"'+'"

>>> ascii('中')

"'\\u4e2d'"

17.enumerate()

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

语法：enumerate(sequence,[start=o])

sequence：一个序列，迭代器或其他支持迭代对象

start：下标起始位置

>>> l1 = ['python','c++','java','php','css']

>>> list(enumerate(l1))     #生成数据和数据下标

[(0, 'python'), (1, 'c++'), (2, 'java'), (3, 'php'), (4, 'css')]

>>> list(enumerate(l1,1))   #指定下标从1开始

[(1, 'python'), (2, 'c++'), (3, 'java'), (4, 'php'), (5, 'css')]

>>> l1 = ['python','c++','java','php','css']


>>> for i,v in enumerate(l1):


...   print(i,v)


...


0 python


1 c++


2 java


3 php


4 css

18.input()

用来获取交换输入，python3默认接受的是字符串

>>> in1 =input('inside:')

inside:123

>>> type(in1)   #默认接受字符串

<class 'str'>

>>> in2 =input('inside:')

inside:python

>>> type(in2)

<class 'str'>

19.oct()

将一个整数转换成8进制字符串

>>> oct(10)   #十进制转八进制

'0o12'

>>> oct(0b1010)  #二进制转八进制

'0o12'

>>> oct(0xA)  #十六进制转八进制

'0o12'

>>> oct(3.3)   #不支持float浮点型转八进制

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: 'float' object cannot be interpreted as an integer

>>> oct(0.1+1.2j)   #不支持complex复数转八进制

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: 'complex' object cannot be interpreted as an integer

20.staticmethod()

返回函数的静态方法

21.bin()

返回一个整数 int 或者长整数 long int 的二进制表示。可以将八进制，十进制，十六进制转换为二进制，不支持float类型

>>> bin(10)   #十进制转二进制

'0b1010'

>>> bin(10.1)  #float不支持转二进制

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: 'float' object cannot be interpreted as an integer

>>> bin(0o10)  #八进制转二进制

'0b1000'

>>> bin(0xA)  #十六进制转二进制

'0b1010'

22.eval()

用来执行一个字符串表达式，并返回表达式的值。

>>> eval('')

123

>>> a = eval('')   #可以将数值字符串转换为int类型

>>> type(a)

<class 'int'>

>>> eval('2**8')  #将数值字符串当表达式并计算结果返回int类型

256

>>> eval("'a'+'b'")  #字符串运算，必须这么写

'ab'

>>> eval("'a'*5")  #必须这么写，5不能加引号否则报错

'aaaaa'

>>> eval("'a'*'5'")

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

  File "<string>", line 1, in <module>

TypeError: can't multiply sequence by non-int of type 'str'

23.int()

用于将一个字符串数值或数字转换为整形

>>> int()     #不传入参数结果为0

0

>>> a =int('')    #将字符串转换成int类型

>>> type(a)

<class 'int'>

>>> a

2

>>> int(2.6)    #将浮点型转换为整型

2

>>> b =int('',16)  #以字符串的十六进制转换为十进制

>>> type(b)

<class 'int'>

>>> b

18

>>> int('0xC',16)  #可以这样写十六进制

12

>>> int('',8)   #八进制转十进制

8

>>> int('0o10',8)

8

>>> int('0b1000',2)  #二进制转十进制

8

>>> int('',2)   #可以省略进制表示法

8

24.open()

用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写

>>> f = open('aa.txt','r+')   #以读写方式打开一个文件

>>> f.write('hello python\n')  #写入内容到文件中

13

>>> f.flush()   #刷新文件内容

>>> f.tell()   #查看指针位置

13

>>> f.seek(0)  #移动文件指针到起始位置

0

>>> f.tell()   #查看指针

0

>>> f.readline()  #根据指针位置返回一行文件内容

'hello python\n'

file1 = open('aa.txt','a+',1) #以追加写的模式打开文件，1表示行缓冲，如为0则不缓冲，大于1时表示缓冲区大小，为负数时使用系统默认值。

25.str()

将字节转换成字符串，bytes() 将字符串转换为字节

>>> s1=str(11)

>>> type(s1)   #将对象转换成字符串

<class 'str'>

>>> bytes('中',encoding = 'utf-8')   #将字符串转换bytes字节


b'\xe4\xb8\xad'


>>> str(b'\xe4\xb8\xad',encoding = 'utf-8')  #将字节转换为字符串


'中'

>>> bytes()  #生成空字节对象


b''

26.bool()

判断给的参数是否为真，则返回True,否则返回False

>>> bool()

False

>>> bool(0)

False

>>> bool(1)

True

>>> bool(2)

True

>>> bool(False)

False

>>> bool(True)

True

>>> bool('')

False

>>> bool('a')

True

>>> bool(None)

False

>>> bool("")

False

>>> bool([])

False

>>> bool(())

False

>>> bool({})

False

27.exec()

执行字符串或complie方法编译过的字符串，没有返回值

>>> exec("a=1+2+3+4")

>>> a

10

>>> exec('''sum = 0


... for i in range(101):


...   sum+=i


... print(sum)


... ''')


5050

28.isinstance()

判断对象是否是某个类的实例

>>> isinstance('a',str)    #判断a是否是字符类的对象

True

>>> isinstance('a',int)

False

>>> isinstance(11,int)

True

>>> isinstance({1:'a'},dict)

True

>>> isinstance({1,2},dict)

False

>>> isinstance({1,2},set)

True

>>> isinstance((1,2),(str,int,list))  #判断对象是否在元祖中的一个类创建返回True，否则返回False

False

>>> isinstance((1,2),(str,int,list,tuple))

True

29.ord()

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

>>> ord('')   #长度只能为一个字符串

50

>>> ord('a')

97

>>> ord('A')

65

>>> ord('中')  #返回对应的unicode值

20013

>>> ord('国')

22269

>>> ord('+')  #返回ascii数值

43

30.sum()

对系列进行求和计算，只能是列表或元祖

>>> sum([1,2,3,4])   #求有序列的和，只能是数字类型

10

>>> sum([1,2,3,4],5)  #对有序列求和后相加的数字

15

31.bytearray()

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

>>> bytearray()   #没有参数时，初始化数组0个元素

bytearray(b'')

>>> bytearray(12)  #为整数时，返回一个长度为源的初始化数组

bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')

>>> bytearray('python','utf-8')  #为字符串时，按指定编码转换为字节序列

bytearray(b'python')

>>> bytearray([1,2,3])  #可迭代时，必须为0-255中的整数，字节序列

bytearray(b'\x01\x02\x03')

32.filter()

用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的迭代器

语法：filter(function,iterable)     function:判断函数，iterable:可迭代对象

>>> def is_odd(x):

...   return x % 2 == 1    #创建一个过滤奇数的函数

...

>>> newlist = filter(is_odd,[1,2,3,4,5,6,7,8,9])  #使用filter过滤以is_odd函数为判断依据的迭代器

>>> print(newlist)

<filter object at 0x7f544ab79908>

>>> next(newlist)  #使用next打印迭代器的下一个值

1

>>> next(newlist)

3

>>> next(newlist)

5

>>> next(newlist)

7

>>> next(newlist)

9

33.issubclass()

用于判断参数 class 是否是类型参数 classinfo 的子类

class A(object):

    pass

class B(A):


pass

print(issubclass(B,A))  #判断B是否是A的派生类，是返回True，否则返回False

34.pow()

返回x的y次方，如果z存在则再对结果取模（pow(x,y)%z）

>>> pow(6,2)    #6的2次方

36

>>> pow(6,2,5)  #先预算6的2次方，在对结果取5的模

1

>>> pow(8,2)

64

>>> pow(8,2,5)

4

#math模块的pow（）方法对比

>>> import math

>>> math.pow(6,2)    #math模块会把参数转换成float计算

36.0

>>> math.pow(6,2,5)   #math模块中没有取模方法参数

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: pow expected 2 arguments, got 3

35.super()

调用父类的方法

class A(object):

    def __init__(self):

        self.name = 'python'

    def foo(self):

        print('class,A')

class B(A):


super(A)  #调用父类的方法和属性


def foo_b(self):


print('class',self.name)

#print(issubclass(B,A))


bb = B()


bb.foo()


bb.foo_b()

#output


class,A


class python

36.float()

用于将整数和字符串转换成浮点数

>>> float(2)

2.0

>>> float('')

2.0

>>> float(-23)

-23.0

37.iter()

用来生成迭代器

>>> new1 = iter(('a','b','c','e','g'))

>>> new1

<tuple_iterator object at 0x7f544ab7b5f8>

>>> next(new1)

'a'

>>> next(new1)

'b'

38.print()

打印输出

语法：print(*objects,sep=' ',end='\n',file=sys.stdout)

  • objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
  • sep -- 用来间隔多个对象，默认值是一个空格。
  • end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
  • file -- 要写入的文件对象。
>>> print('hello world')

hello world

>>> print('hello world',123)  #多对象打印

hello world 123

>>> print('hello world',123,sep='++')   #多对象打印连接符

hello world++123

>>> print('hello world',123,sep='++',end='\t')  #结尾符设置

hello world++123    >>>

>>> print('hello world',123,sep='++',end='')

hello world++123>>>

39.tuple()

将列表转换成元组

>>> tuple([1,2,3,4,5])   #列表转元组

(1, 2, 3, 4, 5)

>>> tuple({1,2,3,4,5})   #集合转元组

(1, 2, 3, 4, 5)

>>> tuple({1:'a',2:'b',3:'c'})  #字典转元组，只获取自动的key

(1, 2, 3)

40.callable()

检查一个对象是否是可调用的，返回True否则返回False

>>> def func():

...   return 1 + 2

...

>>> func()

3

>>> callable(func)   #对象函数可执行返回True

True

41.format()

格式化字符串，语法通过{}和:来代替以前的%，不限制参数个数，可以不按顺序传参

In [27]: '{}+{}={}'.format(1,2,3)   #格式化按顺序应用参数值

Out[27]: '1+2=3'

In [28]: '{2}-{1}={0}'.format(1,2,3)  #指定顺序应用参数值，0代表第一个元素，1代表第二个元素，以此类推，指定元素位置时要么全部指定，要不都不指定，不能只指定一部分

Out[28]: '3-2=1'

In [29]: '{0}+{0}={1}'.format(2,3)  #指定参数可以重复使用

Out[29]: '2+2=3'

In [30]: '{}+{}={}'.format(2,3)   #如不指定顺序，format参数不够就会报错

---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

<ipython-input-30-29f40e412920> in <module>()

----> 1 '{}+{}={}'.format(2,3)

IndexError: tuple index out of range

In [31]: l1 = [2,4,8]


In [32]: '{}{}={}'.format(l1)   #使用列表引用参数值


Out[32]: '2*4=8'

In [33]: dct = {'name':'python','age':20}   #定义字典


In [35]: 'welcom to {name},age is {age}'.format(name='qi',age=28) #变量引用


Out[35]: 'welcom to qi,age is 28'

In [36]: 'welcom to {name},age is {age}'.format(dct) #使用引用字典参数必须填写key值


Out[36]: 'welcom to python,age is 20'

填充与格式化：


In [53]: "{0: >20}".format("string")   #使用空格填充20宽度右对齐，0代表指定第一个参数值


Out[53]: '              string'

In [54]: "{0:&>20}".format("string")


Out[54]: '&&&&&&&&&&&&&&string'

In [55]: "{0:#>20}".format("string") #使用#号会有个小bug


   ....:


Out[55]: '##############string'

In [60]: '{0:+<20}'.format("string")  #向左对齐填充+


Out[60]: 'string++++++++++++++'

In [61]: '{0:+^20}'.format("string")  #剧中对齐填充+


Out[61]: '+++++++string+++++++'

精度与进制：


>>> '{0:.3f}'.format(10/3)    #小数位进度格式化


'3.333'


>>> '{0:b}'.format(8)    #格式化二进制


''


>>> '{0:o}'.format(9)  #格式化八进制


''


>>> '{0:x}'.format(26) #格式化十六进制


'1a'


>>> '{0:,}'.format(123456789)  #千分位格式化


'123,456,789'

使用索引：


>>> l2 = ['AA',{'bb':'cc'},('d','e')]   #列表索引引用


>>> 'outing:{0[0]}'.format(l2)


'outing:AA'


>>> 'outing:{0[0]},{0[1]}'.format(l2)  #将列表当成一个元素，在其中索引值


"outing:AA,{'bb': 'cc'}"

42.len()

返回对象（字符、列表、元组等）长度或项目个数

>>> len('python')

6

>>> len('')

3

>>> len([1,2,3,4])

4

>>> len((1,2,3,4))

4

>>> len({1:'a',2:'b',3:'c'})

3

>>> len({1,2,3,4})

4

43.property()

在新式类中返回属性值

44.type()

返回对象的类型

>>> type('')

<class 'str'>

>>> type(12)

<class 'int'>

>>> type(12.2)

<class 'float'>

>>> type([])

<class 'list'>

>>> type(())

<class 'tuple'>

>>> type({})

<class 'dict'>

>>> type({1,2,3})

<class 'set'>

45.chr()

返回一个数字在ASCII编码中对应的字符，取值范围256个

>>> chr(1)

'\x01'

>>> chr(11)

'\x0b'

>>> chr(255)

'ÿ'

>>> chr(256)

'Ā'

>>> chr(257)

'ā'

>>> chr(0x31)

''

>>> chr(0x3)

'\x03'

>>> chr(0x11)

'\x11'

46.frozenset()

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

>>> set1 = frozenset([1,2,3,4])  #列表返回一个不可变集合

>>> set1

frozenset({1, 2, 3, 4})

>>> frozenset((5,6,7))  #元祖返回一个不可变集合

frozenset({5, 6, 7})

>>> a

{1: 'a', 2: 'b', 3: 'c'}

>>> frozenset(a)     #字典返回一个不可变集合

frozenset({1, 2, 3})

>>> frozenset({3,4,5})  #集合返回一个不可变集合

frozenset({3, 4, 5})

47.list()

将字符串或元祖转换为列表

>>> l1 = list('python')   #字符串转列表

>>> type(l1)

<class 'list'>

>>> l1

['p', 'y', 't', 'h', 'o', 'n']

>>> list((1,2,3,4,5))  #元祖转列表

[1, 2, 3, 4, 5]

>>> dic1 = {1:'a',2:'b',3:'c'}

>>> list(dic1)   #字典转列表

[1, 2, 3]

>>> list({1,2,3,4})  #集合转列表

[1, 2, 3, 4]

>>> list()   #返回空列表

[]

48.range()

创建一个整数列表

>>> l1 = range(5)

>>> l1

range(0, 5)

>>> for i in l1:    #循环取序列

...   print(i)

...

0

1

2

3

4

>>> for i in range(1,4):print(i)  #指定起始和结束位置

...

1

2

3

>>> for i in range(1,10,3):print(i) #指定起始和结束位置和步长

...

1

4

7

>>> for i in range(0,-10,-4):print(i) #负数以补偿循环

...

0

-4

-8

>>> for i in range(len('python')):print('python'[i]) #字符串循环打印

...

p

y

t

h

o

n

49.vars()

返回当前模块中的所有变量

>>> class runoob:

...   a = 1

...

>>> print(vars(runoob))

{'__dict__': <attribute '__dict__' of 'runoob' objects>, '__module__': '__main__', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'runoob' objects>, 'a': 1}

>>> aa = runoob()

>>> aa

<__main__.runoob object at 0x7f98f1b3c0d0>

>>> print(vars(aa))

{}

50.classmethod()

返回一个类方法，具体实例请看python3之面向对象类定义

51.getattr()

返回一个对象属性值,也就是函数内存地址

class test(object):

    i = 'hello'

    def show(self):

        print('output:',self.i)

obj1 = test()  #实例化对象


ss = getattr(obj1,'show')  #返回一个对象的方法内存地址


ss()   #执行对象方法

#output


output: hello

52.set()

创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等

>>> s1 = set('pythonpython')

>>> s1 = set('pythonpython')  #重复的被删除

>>> s1

{'h', 'n', 'o', 'p', 't', 'y'}

>>> type(s1)

<class 'set'>

>>> s2 = set('pyqi')


>>> s2


{'p', 'y', 'i', 'q'}


>>> s1 & s2  #交集


{'p', 'y'}


>>> s1 | s2  #并集


{'p', 'q', 't', 'i', 'h', 'y', 'n', 'o'}


>>> s1 - s2   #差集i


{'h', 't', 'n', 'o'}

53.locals()

以字典类型返回当前位置的全部局部变量

>>> def funct(*args):   #两个局部变量

...   a = 22

...   print(locals())

...

>>> funct(33,44)    #返回所有局部变量的健值

{'a': 22, 'args': (33, 44)}

54.repr()

将对象转化为供解释器读取的形式

>>> aa = repr([1,2,3])

>>> type(aa)   #将对象转换为字符

<class 'str'>

>>> repr({'a':'A','b':'B'})

"{'a': 'A', 'b': 'B'}"

55.zip()

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

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表

>>> aa = (zip([1,2,3],['a','b','c']))

>>> aa

<zip object at 0x7f98f1893680>

>>> next(aa)

(1, 'a')

>>> next(aa)

(2, 'b')

>>> next(aa)

(3, 'c')

>>> bb = zip([1,2,3],['a','b','c','d'],['A','B','C','D','E'])

>>> bb

<zip object at 0x7f98f18936c8>

>>> next(bb)

(1, 'a', 'A')

>>> next(bb)

(2, 'b', 'B')

>>> next(bb)

(3, 'c', 'C')

56.compile()

将一个字符串编译为字节代码

>>> str = 'for i in range(10):print(i)'

>>> c = compile(str,'','exec')

>>> c

<code object <module> at 0x7f98f1b774b0, file "", line 1>

>>> exec(c)

0

1

2

3

4

5

6

7

8

9

>>> str = '3*5+3'

>>> a = compile(str,'','eval')

>>> eval(a)

18

57.globals()

以字典类型返回当前位置的全部全局变量

>>> a = 'python'

>>> print(globals())   #返回一个全局变量的字典，包括导入的变量

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

58.map()

将函数调用映射到每个序列的对应元素上并返回一个含有所有返回值的列表

>>> def out(x,y):

...   return (x,y)

...

>>> l1 =map(out,[1,2,3,4,5],['a','b','c','d','e'])  #映射序列，返回函数的值

>>> print(list(l1))

[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')]

>>> def foo(x,y):


...   return x*y


...


>>> print(list(map(foo,[2,3,4],[5,6,7])))


[10, 18, 28]

59.reversed()

返回一个反转的迭代器

>>> print(list(reversed(range(10))))  #range反转

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

>>> print(list(reversed(['a','c','f'])))

['f', 'c', 'a']

>>> print(list(reversed(('java','c++','python'))))

['python', 'c++', 'java']

>>> print(list(reversed('python')))

['n', 'o', 'h', 't', 'y', 'p']

60.__import__()

用于动态加载类和函数

61.complex()

返回一个复数

>>> complex(1,2)

(1+2j)

>>> complex('')

(2+0j)

>>> complex('','')    #为字符串时只能指定一位

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: complex() can't take second arg if first is a string

>>> complex('2+3j')

(2+3j)

62.hasattr()

用于判断对象是否包含对应的属性

>>> print(hasattr(list,'append'))

True

>>> print(hasattr(tuple,'append'))

False

>>> print(hasattr(tuple,'index'))

True

>>> print(hasattr(dict,'keys'))

True

>>> print(hasattr(dict,'values'))

True

63.max()

返回给定参数的最大值

>>> max([2,44,55,88])

88

>>> max((3,48))

48

>>> max({1:48,2:23})

2

64.round()

返回浮点数x的四舍五入值

>>> print(round(1.345))

1

>>> print(round(1.345,3))   #3为小数点后位数

1.345

>>> print(round(1.345,2))

1.34

>>> print(round(1.345,1))

1.3

>>> print(round(1.545,1))

1.5

>>> print(round(1.545,2))

1.54

65.delattr()

删除对象的属性

66.hash()

获取一个对象（字符串或者数值等）的哈希值

>>> hash('python')

-7183818677546017823

>>> hash(1)

1

>>> hash(36)

36

>>> hash([1,2,3])   #列表不能取哈希值

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: unhashable type: 'list'

>>> hash(str([1,2,3]))

-1281906435344341319

>>> hash(str({1:'a'}))

-6473938891374685725

>>> hash(str({'':''}))

-5747816388481399936

67.memoryview()

返回字节对象的内存地址

>>> a = bytes([1,2,3])   #定义一个字节对象

>>> a

b'\x01\x02\x03'

>>> memoryview(a)

<memory at 0x7f7cd1bbcb88>

>>> b = memoryview(a)    #返回字节对象的内存地址

>>> b[0]

1

>>> b[1]

2

>>> b[1:4]    #切片取的是一个迭代器

<memory at 0x7f7cd1bbcb88>

>>> b[1:3].tobytes()

b'\x02\x03'

>>> for i in b:print(i)   #迭代取数值

...

1

2

3

后续更新实例。。。。

(二十一)python 3 内置函数的更多相关文章

  1. python基础-内置函数详解

    一.内置函数(python3.x) 内置参数详解官方文档: https://docs.python.org/3/library/functions.html?highlight=built#ascii ...

  2. python_way,day3 集合、函数、三元运算、lambda、python的内置函数、字符转换、文件处理

    python_way,day3 一.集合 二.函数 三.三元运算 四.lambda 五.python的内置函数 六.字符转换 七.文件处理 一.集合: 1.集合的特性: 特性:无序,不重复的序列 如果 ...

  3. python基础——内置函数

    python基础--内置函数  一.内置函数(python3.x) 内置参数详解官方文档: https://docs.python.org/3/library/functions.html?highl ...

  4. Python的内置函数

    python的内置函数一共有68个,下面将简单介绍各个函数的功能. abs() dict() help() min() setattr() all() dir() hex() next() slice ...

  5. 如何查看Python的内置函数

    经常调用的时候不知道python当前版本的内置函数是哪些,可以用下面的指令查看: C:\Users\Administrator>python Python 2.7.11 (v2.7.11:6d1 ...

  6. python print()内置函数

    啦啦啦啦啦啦,我又来了,学习任何东西都得坚持,我一定的好好加油!!! 今天来说说print()函数,前边我们已经用过好好多次啦,现在来学习哈吧!!! Python的内置函数,print() print ...

  7. Python入门-内置函数一

    什么是内置函数?就是python给你提供的拿来直接用的函数,比如print,input等等,截止到python版本3.6.2 python一共提供了68个内置函数,他们就是python直接提供给我们的 ...

  8. Python 集合内置函数大全（非常全！）

    Python集合内置函数操作大全 集合(s).方法名 等价符号 方法说明 s.issubset(t) s <= t 子集测试(允许不严格意义上的子集):s 中所有的元素都是 t 的成员   s ...

  9. Python字典内置函数和方法

    Python字典内置函数和方法: 注:使用了 items.values.keys 返回的是可迭代对象,可以使用 list 转化为列表. len(字典名): 返回键的个数,即字典的长度 # len(字典 ...

随机推荐

  1. linux添加开机启动脚本

    [root@mysql ~]# ll /etc/rc.local lrwxrwxrwx. 1 root root 13 Mar 12 22:20 /etc/rc.local -> rc.d/rc ...

  2. SUSAN角点检测

    close all; clear all; I=imread('corner2.gif'); [posX,posY]=susan(I,); figure; imshow(I);hold on; plo ...

  3. Spark MLlib编程API入门系列之特征选择之向量选择（VectorSlicer）

    不多说,直接上干货! 特征选择里,常见的有:VectorSlicer(向量选择) RFormula(R模型公式) ChiSqSelector(卡方特征选择). VectorSlicer用于从原来的特征 ...

  4. Unity3d的Sprite Packer用法介绍

    我们用来做sprite 的图片,通常会留有很多空白的地方,我们在画完了sprite之后,这些地方很可能就没有什么作用了.如果想避免这些资源上的浪费,我们可以把各个sprite做成图集,把图片上的空间尽 ...

  5. 前端之CSS创建的样式

    CSS即层叠样式表,在创建时有以下几种样式: 1.内联样式(行内样式.行间样式): <标记 style=“属性:属性值:”></标记> 2.内部样式(嵌入式样式): <s ...

  6. websocket 加layim实现在线聊天系统

    实现流程: 1.浏览器连接服务器时保存所有用户id以及对应的唯一session(session用户用户消息推送). 1.1:判断登录用户是否有离线消息(个人消息以及群消息),有则将离线消息进行推送给登 ...

  7. 分布式数据存储 之 Redis(一) —— 初识Redis

    分布式数据存储 之 Redis(一) -- 初识Redis 为什么要学习并运用Redis?Redis有什么好处?我们步入Redis的海洋,初识Redis. 一.Redis是什么 ​ Redis 是一个 ...

  8. Bloom Filter概念和原理【转】

    Bloom Filter概念和原理 Bloom Filter是一种空间效率很高的随机数据结构,它利用位数组很简洁地表示一个集合,并能判断一个元素是否属于这个集合.Bloom Filter的这种高效是有 ...

  9. Hibernate懒加载深入分析

    Hibernate懒加载深入分析 懒加载可以提高性能吗?  不可以简单的说"能",因为Hibernate的关系映射拖累了SQL的性能,所以想出懒加载来弥补.只是弥补而以,不会超越. ...

  10. COGS 942. [東方S3] 比那名居天子

    Problem 1 比那名居天子(tenshi.cpp/c/pas) 题目描述 在幻想乡,比那名居天子是管理着『要石』的天人.『要石』是能够引发和镇压地震的存在,当然也可以用来改变地形.因为在幻想乡引 ...