python函数

关键参数必须要放在位置参数后边,由于实参是这个顺序,所以形参接收的时候也是这个顺序.也就是说位置参数必须在关键字参数前面.动态接收关键字参数也要在后面

最终顺序:

位置参数 > *args(动态位置参数) > 默认值参数 > **kwargs(动态默认参数)

这四种参数可以任意的使用

函数的注释

在外部查看函数的注释 函数名.*doc*

def eat(food,drink):
    '''
    这里描述这个函数是做什么的.例如这函数eat就是吃
    :param food:  food这个参数是什么意思
    :param drink: drink这个参数是什么意思
    :return:  执行完这个函数想要返回给调用者什么东西
    '''
    print(food,drink)
eat('麻辣烫','肯德基')

print(eat.__doc__)  #函数名.__doc__

命名空间

在python解释器开始执行之后, 就会在内存中开辟一个空间, 每当遇到一个变量的时候, 就把变量名和值之间的关系记录下来, 但是当遇到函数定义的时候, 解释器只是把函数名读入内存, 表示这个函数存在了, 至于函数内部的变量和逻辑, 解释器是不关心的.

也就是说一开始的时候函数只是加载进来, 仅此而已, 只有当函数被调用和访问的时候, 解释器才会根据函数内部声明的变量来进行开辟变量的内部空间. 随着函数执行完毕, 这些函数内部变量占用的空间也会随着函数执行完毕而被清空.

def fun():   
    a = 10   
    print(a)
fun()
print(a)    # a不存在了已经..

我们给存放名字和值的关系的空间起一个名字叫: 命名空间. 我们的变量在存储的时候就是存储在这片空间中的.

命名空间分类:

1. 全局命名空间—> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间

2. 局部命名空间—> 在函数中声明的变量会放在局部命名空间

3. 内置命名空间—> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间

加载顺序:

1. 内置命名空间

2. 全局命名空间

3. 局部命名空间(函数被执行的时候)

取值顺序:

1. 局部命名空间

2. 全局命名空间

3. 内置命名空间

a = 10
def func():  
    a = 20   
    print(a)
func()  # 20

作用域

作用域就是作用范围, 按照生效范围来看分为 全局作用域 和 局部作用域

全局作用域:

​ 包含内置命名空间和全局命名空间. 在整个文件的任何位置都可以使用(遵循 从上到下逐⾏执行).

​ 全局命名空间 + 内置命名空间

局部作用域:

​ 在函数内部可以使用.

​ 局部命名空间

我们可以通过globals()函数来查看全局作⽤用域中的内容,也可以通过locals()来查看局部作用域中的变量量和函数信息

a = 10
def func():   
    a = 40   
    b = 20   
    print("哈哈")   
    print(a, b)        
    print(globals())    # 打印全局作用域中的内容   
    print(locals())     # 打印局部作用域中的内容
func()

结果：
哈哈
40 20
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000015ADAD2D198>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/python_code/day04-20190720/day04-20190720.py', '__cached__': None, 'a': 10, 'func': <function func at 0x0000015ADAC22EA0>}
{'b': 20, 'a': 40}

函数的嵌套

1. 只要遇见了()就是函数的调用. 如果没有()就不是函数的调用
2. 函数的执行顺序

def fun2():
    print(222)
    def fun3():
        print(666)
    print(444)
    fun3()
    print(888)
print(33)
fun2()
print(555)

结果：
33
222
444
666
888
555

gloabal、nonlocal

global表示. 不再使用局部作用域中的内容了. 而改用全局作用域中的变量

a = 100
def func():
    global a    # 加了个global表示不再局部创建这个变量了. 而是直接使用全局的a
    print(a)
    a = 28
print(a)
func()
print(a)

100
100
28

global 宗旨

在函数内部修改全局的不可变变量,如果全局中不存在就创建一个不可变变量

lst = ["麻花藤", "刘嘉玲", "詹姆斯"]
def func():   
    lst.append("⻢云")   
    # 对于可变数据类型可以直接进⾏访问
　　 print(lst)
func()
print(lst)

结果：
['麻花藤', '刘嘉玲', '詹姆斯', '⻢云']
['麻花藤', '刘嘉玲', '詹姆斯', '⻢云']

nonlocal宗旨

nonlocal 只修改上一层变量,如果上一层中没有变量就往上找一层,只会找到函数的最外层,不会找到全局进行修改

a = 10
def func1():
    a = 20
    def func2():
        nonlocal a
        print(a)
        a = 30
        print(a)
    func2()
    print(a)
func1()


结果：
20
30
30





a = 10
def func1():
    a = 20
    def func2():
        #nonlocal a
        #print(a)
        a = 30
        print(a)
    func2()
    print(a)
func1()

结果：
30
20

终极

a = 1
def fun_1():
    a = 2
    def fun_2():
        nonlocal a
        a = 3
        def fun_3():
            a = 4
            print(a)
        print(a)
        fun_3()
        print(a)
    print(a)
    fun_2()
    print(a)
print(a)
fun_1()
print(a)

结果：
1
2
3
4
3
3
1

内置函数

是python给你提供的. 拿来直接用的函数, 比如print., input等等.

截止到python版本3.6.2 python一共提供了68个内置函数

[外链图片转存失败(img-CPNTHvZ7-1563613365319)(C:\Users\Benson\AppData\Roaming\Typora\typora-user-images\1563608433079.png)]

作用域相关

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()

​ 执行字符串类型的代码

msg = '''
def func():
    print('有计划没行动等于零')
func()
'''
exec(msg)

以上这两个在公司开发中禁止使用,如果里边出现del就会出现很大的问题

输入和输出相关

input()

​ 获取用户输入的内容

