9 函数

2021-07-10 本文已影响0人雨小风轻潜入夜

1 三元运算

# v1 = 前面 if 条件 else 后面 
data = input('>>>')
value = int(data) if data.isdecimal() else None

2 函数

2.1 函数的基本结构

# 函数的定义
def func(val):  # 形参
    print(val)  # 实参
    pass


func()

2.2 参数

2.2.1 基本参数知识

任意个数
任意类型

2.2.2 位置参数

# 位置参数
def func(n1, n2):
    print(n1, n2)


func(1, 2)
# 严格按照顺序传参数：位置方式传参

2.2.3 关键字传参

def func(n1, n2, n3):
    print(n1, n2, n3)


func(1, n3=2, n2=5)
# 可以和位置传参混合使用（位置参数在前》关键字参数在后 = 总场数的个数）

2.2.4 默认参数

def func(n1, n2, n3=9):
    print(n1, n2, n3)


func(1, n2=5)

2.2.5 万能参数（打散）

# 接受到的是元组,不支持关键字传参，只能位置传参
def func(*args):
    print(args)


func(1, 2)
func(*(1, 2, 3, 4, 5))  # (1, 2, 3, 4, 5)
func((1, 2, 3, 4, 5))  # ((1, 2, 3, 4, 5),)


# 接受到的是字典，只能关键字传参
def func(**kwargs):
    print(kwargs)


func(a=1)  # {'a': 1}
func(a=1, b=2)  # {'a': 1, 'b': 2}


# 多种形式
def func(a1, a2, *args, **kwargs):
    print(a1, a2, args, kwargs)


func(1, 2, 3, 4, c=6)  # 1 2 (3, 4) {'c': 6}
func(1, 2, *[4, 5, 6], **{'a': 7, 'b': 8})  # 1 2 (4, 5, 6) {'a': 7, 'b': 8}

参数相关重点

# 1.定义函数
def func(a1, a2):
    pass


def func(a1, a2=None):
    pass


def func(*args, **kwargs):
    pass

# 2.调用函数
# 位置参数 》 关键字参数

2.3 作用域

全局作用域
局部作用域
一个函数是一个作用域
作用域查找规则：优先在自己的作用域，自己没有去父级找，直到全局，全局没有就报错
子作用域只能找到父级中的值，默认不能对父级变量重新赋值


name = [1, 2, 3]


def func():
    name.append(4)
    print(name)

如果想赋值，需要使用global关键字,只改全局的

name = [1, 2, 3]


def func():
    global name
    name = 8
    print(name)

nonlocal,只改父级的

name = [1, 2, 3]


def func():
    name = 9

    def chg():
        nonlocal name
        name = 10
        print(name)

    chg()
    print(name)


print(name)

全局变量，全部大写

2.4 函数的小高级

a = 123
name = 'breeze'
nums = [1, 2, 3, 4]


def func():
    pass
# func = 函数

2.4.1 函数的赋值

def func():
    print(123)


v1 = func
v1()
func()
func_list = [func, func]
func_set = {func, func}
func_dict = {'k1': func, func: 6}

func_list = [func(), func(), func()]  # [None, None, None]

2.4.2 函数可以当参数进行传递

def func(arg):
    print(arg())


def show():
    print(666)


func(show)
# 666
# None

2.5 lambda 表达式

# 三元运算 ，解决简单的if else
# lambda 表达式，解决简单的函数
func = lambda a1, a2: a1 + a2
func1 = lambda: 100
func2 = lambda *args, **kwargs: len(args) + len(kwargs)
func3 = lambda n1, n2: n1 if n1 > n2 else n2

# list的方法基本都返回None
# 字符串的所有方法都返回新的值
user_list = []
func4 = lambda x: user_list.append(x)
res = func4(4)
print(res)

func_list=[lambda x:x.strip(),lambda x:x.strip()]

2.6 内置函数

img_6.png

输入输出
- print
- input
其他
- len
- range
- open
- id
- type
强制转换
- list
- tuple
- dict
- int
- str
- set
- bool
数学相关
- abs
- float
- max
- min
- sum
- divmod 求2个数的商和余数
- pow pow(2,3)/8
- round round(3.16323,1) 3.2

进制转换相关
- bin 0b
- oct 0o
- int
- hex 0x

补充

img_9.png

img_10.png

2.7 函数中高级

2.7.1 函数可以作为返回值

img_11.png

注意：函数在何时被谁创建

2.7.2 闭包

img_12.png

2.7.3 高阶函数

对函数进行赋值
把函数当做参数传递
把函数当做返回值

2.7.4 总结

函数执行流程分析
闭包概念：为函数创建一块区域并为其维护自己的数据，以后执行时方便调用（封装值+内层函数调用）
- 应用场景：装饰器/SQLAIchemy源码

2.8 内置函数

