python函数 python之函数介绍及使用 python之内置函数

python之函数介绍及使用

 

为什么要用函数？

　　1、减少代码量

　　2、保持一致性

　　3、易维护

一、函数的定义和使用

1 2 3 4 5 6

def  test(参数):               ...      函数体      ...      return  返回值

函数的定义：

　　　　def：表示函数的关键字

　　　　函数名：以后可以根据函数名调用函数，test可以作函数名

　　　　函数体：中间可以做一系列的运算

　　　　参数：为函数提供数据

　　　　返回值（return）：当函数执行完毕后，可以给调用者返回数据。 多个返回元组形式，单个为原形式

  View Code

　　　　形参和实参

　　　　　　形参不占用内存空间，调用时才会占用内存，在调用结束后，才会被释放。实参是给实参进行赋值

 1 def test(x):       # x代表形参
 2     '''
 3     2*x+1
 4     :param x:整形数字
 5     :return:返回计算结果
 6     '''
 7     y = 2*x+1
 8     return y
 9 p = test(3)     # test()表示运行名为test函数，3代表实参，给x进行赋值
10 print(p)

　　　　位置参数：位置要一一对应，不能缺也不能多且不能给同一个形参赋予多个值（会报错）

　　　　关键字参数：位置无需固定，但是缺一不行多一也不行　　

　　　　　 位置参数必须在关键字参数的左边

 1 def test(x,y,z):#x=1,y=2,z=3
 2     print(x)
 3     print(y)
 4     print(z)
 5 
 6 # 位置参数，必须一一对应，缺一不行多一也不行
 7 test(1,2,3)
 8 
 9 # 关键字参数，无须一一对应，缺一不行多一也不行
10 test(y=1,x=3,z=4)
11 
12 # 位置参数必须在关键字参数左边
13 test(1,y=2,3)#报错
14 test(1,3,y=2)#报错
15 test(1,3,z=2)
16 test(1,3,z=2,y=4)#报错
17 test(z=2,1,3)#报错
18 
19 位置参数和关键字参数一起也不能给同一参数赋多个值(会报错)
20 不能缺也不能多

　　　　默认参数　　如果之前给了一个值一个参数，再赋予这个值一个参数，则这个值原有的参数会被覆盖掉

def handle(x, type='mysql'):
    print(x)
    print(type)

handle('hello')                # 调用handle函数，x赋值为hello，type有了默认参数
handle('hello', type='sqlite') # x赋值，type用关键字重新赋值   
handle('hello', 'sqlite')      # 用位置一一对应关系赋值，覆盖type原来的值

结果

hello
mysql                   
hello
sqlite
hello
sqlite    

　　　　参数组（*args列表，**kwargs字典） 非固定长度参数　　*args是以元祖的形式表达

def test(x, *args):
    print(x)
    print(args)


test(1)　　　　　　　　　　　　　　　　 # 只传入x的值，*args默认为空，元组形式
test(1, 2, 3, 4, 5)　　　　　　　　   # 传入x的值后，位置关系对应后，2 3 4 5对应*args以元组形式表达
test(1, {"name": "alex"})　　　　　  # 传入x的值后，有一个字典，整体传入
test(1, ["x", "y", "z"])　　　　　　 # 传入x的值后，有一个列表，整体传入 
test(1,*["x","y","z"])　　　　　　　  # 传入x的值后，列表前面加了个*，则表示遍历，逐一出现表达
test(1,*("x","y","z"))　　　　　　　　# 同上，注意表现形式

结果

1　　　　　　　　　　　　
()　　　　　　　　　　　　　　
1
(2, 3, 4, 5)
1
({'name': 'alex'},)
1
(['x', 'y', 'z'],)
1
('x', 'y', 'z')
1
('x', 'y', 'z')

 　　　　**kwargs

def test(x, **kwargs):
    print(x)
    print(kwargs)       以字典的形式表达

test(1, y=2, z=3)     #y，z为key 后面均为值
test(1,y=2,z=3,z=4)   #会报错：一个参数不能传俩个值

结果
1
{'y': 2, 'z': 3}     

 　　　　*args，**kwargs同时存在，扩展性

def test(x,*args,**kwargs):
    print(x)
    print(args,args[-1])
    print(kwargs,kwargs.get('y'))
# test(1,1,2,1,1,11,1,x=1,y=2,z=3)   #报错，x传了多个值
test(1, 1, 2, 1, 1, 11, 1, y=2, z=3) #1传给x，中间位置参数给*args，关键字参数给**kwargs
test(1,*[1,2,3],**{'y':1})           #1传给x，*[1,2,3]传给*args遍历传，**{'y':1}传给**kwargs

结果
1                                    
(1, 2, 1, 1, 11, 1) 1
{'y': 2, 'z': 3} 2
1
(1, 2, 3) 3
{'y': 1} 1

　　　　全局变量(大写)

　　　　定义：没有缩进的变量

　　　　局部变量(小写)

　　　　定义：子程序下定义的变量

　　　　 global声明是全局变量，nolocal指定上一级变量

　　　　　　如果函数的内容无global关键字

　　　　　　- 有声明局部变量

　　　　　　- 无声明局部变量

　　　　　　　　如果函数的内同有global关键字

　　　　　　- 有声明局部变量

　　　　　　- 无声明局部变量

　　　　　　优先读取局部变量，能读取全局变量，但无法对全局变量重新赋值NAME=“fff”，但是对于可变类型，可以对内部元素进行操作

　　　　　 如果函数中有glabal关键字，变量本质上就是全局的那个变量，可读取可赋值 NAME=“fff”

　　递归函数

　　　　自己调用自己的函数，则为递归

　　　　特性：必须有一个明确的结束条件

