内置函数详解

abs(x)

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

  1. # 如果参数是复数,则返回其大小。
  2. >>> abs(-25)
  3. 25
  4. >>> abs(25)
  5. 25

all(iterable)

all()会循环括号内的每一个元素,如果括号内的所有元素都是真的,或者如果iterable为空,则返回True,如果有一个为假的那么就返回False

  1. >>> all([])
  2. True
  3. >>> all([1,2,3])
  4. True
  5. >>> all([1,2,""])
  6. False
  7. # 如果有一个为假,则都为假
  8. >>> all([1,2,None])
  9. False

假的参数有:False、0、None、""、[]、()、{}等,查看一个元素是否为假可以使用bool进行查看。

any(iterable)

循环元素,如果有一个元素为真,那么就返回True,否则就返回False

  1. >>> any([0,1])
  2. True
  3. >>> any([0])
  4. False

ascii(object)

在对象的类中寻找__repr__方法,获取返回值

  1. >>> class Foo:
  2. ... def __repr__(self):
  3. ... return "hello"
  4. ...
  5. >>> obj = Foo()
  6. >>> r = ascii(obj)
  7. >>> print(r)
  8. # 返回的就是__repr__的返回值,只能是字符串
  9. <__main__.Foo object at 0x000001FDEE13D320>

bin(x)

将整数x转换为二进制字符串,如果x不为Python中int类型,x必须包含方法__index__()并且返回值为integer

  1. # 返回一个整数的二进制
  2. >>> bin(999)
  3. '0b1111100111'
  4. # 非整型的情况,必须包含__index__()方法切返回值为integer的类型
  5. >>> class myType:
  6. ... def __index__(self):
  7. ... return 35
  8. ...
  9. >>> myvar = myType()
  10. >>> bin(myvar)
  11. '0b100011'

bool([x])

查看一个元素的布尔值,非真即假

  1. >>> bool(0)
  2. False
  3. >>> bool(1)
  4. True
  5. >>> bool([1])
  6. True
  7. >>> bool([10])
  8. True

bytearray([source [, encoding [, errors]]])

返回一个byte数组,Bytearray类型是一个可变的序列,并且序列中的元素的取值范围为 [0 ,255]。

source参数:

  1. 如果source为整数,则返回一个长度为source的初始化数组;
  2. 如果source为字符串,则按照指定的encoding将字符串转换为字节序列;
  3. 如果source为可迭代类型,则元素必须为[0 ,255]中的整数;
  4. 如果source为与buffer接口一致的对象,则此对象也可以被用于初始化bytearray;
  1. >>> bytearray(3)
  2. bytearray(b'\x00\x00\x00')

bytes([source[, encoding[, errors]]])

  1. >>> bytes("asdasd",encoding="utf-8")
  2. b'asdasd'

callable(object)

返回一个对象是否可以被执行

  1. >>> def func():
  2. ... return 123
  3. ...
  4. >>> callable(func)
  5. True
  6. >>> func = 123
  7. >>> callable(func)
  8. False

chr(i)

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

  1. >>> chr(66)
  2. 'B'
  3. >>> chr(5)
  4. '\x05'
  5. >>> chr(55)
  6. '7'
  7. >>> chr(255)
  8. '\xff'
  9. >>> chr(25)
  10. '\x19'
  11. >>> chr(65)
  12. 'A'

classmethod(function)

返回函数的类方法

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

把字符串编译成python可执行的代码

  1. >>> str = "for i in range(0,10): print(i)"
  2. >>> c = compile(str,'','exec')
  3. >>> exec(c)
  4. 0
  5. 1
  6. 2
  7. 3
  8. 4
  9. 5
  10. 6
  11. 7
  12. 8
  13. 9

complex([real[, imag]])

创建一个值为real + imag * j的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数

  1. >>> complex(1, 2)
  2. (1+2j)
  3. # 数字
  4. >>> complex(1)
  5. (1+0j)
  6. # 当做字符串处理
  7. >>> complex("1")
  8. (1+0j)
  9. # 注意:这个地方在“+”号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错
  10. >>> complex("1+2j")
  11. (1+2j)

delattr(object, name)