编码相关
- chr 将十进制数字转换成Unicode编码中对应的字符串
- ord 根据字符在Unicode编码中找到其对应的十进制

import random
v=random.randint(1,3)
print(chr(v))

data=[]
for i in range(6):
  v=random.randint(65,91)
  data.append(chr(v))
print(''.join(data))

高级一点的内置函数
- map
- filter
- reduce
匿名函数 lambda

2.9 模块

将指定的字符串进行加密

import hashlib
import getpass

USER_LIST = []


def get_md5(data):
    # 加盐
    obj = hashlib.md5('helloworld'.encode('utf-8'))
    obj.update(data.encode('utf-8'))
    res = obj.hexdigest()
    print(res)
    return res


def register():
    while True:
        user = input('请输入用户名：')
        if user.upper() == 'N':
            return
        pwd = input('请输入密码：')
        temp = {'username': user, 'password': get_md5(pwd)}
        USER_LIST.append(temp)


def login():
    print('开始登录')
    user= input('请输入用户名：')
    pwd =input('请输入密码')
    # pwd =getpass.getpass('请输入密码')

    for item in USER_LIST:
        if item['username'] == user and item['password'] == get_md5(pwd):
            return True

register()
print(USER_LIST)
res = login()
if res:
    print('success')
else:
    print('fail')

sys

img_13.png

import sys
import time
import os
# \r 回到当前行的起始位置
# print('123\r',end='')
# print('456',end='')
#
# for i in range(100):
#     msg="{}%".format(i)
#
#     print(msg,end='\r')
#     time.sleep(0.1)

#读取文件的大小（字节）
file_size=os.stat('测试压缩.zip').st_size
print(file_size)
# 一点一点读文件
chunk_size = 64
read_size = 0
with open('测试压缩.zip','rb') as f1:
    while read_size<file_size:
        chunk =f1.read(chunk_size)
        read_size+=len(chunk)
        val=int(read_size/file_size *100)
        print('{}%'.format(val),end='\r')
        time.sleep(0.1)

import sys
import time
import os
import shutil

#删除文件的脚本
print(sys.argv)
shutil.rmtree()

import os
import shutil

# os.path.exists()
# os.stat()
# os.path.abspath()
# os.path.dirname()
# os.path.join()
#
# res=os.listdir('./hello')
# print(res)

res=os.walk('hello')
for a,b,c in res:
    #a.正在查看的目录，b此目录下的文件夹，c此目录下的文件
    # print(a,b,c)
    for item in c:
        path=os.path.join(a,item)
        print(path)

shutil

import shutil

shutil.rmtree()
shutil.make_arch

2.10 装饰器

在不改变原函数内部代码的基础上，在函数执行之前和之后自动执行某个功能


# 装饰器
def func(arg):
    def inner():
        print('start')
        v=arg()
        print('end')
        return v
    return inner

def index():
    print(123)
    return 666

index=func(index)
index()
########################

def func(arg):
    def inner():
        print('start')
        v=arg()
        print('end')
        return v
    return inner

# 第一步：执行func函数并将下面的函数参数传递，相当于func(index)
# 第二步：将func的返回值重新赋值给下面的函数名 index=func(index)
@func
def index():
    print(123)
    return 666

res=index()
print(res)

# 带参数的装饰器
# 第一步：执行wrapper =x(9)
# 第二步：data = wrapper(index)
# 第三步：index = data
def x(counter):
    def wrapper(func):
        def inner(*args,**kwargs):
            print('start')
            v = []
            for i in range(counter):
                data = func(*args,**kwargs)
                v.append(data)
            print('end')
            return v
        return inner
    return wrapper
        
@x(9)                                                                                                                                                      
def index():
    print(123)
    return 666

res=index()
print(res)

总结

编写装饰器

def x(func):
    def y():
        ret =func()
        return ret
    return y

@x
def index():
    pass

应用场景

想要为函数扩展功能时，可以选择装饰器

记住

# 编写格式
def 外层函数(参数):
    def 内层函数(*args, **kwargs):
        return 参数(*args, **kwargs)
    return 内层函数

# 装饰器应用格式
@ 外层函数
def index():
    pass

# 为什么要加*args, **kwargs

2.11 推导式

列表推导式

vals = [i for i in range(10) if i > 5]

集合推导式

vals = {i for i in range(10)}

字典推导式

vals = {'k'+str(i):i for i in range(10)}

面试题

import functools

num1 = 0
num2 = 1
count = 0
while num2 < 400:
    num1,num2 = num2,num1+num2
    count += 1
    print(num1,count)


for i in range(1,1001):
    if sum([j for j in range(1,i) if i%j==0]) == i == functools.reduce(lambda x,y:x*y,[j for j in range(1,i) if i%j==0]) :
        print(i)

2.12 内置模块

2.12.1 os

os.mkdir
os.makedirs
os.path.join
os.path.dirname
os.path.abspath
os.path.exists
os.stat
os.listdir
os.walk
os.rename