　　　　　　　每次进入深一层递归时，问题规模都应有所减少

def calc(n):
    print(n)
    if int(n / 2) == 0:
        return n # 当上面的条件成立后一个真值，返回到函数
    res = calc(int(n / 2))    
    print(n,res) 
    return res # 返回res的值，要将真值一层一层传递回去

calc(10)                                                

 　　　　匿名函数   用lambda去定义

　　　　函数式编程

　　　　　　函数接收的参数是一个函数名

　　　　高阶函数

　　　　　　1、把函数当作一个参数传给另一个函数

　　　　　　2、返回值中包含参数

python之内置函数

 

map

　　　　map(处理逻辑，可遍历的对象)   处理序列中的每个元素，元素个数及位置与原来一样

1 2	v  =  "ALEX"         print ( list ( map ( lambda  x: x.lower(), v)))      # 结果为 ['a', 'l', 'e', 'x']

　　　　更节省代码。

1 2 3 4 5 6 7 8 9

a  =  [] def  jianer(array):      for  i  in  array:          a.append(i.lower())      print (a) jianer(v)   结果 [ 'a' ,  'l' ,  'e' ,  'x' ]

filter

　　　　filter(处理逻辑，可遍历对象)　遍历序列中的每个元素，判断每个元素的布尔值为True则保留元素

1 2 3 4 5 6 7 8 9

movie_people  =  [ 'alex_sb' ,  'wupeiqi_sb' ,  'linhaifeng' ,  'yuanhao_sb' ] def  filter_test(array):      ret  =  []      for  i  in  array:          if  not  i.endswith( 'sb' ):              ret.append(i)      return  ret res  =  filter_test(movie_people) print (res)<br>结果<br>[ 'linhaifeng' ]

1 2	movie_people = [ 'alex_sb' , 'wupeiqi_sb' , 'linhaifeng' , 'yuanhao_sb' ] print ( list ( filter ( lambda  n: n.endswith( 'sb' ), movie_people)))　　　　 # 判断元素endswith的值为True，为True则保留元素<br>结果<br>['alex_sb', 'wupeiqi_sb', 'yuanhao_sb']<br>

reduce

　　　from funtools import reduce

　　　reduce(函数，序列，默认空参数)　处理一个序列，然后把序列进行合并操作

  铺垫例子

1 2 3 4 5

from  functools  import  reduce 　　　　　　　　　　 # reduce 用reduce函数要定义这句话   num_l  =  [ 1 ,  2 ,  3 ,  100 ] print ( reduce ( lambda  x, y: x  +  y, num_l,  1 )) print ( reduce ( lambda  x, y: x  +  y, num_l))

其余内置函数总结

用法如下(缺少的待补充)

　　abs　　取绝对值  参数可以是：负数、正数、浮点数或者长整形；只取绝对值，但是不会取整

print ( abs ( - 1 )) print ( abs ( 1 ))   结果 1 1

　　all　　判断所有里面的元素是否为真值，如果有单个为空则返回True。参数为可迭代对象

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

>>>  all ([ 'a' ,  'b' ,  'c' ,  'd' ])   #列表list，元素都不为空或0 True >>>  all ([ 'a' ,  'b' , ' ', ' d'])    #列表list，存在一个为空的元素 False >>>  all ([ 0 ,  1 ， 2 ,  3 ])            #列表list，存在一个为0的元素 False     >>>  all (( 'a' ,  'b' ,  'c' ,  'd' ))   #元组tuple，元素都不为空或0 True >>>  all (( 'a' ,  'b' , ' ', ' d'))    #元组tuple，存在一个为空的元素 False >>>  all (( 0 ,  1 ， 2 ,  3 ))            #元组tuple，存在一个为0的元素 False         >>>  all ([])  # 空列表 True >>>  all (())  # 空元组 True

　　any　　有一个为真则为真，返回True

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

>>>  any ([ 'a' ,  'b' ,  'c' ,  'd' ])   #列表list，元素都不为空或0 True >>>  any ([ 'a' ,  'b' , ' ', ' d'])   #列表list，存在一个为空的元素 True >>>  any ([ 0 , ' ', False])  #列表list,元素全为0,' ',false False    >>>  any (( 'a' ,  'b' ,  'c' ,  'd' ))   #元组tuple，元素都不为空或0 True >>>  any (( 'a' ,  'b' , ' ', ' d'))   #元组tuple，存在一个为空的元素 True >>>  any (( 0 , ' ', False))    #元组tuple，元素全为0,' ',false False       >>>  any ([])  # 空列表 False >>>  any (())  # 空元组 False

　　bin　　十进制转二进制

1 2 3

print ( bin ( 5 ))   0b101         # 0b表示二进制

　　hex　  十进制转十六进制

1 2 3

print ( hex ( 74 ))   0x4a

　　oct　　十进制转八进制

1 2 3

print ( oct ( 18 ))   0o22

　　bool　 判断布尔值

　　bytes　编码　　ascll码不能编译中文，会报错

1 2 3 4 5 6

name  =  '你好' print (bytes(name,encoding = 'utf8' ))                 # 手动把字符串编码，转为二进制 print (bytes(name,encoding = 'utf8' ).decode( 'utf8' ))  # 需要把字符串进行编码，再解码（用什么方式编码就用什么解码，decode）   b '\xe4\xbd\xa0\xe5\xa5\xbd' 你好

　　dir　　显示函数内置属性和方法

1 2 3

