Python零基础入门学习笔记(二)

Python 基础入门学习

三.函数

函数：

def 函数名(参数):
```
**""" 说明文档内容 """**

**代码1**

**代码2**

**.......**
```
注意：参数可有可无，必须先定义后使用

函数中return之后的代码并不会执行

help(函数名) 查看函数解释说明的信息
函数（二）：

局部变量：只在函数体内部生效的变量

全局变量：指在函数体内、外都能生效的变量

在函数体内部修改全局变量：在函数体内部用 global 声明变量为全局变量后修改

函数有多个返回值时： return 后面可以直接书写元组、列表、字典，返回多个值

位置参数：调用函数时根据函数定义的参数位置来传递参数，传递和定义参数的顺序及个数必须一致

关键字参数：函数调用时，通过“键=值”的形式加以指定传参，关键字参数之间不存在先后顺序

缺省参数：也叫默认参数，用于在定义函数时为参数提供默认值，调用函数时可以不传入有默认值的参数。在定义和调用函数时，位置参数必须在缺省参数之前

不定长参数：也叫可变参数，用于不确定调用时会传递多少个参数的场景，可用包裹位置参数或包裹关键字参数来进行参数传递

包裹位置传递(元组)：
```
def 函数名( *args ): 
    print( args )

函数名( 'abc' , 123 )
```
包裹关键字传递(字典)：
```
def 函数名( **kwargs): 
    print( kwargs )
    
函数名( a = 'abc' , b = 123)
```
包裹位置传递和包裹关键字传递都是一个组包的过程，即收集零散数据并组成一个元组或字典

返回值拆包：

元组： return 10, 20 num1, num2 = 函数即得到num1 = 10 , num2 = 20

字典：对字典拆包，得到的是字典的key
交换变量值：

方法一：借助第三变量存储数据

方法二： a, b = b, a
引用：在python中，值是靠引用来传递的

可以用 id() 来判断两个变量是否为同一个值的引用。可以将id理解为那块内存的地址标识。
可变类型与不可变类型：

可变类型：列表(list)、字典(dict)、集合(set)

不可变类型：整型、浮点型、字符串、元组

函数加强应用—学员管理系统：

#定义功能界面函数
def print_info():
    """函数功能界面"""
    print('---select---')
    print('1.add')
    print('2.delete')
    print('3.modify')
    print('4.query')
    print('5.show all')
    print('6.exit')
    print('----end----')

#定义列表等待存储学员信息
info = []

#添加学员信息函数
def add_info():
    """学员添加函数"""
    new_name = input('input name:')
    new_id = input('input id:')
    new_tel = input('input telephone:')

    global info

    for i in info:
        if new_name == i['name']:
            print('name exists!')
            #return 退出当前函数，不执行下面添加信息的代码
            return

    info_dict = {
      
      }
    info_dict['name'] = new_name
    info_dict['id'] = new_id
    info_dict['tel'] = new_tel
    info.append(info_dict)
    print('add successful!')

#删除学员信息
def del_info():
    """学员删除函数"""
    del_name = input('input name:')

    global info

    for i in info:
        if del_name == i['name']:
            info.remove(i)
            print('delete successful!')
            break
    else:
        print('name does not exist!')

#修改学员信息
def modify_info():
    """学员信息修改函数"""
    modify_name = input('input name:')

    global info

    for i in info:
        if modify_name == i['name']:
            i['tel'] = input('input new telephone:')
            print('modify successful!')
            break
    else:
        print('name does not exist!')


#查询学员信息
def search_info():
    """查询信息函数"""
    search_name = input('input name:')

    global info

    for i in info:
        if search_name == i['name']:
            print('---Message---')
            print(f"The name is {i['name']}, The id is {i['id']}, The telephone is {i['tel']}。")
            break
    else:
        print('name does not exist!')

