学习python基础函数编程部分梳理

三元运算【三目运算】

• 语法：
  • "v = a if a >b else b" #自我总结：当条件满足时返回a，条件不满足时返回b

函数

1.函数基础

1.1函数基础结构

def 函数名(参数):
    #函数内容
    pass
函数名（参数） # 执行函数 

1.2返回值

• return值，函数默认return None

def func():
    reuturn 1,3,"abc" #这种情况会自动转换为元组返回

1.3函数参数

• 函数的参数传递是什么？【内存地址=引用】
• 任意个数
• 任意类型
• 位置传参

def func(name,age,gender):
    pass
func("伊万科夫",25,"人妖")

• 关键字传参
  & 关键字与位置混合传参的情况，位置参数一定在前，关键字参数在后
• 参数默认值【定义】
  & 如果给默认值为可变类型---》坑

#该部分代码解释了为什么默认值慎用可变类型
def func(data,value=[]):
    value.append(data)
    return value
v1=func(1) #[1,]
v2=func(1,[11,22,33]) # [11,22,33,1]
v3=func(2) # [1,2]
print(v1) #[1,2]

def func(name,age,gender='男'):
    pass
func("伊万科夫",25,gender="人妖")
func("伊万科夫",gender="人妖",25)  # 错误方式
func("伊万科夫",25)     # gender不传的情况下使用默认值 “男”

• 万能参数

  • *args 接收任意个数的位置参数
    & 可以接收任意个数的参数，并且将所有参数转换成一个元组

    def func(*args): # 将所有参数打包成元组传递
        print(args)
    v1 = func((11,22,33,44,55)) #将参数元祖作为整个元组的第一个参数
    print(v1) # ((11,22,33,44,55),)
    v2 = func(*(11,22,33,44,55))# 将元组元素打散再打包成元组传递
    print(v1) # (11,22,33,44,55)
    #**********************************************************
    def func(*args,**kwargs):
        print(args)
        print(kwargs)
    func(*(11,"aaa"),444,"abc",name="沙鳄鱼",age='30')
    """
    (11, 'aaa', 444, 'abc')
    {'name': '沙鳄鱼', 'age': '30'}
    """
    

  • **kwargs 接收任意个数的关键字参数
    & 接收关键字参数，按键值转换成字典

    def func(**kwargs):
        print(kwargs)
    func(k1="v1",k2="v2")  #转换字典{"k1":"v1","k2":"v2"}
    func(**{"k1":"v1","k2":"v2"})  #直接传递字典{"k1":"v1","k2":"v2"}
    #**********************************************************
    def func(*args,**kwargs):
        print(args)
        print(kwargs)
    func((11,"aaa"),444,"abc",name="沙鳄鱼",age='30')
    """
    ((11, 'aaa'), 444, 'abc')
    {'name': '沙鳄鱼', 'age': '30'}
    """
    

1.4 函数作用域

• 全局作用域
• 局部作用域
• 总结：
  • 一个函数一个作用域
  • 作用域中查找数据规则：现在自己的作用域内部查找，找不到在沿父级查找
  • 子作用域只能使用父级变量的值，不能重新给其父级的变量赋值 【给变量重新赋值相当于在子作用域给自己定义了新的变量】
  • 对于可变类型变量，子作用域可对其进行修改
  • 如果需要给全局中的变量赋值，需要使用global关键字找到全局变量

name = 'enki'
def func():
    global name # global 关键字 只找全局的变量 【global关键字只查找全局中的变量】
    name = 'alex' 

- 查找父级【上一级】的变量
# 使用关键noglobal关键字

• 变量命名规范
  • 全局变量全大写
  • 局部变量全小写

第11节/第12节

1.函数的小高级

1.1 函数的赋值

• 函数名赋值

def func():
    pass
v1 = func 
v1()

• 函数可以放到list,dict,set,tuple，也可以作为字典的键和值
• 函数名可以当做变量名使用
• 函数可以当做参数传递

def func(arg):
    print(arg)
 def show():
    return 9
func(show)
def func(arg):
    arg() #执行函数
 def show():
    print("执行show函数")
func(show)	

1.2lambda表达式