print()

​ 打印输出

print('你好','我好')    
print('你好','我好',sep='|')
结果:
你好 我好
你好|我好

print('你好')
print('我好')
print('你好',end='')
print('我好')
结果：
你好
我好
你好我好

sep是将多个元素进行修改 默认的是空格

end默认是\n 这就是我们为什么使用print的时候会出现换行,end的值修改成了空字符串

内存相关

hash()

​ 获取到对象的哈希值(int, str, bool, tuple)

​ 这样是求出数据结构,如果能够获取到哈希值就是可以当做字典的键

print(hash('123'))
结果:
-6822401661081700707

id()

​ 获取到对象的内存地址

文件操作相关

open()

​ 用于打开一个文件, 创建一个文件句柄

帮助

help()

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

help(print)
结果:
Help on built-in function print in module builtins:
print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.
Process finished with exit code 0

调用相关

callable()

用于检查一个对象是否是可调用的. 如果返回True, object有可能调用失败, 但如果返回False. 那调用绝对不会成功

print(callable(print))
结果:
True

查看内置属性

dir()

查看对象的内置属性

方法.访问的是对象中的dir()方法

基础数据类型相关

数字相关

bool() 将给定的数据转换成bool值. 如果不给值. 返回False
​ int() 将给定的数据转换成int值. 如果不给值, 返回0
​ float() 将给定的数据转换成float值. 也就是小数
​ complex() 创建一个复数. 第一个参数为实部, 第二个参数为虚部. 或者第一个参数直接 用字符串来描述复数

数学运算

abs() 返回绝对值

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

divmod() 返回商和余数

print(divmod(15,2))
结果:
(7, 1)

round() 四舍五入

print(round(15.1111,2))  # 保留2位小数
结果:
15.11

pow(a, b) 求a的b次幂, 如果有三个参数. 则求完次幂后对第三个数取余

print(pow(15,2,3))
结果:
0

sum() 求和

print(sum([12,3,4]))  #sum里边的参数是一个可迭代对象
结果:
19

min() 求最小值

print(min([12,3,4]))  # 寻找最小的数字
结果:
3

max() 求最大值

print(max([12,3,4]))  # 寻找最大的数字
结果:
12

数据结构相关

列表和元组:
list() 将一个可迭代对象转换成列表
tuple() 将一个可迭代对象转换成元组
reversed() 将一个序列翻转, 返回翻转序列的迭代器

reversed 示例:

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

结果 :
<reversed object at 0x000001655B05A390>
['好', '你'

字符串相关:
str() 将数据转化成字符串
format() 与具体数据相关, 用于计算各种小数, 精算等

print(format('meet','>20'))   # 右对齐
print(format('meet','<20'))   # 左对齐
print(format('meet','^20'))   # 居中

结果：
                meet
meet                
        meet        

数值

#数值
print(format(3,'b'))    # 二进制
print(format(97,'c'))   # 转换成unicodezif
print(format(11,'d'))   #十进制
print(format(56))     #和d一样
print(format(11,'n'))   #十进制
print(format(11,'o'))   #八进制
print(format(11,'x'))  # 十六进制(小写字母)
print(format(11,'X'))  # 十六进制(大写字母)
# 浮点数
print(format(1234567890,'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')) # 小数点计数法,保留2位数
print(format(1.23456789e+1000,'F')) # 小数点计数法

结果：
11
a
11
56
11
13
b
B
1.234568e+09
1.23e+08
1.23E+08
1.234568
1.23
1.2345678900
INF

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)

结果：
b'\xe4\xbd\xa0\xe5\xa5\xbd'
你好

数据集合

dict() 创建一个字典

set() 创建一个集合

frozenset() 创建一个冻结的集合,冻结的集合不能进行添加和删除操作

其他相关

len() 返回一个对象的元素个数

enumerate() 获取枚举对象

enumerate() 举例

lst = ['alex','wusir','taibai']
for i,k in enumerate(lst):
    print('这是序号',i)
    print('这是元素',k)
    
结果：
这是序号 0
这是元素 alex
这是序号 1
这是元素 wusir
这是序号 2
这是元素 taibai

all() 可迭代对象中全部是True,结果才是True

lst = [1,2,3,4,True,0,False]
lst1 = [1,2,3,4,True]
print(all(lst))
print(all(lst1))

结果：
False
True

any() 可迭代对象中有一个是True,就是True

lst = [1,2,3,4,True,0,False]
lst1 = [1,2,3,4,True]
print(any(lst))
print(any(lst1))

结果：
True
True

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)

lambda表达式

匿名函数,为了解决一些简单的需求而设计的一句话函数

def func(n):
    return n**n
print(func(4))
f = lambda x: x**x
print(f(4))

结果：
256
256

lambda表示的是匿名函数,不需要用def来声明,一句话就可以声明出一个函数

语法:

函数名 = lambda 参数:返回值

注意:

1.函数的参数可以有多个,多个参数之间用逗号隔开

2.匿名函数不管多复杂.只能写一行.且逻辑结束后直接返回数据

3.返回值和正常的函数一样,可以是任意数据类型,返回值的时候只能返回一个不能返回多个

匿名函数并不是说一定没有名字,这里前面的变量就是一个函数名,说他是匿名原因是我们通过name查看的时候是没有名字的.统一都叫做lambda.在调用的时候没有什么特别之处像正常的函数调用即可。

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}]

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}]

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))

结果：
<map object at 0x0000023AD68AA470>
[1, 4, 9, 16, 25]

改写成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]

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保住了.

参考资料:

https://www.processon.com/view/link/5b4ee15be4b0edb750de96ac

https://pythonav.com/wiki/detail/1/9/