2019年Python入门到精通_个人代码及笔记_02

目录：

1. 函数1
2. 函数2
3. 引用
4. 函数应用
5. 递归
6. lambda表达式
7. 高阶函数
8. 文件操作

1. 函数1

#1.定义函数
def func_print(i):
    print(i)

def func_add(i,j):
    print(i+j)

def func_str():
    return 'money' #返回值 + 退出当前函数

def func_sum(i,j):
    """说明文档：求和函数"""
    return i+j

def testB():
    print('I am testB')
    print('testB over')

def testA():
    print('I am testA')
    testB()
    print('testA over')

def print_line():
    print('-' * 20)

def print_lines(num):
    i = 0
    while i < num:
        print_line()
        i += 1

def sum_num(a,b,c):
    """三个数求和"""
    return a + b + c

def average_num(a,b,c):
    """求三个数平均值"""
    return sum_num(a,b,c)/3 #浮点数

#2.调用函数
c = [1,2,2,3]
func_print(c)

#3.函数的参数作用
func_add(5,6)

#4.函数的返回值作用
dollar = func_str()
print(dollar)

#5.函数的说明文档
print('\n函数说明help(函数名)：--------------------')
help(func_sum) #查看函数的说明文档help()
print('------------------------------------------')
print(func_sum(3,4))

#6.函数嵌套调用
print('\n函数嵌套调用：')
testA()

#7.函数嵌套调用应用
print('\n函数嵌套调用应用：')
print('应用1：打印多条横线')
#print_line()
print_lines(5)
print('应用2：求三个数平均值')
print(average_num(3,6,9))

输出结果：

2. 函数2

#1)变量作用域
print('1）变量作用域：')
#1.局部变量
def testA():
    a = 100 #局部变量，在函数体内部，临时保存数据
    print(a)
testA() #100
#2.全局变量
a = 100 #全局变量，在函数体内、外部都能生效
def testB():
    print(a)
def testC():
    global a #声明为全局变量
    a = 200 #在局部修改全局变量，加了global a后变为全局变量
    print(a)
testB() #100
testC() #200
print(a) #200

#2)多函数程序执行流程
print('\n2)多函数程序执行流程：')
#1.公用全局变量
print('1.公用全局变量：')
glo_num = 0
def test1():
    """修改glo_num为全局变量"""
    global glo_num
    glo_num = 100
def test2():
    """调用test1函数中修改后的全局变量"""
    print(glo_num)
test2() #0
print(glo_num) #0
test1()
test2() #100
print(glo_num) #100，调用test1后glo_num值变为100
#2.返回值作为参数传递
print('2.返回值作为参数传递：')
def test3():
    return 50
def test4(num):
    print(num)
result = test3() #保存函数test3的返回值
test4(result) #将函数返回值所在变量作为参数传递到test4函数

#3)函数的返回值
print('\n3)函数的返回值：')
def return_num():
    #return 1,2 #默认返回的是 元组
    #return (10,20) #返回的是 元组
    #return [10,20] #返回的是 列表
    return {'name':'Tom','age':20} #返回的是 字典
result = return_num()
print(result) 

#4)函数的参数
print('\n4)函数的参数：')
#1.位置参数
print('1.位置参数：',end='')
def user_info(name,age,sex):
    print(f'名字是：{name},年龄是：{age},性别是：{sex}') #传递和定义 的参数的 顺序和个数 须一致
user_info('Tom',20,'male')
#2.关键字参数
print('2.关键字参数：',end='')
user_info('Sarah',sex='female',age=18) #key = value，顺序可以打乱 #位置参数(name)必须写在关键字参数的前面
#3.缺省参数 (默认参数)
print('3.缺省参数：')
def user_info1(name,age,sex='male'): #sex默认参数为male
    print(f'名字是：{name},年龄是：{age},性别是：{sex}')
user_info1('Mike',19) #没有为缺省参数传值
user_info1('Amy',18,'female') #为缺省参数传值
#4.不定长参数 (可变参数)
print('4.不定长参数：') #组包的过程
#①包裹位置传递
print('①包裹位置传递：')
def user_info2(*args):
    print(args) #args是元组类型