• 基本写法
  & 用来表示简单的函数，【函数内部没有复杂代码，只有简单返回值情况】

def func(a,b):
    return a + b
func1=lambda a,b:a+b
func2=lambda : 100
func3=lambda a: a+100
func4=lambda *args,**kwargs: len(args)
#默认会将":"后的结果作为返回

lambda表达式不能定义变量，自己查找变量，没有则向父级查找.[lambda表达式就是一个一行的函数]

#一行实现比较两个值大小，返回大的值
func = lambda a,b: a if a > b else b
n = func(33,5)
print(n)

1.3内置函数

• 自定义函数
• 内置函数

  • 强制类型转换 【int,str,bool,list,tuple,dict,set】

  • 数值相关 【max(),min(),float(),abs():求绝对值，sum()】

    • divmod():让两个值相除，得到商和余数 【分页用到】
    • round():转化保留几位销售，四舍五入

  • 输入输出【print,input】

  • 进制相关

    • bin 二进制转换，0b开头
    • oct 八进制 0o开头
    • int 十进制
    • hex 十六进制 0x开头

    # 二进制转十进制
    v1 = '0b1101'
    result = int(v1,base=2)
    print(result)
    # 八进制转十进制
    v1 = '0o1101'
    result = int(v1,base=8)
    print(result)
    # 十六进制转十进制
    v1 = '0x1101'
    result = int(v1,base=16 )
    print(result)
    

  • 其他 【type,len,range,open,id】

  • 编码相关

    • chr() # 根据十进制数字在Unicode编码中找到对应字符
    • ord() # 根据字符在Unicode编码中找到对应的十进制数字
    • 应用：随机验证码的生成【引入random模块 random.randint(10,50)随机返回数字】

  • 高级内置函数

    • map(func,v1) [处理数据]
      & func为一个函数，V1为一个可迭代类型数据，map()函数通过循环V1参数的每个元素，让每个元素执行函数func，将func函数执行的结果添加到一个新列表中返回。

    v1 = [11,22,33,44]
    result = map(lambda x: x+100,v1)
    print(list(result)) # 特殊 ,result是一个object对象
    

    • filter(func,v1) [过滤数据]
      & 循环v1参数中的每个元素并交给func函数执行，如果func函数返回为True,将该元素追加到一个新列表中。
    • reduce(func,v1) [整合数据]
      & 循环v1参数的中的每个元素交给func函数执行，将func函数最终执行的结果返回；【func函数需要两个参数，第一个参数为函数前一次执行的返回值】
      & python3需要导入模块 import functools

    v1 = [1,2,3,4,5]
    result = reduce(lambda x,y: x+y,v1)
    print(result)
    

2.函数中高级

2.1 函数做返回值

• 闭包
  • 为函数创建一块内存空间维护自己的数据（内部变量供自己使用），方便后面函数执行调用【应用场景：装饰器/SQL Alchemy源码】
  • 函数是由谁创建的，函数就从哪儿开始执行
  • 闭包作用：每次调用函数时，都会为此调用开辟一块内存，内存可以保存自己以后想用的值
• 把函数当做参数传递
• 把函数当做返回值
• 注意：对函数进行赋值
• 执行函数
  • 函数不被调用，内部代码永远不会执行
  • 执行函数时，会创建一块内存保存自己函数执行的信息【闭包】
    # 函数开辟的内存中未使用name,不是闭包

2.2 递归

• 递归默认最大次数为1000，可通过sys模块中的方法调整；效率较低

def func(a):
    if a ==5:
        return 100000
    result = func(a+1) + 10
    return result
v = func(1) # 100050

2.3 加密模块

• hashlib模块

import hashlib
def get_md5(data):
    obj = hashlib.md5("一套随机字符串",encode='utf-8')
    obj.update(data.encode('utf-8')) #python3需要加编码指定
    result = obj.hexdigest()
	return result

• 密码不不显示，模块 getpass

import getpass
pwd = getpass.getpass('请输入密码：') #密码隐藏不显示
#在终端输入运行（pycharm无法运行不行）
 # getpass 在pycharm终端无法直接运行，如果需要请在命令行或者下方terminal窗口输入py文件运行

第十三节/第十四节

1.装饰器