#展示所有学员信息函数
def showall_info():
    """展示信息函数"""
    print('name\tid\ttelephone')

    global info

    for i in info:
        print(f"{i['name']}\t{i['id']}\t{i['tel']}")

while True:
    #1.显示功能界面
    print_info()

    #2.用户输入功能序号
    user_num = int(input('your choice:'))

    #3.按照用户输入的功能序号，执行不同的功能（函数）
    if user_num == 1:
        add_info()

    elif user_num == 2:
        del_info()

    elif user_num == 3:
        modify_info()

    elif user_num == 4:
        search_info()

    elif user_num == 5:
        showall_info()

    elif user_num == 6:
        exit_flag = input('are you sure? Y/N')
        if exit_flag == 'Y':
            break
    else:
        print('Error!')

递归：

特点：函数内部自己调用自己、必须有出口。

#递归函数求1~n的累加和
def num(n):
    #出口
    if n == 1:
        return 1
    #函数内部自己调用自己
    return n+num(n-1)

若没有出口，则报错提示超出最大递归深度（996）。

lambda表达式（匿名函数）：

应用场景： 化简代码。如果一个函数只有一个返回值，并且只有一句代码，可以使用lambda简化。

lambda 参数列表: 表达式

lambda表达式的参数列表可有可无，函数的参数在lambda表达式中完全适用。

lambda表达式能够接收任何数量的参数但只能返回一个表达式的值。

#计算 a+b 的lambda实现
fn = lambda a,b: a+b
print(fn(1,2))
#输出结果： 3

lambda的参数形式：无参、有参、缺省参数（默认）、可变参数*args、可变参数**kwargs。

#无参
fn1 = lambda : 100

#有参
fn2 = lambda a: a

#缺省参数
fn3 = lambda a,b,c=100: a+b+c

#可变参数 *args(元组)
fn4 = lambda *args: args

#可变参数 *kwargs(字典)
fn5 = lambda **kwargs: kwargs

lambda的应用：

#1.带判断的lambda
fn1 = lambda a,b: a if a>b else b  #两个数比大小

fn2 = lambda n: n+fn2(n-1) if n != 1 else 1  #递归求1~n的累加和


#2.列表数据按字典key的值排序
students = [
    {
      
      'name':'Tom','age':19},
    {
      
      'name':'Alice','age':20},
    {
      
      'name':'Hack','age':18}
]

students.sort(key=lambda n: n['name'])  #按照名字首字母升序排序

students.sort(key=lambda n: n['age'], reverse=True)  #按照年龄降序排序

高阶函数：

把函数作为参数传入，这样的函数称为高阶函数（即复合函数）。

测试用到的小函数：

abs()：对数字求绝对值

round()：对数字进行四舍五入

def sum(a, b, f):
    return f(a)+f(b)

result1 = sum(3.14, -2.8, abs)
result2 = sum(3.14, -2.8, round)

#lambda表达式改写
sum = lambda a,b,f: f(a)+f(b)

Python内置高阶函数： map()、reduce()、filter()。

map(func, list) ：将传入的函数变量func作用到列表变量list中的每个元素中，并将结果组成新的列表(python2)/迭代器(python3)返回。

#计算list1序列中各个数字的三次方
list1 = [1,2,3,4,5]

def func(x):
    return x ** 3

result = map(func, list1) #此时result为map返回的迭代器
print(result)  #将返回迭代器result的地址
print(list(result))  #[1, 8, 27, 64, 125]

reduce(func, list)：functools模块中的一个高阶函数，其中func必须有两个参数。每次func结算的结果继续和序列的下一个元素做累积计算。

#计算list2序列中各个数字的累加和
import functools  #导入模块

list2 = [1,2,3,4,5]

def func(a,b):
    return a+b

result = functools.reduce(func,list2)

print(result)  #15

filter(func, list)：用于过滤序列，过滤掉不符合条件的元素，并返回一个filter对象。可用 list() 转换为列表。