删除对象的属性值

  1. >>> class cls:
  2. ... @classmethod
  3. ... def echo(self):
  4. ... print('CLS')
  5. ...
  6. >>> cls.echo()
  7. CLS
  8. >>> delattr(cls, 'echo')
  9. >>> cls.echo()
  10. Traceback (most recent call last):
  11. File "<stdin>", line 1, in <module>
  12. AttributeError: type object 'cls' has no attribute 'echo'

dict(**kwarg)

创建一个数据类型为字典

  1. >>> dic = dict({"k1":"123","k2":"456"})
  2. >>> dic
  3. {'k1': '123', 'k2': '456'}

dir([object])

返回一个对象中中的所有方法

  1. >>> dir(str)
  2. ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce\_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

divmod(a, b)

返回的是a//b(除法取整)以及a对b的余数,返回结果类型为tuple

  1. >>> divmod(10, 3)
  2. (3, 1)

enumerate(iterable, start=0)

为元素生成下标

  1. >>> li = ["a","b","c"]
  2. >>> for n,k in enumerate(li):
  3. ... print(n,k)
  4. ...
  5. 0 a
  6. 1 b
  7. 2 c

eval(expression, globals=None, locals=None)

把一个字符串当作一个表达式去执行

  1. >>> string = "1 + 3"
  2. >>> string
  3. '1 + 3'
  4. >>> eval(string)
  5. 4

exec(object[, globals[, locals]])

把字符串当作python代码执行

  1. >>> exec("for n in range(5): print(n)")
  2. 0
  3. 1
  4. 2
  5. 3
  6. 4

filter(function, iterable)

筛选过滤,循环可迭代的对象,把迭代的对象当作函数的参数,如果符合条件就返回True,否则就返回False

  1. >>> def func(x):
  2. ... if x == 11 or x == 22:
  3. ... return True
  4. ...
  5. >>> ret = filter(func,[11,22,33,44])
  6. >>> for n in ret:
  7. ... print(n)
  8. ...
  9. 11
  10. 22
  1. >>> list(filter((lambda x: x > 0),range(-5,5)))
  2. [1, 2, 3, 4]

float([x])

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

  1. >>> float("124")
  2. 124.0
  3. >>> float("123.45")
  4. 123.45
  5. >>> float("-123.34")
  6. -123.34

format(value[, format_spec])

字符串格式化

frozenset([iterable])

frozenset是冻结的集合,它是不可变的,存在哈希值,好处是它可以作为字典的key,也可以作为其它集合的元素。缺点是一旦创建便不能更改,没有add,remove方法。

getattr(object, name[, default])

返回对象的命名属性的值,name必须是字符串,如果字符串是对象属性之一的名称,则结果是该属性的值。

globals()

获取或修改当前文件内的全局变量

  1. >>> a = "12"
  2. >>> bsd = "54asd"
  3. >>> globals()
  4. {'__doc__': None, 'a': '12', '__loader__': <class '_frozen_importlib.BuiltinImporter'>, 'bsd': '54asd', '__builtins__': <module 'builtins' (built-in)>, 'n': '__doc__', '__name__': '__main__', '__spec__': None, '__package__': None}

hasattr(object, name)

参数是一个对象和一个字符串,如果字符串是对象的某个属性的名称,则结果为True,否则为False。

hash(object)

返回一个对象的hash值

  1. >>> a = "asdadasdwqeq234sdfdf"
  2. >>> hash(a)
  3. 5390438057823015497

help([object])

查看一个类的所有详细方法,或者查看某个方法的使用详细信息

  1. >>> help(list)
  2. Help on class list in module __builtin__:
  3. class list(object)
  4. | list() -> new empty list
  5. | list(iterable) -> new list initialized from iterable's items
  6. |
  7. | Methods defined here:
  8. |
  9. | __add__(...)
  10. | x.__add__(y) <==> x+y
  11. |
  12. | __contains__(...)
  13. | x.__contains__(y) <==> y in x
  14. |
  15. | __delitem__(...)
  16. | x.__delitem__(y) <==> del x[y]
  17. |
  18. | __delslice__(...)
  19. | x.__delslice__(i, j) <==> del x[i:j]
  20. |
  21. | Use of negative indices is not supported.
  22. ..........

hex(x)

获取一个数的十六进制

  1. >>> hex(13)
  2. '0xd'

id(object)

