14 内置函数(一)

13. 前 方 高能-内置函数 一

一. 本节主要内容:

1.  内置函数

什什么是内置函数? 就是python给你提供的. 拿来直接 用的函数, 比如print., input等等. 截 止到python版本3.6.2 python 一共提供了了68个内置函数. 他们就是python直接提供给我们的. 有 一些我们已经 用过了了. 有 一些还没有 用过. 还有 一些需要学完了了 面向对象才能继续学习的. 今天我们就认识 一下python的内置函数.


abs()
dict()
help()
min()
setattr()

all()
dir()
hex()
next()
slice()

any()
divmod()
id()
object()
sorted()

ascii()
enumerate()
input()
oct()
staticmethod(

bin()
eval()
int()
open()
str()

bool()
exec()
isinstance()
ord()
sum()

bytearray()
filter()
issubclass()
pow()
super()

bytes()
float()
iter()
print()
tuple()

callable()
format()
len()
property()
type()

chr()
frozenset()
list()
range()
vars()

classmethod()
getattr()
locals()
repr()
zip()

compile()
globals()
map()
reversed()
__import__()

complex()
hasattr()
max()
round()

delattr()
hash()
memoryview()
set()

作 用域相关:

locals()
返回当前作 用域中的名字

globals()      返回全局作
用域中的名字

迭代器相关: range()  生成数据

next()             迭代器向下执 行行 一次, 内部实际使 用了了__next__() 方法返回迭代器的下 一个项 目

iter()              获取迭代器, 内部实际使 用的是__iter__()
方法来获取迭代器

字符串串类型代码的执
行行

eval()          执
行行字符串串类型的代码. 并返回最终结果

print(eval("2+2"))                   # 4

n = 8

print(eval("2+n"))                   # 10

def   func(): print(666)

eval("func()")                # 666

exec()         执
行行字符串串类型的代码

exec("""

for    i in range(10): print(i)

""")

exec("""

def func():

print("我是周杰伦")
func()

""")

compile()    将字符串串类型的代码变异. 代码对象能够通过exec语句句来执 行行或者eval()进 行行求

值

‘‘‘

参数说明:

  1. 1.    
    resource 要执 行行的代码, 动态代码 片段

 

  1. 2.    
     文件名, 代码存放的 文件名, 当传 入了了第 一个参数的时候, 这个参数给空就可以了了

 

  1. 3.    
    模式, 取值有3个,

 

  1. 1.   
    exec:  一般放 一些流程语句句的时候

 

  1. 2.   
    eval: resource只存放 一个求值表达式.

 

  1. 3.   
    single: resource存放的代码有交互的时候. mode应为single

‘‘‘

code1 = "for
i in range(10): print(i)" c1 = compile(code1, "", mode="exec") exec(c1)

code2 = "1+2+3"

c2 = compile(code2, "", mode="eval") a
= eval(c2)

print(a)

code3 = "name =
input(‘请输 入你的名字:‘)" c3
= compile(code3, "", mode="single") exec(c3)

print(name)

有返回值的字符串串形式的代码
用eval(). 没有返回值的字符串串形式的代码
用exec().  一般很少 用到compile()

输入和输出相关: input() 获取 用户输入的内容 print() 打印输出

内存相关:

hash() 获取到对象的哈希值(int, str, bool, tuple) id() 获取到对象的内存地址

文件操作相关: open()  用于 口打开
一个 文件, 创建
一个 文件句句柄

模块相关:

__import__()    
用于动态加载类和函数

帮助:

help() 函数 用于查看函数或模块 用途的详细说明调
用相关:

callable()  用于检查
一个对象是否是可调 用的. 如果返回True, object有可能调 用失败, 但如果返回False. 那调 用绝对不会成功查看内置属性:

dir() 查看对象的内置属性,  方法. 访问的是对象中的__dir__()
方法基础数据类型相关:

数字相关: bool() 将给定的数据转换成bool值. 如果不给值. 返回False

int() 将给定的数据转换成int值. 如果不给值, 返回0 float() 将给定的数据转换成float值. 也就是 小数

complex() 创建 一个复数. 第 一个参数为实部, 第 二个参数为虚部. 或者第 一个参数直接 用字符串串来描述复数

进制转换: bin() 将给的参数转换成 二进制

otc() 将给的参数转换成八进制 hex() 将给的参数转换成 十六进制

数学运算: abs() 返回绝对值

divmode() 返回商和余数 round() 四舍五入

pow(a, b) 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余 sum() 求和 min() 求最 小值 max() 求最 大值

和数据结构相关:列列表和元组:

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

reversed() 将
一个序列列翻转, 返回翻转序列列的迭代器 slice() 列列表的切片

st
= " 大家好, 我是麻花藤" s = slice(1, 5, 2) print(st[s])


字符串串相关:

str()
将数据转化成字符串串

format()
与具体数据相关,  用于计算各种
小数, 精算等

# 字符串串

print(format(‘test‘, ‘<20‘))
# 左对 齐

print(format(‘test‘, ‘>20‘))
# 右对 齐

print(format(‘test‘, ‘^20‘))
# 居中

# 数值

print(format(3, ‘b‘))
#  二进制

print(format(97, ‘c‘))
# 转换成unicode字符

print(format(11, ‘d‘))
#  十进制

print(format(11, ‘o‘))
#  八进制

print(format(11, ‘x‘))
#  十六进制( 小写字 母)

print(format(11, ‘X‘))
#  十六进制( 大写字 母)

print(format(11, ‘n‘))
# 和d 一样

print(format(11))   # 和d 一样

# 浮点数

print(format(123456789, ‘e‘))
# 科学计数法. 默认保留留6位 小数

print(format(123456789, ‘0.2e‘))
# 科学计数法. 保留留2位 小数( 小写)

print(format(123456789, ‘0.2E‘))
# 科学计数法. 保留留2位 小数( 大写)

print(format(1.23456789, ‘f‘))
#  小数点计数法. 保留留6位 小数

print(format(1.23456789, ‘0.2f‘))
#  小数点计数法. 保留留2位 小数

print(format(1.23456789, ‘0.10f‘))
#  小数点计数法. 保留留10位 小数

print(format(1.23456789e+10000, ‘F‘))                              #  小数点计数法.

bytes() 把字符串串转化成bytes类型

s =
"你好" bs = s.encode("UTF-8") print(bs)

s1 = bs.decode("UTF-8") print(s1)

bs
= bytes(s, encoding="utf-8")                                 # 把字符串串编码成UTF-8

print(bs)

bytearray()      返回
一个新字节数组. 这个数字
里里的元素是可变的, 并且每个元素的值得范

围是[0,256)

ret = bytearray(‘alex‘,encoding=‘utf-8‘) print(ret[0])

print(ret)

memoryview() 查看bytes在内存中的情况

# 查看bytes字节在内存中的情况
s =
memoryview("麻花藤".encode("utf-8")) print(s)

ord() 输入字符找带字符编码的位置 chr() 输入位置数字找出对应的字符

ascii() 是ascii码中的返回该值 不是就返回\u...

# 找到对应字符的编码位置
print(ord(‘a‘)) print(ord(‘中‘))

#   找到对应编码位置的字符 print(chr(97)) print(chr(20013))

#   在ascii中就返回这个值.
如果不不在就返回\u...

print(ascii(‘a‘))

print(ascii(‘好‘))

repr()     返回
一个对象的string形式

#   repr 就是原封不不动的输出, 引号和转义字符都不不起作
用print(repr(‘ 大家好,\n \t我叫周杰伦‘)) print(‘ 大家好我叫周杰伦‘)

#   %r 
原封不不动的写出来

name
= ‘taibai‘ print(‘我叫%r‘ % name)

数据集合: dict() 创建 一个字典

set()      创建
一个集合

frozenset() 创建 一个冻结的集合. 冻结的集合不能进 行行添加和删除操作其他相关:

len() 返回
一个对象中的元素的个数 sorted() 对可迭代对象进
行行排序操作(讲完lamda后再讲这个) enumerate() 获取集合的枚举对象

lst = ["alex", "wusir", "taibai"] for
index, el in enumerate(lst): print(str(index)+"==>"+el)

all() 可迭代对象中全部是True, 结果才是True any() 可迭代对象中有 一个是True, 结果就是True

print(all([1,2,True,0]))
print(any([1,‘‘,0]))

zip() 函数 用于将可迭代的对象作为参数, 将对象中对应的元素打包成 一个个元组, 然后返回由这些元组组成的开了了表. 如果各个迭代器的元素个数不 一致, 则返回列列表 长度与最短的对象相同.

l1 = [1,2,3,]

l2 = [‘a‘,‘b‘,‘c‘,5]

l3 = (‘*‘,‘**‘,(1,2,3)) for
i in zip(l1,l2,l3):

print(i)

filter() 过滤(讲完lamda) map() 会根据提供的函数对指定序列列做映射(lamda)

# def func():#     a = 10#     print(locals())  # 当前作用域中的内容#     print(globals())  # 全局作用域中的内容#     print("今天内容很简单")# func()

# for i in range(20,15,-3):#     print(i)

# lst = ["大阳哥", "喜欢", "私密的徒步"]# it = iter(lst)  #  __iter__()# print(it.__next__())# print(next(it)) # __next__()# print(next(it))# print(next(it))

# print("李嘉诚", "黄花菜", "马云", sep="*", end="大阳哥") # seperator# input("提示语")

# hash算法:    # 目的是唯一性    # dict 查找效率非常高, hash表.用空间换的时间 比较耗费内存

# s = "大阳哥"# print(hash(s))# a = 12# print(hash(a))

# lst = [1,2,3,4,5,6,7]# # print(hash(lst))    # 列表是不可哈希的# print(hash((1,)))# print(hash("呵呵"))# print(hash("哈哈"))

# 让用户输入一个要导入的模块# import os# name = input("请输入你要导入的模块:")# __import__(name)    # 可以动态导入模块

# print(help(str))

# print(dir(str))

# a = 11.25# print(type(a))

# bin() 把一个十进制的数, 转换成二进制# print(bin(10))  # 二进制# print(hex(10))  # 十六进制# print(oct(10))  # 八进制

# a = 10# print(callable(a))## def func():#     print("马化腾")# print(callable(func))   # 函数是可以被调用的

# s = input("请输入a+b:")# print(eval(s))  # 可以动态的执行代码. 代码必须有返回值

# s = "25*4"# a = eval(s) # 运算# print(a)

# s = "for i in range(10): print(i)"# a = exec(s) # exec 执行代码不返回任何内容# print(a)

# 动态执行代码# exec("""# def func():#     print(" 我是周杰伦")# """ )# func()

# code1 = "for i in range(10): print(i)"# com = compile(code1, "", mode="exec")   # compile并不会执行你的代码.只是编译# exec(com)   # 执行编译的结果## code2 = "5+6+7"# com2 = compile(code2, "", mode="eval")# print(eval(com2))## code3 = "name = input(‘请输入大阳哥的名字:‘)"# com3 = compile(code3, "", mode="single")# exec(com3)# print(name)

# print(abs(-2))  # 绝对值# print(abs(2))

# print(divmod(20,3)) # 求商和余数

# print(round(4.50))   # 五舍六入 => 四舍五入

# print(pow(10,2,3))  # 如果给了第三个参数. 表示最后取余

# print(sum([1,2,3,4,5,6,7,8,9,10]))  # 求和

# lst = "你好啊"# it = reversed(lst)   # 不会改变原列表. 返回一个迭代器, 设计上的一个规则# print(list(it))

# lst = [1, 2, 3, 4, 5, 6, 7]# print(lst[1:3:1])## s = slice(1, 3, 1)  #  切片用的# print(lst[s])

# name = "你好. \n我叫%s周润发" % "李嘉诚"# print(name)# print(repr(name))   # 原样输出,过滤掉转义字符 \n \t \r 不管百分号

# print(ord(‘a‘)) # 97, 返回字母a在编码表中的码位# print(ord(‘中‘)) # 20013 中国的中字在编码表中的位置

# print(chr(65)) # 已知码位. 计算字符# print(chr(20018))## for i in range(65536):#     print(chr(i), end=" ")

# print(ascii("房"))

# s = "李嘉诚的爸爸"# a = s.encode("UTF-8")# print(a)# print(a.decode("GBK"))

# bs = bytes("大阳哥今天很厉害", encoding="utf-8")# print(bs.decode("utf-8"))

# ret =  bytearray("alex" ,encoding =‘utf-8‘)# print(ret[0])# ret[0] = 65# print(str(ret))

# s = memoryview("麻花藤".encode( "utf-8")) # 查看内存# print(s)

# s = "我叫王尼玛"# print(format(s, "^20"))# print(format(s, "<20"))# print(format(s, ">20"))

# print(format(3, ‘b‘ ))   # ?进制# print(format(97, ‘c‘ ))   # 转换成unicode字符# print(format(11, ‘d‘ ))   # ?进制 %d# print(format(11, ‘o‘ ))   # ?进制  8# print(format(11, ‘x‘ ))   # ?六进制(?写字?)# print(format(11, ‘X‘ ))   # ?六进制(?写字?)# print(format(11, ‘n‘ ))   # 和d?样# print(format(11))   # 和d?样

# print(format(123456789, ‘e‘ ))   # 科学计数法. 默认保留6位小数# print(format(123456789, ‘0.2e‘ ))   # 科学计数法. 保留2位小数(小写)# print(format(123456789, ‘0.2E‘ ))   # 科学计数法. 保留2位小数(大写)# print(format(1.23456789, ‘f‘ ))   # 小数点计数法. 保留6位小数# print(format(1.23456789, ‘0.2f‘ ))   # 小数点计数法. 保留2位小数# print(format(1.23456789, ‘0.10f‘))   # 小数点计数法. 保留10位小数# print(format(1.23456789e+3, ‘F‘))   # 小数点计数法. 很大的时候输出 INF

# lst = ["蛋1", "蛋2", "蛋3", "蛋4"]# for i in range(len(lst)):#     print(i)#     print(lst[i])

# for index, el in enumerate(lst, 100):    # 把索引和元素一起获取,索引默认从0开始. 可以更改#     print(index)#     print(el)

# print(any([0, "哈哈", "馒头", True]))

lst1 = ["施瓦辛格", "泰达米尔", "阿米尔汗", "威震天"]lst2 = ["终结者", "英雄联盟", "我的个神啊", "变形金刚"]lst3 = [10000000, 3, 10, 55,66]for el in zip(lst1, lst2, lst3):    print(el)

参考资料料:

https://www.processon.com/mindmap/5de20a11e4b074c442eefe1d

原文地址：https://www.cnblogs.com/Selbst/p/11968379.html

时间： 2024-10-07 11:56:46

14 内置函数(一)的相关文章

14 内置函数

主要内容: 内置函数:就是python给你提供,拿来直接使用的函数. 1. 作用域相关: locals()    返回当前作用域中的名字. globals()  返回全局作用域中的名字. def fn(): a = 10 print(locals()) #当前作用域中的内容,如果在全局作用域中,则显示全局作用域的内容. print(globals()) #全局作用域中的内容 print("今天内容很简单") fn() 2. 迭代器相关: range()    生成数据 for i in

万物之源泉14 内置函数二

一. lamda匿名函数 为了解决一些简单的需求而设计的一句话函数# 计算n的n次方 #先用之前的函数办法 def func(n): return n**2 print(func(9)) #用lambda方法: a = lambda n : n*n print(a(9)) lambda表示的是匿名函数 不需要用def声明 语法: 函数名 = lambda 参数 : 返回值 而匿名函数返回的是lambda,所有函数都叫lambda 注意: 1.函数可以参数可以有多个,多个参数用逗号隔开 2.匿名函

14 内置函数 递归 二分法查找

今日主要内容 1. 昨日补充 repr() 显示出字符串的官方表示形式 chr() ord() 2. 递归 自己调用自己 递归的入口(参数) 和 出口(return) 树形结构的遍历 3. 二分法 掐头结尾取中间 查找效率非常的高 1.递归2.二分法查找 原文地址:https://www.cnblogs.com/work14/p/10209198.html

14、内置函数、递归函数、匿名函数

一.内置函数 # print(abs(-1))# print(all([1,2,3]))# print(all([0,2,3])) # print(all('')) # print(any([0,None,'',1]))# print(any([0,None,'']))# print(any([])) # print(bin(3))# print(hex(17))# print(oct(9)) #0 None 空===>bool值为False,其余都为True # def func():# pa

14，内置函数，和匿名函数

作用域相关: locals :函数会以字典的类型返回当前位置的全部局部变量. globals:函数以字典的类型返回全部全局变量 a = 1 b = 2 print(locals()) print(globals()) # 这两个一样,因为是在全局执行的. #########################################华丽分割线 def func(argv): c = 2 print(locals()) print(globals()) func(3) #这两个不一样,loca

14 python初学（高阶函数 递归函数 内置函数）

高阶函数:1.  函数名是一个变量,函数名可以进行赋值 2. 函数名可以作为函数参数,还可以作为函数返回值(函数名称作为函数返回值时返回的是:函数的地址:print 这个返回值的调用相当于执行这个函数. 函数调用作为函数返回值相当于返回这个函数的执行结果) def f(n): return n*n def foo(a, b, func): return func(a)+func(b) print(foo(1, 2, f)) # >>> 5 递归函数: 调用自身函数 设置结束条件 每次进入

Python中内置函数的介绍

内置函数的功能介绍 常用内置函数如下: 1.abs() 绝对值 格式:abs(x) 例如:print(abs(-18)) >>> 18 返回值:number #该函数主要用于数值类的操作 2.all() 是否都为真 格式:all(iterable) 例如:print(all([1,2,3,])) >>> Ture 返回值:bool #该函数主要用于可迭代对象的操作,主要为列表.元祖.字典和集合.当这些类型的元素中有空字符串.空列表.空元祖.空字典.空集合时,则返回值为F

Day10：内置函数、匿名函数、递归函数

一.内置函数 1.数学运算类 2.集合类操作 内置函数个别使用示例 1.any 集合中的元素有一个为真的时候为真, 特别的,若为空串返回为False 1 print(any([0,''])) 2 print(any([0,'',1])) 执行结果 1 False 2 True 2.divmod 取商得余数,用于做分页显示功能 1 print(divmod(10,3)) #取商得余数,用于做分页显示 执行结果 1 (3, 1) 3.eval  把字符串中的数据结构给提取出来 1 dic={'nam

day23 内置函数，匿名函数，递归

Python之路,Day11 = Python基础11 内置函数divmod(x, y)   # (商, 模)enumerate(可迭代对象)     # (序号,值)eval(字符串) # 把字符串当成命令执行set({1,2,3})   # 可变集合(增删改)frozenset({1,2,3})        # 不可变集合globals()   # 查看全局变量locals()   # 查看局部变量isinstance(3, int)     # 查看3是不是int类型pow(3,3)