user_info2('Tom') #元组
user_info2('Tom',18) #元组
user_info2() #空元组
#②包裹关键字传递
print('②包裹关键字传递：')
def user_info3(**kwargs):
    print(kwargs) #kwargs是字典类型
user_info3() #空字典
user_info3(name='Tom',age='18',sex='male') #字典

#5)拆包和交换变量值
print('\n5)拆包和交换变量值：') 
#1.元组 拆包
print('1.元组拆包：')
def return_numb():
    return 100,200
num1,num2 = return_numb() #元组拆包
print(num1)
print(num2)
#2.字典 拆包
print('2.字典拆包：')
dict1 = {'name':'Tom','age':20}
dict_a,dict_b = dict1 #对字典进行拆包，取出来的是字典的key
print(dict_a) #name #key值
print(dict_b) #age
print(dict1[dict_a]) #Tom #value值
print(dict1[dict_b]) #20
#3.交换变量值
print('3.交换变量值：')
#①方法一：
print('①方法一：')
num1,num2 = 10,20
tmp = 0 #定义中间变量
tmp = num1
num1 = num2
num2 = tmp
print(num1) #20
print(num2) #10
#②方法二：
print('②方法二：')
num_a,num_b = 1,2
print(f'a是：{num_a},b是：{num_b}')
num_b,num_a = num_a,num_b #交换变量
print(f'a是：{num_a},b是：{num_b}')

输出结果：

3. 引用

#值 靠 引用 传递
#1）可变和不可变
print('1)可变和不可变：')
#1.不可变类型：int
print('1.不可变类型int：') #不修改原数据int,float,str,tuple                                        
#id()判断两个变量是否为同一个值的引用
a = 1
b = a
print(b) #1
print(id(a)) #id()内存的十进制值
print(id(b)) #b和a的id值相同

a = 2
print(b) #1
print(id(a)) #a的id值改变
print(id(b)) #b的id值不变

#2.可变类型：list
print('2.可变类型list：') #直接修改原数据list,dict,set
aa = [100,200]
bb = aa
print(bb) #[100,200]
print(id(aa))
print(id(bb)) #bb和aa的id值相同

aa.append(300)
print(bb) #[100,200,300]
print(id(aa)) #aa的id值不变
print(id(bb)) #bb的id值不变

#2）引用当作实参
print('\n2）引用当作实参：')
def test1(a):
    print(a)
    print(id(a))

    a += a
    print(a)
    print(id(a)) #int类型id值改变，list类型id值不变

b = 100
test1(b) #前后id值不同
c = [100,200]
test1(c) #前后id值相同 

d = (300,400) #元组
test1(d) #前后id值不同

输出结果：

4. 函数应用

#函数应用：学生管理系统(该系统不允许学生姓名相同)
print('1)应用：学生管理系统')

info = [] #用于存储学生信息

def info_print():
    print('请选择功能--------------------')
    print('1.添加学生')
    print('2.删除学生')
    print('3.修改学生')
    print('4.查询学生')
    print('5.显示所有学生信息')
    print('6.退出系统')
    print('-' * 30)

#1)添加学生函数
def add_info():
    """添加学生"""
    #1.用户输入：学号、姓名、手机号
    new_id = input('请输入学号：')
    new_name = input('请输入姓名：')
    new_tel = input('请输入手机号：')

    #2.判断是否添加这个学生
    global info #声明info是全局变量，可以修改
    #2.1学生已存在
    for i in info:
        if new_name == i['name']:
            print('该用户名已存在')
            #退出当前函数，后面的代码不执行
            return

    #2.2学生不存在
    info_dict = {}
    info_dict['id'] = new_id
    info_dict['name'] = new_name
    info_dict['tel'] = new_tel
    print(f'输入的学生信息是：{info_dict}')

    info.append(info_dict) #列表 追加 字典 学生数据
    print(f'目前学生列表数据：\n{info}')

