Python基础(2)-函数、文件、异常

第四章 函数

1 函数的概念

1:函数就是一段具有特定功能的代码片段;
2:函数的使用:两步走 A:先定义； B:后调用。
格式:

def 函数名(): # 结尾有:,函数使用def来定义
	代码1 # 强制缩进 --操作步骤
	代码2
	...

1:！一般给函数命名: 动词() 动词_名词() play() play_ball()
2:当一个函数定义好后,一般具有特点:
①通用性；可以应用很多地方
②代码固定了；一旦定义好,函数内的代码尽可能不用更改.

1.2 函数的参数

1:没有参数的函数 = 无参函数(一般叫函数);有参数的函数,叫做有参函数;
2:形参:在【定义】函数时,函数名后面的参数就叫做形式参数,简称为形参; def 函数名(形参1,形参2,xxx)
3:实参:只有在【调用】了函数后,才会有实际参数,简称实参; 函数名(实参1,实参2,xxx) --有实际意义
4:在调用函数时,传递参数要注意:参数的个数、类型、顺序.

1.3 函数的返回值

函数完成一件事情后，最后要返回给函数的结果
返回值语法：

def 函数名（[参数1，参数2，...]）：
	代码1
	代码2
	reyurn 值
)

eg：带有返回值的函数定义

# 1.定义函数
def get_multiply(a,b):
    ret=a*b
    return ret
# 2.调用函数
result=get_multiply(10,20)  #也可以用变量来接收返回值
print(result)

注意:return关键字的作用有两个：把结果返回给函数，结束函数

2 变量的作用域

局部变量

1:局部变量:定义在函数内的变量,就叫做局部变量;
2:全局变量:与函数处于同一级别的变量,定义在模块(.py文件)中的变量,就叫做全局变量.

全局变量名 = 值
def 函数名([局部变量1,局部变量2,...]):
	局部变量x = 值
	代码...
	代码...

3 函数的多种参数

3.1 位置参数

# 1.定义变量
# 2.显示数据,格式化符号
def show_info(name,age):
    print("=="*10)
    print("显示个人信息如下:")
    print("姓名:%s"%name)
    print("年龄:%d"%age)
    print("=="*10)
# 3.调用
show_info("smile",19)
# show_info("smile","19") #报错 TypeError: %d format: a number is required, not str

#报错:缺少位置参数, positional argument:位置参数
TypeError: show_info() missing 1 required positional argument: 'age'

show_info("smile")

3.2 关键字参数

当函数调用时，也通过“键=值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。【个数、类型、顺序】

def 函数名(参数1,参数2,...):
	代码
	...
函数名(参数名1=值,参数名2=值,...) # 关键字参数

eg：定义一个显示姓名、年龄、性别的函数，在调用时使用关键字参数

def show_infos(name,age,sex):
    print("个人信息如下:")
    print(f"姓名:{name}")
    print(f"年龄:{age}")
    print(f"性别:{sex}")
# 调用
show_infos(age=24,name="smile",sex="男")

报错 关键字参数异常

show_infos(age=24,name="smlie",female="男")

运行结果如下：TypeError: show_infos() got an unexpected keyword argument 'female'

3.3 缺省参数！

缺省参数也叫默认参数，用于在定义函数时，为参数提供默认值。
1:当不给缺省参数传递值时,就默认使用默认值;
2:当给缺省参数传递了值时,以传递的值为准.

def show_info(name,age,sex="男"):  # 缺省参数
    print("个人信息如下:")
    print(f"姓名:{name}")
    print(f"年龄:{age}")
    print(f"性别:{sex}")
show_info("smile",18,"女")

3.4 不定长参数！

不定长参数也叫可变参数。用于不确定调用时要传递多少个参数的场景，当然也可以不传递参数。

1:不定长参数可以使用*args、**kwargs; --规范! *fangge **kwfangge
2:*args表示的是元组形式,传递参数时使用位置参数;
3:**kwargs表示的是键值对形式(字典),传递参数时使用关键字参数;
4:两个参数可以一起使用,**kwargs放在结尾处.

定义函数:
def 函数名(参数1,..,*args,**kwargs):
	代码
	...