print ( dir ( dict ))   [ '__class__' ,  '__contains__' ,  '__delattr__' ,  '__delitem__' ,  '__dir__' ,  '__doc__' ,  '__eq__' ,  '__format__' ,  '__ge__' ,  '__getattribute__' ,  '__getitem__' ,  '__gt__' ,  '__hash__' ,  '__init__' ,  '__iter__' ,  '__le__' ,  '__len__' ,  '__lt__' ,  '__ne__' ,  '__new__' ,  '__reduce__' ,  '__reduce_ex__' ,  '__repr__' ,  '__setattr__' ,  '__setitem__' ,  '__sizeof__' ,  '__str__' ,  '__subclasshook__' ,  'clear' ,  'copy' ,  'fromkeys' ,  'get' ,  'items' ,  'keys' ,  'pop' ,  'popitem' ,  'setdefault' ,  'update' ,  'values' ]

　　divmod　　得到商和余数（可用作分页用）

1 2 3

print ( divmod ( 10 , 3 ))   ( 3 , 1 )

　　eval　　1、提取字符串的数据结构 2、作字符串中的数据运算

1 2 3 4 5 6

dic = { 'name' : 'alex' }   #字典类型转成字符串 dic_str = str (dic) print (dic_str)   d1 = eval (dic_str)      #eval:把字符串中的数据结构给提取出来 print (d1)

express = "1+2*(3/3-1)-2"
print(eval(express))

输出
-1，0               第二种数据运算

　　hash　　可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型

　　　　　　 hash的作用：从下载的软件判断是否被改变，通过对比hash值，便知道

　　help　　查看函数的用法的详细信息

　　isinstance　　判断类型

1 2 3 4 5 6 7 8 9 10 11

print ( isinstance ( 1 , int ))        #判断是不是int类型 print ( isinstance ( 'abc' , str ))    #判断字符串 print ( isinstance ([], list ))      #判断列表 print ( isinstance ({}, dict ))      #判断字典 print ( isinstance ({ 1 , 2 }, set ))    #判断集合   True True True True True

　　locals

def test():
    age = "18"
    print(globals())    # 输出全局变量
    print(locals())     # 输出上一层的变量

test()