2.12.2 sys

sys.argv
sys.getrefcount是解释器相关的数据，递归次数/引用次数
sys.path 默认python去导入模块时，会按照sys。path中的路径挨个查找
sys.path.append(r'D:')

2.12.3 json

json是一种特殊的字符串，序列化成json

json外层必须是列表或字典

json中字符串必须是双引号

import json

v=[1,2,3,{'k1':'v1'},True,'HELLO',[4,5,6],None]
#序列化
v1=json.dumps(v)
print(v1)

v2='[1, 2, 3, {"k1": "v1"}, true, "HELLO", [4, 5, 6],null]'
print(type(v2))
#反序列化
v3=json.loads(v2)
print(v3)

import json

v={'k1':'breeze','k2':'多少'}
val =json.dumps(v,ensure_ascii=False)
print(val)


with open('testjson.josn','w') as file_object:
    json.dump(v,file_object,ensure_ascii=False)

2.12.4 pickle

json 所有语言通用
pickle python中所有的东西都能被序列化。序列化的内容只有python认识

import pickle
v={"k1": "breeze", "k2": "多少"}
val=pickle.dumps(v)
print(val)
data= pickle.loads(val)
print(data)

2.12.5 shutil

shutil.rmtree()
shutil.move('yuan','new')
shutil.make_archive('new','zip','path')
shutil.unpack_archive('new',extract_dir='path',format='zip')
shutil.copy('gp.csv','hello1.csv')

from datetime import datetime
import shutil
import os
# ctime =datetime.now().strftime('%Y-%m-%d %H-%M-%S')
# print(ctime)
# shutil.make_archive(ctime,'zip','H:\\pyspace\\learn\\note\压缩\\')

# shutil.rmtree('2021-04-13 14-29-00.zip')
# os.remove('2021-04-13 14-29-00.zip')
# os.rmdir(r'H:\pyspace\learn\note\hello\777') #不是空的，不能删除
shutil.rmtree(r'H:\pyspace\learn\note')

2.15.6 time & datetime

1.time 模块

UTC/GMT：世界时间

本地时间：本地时区时间

time.time(),时间戳：1970-1-1 00:00
time.sleep()
time.timezone #-28800

2.datetime

from datetime import datetime,timezone,timedelta
import time

v1=datetime.now()
print(v1)


v2=datetime.utcnow()
print(v2)

#当前东7区时间
tz=timezone(timedelta(hours=7))
v3=datetime.now(tz)
print(v3)

# 将datetime时间转换成字符串
fmt='%Y-%m-%d %H:%M:%S'
print(v1.strftime(fmt))

#字符串转datetime
tm='2021-04-13 15:14:34'
v4 = datetime.strptime(tm,fmt)
print(v4)

# 时间的加减
v5=v4+timedelta(days=1)
print(v5)

# 时间戳和datetime的关系

ctime= time.time()
print(ctime)
v6=datetime.fromtimestamp(ctime,tz=tz)
print(v6)

# datetime转时间戳
v7=datetime.timestamp(v6)
print(v7)

2.15.7 异常处理

import requests

def func(url_list):
    result=[]
    for url in url_list:
        try:
            response = result.get(url)
            result.append(response.text)
        except Exception as e:
            pass
    return result

3 迭代器

3.1迭代器

帮助你对某种对象中的元素进行逐一获取，表象：具有next（），且每次调用都获取可迭代对象中的元素，从前到后一个一个获取。

列表转换成迭代器 v1=iter([1,2,3])/ v1=[1,2,3].iter()

v1=[1,2,3,4,5]
v1.__iter__()
v2=iter(v1)
print(type(v2))
print(v2.__next__())

print(next(v2))

如何判断是否是迭代器，看内部是否有next()方法

3.2 可迭代对象

内部有iter()方法且返回一个迭代器(生成器)
可以for循环

4 生成器（函数的变异）

#生成器函数，内部是否包含yield
def func(arg):
    arg=arg+1
    print('a')
    print('a')
    print('a')
    yield 1
    print('b')
    yield 2
    print('c')

#函数内部代码不会执行，返回一个生成器对象
v1=func(2)

# 生成器可以被for循环，开始循环那么函数内部代码就会开始执行
for item in v1:
    print(item)

def func():
    count=1
    while True:
        yield count
        count+=1

val=func()

for item in val:
    print(item)

def base():
    yield 88
    yield 99

def func():
    yield 1
    yield 2
    yield from base()
    yield 3

res = func()

for item in res:
    print(item)

def func():
    for i in range(10):
        def f():
            return i
        yield f


v1=func()
for item in v1:
    print(item())

img_15.png

其他知识
- yield from
- 生成器推导式

v1=(i for i in range(10))
print(v1)

生成器也是一种特殊的迭代器，也是一种特殊的可迭代对象

img_17.png

img_16.png