返回一个对象的内存地址

  1. >>> a = 123
  2. >>> id(a)
  3. 1835400816

input([prompt])

交互式输入

  1. >>> name = input("Pless your name: ")
  2. Pless your name: ansheng
  3. >>> print(name)
  4. ansheng

int(x, base=10)

获取一个数的十进制

  1. >>> int("31")
  2. 31

也可以作为进制转换

  1. >>> int(10)
  2. 10
  3. >>> int('0b11',base=2)
  4. 3
  5. >>> int('11',base=8)
  6. 9
  7. >>> int('0xe',base=16)
  8. 14

isinstance(object, classinfo)

判断对象是否是这个类创建的

  1. >>> li = [11,22,33]
  2. >>> isinstance(li,list)
  3. True

issubclass(class, classinfo)

查看一个对象是否为子类

iter(object[, sentinel])

创建一个可迭代的对象

  1. >>> obj = iter([11,22,33,44])
  2. >>> obj
  3. <list_iterator object at 0x000002477DB25198>
  4. >>> for n in obj:
  5. ... print(n)
  6. ...
  7. 11
  8. 22
  9. 33
  10. 44

len(s)

查看一个对象的长度

  1. >>> url="ansheng.me"
  2. >>> len(url)
  3. 10

list([iterable])

创建一个数据类型为列表

  1. >>> li = list([11,22,33,44])
  2. >>> li
  3. [11, 22, 33, 44]

locals()

返回当前作用域的局部变量,以字典形式输出

  1. >>> func()
  2. >>> def func():
  3. ... name="ansheng"
  4. ... print(locals())
  5. ...
  6. >>> func()
  7. {'name': 'ansheng'}

map(function, iterable, ...)

对一个序列中的每一个元素都传到函数中执行并返回

  1. >>> list(map((lambda x : x +10),[1,2,3,4]))
  2. [11, 12, 13, 14]

max(iterable, *[, key, default])

max(arg1, arg2, *args[, key])

取一个对象中的最大值

  1. >>> li = list([11,22,33,44])
  2. >>> li = [11,22,33,44]
  3. >>> max(li)
  4. 44

memoryview(obj)