# # 1.函数1   *args 元组
def get_sum1(*args):
    # print(args)
    # pass
    sum1=0
    for temp in args:
        sum1+=temp
    print(f"多数之和为{sum1}")
get_sum1(1,2)
# 2.函数2     **kwargs 字典
def get_sum2(**kwargs):
    # print(kwargs)
    sum2=0
    for value in kwargs.values():
        sum2+=value
    print(f"多数之和为{sum2}")
get_sum2(a=2,b=24)
# 3.函数3
def get_sum3(*args, **kwargs):
    sum3 = 0
    for temp in args:
        sum3 += temp
    sum4 = 0
    for value in kwargs.values():
        sum4 += value
    print(f"多数之和为{sum4}")
get_sum3(10,20,30,40,a=19,b=199,c=178)

4 拆包和交换变量值

拆包

# 1.定义函数,返回多个数据
def get_sum_sub(a,b):
    sum=a+b
    sub=a-b
    return sum,sub
# 拆包
ret1,ret2 =get_sum_sub(28,10)
print(f"和为:{ret1}")
print(f"差为:{ret2}")
# 2.items()处理
student={"name":"smile","age":"18","gender":"boy"}
# for (key,value) in student.items():  #要不要括号都行
for key,value in student.items():
    print(f"{key}-->{value}")

（1）当要把一个组合的结果快速获取元素数据时，可以使用拆包来完成；
（2）注意：对列表、元组数据结果，都可以使用拆包方式。

！交换变量值
使用拆包方式可以用于交换变量的值。

1.拆包-呼唤两个数位置
a=10
b=98
# (a,b)=(b,a)  #方法一
b,a=(a,b)    #方法二
print(f"变量a={a},b={b}")

data = [12, 3, 14, 56, 7, 100, 1,199]
max_value = data[0]
min_value = data[0]
for temp in data:
    if max_value < temp:
        max_value = temp
    if min_value > temp:
        min_value = temp
print(f"最大值为:{max_value}")
print(f"最小值为:{min_value}")

5 扩展函数：引用&匿名函数

引用
引用可以通俗的称为内存地址值。在Python中，引用有两种表现形式：
（1）十进制数 5040624
（2）十六进制数 0x45AC6
查看引用语法：id(变量名)
我们可以把id()值理解为变量所在内存的地址值。

# 1.定义变量,查看引用
a=10
print(a)
print(id(a))  #140713865091008
# 内存地址值是操作系统随机分配的

alist=[1,2]
blist=[1,2]
print(alist==blist)   # == 比较的是内容值
print(alist is blist)  #is比较的是内存地址值
print(id(alist)) # 2559023101952
print(id(blist)) # 2559023101952

把引用当做参数传递
当定义函数时设定了参数，则在调用函数时也需要传递参数值。
而实际上，当给函数传递参数时，其本质就是：把引用当做参数进行传递。

# 1.定义有参数的函数
def func(a):
    print("=========================")
    print(f"a的引用值:{id(a)}")
    print("=========================")

# 2.外面输出.函数内输出
numbers=100
print(id(numbers))
func(numbers)

运行结构如下：

匿名函数
用的较少，了解
定义匿名函数需要使用lambda关键字，可以创建小型匿名函数。
匿名函数表示没有名字的函数，这种函数得名于省略了用def关键字声明函数的标准步骤。
定义匿名函数语法：
lambda 参数列表 : 表达式
调用匿名函数语法：

函数名 = lambda 参数列表 : 表达式
函数名([参数列表])

eg：使用匿名函数，对比匿名函数

# 定义求和函数,调用
def get_sum(a,b):
    c=a+b
    return c
print(get_sum(19,23))
print(get_sum)  #定义函数时会在内存开辟一块空间存此函数<function get_sum at 0x0000026A92F05160>

# 匿名函数
get_sum1=lambda a,b:a+b
print(get_sum1(19,23))
print(get_sum1)  #定义函数时会在内存开辟一块空间存此函数<function <lambda> at 0x0000026A930CE3A0>

匿名函数有以下几个特点和用途:

简洁：通过lambda关键字定义的匿名函数比一般的函数定义更简洁。
方便传递：由于匿名函数没有函数名，因此可以方便地将其作为参数传递给其他函数。
节省内存：由于匿名函数没有函数名，因此不需要在内存中为其分配一个名称，节省了内存空间。
简单的功能实现：匿名函数通常用于实现一些简单的功能，例如排序和过滤等。