{'test': <function test at 0x000001C869BB9598>, '__file__': 'C:/Users/lenovo/PycharmProjects/untitled/pythons3/内置函数.py', '__spec__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001C869B56CF8>, '__builtins__': <module 'builtins' (built-in)>, '__package__': None, '__cached__': None, '__name__': '__main__', '__doc__': None}
{'age': '18'}

　　max(最大)和min(最小) 　　遍历比较，不同类型间不能比较

list = [99,55,23,11,68]
print(max(list))
print(min(list))

99
11

age_dic={'alex_age':18,'wupei_age':20,'zsc_age':100,'lhf_age':30}
print(max(age_dic.values()))        # 取出最大年龄
print(max(age_dic))                 # 默认比较key

100
zsc_age

　

  年龄比较高级用法

　　zip　一一对应分配

print(list(zip(('a', 'n', 'c'), (1, 2, 3))))
print(list(zip(('a', 'n', 'c'), (1, 2, 3, 4))))
print(list(zip(('a', 'n', 'c', 'd'), (1, 2, 3))))

[('a', 1), ('n', 2), ('c', 3)]
[('a', 1), ('n', 2), ('c', 3)]
[('a', 1), ('n', 2), ('c', 3)]

p={'name':'alex','age':18,'gender':'none'}
print(list(zip(p.keys(),p.values())))
print(list(p.keys()))    #取keys
print(list(p.values()))  #values
print(list(zip(['a','b'],'12345')))   # zip传俩个参数，都是序列。便可一一对应

[('age', 18), ('gender', 'none'), ('name', 'alex')]
['age', 'gender', 'name']
[18, 'none', 'alex']
[('a', '1'), ('b', '2')]

　　　　max和zip结合使用

age = {"alex":25,"tom":30,"tony":55}
print(list(zip(age.values(),age.keys())))       # 一一对应
print(max(zip(age.values(),age.keys())))        # 一一对应取最大值

[(55, 'tony'), (25, 'alex'), (30, 'tom')]
(55, 'tony')

dic={'age1':18,'age2':10}
print(max(dic))           # 比较的是key
print(max(dic.values()))  # 比较的是值，但是不知道对应的哪个key
print(max(zip(dic.values(),dic.keys()))) # 通过zip，便可以获取到值最大，对应的是哪个key

age2
18
(18, 'age1')

　　pow 几的几次方

print(pow(3,3))
print(pow(2,3,2))

27          # 3**3   3的3次方
0           # 2**3%2 2的3次方取余

　　reversed　　反转

li = [1,2,3,4]
print(list(reversed(li)))     # 反转

[4, 3, 2, 1]      

　　round　　四舍五入

print(round(4.3))

4

　　set  变集合，记得集合的特性

print(set("hello"))

{'o', 'l', 'h', 'e'}

　　slice 切片，可以指定步长

l='hello'
s1=slice(3,5)     # 切片 取3到5的元素
s2=slice(1,4,2)  # 切片，指定步长为2
print(l[3:5])

print(l[s1])         # 切片
print(l[s2])    

print(s2.start)    # 开始
print(s2.stop)    # 结束
print(s2.step)    # 步长

lo
lo
el
1
4
2

　　sorted 排序(排序本质上就是在比较大小，不同类型间不能比较)

l=[3,2,1,5,7]
l1=[3,2,'a',1,5,7]
print(sorted(l))       # 排序
# print(sorted(l1))    # 会报错

[1, 2, 3, 5, 7]

　　sum 求和

1 li = [1,2,3,4]
2 print(sum(li))
3 print(sum(range(101)))
4 
5 10
6 5050

　　type 判断数据类型

vars

　　　　里面如果没有参数，和locals用法相

　　　　如果里面有一个参数，查看某一个方法，并显示成字典的类型

　　import 导入模块(就是导入一个py文件)      

　　　　粗略用法，不能导入字符串类型(以后可能会这种需求)

　　__import__　可以导入有字符串模块儿

　　　　粗略用法

　　　　　

 

 

为什么要用函数？

　　1、减少代码量

　　2、保持一致性

　　3、易维护

一、函数的定义和使用

1 2 3 4 5 6

def  test(参数):               ...      函数体      ...      return  返回值

函数的定义：

　　　　def：表示函数的关键字

　　　　函数名：以后可以根据函数名调用函数，test可以作函数名

　　　　函数体：中间可以做一系列的运算

　　　　参数：为函数提供数据

　　　　返回值（return）：当函数执行完毕后，可以给调用者返回数据。 多个返回元组形式，单个为原形式

  View Code

　　　　形参和实参

　　　　　　形参不占用内存空间，调用时才会占用内存，在调用结束后，才会被释放。实参是给实参进行赋值

 1 def test(x):       # x代表形参
 2     '''
 3     2*x+1
 4     :param x:整形数字
 5     :return:返回计算结果
 6     '''
 7     y = 2*x+1
 8     return y
 9 p = test(3)     # test()表示运行名为test函数，3代表实参，给x进行赋值
10 print(p)

　　　　位置参数：位置要一一对应，不能缺也不能多且不能给同一个形参赋予多个值（会报错）

　　　　关键字参数：位置无需固定，但是缺一不行多一也不行　　

　　　　　 位置参数必须在关键字参数的左边

 1 def test(x,y,z):#x=1,y=2,z=3
 2     print(x)
 3     print(y)
 4     print(z)
 5 
 6 # 位置参数，必须一一对应，缺一不行多一也不行
 7 test(1,2,3)
 8 
 9 # 关键字参数，无须一一对应，缺一不行多一也不行
10 test(y=1,x=3,z=4)
11 
12 # 位置参数必须在关键字参数左边
13 test(1,y=2,3)#报错
14 test(1,3,y=2)#报错
15 test(1,3,z=2)
16 test(1,3,z=2,y=4)#报错
17 test(z=2,1,3)#报错
18 
19 位置参数和关键字参数一起也不能给同一参数赋多个值(会报错)
20 不能缺也不能多

　　　　默认参数　　如果之前给了一个值一个参数，再赋予这个值一个参数，则这个值原有的参数会被覆盖掉

def handle(x, type='mysql'):
    print(x)
    print(type)

handle('hello')                # 调用handle函数，x赋值为hello，type有了默认参数
handle('hello', type='sqlite') # x赋值，type用关键字重新赋值   
handle('hello', 'sqlite')      # 用位置一一对应关系赋值，覆盖type原来的值

结果

hello
mysql                   
hello
sqlite
hello
sqlite    

　　　　参数组（*args列表，**kwargs字典） 非固定长度参数　　*args是以元祖的形式表达

def test(x, *args):
    print(x)
    print(args)


test(1)　　　　　　　　　　　　　　　　 # 只传入x的值，*args默认为空，元组形式
test(1, 2, 3, 4, 5)　　　　　　　　   # 传入x的值后，位置关系对应后，2 3 4 5对应*args以元组形式表达
test(1, {"name": "alex"})　　　　　  # 传入x的值后，有一个字典，整体传入
test(1, ["x", "y", "z"])　　　　　　 # 传入x的值后，有一个列表，整体传入 
test(1,*["x","y","z"])　　　　　　　  # 传入x的值后，列表前面加了个*，则表示遍历，逐一出现表达
test(1,*("x","y","z"))　　　　　　　　# 同上，注意表现形式

结果

1　　　　　　　　　　　　
()　　　　　　　　　　　　　　
1
(2, 3, 4, 5)
1
({'name': 'alex'},)
1
(['x', 'y', 'z'],)
1
('x', 'y', 'z')
1
('x', 'y', 'z')

 　　　　**kwargs

def test(x, **kwargs):
    print(x)
    print(kwargs)       以字典的形式表达

test(1, y=2, z=3)     #y，z为key 后面均为值
test(1,y=2,z=3,z=4)   #会报错：一个参数不能传俩个值

结果
1
{'y': 2, 'z': 3}     

 　　　　*args，**kwargs同时存在，扩展性

def test(x,*args,**kwargs):
    print(x)
    print(args,args[-1])
    print(kwargs,kwargs.get('y'))
# test(1,1,2,1,1,11,1,x=1,y=2,z=3)   #报错，x传了多个值
test(1, 1, 2, 1, 1, 11, 1, y=2, z=3) #1传给x，中间位置参数给*args，关键字参数给**kwargs
test(1,*[1,2,3],**{'y':1})           #1传给x，*[1,2,3]传给*args遍历传，**{'y':1}传给**kwargs

结果
1                                    
(1, 2, 1, 1, 11, 1) 1
{'y': 2, 'z': 3} 2
1
(1, 2, 3) 3
{'y': 1} 1

　　　　全局变量(大写)

　　　　定义：没有缩进的变量

　　　　局部变量(小写)

　　　　定义：子程序下定义的变量

　　　　 global声明是全局变量，nolocal指定上一级变量

　　　　　　如果函数的内容无global关键字

　　　　　　- 有声明局部变量

　　　　　　- 无声明局部变量

　　　　　　　　如果函数的内同有global关键字

　　　　　　- 有声明局部变量

　　　　　　- 无声明局部变量

　　　　　　优先读取局部变量，能读取全局变量，但无法对全局变量重新赋值NAME=“fff”，但是对于可变类型，可以对内部元素进行操作

　　　　　 如果函数中有glabal关键字，变量本质上就是全局的那个变量，可读取可赋值 NAME=“fff”

　　递归函数

　　　　自己调用自己的函数，则为递归

　　　　特性：必须有一个明确的结束条件

　　　　　　　每次进入深一层递归时，问题规模都应有所减少

def calc(n):
    print(n)
    if int(n / 2) == 0:
        return n # 当上面的条件成立后一个真值，返回到函数
    res = calc(int(n / 2))    
    print(n,res) 
    return res # 返回res的值，要将真值一层一层传递回去

calc(10)                                                

 　　　　匿名函数   用lambda去定义

　　　　函数式编程

　　　　　　函数接收的参数是一个函数名

　　　　高阶函数

　　　　　　1、把函数当作一个参数传给另一个函数

　　　　　　2、返回值中包含参数

python之内置函数

 

map

　　　　map(处理逻辑，可遍历的对象)   处理序列中的每个元素，元素个数及位置与原来一样

1 2	v  =  "ALEX"         print ( list ( map ( lambda  x: x.lower(), v)))      # 结果为 ['a', 'l', 'e', 'x']

　　　　更节省代码。

1 2 3 4 5 6 7 8 9

a  =  [] def  jianer(array):      for  i  in  array:          a.append(i.lower())      print (a) jianer(v)   结果 [ 'a' ,  'l' ,  'e' ,  'x' ]

filter

　　　　filter(处理逻辑，可遍历对象)　遍历序列中的每个元素，判断每个元素的布尔值为True则保留元素

1 2 3 4 5 6 7 8 9

movie_people  =  [ 'alex_sb' ,  'wupeiqi_sb' ,  'linhaifeng' ,  'yuanhao_sb' ] def  filter_test(array):      ret  =  []      for  i  in  array:          if  not  i.endswith( 'sb' ):              ret.append(i)      return  ret res  =  filter_test(movie_people) print (res)<br>结果<br>[ 'linhaifeng' ]

1 2	movie_people = [ 'alex_sb' , 'wupeiqi_sb' , 'linhaifeng' , 'yuanhao_sb' ] print ( list ( filter ( lambda  n: n.endswith( 'sb' ), movie_people)))　　　　 # 判断元素endswith的值为True，为True则保留元素<br>结果<br>['alex_sb', 'wupeiqi_sb', 'yuanhao_sb']<br>

reduce

　　　from funtools import reduce

　　　reduce(函数，序列，默认空参数)　处理一个序列，然后把序列进行合并操作

  铺垫例子

1 2 3 4 5

from  functools  import  reduce 　　　　　　　　　　 # reduce 用reduce函数要定义这句话   num_l  =  [ 1 ,  2 ,  3 ,  100 ] print ( reduce ( lambda  x, y: x  +  y, num_l,  1 )) print ( reduce ( lambda  x, y: x  +  y, num_l))

其余内置函数总结

用法如下(缺少的待补充)

　　abs　　取绝对值  参数可以是：负数、正数、浮点数或者长整形；只取绝对值，但是不会取整

print ( abs ( - 1 )) print ( abs ( 1 ))   结果 1 1

　　all　　判断所有里面的元素是否为真值，如果有单个为空则返回True。参数为可迭代对象

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

>>>  all ([ 'a' ,  'b' ,  'c' ,  'd' ])   #列表list，元素都不为空或0 True >>>  all ([ 'a' ,  'b' , ' ', ' d'])    #列表list，存在一个为空的元素 False >>>  all ([ 0 ,  1 ， 2 ,  3 ])            #列表list，存在一个为0的元素 False     >>>  all (( 'a' ,  'b' ,  'c' ,  'd' ))   #元组tuple，元素都不为空或0 True >>>  all (( 'a' ,  'b' , ' ', ' d'))    #元组tuple，存在一个为空的元素 False >>>  all (( 0 ,  1 ， 2 ,  3 ))            #元组tuple，存在一个为0的元素 False         >>>  all ([])  # 空列表 True >>>  all (())  # 空元组 True

　　any　　有一个为真则为真，返回True

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

>>>  any ([ 'a' ,  'b' ,  'c' ,  'd' ])   #列表list，元素都不为空或0 True >>>  any ([ 'a' ,  'b' , ' ', ' d'])   #列表list，存在一个为空的元素 True >>>  any ([ 0 , ' ', False])  #列表list,元素全为0,' ',false False    >>>  any (( 'a' ,  'b' ,  'c' ,  'd' ))   #元组tuple，元素都不为空或0 True >>>  any (( 'a' ,  'b' , ' ', ' d'))   #元组tuple，存在一个为空的元素 True >>>  any (( 0 , ' ', False))    #元组tuple，元素全为0,' ',false False       >>>  any ([])  # 空列表 False >>>  any (())  # 空元组 False

　　bin　　十进制转二进制

1 2 3

print ( bin ( 5 ))   0b101         # 0b表示二进制

　　hex　  十进制转十六进制

1 2 3

print ( hex ( 74 ))   0x4a

　　oct　　十进制转八进制

1 2 3

print ( oct ( 18 ))   0o22

　　bool　 判断布尔值

　　bytes　编码　　ascll码不能编译中文，会报错

1 2 3 4 5 6

name  =  '你好' print (bytes(name,encoding = 'utf8' ))                 # 手动把字符串编码，转为二进制 print (bytes(name,encoding = 'utf8' ).decode( 'utf8' ))  # 需要把字符串进行编码，再解码（用什么方式编码就用什么解码，decode）   b '\xe4\xbd\xa0\xe5\xa5\xbd' 你好

　　dir　　显示函数内置属性和方法

1 2 3

print ( dir ( dict ))   [ '__class__' ,  '__contains__' ,  '__delattr__' ,  '__delitem__' ,  '__dir__' ,  '__doc__' ,  '__eq__' ,  '__format__' ,  '__ge__' ,  '__getattribute__' ,  '__getitem__' ,  '__gt__' ,  '__hash__' ,  '__init__' ,  '__iter__' ,  '__le__' ,  '__len__' ,  '__lt__' ,  '__ne__' ,  '__new__' ,  '__reduce__' ,  '__reduce_ex__' ,  '__repr__' ,  '__setattr__' ,  '__setitem__' ,  '__sizeof__' ,  '__str__' ,  '__subclasshook__' ,  'clear' ,  'copy' ,  'fromkeys' ,  'get' ,  'items' ,  'keys' ,  'pop' ,  'popitem' ,  'setdefault' ,  'update' ,  'values' ]

　　divmod　　得到商和余数（可用作分页用）

1 2 3

print ( divmod ( 10 , 3 ))   ( 3 , 1 )

　　eval　　1、提取字符串的数据结构 2、作字符串中的数据运算

1 2 3 4 5 6

dic = { 'name' : 'alex' }   #字典类型转成字符串 dic_str = str (dic) print (dic_str)   d1 = eval (dic_str)      #eval:把字符串中的数据结构给提取出来 print (d1)

express = "1+2*(3/3-1)-2"
print(eval(express))

输出
-1，0               第二种数据运算

　　hash　　可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型

　　　　　　 hash的作用：从下载的软件判断是否被改变，通过对比hash值，便知道

　　help　　查看函数的用法的详细信息

　　isinstance　　判断类型

1 2 3 4 5 6 7 8 9 10 11

print ( isinstance ( 1 , int ))        #判断是不是int类型 print ( isinstance ( 'abc' , str ))    #判断字符串 print ( isinstance ([], list ))      #判断列表 print ( isinstance ({}, dict ))      #判断字典 print ( isinstance ({ 1 , 2 }, set ))    #判断集合   True True True True True

　　locals

def test():
    age = "18"
    print(globals())    # 输出全局变量
    print(locals())     # 输出上一层的变量

test()


{'test': <function test at 0x000001C869BB9598>, '__file__': 'C:/Users/lenovo/PycharmProjects/untitled/pythons3/内置函数.py', '__spec__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001C869B56CF8>, '__builtins__': <module 'builtins' (built-in)>, '__package__': None, '__cached__': None, '__name__': '__main__', '__doc__': None}
{'age': '18'}

　　max(最大)和min(最小) 　　遍历比较，不同类型间不能比较

list = [99,55,23,11,68]
print(max(list))
print(min(list))

99
11

age_dic={'alex_age':18,'wupei_age':20,'zsc_age':100,'lhf_age':30}
print(max(age_dic.values()))        # 取出最大年龄
print(max(age_dic))                 # 默认比较key

100
zsc_age

　

  年龄比较高级用法

　　zip　一一对应分配

print(list(zip(('a', 'n', 'c'), (1, 2, 3))))
print(list(zip(('a', 'n', 'c'), (1, 2, 3, 4))))
print(list(zip(('a', 'n', 'c', 'd'), (1, 2, 3))))

[('a', 1), ('n', 2), ('c', 3)]
[('a', 1), ('n', 2), ('c', 3)]
[('a', 1), ('n', 2), ('c', 3)]

p={'name':'alex','age':18,'gender':'none'}
print(list(zip(p.keys(),p.values())))
print(list(p.keys()))    #取keys
print(list(p.values()))  #values
print(list(zip(['a','b'],'12345')))   # zip传俩个参数，都是序列。便可一一对应

[('age', 18), ('gender', 'none'), ('name', 'alex')]
['age', 'gender', 'name']
[18, 'none', 'alex']
[('a', '1'), ('b', '2')]

　　　　max和zip结合使用

age = {"alex":25,"tom":30,"tony":55}
print(list(zip(age.values(),age.keys())))       # 一一对应
print(max(zip(age.values(),age.keys())))        # 一一对应取最大值

[(55, 'tony'), (25, 'alex'), (30, 'tom')]
(55, 'tony')

dic={'age1':18,'age2':10}
print(max(dic))           # 比较的是key
print(max(dic.values()))  # 比较的是值，但是不知道对应的哪个key
print(max(zip(dic.values(),dic.keys()))) # 通过zip，便可以获取到值最大，对应的是哪个key

age2
18
(18, 'age1')

　　pow 几的几次方

print(pow(3,3))
print(pow(2,3,2))

27          # 3**3   3的3次方
0           # 2**3%2 2的3次方取余

　　reversed　　反转

li = [1,2,3,4]
print(list(reversed(li)))     # 反转

[4, 3, 2, 1]      

　　round　　四舍五入

print(round(4.3))

4

　　set  变集合，记得集合的特性

print(set("hello"))

{'o', 'l', 'h', 'e'}

　　slice 切片，可以指定步长

l='hello'
s1=slice(3,5)     # 切片 取3到5的元素
s2=slice(1,4,2)  # 切片，指定步长为2
print(l[3:5])

print(l[s1])         # 切片
print(l[s2])    

print(s2.start)    # 开始
print(s2.stop)    # 结束
print(s2.step)    # 步长

lo
lo
el
1
4
2

　　sorted 排序(排序本质上就是在比较大小，不同类型间不能比较)

l=[3,2,1,5,7]
l1=[3,2,'a',1,5,7]
print(sorted(l))       # 排序
# print(sorted(l1))    # 会报错

[1, 2, 3, 5, 7]

　　sum 求和

1 li = [1,2,3,4]
2 print(sum(li))
3 print(sum(range(101)))
4 
5 10
6 5050

　　type 判断数据类型

vars

　　　　里面如果没有参数，和locals用法相

　　　　如果里面有一个参数，查看某一个方法，并显示成字典的类型

　　import 导入模块(就是导入一个py文件)      

　　　　粗略用法，不能导入字符串类型(以后可能会这种需求)

　　__import__　可以导入有字符串模块儿

　　　　粗略用法

　　　　　

 

 

map

　　　　map(处理逻辑，可遍历的对象)   处理序列中的每个元素，元素个数及位置与原来一样

1 2	v  =  "ALEX"         print ( list ( map ( lambda  x: x.lower(), v)))      # 结果为 ['a', 'l', 'e', 'x']

　　　　更节省代码。

1 2 3 4 5 6 7 8 9

a  =  [] def  jianer(array):      for  i  in  array:          a.append(i.lower())      print (a) jianer(v)   结果 [ 'a' ,  'l' ,  'e' ,  'x' ]

filter

　　　　filter(处理逻辑，可遍历对象)　遍历序列中的每个元素，判断每个元素的布尔值为True则保留元素

1 2 3 4 5 6 7 8 9

movie_people  =  [ 'alex_sb' ,  'wupeiqi_sb' ,  'linhaifeng' ,  'yuanhao_sb' ] def  filter_test(array):      ret  =  []      for  i  in  array:          if  not  i.endswith( 'sb' ):              ret.append(i)      return  ret res  =  filter_test(movie_people) print (res)<br>结果<br>[ 'linhaifeng' ]

1 2	movie_people = [ 'alex_sb' , 'wupeiqi_sb' , 'linhaifeng' , 'yuanhao_sb' ] print ( list ( filter ( lambda  n: n.endswith( 'sb' ), movie_people)))　　　　 # 判断元素endswith的值为True，为True则保留元素<br>结果<br>['alex_sb', 'wupeiqi_sb', 'yuanhao_sb']<br>

reduce

　　　from funtools import reduce

　　　reduce(函数，序列，默认空参数)　处理一个序列，然后把序列进行合并操作

  铺垫例子

1 2 3 4 5

from  functools  import  reduce 　　　　　　　　　　 # reduce 用reduce函数要定义这句话   num_l  =  [ 1 ,  2 ,  3 ,  100 ] print ( reduce ( lambda  x, y: x  +  y, num_l,  1 )) print ( reduce ( lambda  x, y: x  +  y, num_l))

其余内置函数总结

用法如下(缺少的待补充)

　　abs　　取绝对值  参数可以是：负数、正数、浮点数或者长整形；只取绝对值，但是不会取整

print ( abs ( - 1 )) print ( abs ( 1 ))   结果 1 1

　　all　　判断所有里面的元素是否为真值，如果有单个为空则返回True。参数为可迭代对象

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

>>>  all ([ 'a' ,  'b' ,  'c' ,  'd' ])   #列表list，元素都不为空或0 True >>>  all ([ 'a' ,  'b' , ' ', ' d'])    #列表list，存在一个为空的元素 False >>>  all ([ 0 ,  1 ， 2 ,  3 ])            #列表list，存在一个为0的元素 False     >>>  all (( 'a' ,  'b' ,  'c' ,  'd' ))   #元组tuple，元素都不为空或0 True >>>  all (( 'a' ,  'b' , ' ', ' d'))    #元组tuple，存在一个为空的元素 False >>>  all (( 0 ,  1 ， 2 ,  3 ))            #元组tuple，存在一个为0的元素 False         >>>  all ([])  # 空列表 True >>>  all (())  # 空元组 True

　　any　　有一个为真则为真，返回True

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

>>>  any ([ 'a' ,  'b' ,  'c' ,  'd' ])   #列表list，元素都不为空或0 True >>>  any ([ 'a' ,  'b' , ' ', ' d'])   #列表list，存在一个为空的元素 True >>>  any ([ 0 , ' ', False])  #列表list,元素全为0,' ',false False    >>>  any (( 'a' ,  'b' ,  'c' ,  'd' ))   #元组tuple，元素都不为空或0 True >>>  any (( 'a' ,  'b' , ' ', ' d'))   #元组tuple，存在一个为空的元素 True >>>  any (( 0 , ' ', False))    #元组tuple，元素全为0,' ',false False       >>>  any ([])  # 空列表 False >>>  any (())  # 空元组 False

　　bin　　十进制转二进制

1 2 3

print ( bin ( 5 ))   0b101         # 0b表示二进制

　　hex　  十进制转十六进制

1 2 3

print ( hex ( 74 ))   0x4a

　　oct　　十进制转八进制

1 2 3

print ( oct ( 18 ))   0o22

　　bool　 判断布尔值

　　bytes　编码　　ascll码不能编译中文，会报错

1 2 3 4 5 6

name  =  '你好' print (bytes(name,encoding = 'utf8' ))                 # 手动把字符串编码，转为二进制 print (bytes(name,encoding = 'utf8' ).decode( 'utf8' ))  # 需要把字符串进行编码，再解码（用什么方式编码就用什么解码，decode）   b '\xe4\xbd\xa0\xe5\xa5\xbd' 你好

　　dir　　显示函数内置属性和方法

1 2 3

print ( dir ( dict ))   [ '__class__' ,  '__contains__' ,  '__delattr__' ,  '__delitem__' ,  '__dir__' ,  '__doc__' ,  '__eq__' ,  '__format__' ,  '__ge__' ,  '__getattribute__' ,  '__getitem__' ,  '__gt__' ,  '__hash__' ,  '__init__' ,  '__iter__' ,  '__le__' ,  '__len__' ,  '__lt__' ,  '__ne__' ,  '__new__' ,  '__reduce__' ,  '__reduce_ex__' ,  '__repr__' ,  '__setattr__' ,  '__setitem__' ,  '__sizeof__' ,  '__str__' ,  '__subclasshook__' ,  'clear' ,  'copy' ,  'fromkeys' ,  'get' ,  'items' ,  'keys' ,  'pop' ,  'popitem' ,  'setdefault' ,  'update' ,  'values' ]

　　divmod　　得到商和余数（可用作分页用）

1 2 3

print ( divmod ( 10 , 3 ))   ( 3 , 1 )

　　eval　　1、提取字符串的数据结构 2、作字符串中的数据运算

1 2 3 4 5 6

dic = { 'name' : 'alex' }   #字典类型转成字符串 dic_str = str (dic) print (dic_str)   d1 = eval (dic_str)      #eval:把字符串中的数据结构给提取出来 print (d1)

express = "1+2*(3/3-1)-2"
print(eval(express))

输出
-1，0               第二种数据运算

　　hash　　可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型

　　　　　　 hash的作用：从下载的软件判断是否被改变，通过对比hash值，便知道

　　help　　查看函数的用法的详细信息

　　isinstance　　判断类型

1 2 3 4 5 6 7 8 9 10 11

print ( isinstance ( 1 , int ))        #判断是不是int类型 print ( isinstance ( 'abc' , str ))    #判断字符串 print ( isinstance ([], list ))      #判断列表 print ( isinstance ({}, dict ))      #判断字典 print ( isinstance ({ 1 , 2 }, set ))    #判断集合   True True True True True

　　locals

def test():
    age = "18"
    print(globals())    # 输出全局变量
    print(locals())     # 输出上一层的变量

test()


{'test': <function test at 0x000001C869BB9598>, '__file__': 'C:/Users/lenovo/PycharmProjects/untitled/pythons3/内置函数.py', '__spec__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001C869B56CF8>, '__builtins__': <module 'builtins' (built-in)>, '__package__': None, '__cached__': None, '__name__': '__main__', '__doc__': None}
{'age': '18'}

　　max(最大)和min(最小) 　　遍历比较，不同类型间不能比较

list = [99,55,23,11,68]
print(max(list))
print(min(list))

99
11

age_dic={'alex_age':18,'wupei_age':20,'zsc_age':100,'lhf_age':30}
print(max(age_dic.values()))        # 取出最大年龄
print(max(age_dic))                 # 默认比较key

100
zsc_age

　

  年龄比较高级用法

　　zip　一一对应分配

print(list(zip(('a', 'n', 'c'), (1, 2, 3))))
print(list(zip(('a', 'n', 'c'), (1, 2, 3, 4))))
print(list(zip(('a', 'n', 'c', 'd'), (1, 2, 3))))

[('a', 1), ('n', 2), ('c', 3)]
[('a', 1), ('n', 2), ('c', 3)]
[('a', 1), ('n', 2), ('c', 3)]

p={'name':'alex','age':18,'gender':'none'}
print(list(zip(p.keys(),p.values())))
print(list(p.keys()))    #取keys
print(list(p.values()))  #values
print(list(zip(['a','b'],'12345')))   # zip传俩个参数，都是序列。便可一一对应

[('age', 18), ('gender', 'none'), ('name', 'alex')]
['age', 'gender', 'name']
[18, 'none', 'alex']
[('a', '1'), ('b', '2')]

　　　　max和zip结合使用

age = {"alex":25,"tom":30,"tony":55}
print(list(zip(age.values(),age.keys())))       # 一一对应
print(max(zip(age.values(),age.keys())))        # 一一对应取最大值

[(55, 'tony'), (25, 'alex'), (30, 'tom')]
(55, 'tony')

dic={'age1':18,'age2':10}
print(max(dic))           # 比较的是key
print(max(dic.values()))  # 比较的是值，但是不知道对应的哪个key
print(max(zip(dic.values(),dic.keys()))) # 通过zip，便可以获取到值最大，对应的是哪个key

age2
18
(18, 'age1')

　　pow 几的几次方

print(pow(3,3))
print(pow(2,3,2))

27          # 3**3   3的3次方
0           # 2**3%2 2的3次方取余

　　reversed　　反转

li = [1,2,3,4]
print(list(reversed(li)))     # 反转

[4, 3, 2, 1]      

　　round　　四舍五入

print(round(4.3))

4

　　set  变集合，记得集合的特性

print(set("hello"))

{'o', 'l', 'h', 'e'}

　　slice 切片，可以指定步长

l='hello'
s1=slice(3,5)     # 切片 取3到5的元素
s2=slice(1,4,2)  # 切片，指定步长为2
print(l[3:5])

print(l[s1])         # 切片
print(l[s2])    

print(s2.start)    # 开始
print(s2.stop)    # 结束
print(s2.step)    # 步长

lo
lo
el
1
4
2

　　sorted 排序(排序本质上就是在比较大小，不同类型间不能比较)

l=[3,2,1,5,7]
l1=[3,2,'a',1,5,7]
print(sorted(l))       # 排序
# print(sorted(l1))    # 会报错

[1, 2, 3, 5, 7]

　　sum 求和

1 li = [1,2,3,4]
2 print(sum(li))
3 print(sum(range(101)))
4 
5 10
6 5050

　　type 判断数据类型

vars

　　　　里面如果没有参数，和locals用法相

　　　　如果里面有一个参数，查看某一个方法，并显示成字典的类型

　　import 导入模块(就是导入一个py文件)      

　　　　粗略用法，不能导入字符串类型(以后可能会这种需求)

　　__import__　可以导入有字符串模块儿

　　　　粗略用法