#过滤list3序列中所有的偶数，只留下奇数
list3 = [1,2,3,4,5,6,7,8,9]

def func(x):
    return x%2 != 0

result = filter(func,list3)

result = list(result)
print(result)  #[1,3,5,7,9]

四.文件操作

文件操作：

作用：把一些内容（数据）存储存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力。

文件操作步骤：打开文件、读写等操作、关闭文件。

open()：打开一个已经存在的文件，或创建一个新文件。

f = open(name, mode)

#name: 是要打开的目标文件名的字符串（可以包含文件所在的具体路径）
#mode: 设置打开文件的模式（访问模式）:只读、写入、追加等
#此时f为name文件的文件对象，可通过f执行之后的读写等操作

主访问模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式（访问模式未指定时，即为只读模式）。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
(b)	以二进制形式读取
(+)	可读可写

访问模式r+、w+、a+的区别：

r+ ：没有该文件则报错，文件指针在开头故能读取数据

w+ ：没有该文件会新建，文件指针在开头并会用新内容覆盖原有内容，故无法读取文件内原有的数据

a+ ：没有该文件会新建，文件指针在结尾故不能读取数据

写入内容：write()

文件对象.write('内容')

读取内容：read()、readlines()、readline()。

文件对象.read(num)
#num 表示要从文件中读取的数据的长度。不写则默认读取所有数据。其中换行符'\n'会占一位

文件对象.readnlines()
#按照行的方式把整个文件的内容进行一次性读取，并返回一个列表，其中每一行数据为一个元素

文件对象.readline()
#一次读取一行内容、重复调用readline()则依次读取文件中每一行的内容

移动文件指针：seek()

文件对象.seek(偏移量，起始位置)

#起始位置参数： 0开头 1当前 2结尾

应用：

#使用 a 访问模式打开文件，通过改变文件指针位置来读取数据
f = open('test.txt','a')

f.seek(0,0)  #此时可简写为 f.seek(0)
con = f.read()

f.close()

文件备份案例：

#用户输入当前目录下任意文件名，程序完成对该文件的备份功功能（备份文件名为 xx[备份].后缀）

#1.接收用户输入的文件名
old_name = input('input yoru backup file name:')

#2.规划备份文件名
index = old_name.rfind('.')  #文件名中'.'的位置
if index > 0:  #判断文件名，防止出现'.txt'类的无效文件名
    postfix = old_name[index:]

new_name = old_name[:index] + '[备份]' + postfix  #利用字符串的切片重新规划备份文件名

#3.备份文件写入数据
old_f = open(old_name,'rb')
new_f = open(new_name,'wb')

while True:  #循环读取，防止文件过大时卡死
    con = old_f.read(1024)
    if len(con) == 0:  #读取完成时
        break
    new_f.write(con)

new_f.close()
old_f.close()

文件和文件夹的操作：

模块：使用 os 模块

import os

#1.文件操作
#文件重命名，也可以重命名文件夹
os.rename(目标文件名或路径, 新文件名)

#文件删除，也可以删除文件夹
os.remove(目标文件名)

#2.文件夹操作
#创建文件夹
os.mkdir(文件夹名字)

#删除文件夹
os.rmdir(文件夹名字)

#3.目录操作
#获取当前目录
os.getcwd()

#改变当前默认目录
os.chdir(目录文件夹)

#获取目录列表
os.listdir(目录文件夹)

文件和文件夹操作应用案例：

 #批量修改文件名，既可添加指定字符串，又能删除指定字符串

import os

#构造条件数据
flag = input('输入操作类型（1为添加，2为删除）：')

#构造指定字符串
str = input('请输入指定字符串：')

#找到所有文件
file_list = os.listdir()

#添加或删除指定字符串
for i in file_list:
    if flag == '1':
        new_name = str + i
    elif flag == '2':
        num = len(str)
        new_name = i[num:]
    else:
        print('操作模式输入错误！')
        break
    #重命名
    os.rename(i, new_name)