函数

什么是函数：就是一堆准备好分代码，在需要时调用这一堆代码

函数的声明，使用关键字def来声明

函数的执行逻辑，要和函数的名字一致

在python中用

# def 函数名（）函数要进行的操作

函数定义好之后需要调用才会运行

1.函数的参数

可以按照位置一一对应传入参数，也可以按照变量名传入（此时可以无序）

2.函数的返回值，函数的文档说明

返回值就是函数执行的结果，并不是所有函数都必须要有返回值

return表示一个函数的执行结果

def add(a:int, b:int):"""这是一个注释:param a: :param b: :return: a和b冒号后为建议传入参数类型"""c = a + b#  c只有在函数内部使用，没有返回值则result无法获取函数结果
result = add(1, 2)
print(result ** 4)

函数调用

3.全局变量和局部变量

全局变量在整个py文件中都可以访问

局部变量只能在函数内部访问，在函数内部定义

如果局部变量和全局变量同名，则是在函数内部定义一个新的局部变量，不是修改去全局变量

如果想要在函数内部修改全局变量，使用global方法

内置函数globals可以查看全局变量， locals可以查看局部变量

在python中，只有函数能够分割作用域

4.多个返回值

一般情况下，一个函数最多只会执行一个return语句

特殊情况（finally语句）下，一个函数可能会执行多个return语句

def test(a, b):x = a // by = a % breturn x, y  #返回的本质是元组，用[]包裹则为列表，{}是时字典#可以用列表，元组，字典将返回值作为整体返回print(test(2, 3))

5.函数的缺省函数

默认参数（若没有传递参数，会使用默认值，如果有参数传入，则使用传入的参数）

如：print（”hello world“，end=‘’）

若end未传入则使用默认的换行

如果有位置参数和关键字参数，则位置参数要放在关键字参数之前

6.可变参数的使用

可使用元组或列表打宝传入

*args表示可变位置参数（可变参数会以元组的方式保存到args里，缺省参数需要放在位置参数后）

**kwargs表示关键字可变参数（多出的关键字参数会以字典的形式保存）

7.可变类型和不可变类型传参

def test(a):print('修改前a的内存地址0x%X'%id(a))a=100print('修改后a的内存地址0x%X'%id(a))def demo(nums):print('修改前nums的内存地址0x%X'%id(nums))nums[0]=10print('修改前nums的内存地址0x%X'%id(nums))
x=1
print('修改前x的内存地址0x%X' % id(x))
test(x)
print('修改后x的内存地址0x%X' % id(x))
print(x)y=[3,5,9,4,6,7,0]
print('修改前y的内存地址0x%X' % id(y))
demo(y)
print('修改前y的内存地址0x%X' % id(y))
print(y)
# 修改前x的内存地址0x7FF9BE827110
# 修改前a的内存地址0x7FF9BE827110
# 修改后a的内存地址0x7FF9BE827D70
# 修改后x的内存地址0x7FF9BE827110
# 1
# 修改前y的内存地址0x2232E6D5208
# 修改前nums的内存地址0x2232E6D5208
# 修改前nums的内存地址0x2232E6D5208
# 修改前y的内存地址0x2232E6D5208
# [10, 5, 9, 4, 6, 7, 0]

8.函数的注意事项

函数的三要数：函数名，参数，返回值

在有的编程里，允许函数重名，python中不允许

在python中，如果函数重名，后一个函数会覆盖前一个函数

python里函数名也可以理解为一个变量名

变量名也不能和自定义函数名或内置函数名或内置类重名

9.递归函数的使用

简单来说就是函数内部自己调用自己

递归最重要的是找到出口（停止的条件）

count = 0def test():global countcount += 1print('laji')if count < 5:test()test()def factorial(n):if n == 0:return 1return n * factorial(n - 1)print(factorial(6))

10.匿名函数的使用

除了def可以定义一个函数以外，还能使用lambda表达式定义一个函数

匿名函数用来表达一个简单的函数，调用次数很少，基本上只调用一次