lambda的应用
在实际应用中，为便于简化函数传递处理，我们可以使用lambda表达式作为参数进行传递，但要注意：传递的是一个引用。
eg：（1）把lambda表达式当作参数传递给函数；
（2）求解两个数之和，注意：在函数中定义变量并传递。

def get_sum(func):
    print("=============")
    print(f"输出func的引用值:{func}") #十六进制引用值 输出func的引用值:<function <lambda> at 0x000002937974E3A0>
    x=100
    y=998
    func(x,y)
    print(f"求和:{func(x,y)}")
    print("=============")
get_sum(lambda a,b:a+b)

第五章 文件操作、模块

1 文件操作

操作文件的步骤：变量名.函数名(xxx)

(1)打开文件，或新建一个文件； open()
(2)读取或写入数据内容； 读read() 写write()
(3)关闭文件。close()

1 打开文件
open(name,mode)：创建一个新文件或打开一个已经存在的文件，name指的是文件名，mode指的是访问模式。
对于mode访问模式，如下：

模式	描述
r	以读数据的方式打开文件，这是默认模式，可以省略。
rb	以读二进制原始数据的方式打开文件。
w	以写数据的方式打开文件。如果文件已存在，则打开文件写入数据是会覆盖原有内容。如果文件不存在，则创建新文件。
wb	以写二进制原始数据的方式打开文件。
a	使用追加内容形式，打开一个文件。通常用于写数据，此时会把新内容写入到已有内容后。

2 读写数据
读数据
read()：从文件中一次性读完整的数据。
readlines()：按照行的方式把文件中的完整内容一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
readline()：一次读取一行内容。 A.一行一行读取数据; B.当没有数据时，读取的内容就为空字符串 "“

# ---------------------03-快捷读取内容------------------------------
# (1)打开文件，或新建一个文件； open()
file=open("./file/hello.txt","r",encoding="utf-8")
# (2)写入数据内容； 读read()
text=file.read()
print(text)
# (3)关闭文件。close()
file.close()
print("已读取数据")
# ---------------------04-with open读取内容------------------------------
with open("./file/hello.txt","r",encoding="utf-8") as file1:
    texts1=file1.read()
print(texts1)

其他读取方式：
readlines()：按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。一行文本内容结尾：\n

# (1)打开文件，或新建一个文件； open()
file=open("./file/hello.txt","r",encoding="utf-8")
# (2)写入数据内容  # 使用readlines()读取
lines=file.readlines()
print(lines)
# (3)关闭文件。close()
file.close()
print("已读取数据")

readline()：一次读取一行内容。

# 使用readline()读取
while True:
    line=file.readline()
    print(line)
    if len(line)==0:
        break

写数据
write(seq)：将数据内容写入文件。
（1）一定要注意mode访问模式是w、wb，才能使用write()；
（2）一般情况下，write()能写入字符串或二进制数据。 --若要把其他类型的数据写入文件，需转类型。
（3）read()读也是读取字符串或二进制数据。–若要把字符串类型的结果表示成其他类型，需转类型。

# (1)打开文件，或新建一个文件； open()
file=open("./file/test2.txt","w",encoding="utf-8") #中午需要设置编码encoding="utf-8"

# (2)读取或写入数据内容； 读read() 写write()
file.write("你好，python")

# (3)关闭文件。close()
file.close()
print("已写入数据")

3 关闭文件
close()：关闭文件

file.close()

2 备份文件

3 模块

Python模块(Module)，指的是以.py结尾的Python文件。
模块名是标识符。它可以包含了Python对象定义和Python语句。
模块中能定义函数、变量和类，也能包含其他一些可执行的代码，例如print(xxx)等。
在使用模块前，需要想导入模块，有3种方式：

import 模块名1[, 模块名2...]
from 模块名 import 功能1[, 功能2, 功能3...] 不推荐使用，通常用于对框架内容的导入，框架功能多便于细化
from 模块名 import *不推荐使用，加载缓慢，不好阅读程序

import导入模块时，搜索路径：