返回对象obj的内存查看对象

  1. >>> import struct
  2. >>> buf = struct.pack("i"*12, *list(range(12)))
  3. >>> x = memoryview(buf)
  4. >>> y = x.cast('i', shape=[2,2,3])
  5. >>> print(y.tolist())
  6. [[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]

min(iterable, *[, key, default])

min(arg1, arg2, *args[, key])

取一个对象中的最小值

  1. >>> li = list([11,22,33,44])
  2. >>> li = [11,22,33,44]
  3. >>> min(li)
  4. 11

next(iterator[, default])

每次只拿取可迭代对象的一个元素

  1. >>> obj = iter([11,22,33,44])
  2. >>> next(obj)
  3. 11
  4. >>> next(obj)
  5. 22
  6. >>> next(obj)
  7. 33
  8. >>> next(obj)
  9. 44
  10. >>> next(obj)
  11. # 如果没有可迭代的元素了就会报错
  12. Traceback (most recent call last):
  13. File "<stdin>", line 1, in <module>
  14. StopIteration

object

返回一个新的无特征对象

oct(x)

获取一个字符串的八进制

  1. >>> oct(13)
  2. '0o15'

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

文件操作的函数,用来做文件操作的

  1. # 打开一个文件
  2. >>> f = open("a.txt","r")

ord(c)

把一个字母转换为ASCII对对应表中的数字

  1. >>> ord("a")
  2. 97
  3. >>> ord("t")
  4. 116

pow(x, y[, z])

返回一个数的N次方

  1. >>> pow(2, 10)
  2. 1024
  3. >>> pow(2, 20)
  4. 1048576

print(*objects, sep=' ', end='n', file=sys.stdout, flush=False)

打印输出

  1. >>> print("hello word")
  2. hello word

property(fget=None, fset=None, fdel=None, doc=None)

range(start, stop[, step])

生成一个序列

  1. >>> range(10)
  2. range(0, 10)
  3. >>> for n in range(5):
  4. ... print(n)
  5. ...
  6. 0
  7. 1
  8. 2
  9. 3
  10. 4

repr(object)

返回一个包含对象的可打印表示的字符串

  1. >>> repr(111)
  2. '111'
  3. >>> repr(111.11)
  4. '111.11'

reversed(seq)

对一个对象的元素进行反转

  1. >>> li = [1, 2, 3, 4]
  2. >>> reversed(li)
  3. <list_reverseiterator object at 0x000002CF0EF6A940>
  4. >>> for n in reversed(li):
  5. ... print(n)
  6. ...
  7. 4
  8. 3
  9. 2
  10. 1

round(number[, ndigits])

四舍五入

  1. >>> round(3.3)
  2. 3
  3. >>> round(3.7)
  4. 4

set([iterable])

创建一个数据类型为集合

  1. >>> varss = set([11,222,333])
  2. >>> type(varss)
  3. <class 'set'>

setattr(object, name, value)

为某个对象设置一个属性

slice(start, stop[, step])

元素的切片操作都是调用的这个方法

sorted(iterable, key)

为一个对象的元素进行排序

代码:

  1. #!/usr/bin/env python
  2. # _*_ coding:utf-8 _*_
  3. char=['赵',"123", "1", "25", "65","679999999999", "a","B","alex","c" ,"A", "_", "ᒲ",'a钱','孙','李',"余", '佘',"佗", "㽙", "铱", "钲钲㽙㽙㽙"]
  4. new_chat = sorted(char)
  5. print(new_chat)
  6. for i in new_chat:
  7. print(bytes(i, encoding='utf-8'))

输出结果:

  1. C:\Python35\python.exe F:/Python_code/Note/soretd.py
  2. ['1', '123', '25', '65', '679999999999', 'A', 'B', '_', 'a', 'alex', 'a钱', 'c', 'ᒲ', '㽙', '佗', '佘', '余', '孙', '李', '赵', '钲钲㽙㽙㽙', '铱']
  3. b'1'
  4. b'123'
  5. b'25'
  6. b'65'
  7. b'679999999999'
  8. b'A'
  9. b'B'
  10. b'_'
  11. b'a'
  12. b'alex'
  13. b'a\xe9\x92\xb1'
  14. b'c'
  15. b'\xe1\x92\xb2'
  16. b'\xe3\xbd\x99'
  17. b'\xe4\xbd\x97'
  18. b'\xe4\xbd\x98'
  19. b'\xe4\xbd\x99'
  20. b'\xe5\xad\x99'
  21. b'\xe6\x9d\x8e'
  22. b'\xe8\xb5\xb5'
  23. b'\xe9\x92\xb2\xe9\x92\xb2\xe3\xbd\x99\xe3\xbd\x99\xe3\xbd\x99'
  24. b'\xe9\x93\xb1
  25. Process finished with exit code 0

staticmethod(function)

返回函数的静态方法

str(object=b'', encoding='utf-8', errors='strict')

转换成字符串

  1. >>> a = str(111)
  2. >>> type(a)
  3. <class 'str'>

sum(iterable[, start])

求和

  1. >>> sum([11,22,33])
  2. 66

super([type[, object-or-type]])

执行父类的构造方法

tuple([iterable])

创建一个对象,数据类型为元组

  1. >>> tup = tuple([11,22,33,44])
  2. >>> type(tup)
  3. <class 'tuple'>

type(object)

查看一个对象的数据类型

  1. >>> a = 1
  2. >>> type(a)
  3. <class 'int'>
  4. >>> a = "str"
  5. >>> type(a)
  6. <class 'str

vars([object])

查看一个对象里面有多少个变量

zip(*iterables)

将两个元素相同的序列转换为字典

  1. >>> li1 = ["k1","k2","k3"]
  2. >>> li2 = ["a","b","c"]
  3. >>> d = dict(zip(li1,li2))
  4. >>> d
  5. {'k1': 'a', 'k2': 'b', 'k3': 'c'}

import(name, globals=None, locals=None, fromlist=(), level=0)

导入模块,把导入的模块作为一个别名

python3 内置函数详解的更多相关文章

  1. python3内置函数详解

    内置函数 注:查看详细猛击这里 abs() 对传入参数取绝对值 bool() 对传入参数取布尔值, None, 0, "",[],{},() 这些参数传入bool后,返回False ...

  2. MYSQL常用内置函数详解说明

    函数中可以将字段名当作变量来用,变量的值就是该列对应的所有值:在整理98在线字典数据时(http://zidian.98zw.com/),有这要一个需求,想从多音字duoyinzi字段值提取第一个拼音 ...

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

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

  4. Python内置函数详解

    置顶   内置函数详解 https://docs.python.org/3/library/functions.html?highlight=built#ascii https://docs.pyth ...

  5. Python内置函数详解——总结篇

    2个多月来,将3.5版本中的68个内置函数,按顺序逐个进行了自认为详细的解析,现在是时候进行个总结了.为了方便记忆,将这些内置函数进行了如下分类:     数学运算(7个)     类型转换(24个) ...

  6. 5.python内置函数详解

    内置函数 声明,转载至这位大哥,感谢之至 http://blog.csdn.net/oaa608868/article/details/53506188 关于分类 数学运算(7个) 类型转换(24个) ...

  7. 11_Python的69个内置函数详解

    1.内置函数分类 思维导图: https://www.processon.com/view/link/5dcabc48e4b0bd68d813b24f 2.基础数据类型-和数字相关的函数(14) 数据 ...

  8. python 部分内置函数详解

    简介 eval与exec eval和exec都是python内置的可以执行python代码的函数,但它们之间有所区别. eval(expression[, globals[, locals]]) ex ...

  9. ThinkPHP内置函数详解D、F、S、C、L、A、I

    单字母函数D.F.S.C.L.A.I 他们都在ThinkPHP核心的ThinkPHP/Mode/Api/functions.php这个文件中定义. 下面我分别说明一下他们的功能: D() 加载Mode ...

随机推荐

  1. numpy 命令 ravel 等

    xx.ravel()  :表示把一个矩阵行优先展成一个向量.跟flatten一样. import numpy as np print (np.c_[np.array([[1,2,3],[2,3,5]] ...

  2. CSS 关键的基础知识

    今晚看了 百度传课 一门关于CSS的课程, 感觉不错, 随手记了点儿笔记, 供以后查阅. =================================================== pos ...

  3. 使用Jsoup获取网页内容超时设置

    使用Jsoup获取网页内容超时设置 最近使用Jsoup来抓取网页,并对网页进行解析,发现很好用.在抓取过程中遇到一个问题,有些页面总是报Timeout异常,开始想是不是被抓取网站对IP进行了限制,后来 ...

  4. java网络爬虫实现信息的抓取

    转载请注明出处:http://blog.csdn.NET/lmj623565791/article/details/23272657 今天公司有个需求,需要做一些指定网站查询后的数据的抓取,于是花了点 ...

  5. 2018.09.08 bzoj1531: [POI2005]Bank notes(二进制拆分优化背包)

    传送门 显然不能直接写多重背包. 这题可以用二进制拆分/单调队列优化(感觉二进制好写). 所谓二进制优化,就是把1~c[i]拆分成20,21,...2t,c[i]−2t+1+1" role= ...

  6. [GO]关于go的waitgroup

    watigroup是用来控制一组goroutine的,用来等待一组goroutine结束 比如关于kafka的消费者代码除了生硬的让程序等待一个小时,也可以这样写 package main impor ...

  7. HDU 1503 Advanced Fruits (LCS+DP+递归)

    题意:给定两个字符串,让你求一个最短的字符串,并且这个字符串包含给定的两个. 析:看到这个题,我知道是DP,但是,不会啊...完全没有思路么,我就是个DP渣渣,一直不会做DP. 最后还是参考了一下题解 ...

  8. Java解决高并发方案(帮助你我他)

           一个小型的网站,可以使用最简单的html静态页面就实现了,配合一些图片达到美化效果,所有的页面均存放在一个目录下,这样的网站对系统架构.性能的要求都很简单.随着互联网业务的不断丰富,网站 ...

  9. (连通图 模板题 出度和入度)Network of Schools--POJ--1236

    链接: http://poj.org/problem?id=1236 http://acm.hust.edu.cn/vjudge/contest/view.action?cid=82833#probl ...

  10. HDU1237 简单计算器 2016-07-24 13:34 193人阅读 评论(0) 收藏

    简单计算器 Problem Description 读入一个只包含 +, -, *, / 的非负整数计算表达式,计算该表达式的值. Input 测试输入包含若干测试用例,每个测试用例占一行,每行不超过 ...