lambda a,b:a+b #匿名函数

调用匿名函数的两种方式：

1）给他定义一个名字

nul=lambda a,b:a+b #匿名函数

2） 把这个函数当作一个参数传给另一个函数使用（使用场景比较多）

def cal(a, b, fn):reslut = fn(a, b)return reslutdef add(x, y):return x + ydef munils(x, y):return x - yprint(cal(9, 7, add))
print(cal(78, 16, munils))
result1 = cal(89, 12, lambda x, y: x + y)
result2 = cal(89, 12, lambda x, y: x - y)
result3 = cal(89, 12, lambda x, y: x * y)
result4 = cal(89, 12, lambda x, y: x / y)
print(result1, result2, result3, result4)

11.sort方法的使用

有几个内置函数和内置类，用到了匿名函数

sorted内置函数，不会改变原有数据，而是生成一个新的结果

字典和字典之间不能使用比较运算，因为缺少比较规则

students = [{'name': 'dear', 'age': 18, 'score': 89},{'name': 'honey', 'age': 21, 'score': 95},{'name': 'henry', 'age': 19, 'score': 78},{'name': 'jerry', 'age': 20, 'score': 98}]def foo(x):return x['age']# print('传入了{}',format(x))students.sort(key=foo)
print(students)

12.filter&map&reduce方法的使用

filter 过滤，python2中是内置函数，python3中是内置类

filter对可迭代对象进行过滤，得到的是一个filter对象

filter可以给定两个参数，第一个参数是函数，第二个参数是可迭代对象

filter结果是一个filter类型的对象，filter也是一个可迭代对象

map:让每个元素都执行函数里的内容

map可以给定两个参数，第一个参数是函数，第二个参数是可迭代对象

reduce以前是一个内置函数

students = [{'name': 'dear', 'age': 18, 'score': 89},{'name': 'honey', 'age': 21, 'score': 95},{'name': 'henry', 'age': 19, 'score': 78},{'name': 'jerry', 'age': 20, 'score': 98}]
nums = [3, 5, 6, 78, 6, 1, 14]def foo(x, y):return x + yprint(reduce(foo, nums))
def bar(x,y):return x+y['age']print(reduce(bar, students, 0))

13.内置函数的总结

abs：取绝对值

all：将所有元素转换成bool值，如果所有转换结果都为True，则结果为True，否则为False

any：将所有元素转换成bool值，如果所有转换结果都为False，则结果为False，否则为True

chr：将字符编码转换成为对应字符

ord：将字符转换成为对应子符编码

dir：列出可用的此方法

divmod：求两个数相除的商和余数

exit：以指定退出码退出程序

globals：用来查看所有全局变量

locals：查看所有局部变量

help：查看帮助文档

bin：转二进制 oct：转八进制 hex：转十六进制

id：获取数据内存地址

iter：获取到可迭代对象的迭代器

isinstance：判断一个对象是否是由一个类创建出来

issubclass：判断一个类是否是另一个类的子类

open：用来打开一个文件

print：打印数据

input：让用户输入内容

pow：求幂运算

len：获取长度

round：四舍五入保留到指定小数位

next；for…in循环的本质就是调用迭代器的next方法

sorted：求和

repr：用字符串的方式表示一个数据

14.高阶函数

#  1.一个函数作为另一个函数的返回值
# 2.一个函数作为另一个函数的参数
# 3.函数内部再定义一个函数
# def foo():
#     print("我是foo，我被调用了")
#     return foo
#
#
# def bar():
#     print("我是bar，我被调用了")
#     return foo
#
#
# bar()  # 我是bar，我被调用了
# bar()()  # 我是bar，我被调用了 我是foo，我被调用了
def foo():print("我是foo，我被调用了")return foodef bar():print("我是bar，我被调用了")return foo()bar()  # 我是bar，我被调用了 我是foo，我被调用了

nonlocal：在一个内部函数中更改一个变量，使不产生新变量

15.计算代码的执行时间