#2)删除学生函数
def del_info():
    """删除学生"""
    #1.用户输入学生的姓名
    del_name = input('请输入要删除的学生姓名：')

    #2.判断学生姓名是否存在
    global info
    #2.1学生姓名存在
    for i in info:
        if (del_name == i['name']):
            info.remove(i) #已存在则删除
            break
    #2.2学生姓名不存在
    else:
        print('该学生不存在')
    print(f'目前学生列表数据：\n{info}')

#3)修改学生函数
def modify_info():
    """修改学生"""
    #1.用户输入学生的姓名
    modify_name = input('请输入要修改的学生姓名：')

    #2.判断学生姓名是否存在
    global info
    #2.1学生姓名存在则修改手机号
    for i in info:
        if modify_name == i['name']:
            i['tel'] = input('请输入新的手机号：')
            break
    #2.2学生姓名不存在
    else:
        print('该学生不存在')
    print(f'目前学生列表数据：\n{info}')

#4)查询学生函数
def search_info():
    """查询学生"""
    #1.用户输入学生的姓名
    search_name = input('请输入要查询的学生姓名：')
    #2.判断学生姓名是否存在
    global info
    #2.1学生姓名存在
    for i in info:
        if search_name == i['name']:
            print('该学生信息为：--------------------')
            print(f"学号：{i['id']}，姓名：{i['name']}，手机号：{i['tel']}")
            break
    #2.2学生姓名不存在
    else:
        print('该学生姓名不存在')

#5)显示所有学生信息函数
def print_all():
    """显示所有学生信息"""
    print('学号\t姓名\t手机号')
    for i in info:
        print(f"{i['id']}\t{i['name']}\t{i['tel']}")

while True:
    #1.显示功能界面
    info_print()
    #2.用户输入功能序号
    user_num = int(input('请输入功能序号'))
    #3.根据用户输入的功能序号，执行不同的功能(函数)
    if user_num == 1:
        print('添加：')
        add_info() #1)添加学生函数
    elif user_num == 2:
        print('删除：')
        del_info() #2)删除学生函数
    elif user_num == 3:
        print('修改：')
        modify_info() #3)修改学生函数
    elif user_num == 4:
        print('查询：')
        search_info() #4)查询学生函数
    elif user_num == 5:
        print('显示所有学生信息：')
        print_all() #5)显示所有学生信息函数
    elif user_num == 6:
        print('退出系统：') 
        exit_flag = input('确定要退出吗？')
        if (exit_flag == 'yes'):
            break
        else:
            continue
    else:
        print('输入的功能序号有误')

输出结果：

5. 递归

#递归
#1)函数内部自己调用自己
#2)必须有出口

#求5以内数字累加和
#5 + 4 + 3 + 2 + 1
def sum_numbers(num):
    #2)出口 #如果没有出口，会报错：超出最大递归深度
    if (num == 1):
        return 1
    #1)自己调用自己
    return num + sum_numbers(num-1)

result = sum_numbers(5) #递归函数
print(result) #5+4+3+2+1

输出结果：

6. lambda表达式

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

#1)lambda语法：
print('1)lambda语法：')
#1.函数
print('1.函数：')
def fn1():
    return 100

result = fn1()
print(result) #100
#2.lambda表达式
print('2.lambda表达式：')
#lambda 参数列表 : 表达式
fn2 = lambda : 200
print(fn2) #<function <lambda> at 内存地址
print(fn2()) #200

#2)lambda应用：
print('\n2)用lambda计算 a+b ：')
#1.函数实现：
print('1.函数实现：',end='')
def add(a,b):
    return a+b
result = add(2,3)
print(result)
#2.lambda实现：
print('2.lambda实现：',end='')
fn3 = lambda a,b : a+b
print(fn3(2,3))