• 作用：在不改变原函数内部代码的基础上，在函数执行的前后自动执行某个功能
• 编写装饰器：
  • @x的作用：
    & 1.执行x函数，把下面func1函数作为x函数的参数传递。
    & 2.将x函数执行的返回值赋值给下面的func1函数名

#装饰器的编写
def x(func):
    def y():
        ret = func()
        return ret
    return y

#装饰器的应用
@x
def func1():
    pass
@x 
def func2():
    pass

• 应用场景： 为某个或者某些函数做公共功能扩展时使用。
• 装饰器格式：

def 外层函数(参数)：
	def 内层函数(*args,**kwargs):#注意万能参数传递
        return 参数（*args,**kwargs）#注意万能参数传递
    return 内层函数

@外层函数
def index():
    pass
index()

2.推导式

• 列表推导式
  • 基本格式：变量=[for循环的变量；for循环一个可迭代对象]

vals = [ i for i in 'alex' ]
v1 = [i+100 for i in range(10)]
v2 = [100 for i in range(10)]
v3 = [99 if i >5 else 66 for i in range(10)]
i = [lambda:100+i for i in range(10)]
v4[0]() #109
v = [i for i in range(10) if i > 5]
# 条件成立才append进去

• 集合推导式
  & v1 = {i for i in 'alex'} # 区别在于集合去重
• 字典推导式
  & v1 = {'k'+str(i):i for i in range(10)}

3.带参数的装饰器

# 写一个带参数的装饰器，实现：参数是多少，被装饰的函数就要执行多少次。把每次结果添加到列表中返回
 import random
def x(num):
    def wrapper(func):
        def inner(*args,**kwargs):
            results = []
            for i in range(num):
                value = func(*args,**kwargs)
                if value > num:
                    results.append(value)
            return results
        return inner
    return wrapper

@x(5)
def index():
    return random.randint(0,10)

r = index()
print(r)

4.模块

4.1 sys模块 【python解释器相关的数据】

• \n 换行
• \t 制表
• \r 回到当前行的起始位置

##进度条
for i in range(1,101):
    msg = "%s%%\r" %i
    print(msg,end='')

• 转义
  • 字符串前面加字母r，对字符串内容中的特殊字符进行去伪，比如\n不再有它换行的意义。

s = r""D:\code\s21day14\n1.mp4" 

• sys.argv常用；【获取用户执行脚本时，传入的参数】
  & 获取执行脚本的参数以列表方式存储，默认第0个参数为执行脚本的全路径名

print(arg)
path = sys.argv[1]
print("删除",path)

• sys.exit(0) ; 终止程序

4.2 shutil模块 【删除目录/文件】

import shutil
# 删除目录
ret = shutil.rmtree("")
# 重命名
shutil.move("原文件名","新文件名")
#压缩文件
shutil.make_archive("压缩后的文件名称","压缩成什么格式","需要压缩的目录")
#解压文件
shutil.unpack_archive("需要解压的文件名",extract_dir="解压到哪个目录",format="解压格式")

4.3 os模块 【和操作系统相关的数据】

• os.path.exists(path) # 如果path路径存在返回True
• os.path.abspath() # 获取文件的绝对路径
• os.path.dirname(file) # 获取文件的上级目录
• os.path.join(path,file) # 拼接路径
• os.stas(file).st_size # 获取文件的大小
• os.listdir(path) # 列出一个目录下的所有文件【不包括子目录，第一层】
• os.walk() #列出一个目录（包括）子目录下的所有文件【递归方式】

#查看一个目录下所有的文件
import os
listdir = os.listdir("D:\wuhailuo\python_projects\code\python_jichu\模块作业")
# print(listdir)

# 查询显示指定目录下的所有文件，包括子目录下的所有文件
list_file = os.walk("D:\wuhailuo\python_projects\code\python_jichu\模块作业") #得到一个生成器对象，只有当对其循环是给出结果

for a,b,c in list_file: # a：正在查看的目录，b：此目录下的文件夹,c:此目录下的文件
    for filename in c:
        print(os.path.join(a,filename))

15课/16课 ：模块知识

补充知识点

