python的len,abs,str可以直接使用、是因为解释器启动的时候就定义好了。
内置函数 | ||||
abs() | dict() | min() | max() | bool() |
all() | any() | dir() vars() | hex() | slice() |
divmod() | id() | sorted() | enumerate() | input() |
staticmethod() | object() | ascii | oct() | |
bin() | eval() | exec() | int() | open() |
str() | isinstance() | ord() | chr() | sum() |
bytearray() | map() | filter() | reduce() | issubclass() |
list() | pow() | super() | bytes() | float() |
iter() | print() | tuple() | callable() | format() |
len() | property() | type() | frozenset() | range() |
classmethod() | hash() | locals() | globals() | repr() |
zip() | compile() | reversed | __import__() | complex() |
round() | hasattr() | delattr | setattr() | getattr() |
memoryview() | set |
参考:https://www.runoob.com/python/python-built-in-functions.html
# -*- coding:utf-8 -*-
def func(x,y):
return abs(x+y) #abs 取绝对值
print(func(9,-10))
D:\python\python.exe F:/运维笔记/python/函数/函数内置方法.py
1
>>> dict() #函数用于创建一个空字典
{}
>>> dict(a='1',b='2',c='3')
{'c': '3', 'a': '1', 'b': '2'}
>>> m = dict(a='1',b='2',c='3') # 传入关键字
>>> m
{'c': '3', 'a': '1', 'b': '2'}
>>> n = dict(zip(['a','b','c'],[1,2,3])) # 映射函数方式来构造字典
>>> n
{'c': 3, 'a': 1, 'b': 2}
>>> L = dict([('a',1),('b',2),('c',3)]) # 可迭代对象方式来构造字典
>>> L
{'c': 3, 'a': 1, 'b': 2}
>>> a = [1,4,5,-1,2]
>>> min(a)
-1
>>> max(a)
5
>>> min(55,30,20)
20
>>> max(55,30,20)
55
>>> help(bool)
Help on class bool in module builtins:
class bool(int)
| bool(x) -> bool
|
| Returns True when the argument x is true, False otherwise.
#当参数x为真时,|返回True,否则返回False。
| The builtins True and False are the only two instances of the class bool.
| The class bool is a subclass of the class int, and cannot be subclassed.
|
| Method resolution order:
| bool
| int
| object
|
>>> bool(False)
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(-1)
True
#--------------------------------
>>> all([1,4,5,-1,2])
True
>>> all([1,4,5,-1,2,'0']) #'0' 为字符串不是 0
True
>>> all([1,4,5,-1,2,'0',0]) #包含0 所以返回False
False
>>> all([1,4,5,-1,2,'0',False]) #包含False 所以返回False
False
#总结all()函数 返回值中包含 0和False包含任意一个即返回False
#判断空列表
>>> bool([])
False
>>> all([])
True
#--------------------------------------------------------------------------
>>> help(all)
Help on built-in function all in module builtins:
all(iterable, /)
Return True if bool(x) is True for all values x in the iterable.
If the iterable is empty, return True.
用于判断给定的可迭代参数 iterable 是否全部为 False,则返回 False,如果有一个为 True,则返回 True。
元素除了是 0、空、FALSE 外都算 TRUE
>>> any([1, 4, 5, -1, 2])
True
>>> any([1, 4, 5, 0, 2])
True
>>> any([1, 4, 5, -1, 2])
True
>>> any([0,False])
False
>>> any([0,False,1]) #对于bool()有一个True即返回True
True
#--------------------------------------------------------
>>> help(any)
Help on built-in function any in module builtins:
any(iterable, /)
Return True if bool(x) is True for any x in the iterable.
If the iterable is empty, return False.
>>> a = 10
>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a']
>>> vars()
{'__doc__': None, '__spec__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__package__': None, 'a': 10, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__'}
>>> hex(15)
'0xf'
>>> hex(16)
'0x10'
>>> s=slice(5)
>>> s
slice(None, 5, None)
>>> l = list(range(10))
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> l[s]
[0, 1, 2, 3, 4]
>>> help(divmod)
Help on built-in function divmod in module builtins:
divmod(x, y, /)
Return the tuple (x//y, x%y). Invariant: div*y + mod == x.
>>> 10/3
3.3333333333333335
>>> 10//3
3
#-------------------------------------------
>>> divmod(10,3)
(3, 1)
>>> a = "linyaohong"
>>> id(a)
139897178468400
>>> b = [1,2,3]
>>> id(b)
139897038502856
sorted() 函数对所有可迭代的对象进行排序操作
sort 与 sorted 区别:sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作,无返回值,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作
sorted 语法:
sorted(iterable[, cmp[, key[, reverse]]])
参数说明:
- iterable -- 可迭代对象。
- cmp -- 比较的函数,这个具有两个参数,参数的值都是从可迭代对象中取出,此函数必须遵守的规则为,大于则返回1,小于则返回-1,等于则返回0。
- key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
- reverse -- 排序规则,reverse = True 降序 , reverse = False 升序(默认)
>>> a
[5, 7, 6, 3, 4, 1, 2]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5, 6, 7] #元列表被修改
#-----------------------------
>>> a = [5,7,6,3,4,1,2]
>>> sorted(a)
[1, 2, 3, 4, 5, 6, 7]
>>> a
[5, 7, 6, 3, 4, 1, 2] #原列表不被改变
#字典是无序的
>>> d = {}
>>> for i in range(10):
... d[i] = i-50
...
>>> d
{0: -50, 1: -49, 2: -48, 3: -47, 4: -46, 5: -45, 6: -44, 7: -43, 8: -42, 9: -41}
>>> d.items() #把字典变成列表
dict_items([(0, -50), (1, -49), (2, -48), (3, -47), (4, -46), (5, -45), (6, -44), (7, -43), (8, -42), (9, -41)])
>>> sorted(d.items()) #默认排序
[(0, -50), (1, -49), (2, -48), (3, -47), (4, -46), (5, -45), (6, -44), (7, -43), (8, -42), (9, -41)]
>>> sorted(d.items(),key=lambda x:x[1])
[(0, -50), (1, -49), (2, -48), (3, -47), (4, -46), (5, -45), (6, -44), (7, -43), (8, -42), (9, -41)]
>>> d[0]=188
>>> d
{0: 188, 1: -49, 2: -48, 3: -47, 4: -46, 5: -45, 6: -44, 7: -43, 8: -42, 9: -41}
>>> sorted(d.items(),key=lambda x:x[1])
[(1, -49), (2, -48), (3, -47), (4, -46), (5, -45), (6, -44), (7, -43), (8, -42), (9, -41), (0, 188)]
>>> sorted(d.items(),key=lambda x:x[1],reverse=True) #reverse
[(0, 188), (9, -41), (8, -42), (7, -43), (6, -44), (5, -45), (4, -46), (3, -47), (2, -48), (1, -49)]
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中
seq = ['one', 'two', 'three']
for i,p in enumerate(seq):
print(i,p)
D:\python\python.exe F:/运维笔记/python/课堂练习题/enumerate.py
0 one
1 two
2 three
products = [['phone1',100],['phone2',200],['phone3',300],['phone4',500],['phone5',500],['phone6',1800]]
while True:
print("--------商品列表-------")
for index,p in enumerate(products):
print("%s: %s %s" %(index,p[0],p[1]))
D:\python\python.exe F:/运维笔记/python/课堂练习题/enumerate.py
--------商品列表-------
0: phone1 100
1: phone2 200
2: phone3 300
3: phone4 500
4: phone5 500
5: phone6 1800
input() 函数接受一个标准输入数据,返回为 string 类型
raw_input() 将所有输入作为字符串看待,返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性,它返回所输入的数字的类型( int, float )。
注意:input() 和 raw_input() 这两个函数均能接收 字符串 ,但 raw_input() 直接读取控制台的输入(任何类型的输入它都可以接收)。而对于 input() ,它希望能够读取一个合法的 python 表达式,即你输入字符串的时候必须使用引号将它括起来,否则它会引发一个 SyntaxError 。
除非对 input() 有特别需要,否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
注意:python3 里 input() 默认接收到的是 str 类型
>>> a = input("please input:")
please input:linyaohong
>>> type(a)
<class 'str'>
>>> a = input("please input:")
please input:123 #input输入都为str类型
>>> type(a)
<class 'str'>
>>> a = int(input("please input:")) #转为int类型
please input:123
>>> type(a)
<class 'int'>
oct 语法: oct(x)
参数说明: x -- 整数。
返回值: 返回8进制字符串。
>>> oct(7)
'0o7'
>>> oct(8)
'0o10'
>>> oct(9)
'0o11'
bin() 返回一个整数 int 或者长整数 long int 的二进制表示
语法 : bin(x)
参数 : x -- int 或者 long int 数字
返回值 : 字符串
>>> bin(0)
'0b0'
>>> bin(1)
'0b1'
>>> bin(2)
'0b10'
>>> bin(3)
'0b11'
eval() 函数用来执行一个字符串表达式,并返回表达式的值
语法 :eval(expression[, globals[, locals]])
参数
expression -- 表达式。
globals -- 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
返回值 :返回表达式计算结果
>>> f = '1+3/2'
>>> eval(f)
2.5
>>> x = 7
>>> eval('3 * x')
21
>>> eval('3 + x')
10
>>> eval('2 + 2')
4
>>> eval('print("Hello World")') #只能处理单行代码、负载的需要用下文的exec
Hello World
exec()函数 执行储存在字符串或文件中的Python语句,相比于 eval,exec可以执行更复杂的 Python 代码。
需要说明的是在 Python2 中exec不是函数,而是一个内置语句(statement),
但是Python 2中有一个 execfile() 函数。
可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了。
语法 : exec obj
参数 : obj -- 要执行的表达式。
返回值 : exec 返回值永远为 None。 而eval返回值为结果、这也是与eval一个重要区别
>>> exec('print("Hello World")')
Hello World
# -*- coding:utf-8 -*-
code = '''
def test():
print("run test")
print("run test2")
test()
'''
res = exec(code)
print(res)
#D:\python\python.exe F:/运维笔记/python/函数/函数内置方法.py
run test
run test2
None
# -*- coding:utf-8 -*-
res = eval("1+2+3")
res2 = exec("1+2+3")
print("res:",res2)
print("res:",res)
#D:\python\python.exe F:/运维笔记/python/函数/函数内置方法.py
res: None #区别exec返回永远是None
res: 6 #eval返回值
int() 函数用于将一个字符串或数字转换为整型
open() 函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。
https://www.linyaohong.com/blog/python/137.html
str() 函数将对象转化为适于人阅读的形式 (字符串类型https://www.linyaohong.com/blog/python/109.html)
>>> ord("a")
97
>>> ord("L")
76
#---------------
>>> chr(97)
'a'
>>> chr(76)
'L'
>>> a = [3,-1,0,2,6]
>>> a
[3, -1, 0, 2, 6]
>>> sum(a)
10
>>> sum([0,1,2])
3
>>> sum((2, 3, 4), 1)
10
>>> sum([0,1,2,3,4],2)
12
bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256
>>> s
'Linyaohong'
>>> s = s.encode('utf-8')
>>> s
b'Linyaohong'
>>> s[0]
76
>>> s=bytearray(s)
>>> s
bytearray(b'Linyaohong')
>>> s[0]
76
>>> s[0]=77 #在原id(s)内存地址修改s的值、了解即可、大字节修改的时候用到
>>> s
bytearray(b'Minyaohong')
>>> s.decode()
'Minyaohong'
map() 会根据提供的函数对指定序列做映射
第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表
>>> map(lambda x: x*x,[1,2,3,4,5])
<map object at 0x7fd9fa275ac8>
>>> list(map(lambda x: x*x,[1,2,3,4,5]))
[1, 4, 9, 16, 25]
>>> list(map(lambda x: x*1,[1,2,3,4,5]))
[1, 2, 3, 4, 5]
>>> list(map(lambda x: x*2,[1,2,3,4,5]))
[2, 4, 6, 8, 10]
>>> list(map(lambda x: x**x,[1,2,3,4,5]))
[1, 4, 27, 256, 3125]
filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。
该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中
>>> list(filter(lambda x: x>3,[1,2,3,4,5]))
[4, 5]
>>> list(filter(lambda x: x<2,[1,2,3,4,5]))
[1]
#过滤出列表中的所有奇数
# -*- coding: UTF-8 -*-
def test(n):
return n % 2 == 1
newlist = list(filter(test, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
print(newlist)
print(test(3))
#D:\python\python.exe F:/运维笔记/python/函数/函数内置方法.py
[1, 3, 5, 7, 9]
True
reduce() 函数会对参数序列中元素进行累积。
函数将一个数据集合(链表,元组等)中的所有数据进行下列操作:用传给 reduce 中的函数 function(有两个参数)先对集合中的第 1、2 个元素进行操作,得到的结果再与第三个数据用 function 函数运算,最后得到一个结果
>>> sum([1+2+3+4+5])
15
>>> import functools
>>> functools.reduce(lambda x,y:x+y,[1,2,3,4,5],)
15
>>> functools.reduce(lambda x,y:x+y,[1,2,3,4,5],1)
16
>>> functools.reduce(lambda x,y:x+y,[1,2,3,4,5],4)
19
# map filter reduce 三剑客
>>> a = (123, 'xyz', 'zara', 'abc')
>>> s = list(a)
>>> s
[123, 'xyz', 'zara', 'abc']
#----x**y
>>> pow(2,4)
16
>>> pow(2,5)
32
>>> type(pow(2,5))
<class 'int'>
#--- x**y%z
>>> pow(2,5,3)
2
>>> float(1)
1.0
>>> type(float(1))
<class 'float'>
>>> type(1)
<class 'int'>
print() 方法用于打印输出,最常见的一个函数。
print 在 Python3.x 是一个函数,但在 Python2.x 版本不是一个函数,只是一个关键字
>>> s = 'Hello My name is Lin\n from Linyi'
>>> print(s) #print默认最后会换行
Hello My name is Lin
from Linyi
>>>
>>> print(s,end='!')
Hello My name is Lin
from Linyi!>>> #最后为 ! 没有换行,
#------------------sep分割符----------------
>>> print('Linyaohong','Dingqiaoli',sep='-')
Linyaohong-Dingqiaoli
>>> print('Linyaohong','Dingqiaoli',sep='|')
Linyaohong|Dingqiaoli
# -*- coding:utf-8 -*-
msg = "又回到最初的起点"
f = open("test.txt","w")
print(msg,"记忆中你青涩的脸",sep='|',end="",file=f)
print(msg,"记忆中你青涩的脸",sep='|',end="",file=f)
#
D:\python\python.exe F:/运维笔记/python/函数/函数内置方法.py
又回到最初的起点|记忆中你青涩的脸又回到最初的起点|记忆中你青涩的脸 #无换行
>>> tuple([1,2,3,4])
(1, 2, 3, 4)
>>> tuple({1:"a",2:"b"}) #针对字典 会返回字典的key组成的tuple
(1, 2)
>>> tuple((1,2,3,4)) #元组会返回元组自身
(1, 2, 3, 4)
callable() 函数 用于检查一个对象是否是可调用的。如果返回 True,object 仍然可能调用失败;但如果返回 False,调用对象 object 绝对不会成功。
对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True
#如果给了一个变量,是否为 函数可以用callable来判断
>>> a = [1,3,4,5]
>>> def f():
... pass
...
>>> callable(f) #f函数可以调用
True
>>> callable((a)) #不可调用
False
Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数,位置可以不按顺序
print("网站名:{name}, 地址 {url}".format(name="蔺要红", url="www.linyaohong.com"))
# 通过字典设置参数
site = {"name": "蔺要红", "url": "www.linyaohong.com"}
print("网站名:{name}, 地址 {url}".format(**site))
# 通过列表索引设置参数
my_list = ['蔺要红', 'www.linyaohong.com']
print("网站名:{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的
#D:\python\python.exe F:/运维笔记/python/函数/函数内置方法.py
网站名:蔺要红, 地址 www.linyaohong.com
网站名:蔺要红, 地址 www.linyaohong.com
网站名:蔺要红, 地址 www.linyaohong.com
>>> len("Lin Yao")
7
>>> len([1,2,3])
3
>>> len([1,2,3,4])
4
type() 函数如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()
>>> type(1)
<class 'int'>
>>> type('1')
<class 'str'>
>>> type('lin')
<class 'str'>
>>> type({1:'Lin'})
<class 'dict'>
>>> x = 1
>>> type(x) == int #判断类型是否相等
True
isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()
语法:isinstance(object, classinfo)
如果对象的类型与参数二的类型(classinfo)相同则返回 True,否则返回 False
>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list)) # 是元组中的一个返回 True
True
>>> m = {1,3,5,0}
>>> m.discard(0) #删除集合里的内容
>>> m
{1, 3, 5}
>>> n = frozenset(m) #创建不可变集合
>>> n
frozenset({1, 3, 5})
>>> range(10)
range(0, 10)
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] #创建一个列表
>>> list(range(1,7))
[1, 2, 3, 4, 5, 6]
>>> list(range(1,7,3)) #步长3
[1, 4]
>>> range(0)
range(0, 0)
>>> list(range(0)) #空列表
[]
locals() 函数会以字典类型返回 当前名称空间 局部变量。
对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True
globals() 函数会以字典类型返回 当前名称空间 全局变量
>>> locals()
{'__doc__': None, '__spec__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__package__': None, 'a': 10, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__'}
>>> def f(): #定义个函数
... n = 3
... print(locals())
...
>>> f()
{'n': 3} #结果只显示局部变量
>>> m = {'name': 'linyaohong', 'job': 'Linux'}
>>> repr(m)
"{'name': 'linyaohong', 'job': 'Linux'}"
>>> n={12,4}
>>> repr(n)
'{4, 12}'
zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。
我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,
利用 * 号操作符,可以将元组解压为列表
>>> a
[1, 3, 4, 5, 6]
>>> b
['a', 'b', 'c']
>>> list(zip(a,b)) # 元素个数与最短的列表一致
[(1, 'a'), (3, 'b'), (4, 'c')]
>>> a
[1, 3, 4, 5, 6]
>>> reversed(a)
<list_reverseiterator object at 0x7f5e8cb7e6d8>
>>> list(reversed(a)) #顺序反转
[6, 5, 4, 3, 1]
complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
如果第一个参数为字符串,则不需要指定第二个参数
>>> complex(3,4)
(3+4j)
>>> complex(1)
(1+0j)
#待整理
>>> round(1.23124)
1
>>> round(1.23124,2) #保留两位小数
1.23
>>> round(1.00034,2)
1.0
>>> hash('test') #字符串
8933756011063461259
>>> hash(str([1,2,3,4])) #
5939916305192472534
>>> hash(str(sorted({"a":1}))) #字典
752435292895533396
>>> a = [1,2,3,4,5] #把列表变成集合
>>> set(a)
{1, 2, 3, 4, 5}
>>> m = set('hong')
>>> n = set('google')
>>> m,n
({'o', 'n', 'g', 'h'}, {'o', 'l', 'e', 'g'})
>>> m
{'o', 'n', 'g', 'h'}
>>> n
{'o', 'l', 'e', 'g'}
>>> m & n #交集
{'o', 'g'}
>>> m | n #并集
{'n', 'h', 'l', 'g', 'o', 'e'}
>>> m - n #差集
{'n', 'h'}