#3)lambda参数形式
print('\n3)lambda参数形式：')
#1.无参数
print('1.无参数：',end='')
func1 = lambda : 100
print(func1())
#2.一个参数
print('2.一个参数：',end='')
func2 = lambda a : a
print(func2('hello world'))
#3.默认参数 (缺省参数)
print('3.默认参数：',end='') 
func3 = lambda a,b,c=100 : a+b+c
print(func3(10,20)) #130,c默认值为100
#4.可变参数*args (位置：元组)
print('4.可变参数*args：',end='')
func4 = lambda *args : args
print(func4(10,20,30)) #返回元组(10,20,30)
#5.可变参数**kwargs (关键字：字典)
print('5.可变参数**kwargs：',end='')
func5 = lambda **kwargs : kwargs
print(func5(name='Tom',age=20)) #返回字典{'name'='Tom','age'=20}

#4)lambda应用：
print('\n4)lambda应用：')
#1.带判断的lambda
print('1.带判断的lambda：',end='') #三目运算符
function1 = lambda a,b : a if a > b else b
print(function1(10,5)) #(a=)10
#2.列表数据按字典key的值排序
print('2.列表数据按字典key的值排序：')
students = [
    {'name':'Jack','age':20},
    {'name':'Mike','age':18},
    {'name':'Tony','age':19}
    ]
#①按age值升序排列
print('①按age值升序排列：')
students.sort( key=lambda x : x['age']) #x是形参
print(students)
#按age值降序排列
print('①按age值降序排列：')
students.sort( key=lambda x : x['age'],reverse=True)
print(students)

输出结果：

7. 高阶函数

import functools

#高阶函数：把函数作为参数传入
#1)基本高阶函数：
print('1)基本高阶函数：')
#1.方法1
print('1.方法1：',end='')
def add_num(a,b):
    return abs(a) + abs(b)

result = add_num(-1,2)
print(result) #3
#2.方法2
print('2.方法2：',end='')
def sum_num(a,b,f): #f是任意函数名
    return f(a) + f(b)

result2 = sum_num(-1,2,abs)
print(result2,end=',') #3
result3 = sum_num(-1.2,1.8,round)
print(result3) #1

#2)内置高阶函数：
print('2)内置高阶函数：')
#1.map(func,lst) #将函数func作用在lst变量的每个元素中
print('1.map()：') 
list1 = [1,2,3,4,5]
def func(x):
    return x**2
result_map = map(func,list1)
print(result_map) #map object at 内存地址
print(list(result_map)) #转换为list类型 #[1,4,9,16,25]
#2.reduce(func,lst) #func必须有两个参数，每次func计算的结果 继续和序列的下一元素做累积计算
print('2.reduce()：')
list2 = [1,2,3,4,5]
def func2(a,b):
    return a + b
result_reduce = functools.reduce(func2,list2)
print(result_reduce) #15
#3.filter(func,lst) #用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象
print('3.filter()：')
list3 = [1,2,3,4,5,6,7,8,9,10]
def func3(x):
    return x % 2 == 0
result_filter  = filter(func3,list3)
print(result_filter) #filter object at内存地址
print(list(result_filter)) #转换为list类型 #[2,4,6,8,10]

输出结果：

8. 文件操作

import os 

#1)文件的基本操作
print('1)文件的基本操作：')
#1.打开 #open(name,mode) #name：要打开的目标文件名的字符串 #mode：设置打开文件的模式(访问模式)：只读(默认)、写入、追加等
#r/w/a          只读(文件的指针在开头)/写入(文件的指针在开头)/追加(文件的指针在结尾)
#rb/wb/ab       二进制只读/二进制写入/二进制追加
#r+/w+/a+       打开一个文件用于读写(不存在则报错/不存在则写入(存在则覆盖)/不存在则写入(存在则追加))
#rb+/wb+/ab+    二进制打开一个文件用于读写(不存在则报错/不存在则写入(存在则覆盖)/不存在则写入(存在则追加))

#r 只读，如果文件不存在则报错；不支持写入操作 #mode不写的情况下默认执行；
f = open('python.txt','r')
#w 写入，如果文件不存在则新建文件；执行写入会覆盖原有内容；
'''f = open('python.txt','w') #当前目录下python.txt 写入操作'''
#a 追加，如果文件不存在则新建文件；在原有内容基础上追加新内容；
'''f = open('python.txt','a') #当前目录下python.txt 追加操作'''