• range函数：python2/3区别：
  • python2:
    • range(10): 在内存中立即将序列值创建
    • xrang(10): 不会在内存中立即创建，只有当在循环时，边循环边创建
  • python3:
    • range(10) = p2中的xrang（10）

1、模块基础知识

1.1 自定义模块

1.1.1 定义模块

• 定义模块可以把一个py文件或一个文件夹（包）当做一个模块，以便于以后其他py文件的调用。
• 对于包的定义：【python2/3的区别】

py2: 文件夹中必须有 __init__.py
py3:不需要 __init__.py 【推荐写代码时，加上此文件】

1.1.2 模块调用

• import 模块 模块.函数（）
• form 模块 import 函数 函数（）
• form 模块 import 函数 as 别名 别名（）

总结

• 模块和要执行的文件在同一目录且需要模块中的很多功能时，推荐使用import导入模块
• 其他推荐：from 模块 import 模块 模块.函数（）
• 其他推荐：from 模块.模块 import 函数 函数（）

1.1.3 补充

• import

  • import 模块1 模块1.函数（）
  • import 模块1.模块2.模块3 模块1.模块2.模块3.函数（）
  • 特殊： import 文件夹 内部加载 init.py

• from xxx import xxx

  • 特殊：from src import xxx 【内部加载src文件夹的__init__.py】

#！/usr/bin/env python
# -*- coding:utf-8 -*-
# 导入模块，加载此模块中所有的值到内存
import os
# 导入模块中某个函数功能
from lizhongwei import func,show
from lizhongwei import * #导入这个模块的所有功能
from lizhongwei import func as f # 避免函数重复覆盖，取别名

1.2 内置模块

1.2.1 os 模块 import os

• os.mkdir("") 在当前运行脚本的目录创建一个目录（只能生成一级）
• os.makedirs(r"dd\xx\aa") 递归创建目录
• os.rename("") 重命名

1.2.2 sys 模块 import sys

• sys.path 默认Python去导入模块时，按照这个这个值的路径去查找，python文件执行时会将当前文件的路径加载进sys.path里面

import sys
### 给Python添加查找模块的路径
sys.path.append('D:\\ ')    

1.2.3 json模块 【常用】

• json是一个特殊的字符串。【长的像列表、字符串、字典、数字】
  • json中内部包含的字符串必须要用双引号
• json字符串最外层必须是一个容器【列表/字典】
  • 元组序列化后成列表，集合不能序列化
• json格式数据的序列化/反序列化
  • 序列化：将python的值转换成json格式字符串 json.dumps()
  • 反序列化：将json格式字符串 转换Python的数据类型 json.loads()
  • 字典或列表中有中文，序列化要保留中文显示 【ensure_ascii=False】

# 保留中文显示
val = json.dumps(v,ensure_ascii=False)

v = [12,3,4,{'k1':'v1'},True,'asdf']
import json
# 序列化，将python的值转换为json格式的字符串
v1 = json.dumps(v)
s = '["alex",123]'
#反序列化，将json格式的字符串转换为python的数据类型
s1 = json.loads(s)

• json支持python的数据类型

    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict              | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str               | string        |
    +-------------------+---------------+
    | int, float        | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

1.2.4 pickle模块 【与json模块类似】

• json 优点：所有语言通用； 缺点：只能序列化基本的数据类型（字符串，列表，字典，数字）
• pickle 优点：python中所有的东西都能被他序列化（socket对象）； 缺点：序列化的内容只有python能认识。
• pickle.dumps(v) 序列化直接打印是二进制内容，通过pickle.loads(val)处理可正常显示。 【示例下面代码】
• 字节类型pickle序列化后是一个字节类型 比如 b'xxxx' 【示例下面代码】

v = {1,2,3,4,"abc"}
val = pickle.dumps(v) 
print(val)   # b'\x80\x03cbuiltins\nset\nq\x00]q\x01(K\x01K\x02K\x03K\x04X\x03\x00\x00\x00abcq\x02e\x85q\x03Rq\x04.'
******************************
file_obj = open("x.txt",mode='wb')
data = "abc".encode("utf-8")
print(data,type(data))   # b'abc' <class 'bytes'>
file_obj.write(data)
file_obj.close()

1.2.5 time&datetime时间模块