内置函数(***)

1.print() 屏幕输出。

''' 源码分析

def print(self, *args, sep=' ', end='\n', file=None): # known special case of print

"""

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件

sep: 打印多个值之间的分隔符，默认为空格

end: 每一次打印的结尾，默认为换行符

flush: 立即把内容输出到流文件，不作缓存

"""

'''

print(111,222,333,sep='*') # 111*222*333

print(111,end='')

print(222) #两行的结果 111222

f = open('log','w',encoding='utf-8')

print('写入文件',fle=f,flush=True)

2.int, str,bool,set,list,tupie,dict

int():整型

str():字符串

bool():布尔

set(): 集合

list() 将一个可迭代对象转换成列表

tuple() 将一个可迭代对象转换成元组

dict() 通过相应的方式创建字典。

list

l1 = list('abcd')

print(l1) # ['a', 'b', 'c', 'd']

tu1 = tuple('abcd')

print(tu1) # ('a', 'b', 'c', 'd')

3.abs() 返回绝对值

i = -5

print(abs(i)) # 5

4.sum() 求和

print(sum([1,2,3]))

print(sum((1,2,3),100))

5.min() 求最小值

print(min([1,2,3])) # 返回此序列最小值

ret = min([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最小值

print(ret)

# 加key是可以加函数名，min自动会获取传入函数中的参数的每个元素，然后通过你设定的返回值比较大小，返回最小的传入的那个参数。

print(min(1,2,-5,6,-3,key=lambda x:abs(x))) # 可以设置很多参数比较大小

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

print(min(dic,key=lambda x:dic[x]))

# x为dic的key，lambda的返回值(即dic的值进行比较)返回最小的值对应的键

max() 最大值与最小值用法相同。

6.reversed()

将一个序列翻转, 返回翻转序列的迭代器 reversed 示例:

l = reversed('你好') # l 获取到的是一个生成器

print(list(l))

ret = reversed([1, 4, 3, 7, 9])

print(list(ret)) # [9, 7, 3, 4, 1]

7.bytes()转成字节

把字符串转换成bytes类型

s = '你好太白'

bs = s.encode('utf-8')

print(bs)

结果:b'\xe4\xbd\xa0\xe5\xa5\xbd\xe6\xad\xa6\xe5\xa4\xa7'

s1 = bs.decode('utf-8')

print(s1)

结果: 你好太白

s = '你好'

bs = bytes(s,encoding='utf-8')

print(bs)

# 将字符串转换成字节

bs1 = str(bs,encoding='utf-8')

print(bs1)

# 将字节转换成字符串

8.zip() 拉链方法

函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,

然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回

lst1 = [1,2,3]

lst2 = ['a','b','c','d']

lst3 = (11,12,13,14,15)

for i in zip(lst1,lst2,lst3):

print(i)

结果:

(1, 'a', 11)

(2, 'b', 12)

(3, 'c', 13)

9.sorted排序

排序函数

语法:sorted(iterable,key=None,reverse=False)

iterable : 可迭代对象

key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序

reverse :是否是倒叙,True 倒叙 False 正序

lst = [1,3,2,5,4]

lst2 = sorted(lst)

print(lst) #原列表不会改变

print(lst2) #返回的新列表是经过排序的

lst3 = sorted(lst,reverse=True)

print(lst3) #倒叙

结果:

[1, 3, 2, 5, 4]

[1, 2, 3, 4, 5]

[5, 4, 3, 2, 1]

字典使用sorted排序

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

print(sorted(dic)) # 字典排序返回的就是排序后的key

结果:

[1,2,3]

和函数组合使用

# 定义一个列表,然后根据一元素的长度排序

lst = ['天龙八部','西游记','红楼梦','三国演义']

# 计算字符串的长度

def func(s):

return len(s)

print(sorted(lst,key=func))

# 结果:

# ['西游记', '红楼梦', '天龙八部', '三国演义']

和lambda组合使用

lst = ['天龙八部','西游记','红楼梦','三国演义']

print(sorted(lst,key=lambda s:len(s)))

结果:

['西游记', '红楼梦', '天龙八部', '三国演义']

lst = [{'id':1,'name':'alex','age':18},

{'id':2,'name':'wusir','age':17},

{'id':3,'name':'taibai','age':16},]

# 按照年龄对学生信息进行排序

print(sorted(lst,key=lambda e:e['age']))

结果:

[{'id': 3, 'name': 'taibai', 'age': 16}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}]

10.filter筛选过滤

筛选过滤

语法: filter(function,iterable)

function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的True或者False来判断是否保留此项数据

iterable:可迭代对象

lst = [{'id':1,'name':'alex','age':18},

{'id':1,'name':'wusir','age':17},

{'id':1,'name':'taibai','age':16},]

ls = filter(lambda e:e['age'] > 16,lst)

print(list(ls))

结果:

[{'id': 1, 'name': 'alex', 'age': 18},

{'id': 1, 'name': 'wusir', 'age': 17}]

11.map每个值进行映射

映射函数

语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function

计算列表中每个元素的平方,返回新列表

lst = [1,2,3,4,5]

def func(s):

return s*s

mp = map(func,lst)

print(mp)

print(list(mp))

改写成lambda

lst = [1,2,3,4,5]

print(list(map(lambda s:s*s,lst)))

计算两个列表中相同位置的数据的和

lst1 = [1, 2, 3, 4, 5]

lst2 = [2, 4, 6, 8, 10]

print(list(map(lambda x, y: x+y, lst1, lst2)))

结果:

[3, 6, 9, 12, 15]

12.reduce可用来阶乘

from functools import reduce

def func(x,y):

return x + y

# reduce 的使用方式:

# reduce(函数名,可迭代对象) # 这两个参数必须都要有,缺一个不行

ret = reduce(func,[3,4,5,6,7])

print(ret) # 结果 25

reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,

接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始

临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推

注意:我们放进去的可迭代对象没有更改

以上这个例子我们使用sum就可以完全的实现了.我现在有[1,2,3,4]想让列表中的数变成1234,就要用到reduce了.

普通函数版

from functools import reduce

def func(x,y):

return x * 10 + y

# 第一次的时候 x是1 y是2 x乘以10就是10,然后加上y也就是2最终结果是12然后临时存储起来了

# 第二次的时候x是临时存储的值12 x乘以10就是 120 然后加上y也就是3最终结果是123临时存储起来了

# 第三次的时候x是临时存储的值123 x乘以10就是 1230 然后加上y也就是4最终结果是1234然后返回了

l = reduce(func,[1,2,3,4])

print(l)

匿名函数版

l = reduce(lambda x,y:x*10+y,[1,2,3,4])

print(l)

在Python2.x版本中recude是直接 import就可以的, Python3.x版本中需要从functools这个包中导入

龟叔本打算将 lambda 和 reduce 都从全局名字空间都移除, 舆论说龟叔不喜欢lambda 和 reduce

最后lambda没删除是因为和一个人写信写了好多封,进行交流然后把lambda保住了.

13.open()打开文件

open ( "文件名","模式","编码")

14.enumerate()枚举

15.range()生成类列表

16.dir()查看所有操作

如迭代器的__iter__,__next__等

内置函数(**)

1.eval：

执行字符串类型的代码，并返回最终结果。

eval('2 + 2') # 4

n=81

eval("n + 4") # 85

eval('print(666)') # 666

2.exec:

执行字符串类型的代码。

s = '''

for i in [1,2,3]:

print(i)

'''

exec(s)

3.hash：

获取一个对象(可哈希对象：int，str，Bool，tuple)的哈希值。

print(hash(12322))

print(hash('123'))

print(hash('arg'))

print(hash('alex'))

print(hash(True))

print(hash(False))

print(hash((1,2,3)))

'''

-2996001552409009098

-4637515981888139739

1

2528502973977326415

'''

4.help：

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

print(help(list))

print(help(str.split))

5.callable

：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。

name = 'alex'

def func():

pass

print(callable(name)) # False

print(callable(func)) # True

6.int：

函数用于将一个字符串或数字转换为整型。

print(int()) # 0

print(int('12')) # 12

print(int(3.6)) # 3

print(int('0100',base=2)) # 将2进制的 0100 转化成十进制。结果为 4

7.float：

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

8.complex：

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

print(float(3)) # 3.0

print(complex(1,2)) # (1+2j)

9.bin：将十进制转换成二进制并返回。

10.oct：将十进制转化成八进制字符串并返回。

11.hex：将十进制转化成十六进制字符串并返回。

print(bin(10),type(bin(10))) # 0b1010

print(oct(10),type(oct(10))) # 0o12

print(hex(10),type(hex(10))) # 0xa

12.divmod：

计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。

13.round：

保留浮点数的小数位数，默认保留整数。

14.pow：

求x**y次幂。(三个参数为`**y的结果对z取余)

print(divmod(7,2)) # (3, 1)

print(round(7/3,2)) # 2.33

print(round(7/3)) # 2

print(round(3.32567,3)) # 3.326

print(pow(2,3)) # 两个参数为2**3次幂

print(pow(2,3,3)) # 三个参数为2**3次幂，对3取余。

15.bytes：

用于不同编码之间的转化。

# s = '你好'

# bs = s.encode('utf-8')

# print(bs)

# s1 = bs.decode('utf-8')

# print(s1)

# bs = bytes(s,encoding='utf-8')

# print(bs)

# b = '你好'.encode('gbk')

# b1 = b.decode('gbk')

# print(b1.encode('utf-8'))

16.ord:输入字符找该字符编码的位置

17.chr:输入位置数字找出其对应的字符

# ord 输入字符找该字符编码的位置

# print(ord('a'))

# print(ord('中'))

# chr 输入位置数字找出其对应的字符

# print(chr(97))

# print(chr(20013))

18.repr:返回一个对象的string形式(原形毕露)。

# %r 原封不动的写出来

# name = 'taibai'

# print('我叫%r'%name)

# repr 原形毕露

print(repr('{"name":"alex"}'))

print('{"name":"alex"}')

19.all：可迭代对象中，全都是True才是True

20.any：可迭代对象中，有一个True 就是True

# all 可迭代对象中，全都是True才是True

# any 可迭代对象中，有一个True 就是True

# print(all([1,2,True,0]))

# print(any([1,'',0]))

原文：https://www.cnblogs.com/nieice/p/11106602.html