代码运行前，获取一下时间；代码运行完成后，在获取一下时间。time模块可以获取当前的时间

time模块里的time方法，可以获取当前时间的时间戳

时间戳是从1970-01-01 00.00.00 UTC到现在的秒数

16.装饰器的基本使用

def can_play(fn):    def inner(name, game, *args, **kwargs):        clock = kwargs.get('clock', 23)        if clock <= 22:            fn(name, game)        else:print('太晚了，不能玩儿！')    return inner
@can_play
def play_game(name, game):    print('{}正在玩儿{}'.format(name, game))
play_game('zhangsan', '王者荣耀')
play_game('lisi', '绝地求生')
play_game('jerry', '英雄联盟', clock=19)

模块

1、导入模块

模块：在python中一个py文件，就是可以理解为模块

并不是所有py文件都能作为一个模块来导入

如果想让一个py文件能够被导入，模块必须要遵守命名规则

python为了方便开发，提供了很多内置模块

import time  # 使用import+模块名直接导入print(time.time())
# 导入这个模块后，就可以使用这个模块里的方法
time.sleep(3)
from random import randint  # from+模块名+import+函数名，导入一个模块的方法
from math import *  # 导入这个模块里的'所有'方法和变量print(pi)
randint(0, 2)
import datetime as dt  # 导入一个模块并起一个别名
print(dt.MAXYEAR)
from copy import deepcopy as dp #导入模块的方法并起别名

2、常见内置模块

# os:操作系统
# os提供的方法是用来调用操作系统里的方法
# www.mareenoire.info ==>获取操作系统的名字   Windows系列=》nt /非Windows=》posix
import osprint(os.name)
print(os.sep)  # 路径分隔符 windows /   其他 \
print(os.path.abspath('模块.py'))  # 获取文件绝对路径
print(os.path.exists)  # 判断是否存在

（很少用）

hashlib和hmac模块

这两个模块都是用来加密的

import hashlib
import hmac# hashlib模块中主要支持两个算法 ，md5 和 sha加密
# 加密方式：单向加密：只有加密的过程，不能解密  对称加密 非对称加密
# 需要将要加密的内容转换为二进制
num = hashlib.md5()
num.update('abc'.encode('utf8'))
print(num.hexdigest())  # 900150983cd24fb0d6963f7d28e17f72
# 'abc'==>900150983cd24fb0d6963f7d28e17f72

hmac加密可以指定密钥

import uuid# y用来生成一个全局唯一的id
print(uuid.uuid1())
print(16 ** 32)
# uuid3和uuid5是使用传入的字符串根据指定算法所得，固定
print(uuid.uuid3(uuid.NAMESPACE_DNS, 'zhangsan'))
print(uuid.uuid5(uuid.NAMESPACE_DNS, 'zhangsan'))
# uuid4 使用最多
print(uuid.uuid4())

pip

pip命令的使用

# python在查找模块时，在那些路径查找
# pip install用来下载安装一个第三方模块
# pip uninstall用来卸载一个第三方模块
# pip list 用来列出当前环境安装的模块名和版本号
# pip freeze 用来列出当前环境安装的模块名和版本号
# pip freeze > file_name 将安装的模块名华人版本号重定向输出到指定文件
# pip install -r file_name 读取文件里的模块名和版本号并安装
# pip install package_name -i  从指定地址下载(临时修改)
from flask import Flask
import sysprint(Flask.name)print(sys.path)

使用自定义模块

#  自己定义一个模块,其实就是自己写一个py文件
import my_module# 使用 from 模块名 import * 此时使用模块中方法不需要模块名
# 本质是读取模块中的__all__属性,看这个属性理定义了那些变量和函数
# 没有设置__all__会读取所有的除了以_开头的变量和函数
# 以一个下划线开始变量,建议只在模块内部使用,别的模块不要导入
# 使用from 模块名 import *这种方式无法导入
print(my_module.a)
print(my_module.test())

**__name__的使用**
起作用是当直接运行这个py文件时，值是__main__ 如果这个文件作为一个模块，则值是文件名