a.当前目录下找模块
b.找到PATH变量下的环境变量：当前python解释器所在的路径
c.去当前系统用户目录下

3.1 os模块

os模块包含有操作系统所具备的功能，如查看路径、创建目录、显示文件列表等
① 查看目录
exists(pathname)：用来检验给出的路径是否存在。
isfile(pathname)：用来检验给出的路径是否是一个文件。
isdir(pathname)：用来检验给出的路径是否是一个目录。
abspath(pathname)：获得绝对路径。
join(pathname,name)：连接目录与文件名或目录。
basename(pathname)：返回单独的文件名。
dirname(pathname)：返回文件路径。

import os
path="./data/file/hello.txt"
print(os.path.exists(path))
# 是否是文件
print(os.path.isfile(path))
# 目录
print(os.path.isdir(path))
# 绝对路径
print(os.path.abspath(path))
# 单独文件名
print(os.path.basename(path))

② 目录的具体操作
getcwd()：获得当前工作目录，即当前Python脚本工作的目录路径。
system(name)：运行shell命令。
listdir(path)：返回指定目录下的所有文件和目录名，即获取文件或目录列表。
mkdir(path)：创建单个目录。
makedirs(path)：创建多级目录。
remove(path)：删除一个文件。
rmdir(path)：删除一个目录。
rename(old, new)：重命名文件。

import os
# 1.获取当前目录
path=os.getcwd()
print(path)
# 2.获取文件或列表信息
path_name="./data/file"
dir_lists=os.listdir(path_name)
print(dir_lists)
# 3.新建目录：当目录不存在时才需要创建,已存在则不创建
new_path_name="./data/file/hello/world/python"
if not os.path.exists(new_path_name): #如果目录不存在，创建目录
    # 创建文件
    os.makedirs(new_path_name)
    print("创建成功")

Python路径问题

path1="F:\Study\code\pycode\pyproject\day05\data\file\hello.txt"
path2="F:\\Study\\code\\pycode\\pyproject\\day05\\data\\file\\hello.txt"
path3="F:/Study/code/pycode/pyproject/day05/data/file/hello.txt"
path4=r"F:\Study\code\pycode\pyproject\day05\data\file\hello.txt" #正则,原始字符串

3.2 math模块

pow(x, y)：返回xy（x的y次方）的值。
sqrt(x)：返回数值x的平方根。

# 1.导入模块
import math
# 2.求解次方
print(math.sqrt(16))
# 3.求解平方根
print(math.pow(2,10))

ceil(x)：返回数值x的上入整数，如math.ceil(6.3)返回7。
floor(x)：返回数值x的下舍整数。

# 1.导入模块
from math import ceil,floor
# 2.上入
print(ceil(3.14))
# 3.下舍
print(floor(3.14))

3.3 time模块

time模块用于表示时间日期，常用函数如下：
sleep(t):休眠，即延迟运行，注意参数t的单位为秒(s)。
time():返回时间戳，即当前时间毫秒数(与1970年1月1日午夜之间的时间差)。

# 1.导入模块
import time
# 2.使用方法
current_time=time.time()
print(current_time)

eg:5秒倒计时

i=5
while i>0:
    print(i)
    time.sleep(1)
    i-=1

3.4 模块取别名

取了别名后只能用别名调用函数

# import  math as m 
from math import sqrt as sq
# print(m.sqrt(9))
# print(m.pow(2,10))

print(sq(9))

3.5 自定义模块(制作模块)

模块(模块)可以分为3类:

1:标准库 --Python自带的库;
2:扩展库(第三方库) 需要额外安装的库: pip install xxxx
3:自定义库:自定义模块. --定义模块、调用模块
A:模块 == 库
B:[当一个模块很强大时,专业的术语]框架. Django / PySpark / PyFlink

eg:定义与调用模块

自定义模块,mytool.py文件内容如下:

def add(a,b):
    c=a+b
    print(f"两数之和为:{c}")

调用mytool自定义模块,mytest.py文件如下:

import mytool
mytool.add(10,20)

制作模块的几个注意事项
__name__ 变量

1:每个模块中都会有一个__name__变量;
2:当在当前模块输出__name__变量时的值__main__。