#2.文件对象.seek(偏移量,起始位置) #改变文件指针位置 #起始位置：0文件开头 / 1当前位置 / 2文件结尾
f.seek(2,0) #文件指针 指向 文件开头，偏移2个字节

#3.读写  
#①文件对象.write()
'''f.write('bbb') #写入 #追加'''
#②文件对象.read(num) #不写num则读取全部数据，num表示读取数据的长度(字节数)
print(f.read()) #读取全部数据
'''print(f.read(10)) #读取10个字节数'''
#③文件对象.readlines() #按行读取整个文件，并且返回一个列表，每一行的数据为一个元素
'''print(f.readlines())'''
#④文件对象.readline() #一次读取一行内容
'''print(f.readline()) #第一次调用读取第一行
print(f.readline()) #第二次调用读取第二行'''

#4.关闭 #文件对象.close()
f.close()

#2)文件备份
print('\n2)文件备份：')
#1.接收用户输入的文件名
old_name = input('请输入你要备份的文件名：')
print(f'输入的文件名是：{old_name}') 
print(f'输入的文件名类型是：{type(old_name)}')
#2.规划备份文件名
#2.1提取目标文件后缀
index = old_name.rfind('.') #'.'的下标位置
print(f'文件名是：{old_name[:index]}')
print(f'文件格式名是：{old_name[index:]}')

'''判断用户输入的文件名是否有效'''
if (index > 0):
    input_name = old_name[index:]

#2.2组织备份的文件名，xx(备份)后缀
new_name = old_name[:index] + '(备份)' + input_name
print(f'新的文件名是：{new_name}')
#3.备份文件写入数据
#3.1打开源文件 和 备份文件
old_file = open(old_name,'rb') #读取
new_file = open(new_name,'wb') #写入
#3.2将源文件数据写入备份文件
while True:
    length = old_file.read(1024) #循环读取源文件的1024个字节
    if (len(length) == 0):
        #表示读取完成
        break
    new_file.write(length)
#3.3关闭文件
old_file.close()
new_file.close()

#3)文件和文件夹的操作
print('\n3)文件和文件夹的操作：')
#1.rename()：重命名
'''os.rename('src.txt','dst.txt')'''
#2.remove()：删除文件
'''os.remove('dst.txt')'''
#3.创建文件夹
'''os.mkdir('python') #前提是 python文件夹 不存在'''
#4.删除文件夹
'''os.rmdir('python')'''
#5.获取当前目录
print('当前目录路径为：')
print(os.getcwd())
#6.改变目录路径
'''
os.mkdir('aa') #创建'aa'文件夹
os.chdir('aa') #切换目录到'aa'文件夹
os.mkdir('bb') #在aa文件夹目录下 创建'bb'文件夹
'''
#7.获取目录列表
print('当前目录路径所有文件名为：')
print(os.listdir()) #获取指定文件夹目录下(当前目录下)所有文件，返回一个列表
'''print(os.listdir('aa')) #获取指定文件夹目录下(当前目录'aa'文件夹下)所有文件，返回一个列表'''
#8.重命名文件夹
'''os.rename('bb','ccc')'''

#9.批量重命名 Python_xx / 批量删除 Python_xx 重命名
'''
flag = 1 #1重命名/2删除重命名
#9.1找到所有文件：获取code文件夹的目录列表 -- listdir()
file_name = os.listdir()
print('\n当前目录路径所有文件名为：')
print(file_name) #获取指定文件夹目录下(当前目录下)所有文件，返回一个列表
#9.2构造名字
for i in file_name:
    if (flag == 1):
        #new_filename = 'Python_' + 原文件i
        new_filename = 'Python_' + i
    elif (flag == 2):
        #删除前缀
        num = len('Python_')
        new_filename = i[num:]
    #9.3重命名
    os.rename(i,new_filename)
'''

输出结果：