python学习第十三天,内置函数

Posted 2021-01-01 jiandanxie

1.内置函数的定义:

　　拿来就能用的函数,前面不接对象,区分内置函数与基础数据类型所具有的方法之间的不同

2.内置函数额分类:

　　a.作用域相关:

　　　　globals() 与 locals()

　　　　　　globals():返回一个字典,字典里仅包含全局里的变量

　　　　　　locals():返回一个字典,字典里包含当前层级的所有变量

注意:

def func1():
    global list1
    list1 = [1,3]
    print(locals()) # 返回一个空字典
    print(globals()) # 返回所有全局变量,包括list1
print(list1) # 报错
func1()
print(list1) # 打印list1

 　　b.输入与输出:

　　　　input()与print()

　　　　print()的五种用法:

　　　　　　1.接收一个要打印出来的参数,此参数不能是默认或关键字参数　　

print(a=1) #报错

　　　　　　2.接收多个要打印出来的参数*args,此参数不能是**kwargs

print(*(1,2,3,‘a‘))
# 相当于:
print(1,2,3,‘a‘)

def func1(*args):
    print(*args)
func1(1,2,34)
#1 2 34
def func2(**kwargs):
    print(**kwargs)
func2(a=1)
#报错

　　　　　　3.默认以空格分割一次性传入的多个参数,默认sep=‘‘,可以修改sep=‘|‘

print(1,2) # 1 2
print(1,2,3,sep=‘|‘) # 1|2|3

　　　　　　4.默认每打印一次末尾都带有一个换行符end=‘ ‘,可以将末尾的换行符去除end=‘哈哈哈‘

print(1,2,3,sep=‘|‘,end=‘哈哈哈‘) # end=‘‘
print(123)
#1|2|3哈哈哈123

　　　　　　　5.将内容写入文件,默认file = nome,可修改,file = 文件路径

print(12345,file=open(r‘a.txt‘,encoding=‘utf-8‘,mode=‘w‘))
#在没有该文件的情况下只能用a,w
#有文件可以用r+

 

　　c.内存相关

　　　　id()

　　　　hash() 不可变数据类型可hash,可变数据类型不可hash

　　　　　　     hash:是一种算法,比二分法还快的算法,在字典中的应用最为显著,字典的key必须是不肯变数据类型

　　　　　　　　　　字典会将所有的key转化为对应的相同长度的id(直接去除了名称空间的概念),这样检索数据的速度非常快

dic = {1:‘ad‘,‘a‘:‘asd‘,‘1‘:‘as‘,2:‘adad‘}
print(hash(dic[1])) #-5305738840404791500
print(hash(dic[‘a‘]))
# 数字的hash值是数字本身(字典中的key除外)
a = 123
print(hash(a))
# 123

 　　d.   range() , iter() == __iter__ ,和 next() == __next__

　　　　range()口号内加整数,只有一个参数默认从0开始,顾头不顾尾,可以添加步长-1,2...

　　　　　　　python2: a = range(10)返回的是一个列表list

　　　　　　　　　　　a = xrange(10)返回的是一个迭代器

　　　　　　　python3:a = range(10)返回的是一个可迭代对象range(10)

　　　　iter()可以将可迭代对象转化为迭代器

　　　　next()将迭代器里的内容一个一个输出

　　e. 数据类型:bool() , int() , float() , complex()

　　　　int():将只由数字组成的字符串isdigit,转化为整形

　　　　　　将浮点型取整,转换为整形(不是四舍五入)

　　　　　　将2,8,16进制的数据转化为10进制

a = ‘10.1‘
print(int(a)) # 报错
b = 10.6
print(int(b)) # 10

int(a,8) # a 是八进制的数据

 　　f. 进制转换:

　　　　bin() 10进制转换为2进制

　　　　oct() 10进制转换为8进制

　　　　hex() 10进制转换为16进制

　　g.与数学运算相关:

　　　　abs()绝对值

　　　　divmod(a,b)有两个参数,第一个是除数,地问个是被除数,返回一个元组(a//b,a%b)

　　　　　　　　/ : 得到的商带有小数 , //得到的商是整数(取整,不是四舍五入)

　　　　round() 保留浮点型的小数部分,保留几位小数由第二个参数定,默认保留整数,(四舍五入)

a = 5.5555
print(round(a))
# 6
b = 5.6666
print(round(b,3))
#5.667

　　　　pow() 幂,取余,有两个参数,也可以有三个参数

print(pow(2,3))
# 相当于
print(2**3)

print(pow(2,3,5))
#幂对5的取余,相当于
print(2**3%5)

 　　　　sum()对可迭代对象进行计算求和,默认初始值为0,第二个参数可以设置初始值

list1 = [1,2,3,4]
print(sum(list1)) # 初始值为0
print(sum(list1,100)) # 初始值为100

　　　　　　用sum计算list1 = [1,2,3,‘4‘,‘5‘]的和

list1 = [1,2,3,‘4‘,‘5‘]
print(sum(int(i) for i in list1)) #默认初始值0
print(sum(int(i) for i in list1,100)) #设置初始值会报错

 　　　　min() 返回可迭代对象中的最小值, 第二个参数key可以调用函数(可以是内置函数,也可以是自定义函数)******

# key调用内置函数
min([1,-1,-3,1,4,5],key=abs)

# key调用自定义函数                                                
# 取values中最小值                                               
list1 = [(‘alex‘,1000),(‘taibai‘,18),(‘egon‘,19)]           
def func1(argv):                                            
    return argv[-1]                                         
print(min(list1,key=func1))                                 
                                                            

　　　　max()返回可迭代对象中的最大值, 第二个参数key可以调用函数(可以是内置函数,也可以是自定义函数)******

 

注意字典的取值
dic = {‘a‘:1,‘b‘:2,‘c‘:3}
def func1(argv): #--->只能接收一个参数
    return argv[1]
print(max(dic,key=func1)) #---->这样往里面传的是‘a‘,‘b‘,‘c‘
print(max(dic.items(),key=func1)) #----> 往里传的是 键值对

dic = {‘a‘:1,‘b‘:2,‘c‘:3}
for i in dic.items():
    print(i)
for j in dic.keys(): #== for j in dic:
    print(j)
for v in dic.values():
    print(v)

 　　f.其他相关:

　　　　eval() 去掉引号执行字符串里面的代码,返回里面的结果

　　　　　　简单的应用:

a = ‘1+2+3‘
print(eval(a))
#6

b = ‘[1,2,3,5]‘
print(eval(b),type(eval(b)))
#[1, 2, 3, 5] <class ‘list‘>

　　　　exec()去掉引号执行字符串里面的代码,没有返回结果

　　　　　　(一种危险的应用)用exec函数可以直接打开从文件中读取出来的字符串代码,这种方法容易使计算机感染病毒

　　open()打开文件

　　import 模块的引入

　　help() 帮助

　　callable() 判断一个对象是否是可以调用(函数,类)

　　dir()打印一个对象具有的所有方法