在实际开中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果，这个开发人员会自行在py文件中添加一些测试信息.，例如，在 mytool2.py 文件中添加测试代码。
此时就要注意每个模块中都有的 __name__ 变量，语法：

当__name__在当前模块下测试输出结果: __main__
当在另外的模块里调用输出时,结果: 当前模块名

__all__ 变量
如果一个模块文件中有 all 变量，当使用 from xxx import * 导入时，只能导入这个列表中的元素。作用：限制*的取值范围。
语法：
__all__ = ["函数名1","函数名2",xxx]
例如，在自定义模块中有4个函数，但设置了 all 变量值，观察使用 from xxx import * 导入后的调用效果。

3.6 制作Python包

方法一:新建空白文件夹,在文件夹下新疆命名为__init__.py的Python文件

方法二:右键新疆python包

第六章 异常

1.常见的异常类型

1.NameError:直接使用未定义的变量

print(a)

print(a) NameError: name 'a' is not defined
2.IndexError：获取了一个远超列表索引值的元素

# 2.IndexError
strs="hello"
print(strs[100])

print(strs[100]) IndexError: string index out of range
3.KeyError

# 3.KeyError
dicts={}
print(dicts["name"])

print(dicts["name"]) KeyError: 'name'
4.TypeError

print("hello"+666)

print("hello"+666) TypeError: can only concatenate str (not "int") to str

strs="hello"
print("结果:%d"%strs)

print("结果:%d"%strs) TypeError: %d format: a number is required, not str

5.FileNotFoundError

open("./test.txt","r")

open("./test.txt","r") FileNotFoundError: [Errno 2] No such file or directory: './test.txt'

2 异常处理

当程序中遇到了异常时，通常程序会出现崩溃情况。
为了不让程序崩溃，就可以使用异常来快速处理。
异常处理语法：

try:
	可能发生异常的代码
except:
	如果出现异常时, 执行的代码

# 1.制造异常 2.处理
try:
    datas=[1,2,3]
    print(datas[100]) #异常 中断
except:
    print("已经发生了异常")
print("1111111111")  #当处理了异常后,程序可以稳定继续往后的代码

1 捕获一个异常

try:
    可能发生异常的代码
except 异常类型名:
    当捕获到该异常类型时，执行的代码

# 1.可能发生异常 # 2.捕获
print("1")
try:
    print("2")
    datas=[1,2,3]
    print(datas[100]) #异常 中断
    print("3")
except IndexError:
# except TypeError: #报错,IndexError捕获不到
    print("4")
    print("发生了IndexError异常")
print("5")

运行结果如下：

2 捕获多个异常
语法：

try:
    可能发生异常的代码
except (异常类型1,类型2,...):
    如果捕获到该异常类型时,执行的代码

# 1.可能发生异常的代码
try:
    data=[1,2,3]
    print(data[100])
    dicts={}
    print(dicts["name"])
except IndexError:
    print("发生了IndexError异常")
except KeyError:
    print("发生了KeyError异常")
print("11111111")

3 捕获所有异常
语法：

try:
    可能发生异常的代码
except Exception[ as 变量]:
    当捕获到该异常类型时，执行的代码

Exception的首字母要大写。

# 捕获所有异常
try:
    data=[1,2,3]
    print(data[100])
    dicts={}
    print(dicts["name"])
except Exception:
    print("发生了异常...")
print("hello world")

异常的其他关键字:else,finally

# 1.制造异常 # 2.处理指定异常
try:
    data=[1,2,3]
    print(data[100])
except:
    print("=====1======已发生异常信息")
else:   # 3.else :没有发生异常时,处理的事情
    print("没有发生异常时,才会执行代码")
finally:   # 4.finally:文件必须关闭
    print("无论如何,都会执行finally!!")

总结：

（1）关键字else、finally可以配合异常处理一起使用；

（2）注意：当使用finally部分代码时，可以用于完成一些必须完成的操作，例如关闭文件、关闭系统资源等。[思考]

异常面试题:

def test():
    try:
        strs="abc"
        print(strs[60])
    except:
        # print("ssss")
        return 1
    finally:
        return 2
print(test())

结果为2,因为返回值2覆盖了前面的返回值1

异常具有传递性:当一段可能发生异常的代码，发生了异常时，若不处理，则会传递给调用处