python学习笔记(2)

接python学习笔记(1)

一、python之公共方法

enumerate()	用于将一个可遍历的数据对象(列表，元组，字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中

len()的例子

dict1={"name":"python","age":20}
print(len(dict1))
结果为:2

del的例子：

str1="aa"
del str1
print(str1)

max()和min()的例子：

list1=[1,2,3,4,6]
str1="abcdhfiaopr"
print(max(str1))
print(min(list1)
结果为：
r
1

range()的例子：range()要和for循环配合使用，只用print是显示不出结果的

for i in range(10):  #不写开始，默认从0开始，到10结束，不包含10
    print(i)
结果为：
0 1 2 3 4 5 6 7 8 9

enumerate()的例子

语法：enumerate(可遍历对象,start=0)
start参数用来设置遍历数据的下标的起始值，默认为0
返回结果是元组，元组第一个数据是数据的下标，第二个是数据本身

list1=["a","b","c","d"]
for i in enumerate(list1):
    print(i)
结果为：
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')

设置start参数：

list1=["a","b","c","d"]
for i in enumerate(list1,start=1):
    print(i)
结果为：
(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')

二、数据类型的转换

1、tuple():将某个序列转换成元组

list1=["a","b","c","d"]
s1=(10,20,30,40)
s1={4,5,6,7}
print(tuple(list1))
print(tuple(s1))
结果为：
('a', 'b', 'c', 'd')
(4, 5, 6, 7)

list():将某个序列转换成列表

list1=["a","b","c","d"]
t1=(10,20,30,40)
s1={4,5,6,7}
print(list(t1))
print(list(s1))
结果为：
[10, 20, 30, 40]
[4, 5, 6, 7]

set():将某个序列转换成集合

list1=["a","b","c","d","a"]
t1=(10,20,30,40,10,10)
s1={4,5,6,7}
print(set(list1))
print(set(t1))
集合具有去重功能，不支持下标，结果为：
{'a', 'c', 'd', 'b'}
{40, 10, 20, 30}

三、推导式

什么叫做推导式？

推导式就是化简python代码用的
只支持以下三种推导式：
列表推导式，字典推导式，集合推导式

1、列表推导式

用一个表达式创建一个有规律的列表或控制一个有规律的列表

要求：写一个0-9的列表
不用推导式写出来的代码

用while循环实现
i=0
list=[]
while i<10:
    list.append(i)
    i+=1
print(list)
用for循环实现：
list=[]
for i in range(10):
    list.append(i)
print(list)
结果都为：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

用推导式写出来的代码：
写法：都要用到for循环，返回数据要在最左侧填写，即i

list=[i for i in range(10)]
print(list)
结果为：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

带if的列表推导式

需求：创建0-10之间的偶数列表
1、可以用range()步长实现

list=[i for i in range(0,10,2)]
print(list)
结果为：[0, 2, 4, 6, 8]

2、if实现

list=[i for i in range(10) if i%2==0]
print(list)
结果为：[0, 2, 4, 6, 8]

多for循环实现列表推导式

需求：创建列表如下：
【(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)】
如果用嵌套是写效果如下：

list=[]
for i in range(1,3):
    for j in range(3):
        list.append((i,j))
print(list)

用推导式写如下：

list=[(i,j) for i in range(1,3) for j in range(3)]
print(list)

2、字典推导式

快速合并列表为字典，或提取字典中的目标数据

需求：创建一个字典，key为1-5的数字，value为这个数字的2次方

dict1={i:i**2 for i in range(1,6)}
print(dict1)
结果为:
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

将两个字典合并为一个字典

list1=["name","age","gender"]
list2=["tom",20,"man"]
dict1={list1[i]:list2[i] for i in range(len(list1))} 
print(dict1)
两个列表数据个数要相同，不然会报出范围越界的错误
结果为：
{'name': 'tom', 'age': 20, 'gender': 'man'}

提取字典中目标数据
需求：

提取电脑台数大于200的电脑品牌

counts={"dell":268,"lenovo":199,"acer":300,"hp":124}
count1={key:value for key,value in counts.items()if value>200}
print(count1)
结果为：
{'dell': 268, 'acer': 300}

3、集合推导式

使用几率没有前两个高

list1=[1,1,2]
set1={i**2 for i in list1}
print(set1)
结果为：
{1, 4}  集合会去重哦

四、函数(重点)

1、函数的作用

函数就是将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用这个名称即可完成对应的需求。
函数在开发过程中，可以封装代码，实现高效的代码重用

2、函数的使用步骤

1、定义函数

def 函数名(参数):
	代码1
	代码2
	......

2、调用函数

函数名(参数)

注意：
1、不同的需求，参数可有可无
2、在python中，函数必须先定义，后使用
3、当调用函数的时候，解释器会回到定义函数的地方去执行下方缩进的代码，当这些代码执行完，回到调用函数的地方继续向下执行

3、函数的参数作用

可以传入要变化的数据，让函数使用起来更加灵活

def add_num(a,b):#a,b都为形参
    result=a+b
    print(result)

add_num(10,3)  #10,3为真是数据，为实参
结果为：13

4、函数的返回值作用

在函数中，如果需要返回结果给用户，需要使用函数返回值

def buy():
    return "烟"
    print("ok")
goods=buy()
print(goods)
结果为：烟

注意：
1、return退出当前代码，导致return下方的所有代码不执行

5、应用

需求：制作一个计算器，计算任意两个数字之和，并保存结果

def sum_num(x,y):
    return x+y

result=sum_num(1,2)
print(result)
结果为：3

6、函数的说明文档

定义一个函数之后，程序员如何书写程序能够快速提示这个函数的作用？
如果代码很多，我们要找到函数才能看到注释，如果想要更方便的查看函数的作用，就用到函数的说明文档

语法：
定义函数的说明文档

def 函数名(参数):
	"说明文档的位置"
	代码
	......

查看函数的说明文档

help(函数名)

例子：

def sum_num(a,b):
    """求和函数"""
    return a+b

help(sum_num)

结果为：

函数说明文档的高级使用
在多行注释直接加回车，就可以出现高级使用

def sum_num(a,b):
    """
    求和函数
    :param a: 参数1
    :param b: 参数2
    :return: 返回值
    """
    return a+b
help(sum_num)

结果为：

7、函数嵌套调用

一个函数里面又调用了另外一个函数，化简代码量

例子1：两个函数testA和testB,在A里面要嵌套调用B

def testB():
    print("B函数开始")
    print("这是B函数")
    print("B函数结束")
    
def testA():
    print("A函数开始")
    testB()
    print("A函数结束")
testA()

例子2：打印多条横线，横线条数由自己决定输入

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

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

print_lines(3)

结果为：

例子3：求三个数的平均值

def sum_num(a,b,c):
    return a+b+c

def sum_avg(a,b,c):
    sumResult=sum_num(a,b,c)
    return sumResult/3
avg=sum_avg(1,2,3)
print(avg)
结果为：2.0

五、函数的重点

1、变量作用域

局部变量

所谓局部变量是定义在函数体内的变量，即只在函数体内部生效；
在函数体内部，临时保存数据，即当函数调用完之后，则销毁局部变量

def testA():
    a=100
    print(a)

testA()
print(a)

结果为：

变量a是定义testA函数内部的变量，在函数外部访问则立即报错

全局变量

所谓全局变量，指的是在函数内外部都能生效的变量

a=100
def testA():
    print(a)

def testB():
    #a.append(20)
    print(a)

testA()
testB()
结果为：
100
100
100

修改全局变量

global 关键字声明，x为全局变量

a=100
def testA():
    print(a)

def testB():
	#修改全局变量
    global a
    a=300
    print(a)

testA()
testB()
print(a)
结果为：
100
300
300

2、多函数程序执行流程

在实际开发过程当中，一个程序往往由多个函数组成，并且多个函数共享某些数据

glo_num=0
def test():
    global glo_num
    glo_num=90
    print(glo_num)

print(glo_num)  #值为0，因为修改的函数没有执行
test()
print(glo_num)   #值为90，因为调用了函数
结果为：
0
90
90

返回值作为参数传递：先得到test1的返回值，再把这个返回值传入到test2中

def test1():
    return 50

def test2(num):
    print(num)

result=test1()
test2(result)

3、函数的返回值

如果一个函数有两个返回值，程序该如何执行？此时我们就要想到如果写两个return,return也有退出函数的作用，所以第二个return不会返回数据

def return_num():
    return 1,2
result=return_num()
print(result)
结果为：(1, 2)

注意：
1、return a,b写法，函数如果有多个返回值，返回的是一个元组
2、return后面可以连接列表，元组或字典，以返回多个值

4、函数的参数

1、位置参数

调用函数时，根据函数定义的参数位置来传递参数

def user_info(name,age,gender):
    print(f"您的名字是{name},年龄是{age},性别是{gender}")

user_info("tom",20,"man")
结果为：您的名字是tom,年龄是20,性别是man

2、关键字参数

通过"键=值"形式加以指定，可以让函数更加清晰，容易使用，同时也清除了参数的顺序需求。

def user_info(name,age,gender):
    print(f"您的名字是{name},年龄是{age},性别是{gender}")

user_info("tom",gender="man",age=20)
结果为：您的名字是tom,年龄是20,性别是man

注意：位置参数必须写在关键字参数的前面

3、缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值。

def user_info(name,age,gender="男"):
    print(f"您的名字是{name},年龄是{age},性别是{gender}")

user_info(name="tom",age=20)
user_info(name="tom",age=20,gender="女")

注意：位置参数必须写在默认参数的前面

4、不定长参数

不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数的场景。此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行采纳数传递，会显得非常方便

包裹位置传递：

def user_info(*args):
    print(args)
user_info("rose")
user_info("tom",18)
结果为：
('rose',)
('tom', 18)

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，args是元组类型，这就是包裹位置传递

包裹关键字传递

收集所有关键字参数，返回一个字典

def user_info(**kwargs):
    print(kwargs)
user_info()
user_info(name="tom",age=20,id=100)
结果为：
{}
{'name': 'tom', 'age': 20, 'id': 100}

无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程

5、拆包和交换两个变量的值

1、拆包

拆包：元组

def return_num():
    return 100,200
num1,num2=return_num()
print(num1)
print(num2)
结果为：
100
200

拆包：字典

dict1={"name":"tom","age":18}
a,b=dict1  #dict1中有两个键值对，拆包的时候用两个变量接收数据
print(a)   #取key值
print(b)
print(dict1[a]) #取value值
print(dict1[b])

2、交换变量值

a,b=1,2
a,b=b,a
print(a)
print(b)
结果为：
2
1

6、引用

1、了解引用
在python中，值是靠引用来传递来的
可以用id()来判断两个变量是否为同一个值的引用

def test1(a):
    print(a)
    print(id(a))
    a+=a
    print(a)
    print(id(a))

a=100
test1(a)
c=[11,22]
test1(c)

结果为：

7、可变和不可变类型

所谓可变类型与不可变类型：数据能够直接进行修改，若能直接修改就是可变，否则就是不可变

可变类型

• 列表
• 字典
• 集合

不可变类型

• 整型
• 浮点型
• 字符串
• 元组

六、函数的加强

1、应用：学员管理系统

1、系统简介

需求：进入系统显示系统功能界面，功能如下：
1、添加学员
2、删除学员
3、修改学员信息
4、查询学员信息
5、显示所有学员信息
6、退出系统
系统一共6个功能，用户根据自己需求选取

2、步骤分析

1、显示功能界面
2、用户输入功能序号
3、根据用户输入的功能序号，执行不同的功能(函数)

3、需求实现
代码如下：

#1、定义功能界面函数
def info_print():
    print("---请选择功能---")
    print("1、添加学员")
    print("2、删除学员")
    print("3、修改学员信息")
    print("4、查询学员信息")
    print("5、显示所有学员信息")
    print("6、退出系统")
    print("-"*20)
#添加学员信息的函数
# 所有功能函数都是操作学员信息，存储所有学员信息应该是一个全局变量，数据类型为列表
info=[]
def add_info():
    """添加学员函数"""
    #用户输入姓名，学号，手机号
    new_name=input("请输入姓名:")
    new_id=input("请输入学号:")
    new_tel=input("请输入手机号:")
    global info
    #判断学员是否已经存在,存在就报错，不存在就添加数据
    #用户输入的姓名如果和列表里面字典的name值相等，就报错
    #下面遍历的i为字典
    for i in info:
        if new_name==i["name"]:
            print("用户已经存在")
            #退出当前函数，后面添加信息的代码不执行
            return
    #不存在就添加
    info_dict={}
    info_dict["name"] = new_name
    info_dict["id"] = new_id
    info_dict["tel"] = new_tel
    print(info_dict)
    info.append(info_dict)
    print(info)
#删除学员
def del_info():
    """删除学员信息"""
    #用户输入删除学员的姓名
    del_name=input("请输入你要删除的姓名")
    global info
    #判断学员是否存在
    for i in info:
        if del_name==i["name"]:
            info.remove(i)
            break
    #当整个循环正常执行之后，再执行else的代码
    else:
        print("该学员不存在")
    print(info)
#修改学员信息
def modify_info():
    """修改学员信息"""
    modify_name=input("请输入要修改的学员姓名")
    global info
    for i in info:
        if modify_name==i["name"]:
            i["tel"]=input("请输入新的手机号:")
            break
    else:
        print("该学员不存在")
    print(info)
#查询学员信息
def search_info():
    """查询学员信息"""
    searcht_name=input("请输入要查询的学员姓名")
    global info
    for i in info:
        if searcht_name==i["name"]:
            print("-----查找到的学员信息如下：-----")
            print("该学员的姓名是{},学号是{},手机号是{}".format(i["name"],i["id"],i["tel"]))
            break
    else:
        print("该学员不存在")
#显示所有学员信息
def print_all():
    """显示所有学员信息"""
    print('学号\t姓名\t手机号')
    for i in info:
        print(f"{i['id']}\t{i['name']}\t{i['tel']}")
# 系统功能需要循环使用，直到用户输入6才退出系统
while True:
#显示功能界面
    info_print()
    #2、用户输入功能序号
    user_num=int(input("请输入功能序号："))
    #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:
        print_all()
    elif user_num==6:
        exit_flag=input("确定要退出吗? (yes/no):")
        if exit_flag=="yes":
            break
    else:
        print("输入有误，请输入正确的数字(1-6)")

2、递归

1、递归的应用场景

1、在日常开发中，如果要遍历一个文件夹下面所有的文件，通常使用递归来实现
2、在后续算法中，很多算法都离不开递归，例如：快速排序

2、递归的特点

1、函数内部自己调用自己
2、必须有出口

3、递归代码实现
求3以内的数字累加和

#3以内数字累加和为3+2+1
#2以内数字累加和：2+1
#1以内数字累加和：=1，这是出口
def sum_numbers(num):
    #如果是1，直接返回1--->出口
    if num==1:
        return 1
    #如果不是1，重复执行累加并返回结果，当前数字+当前数字-1
    return num+sum_numbers(num-1)

a=sum_numbers(3)
print(a)
结果为：6

4、递归函数的执行流程

3、lambda表达式

1、应用场景

如果一个函数有一个返回值，并且只有依据代码，可以使用lambda简化，lamdba可以节省内存空间

2、lambda语法

lambda  参数列表：表达式
1、lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用
2、lambda表达式能够接收任何数量的参数，但只能返回一个表达式的值

lambda的例子：

用函数表示：
def fn1():
    return 100
print(fn1())
print(fn1)
用lambda表示：
fn2= lambda:100
print(fn2()) 
print(fn2) #打印的是lambda内存地址
结果为：
100
<function <lambda> at 0x0000025C6DB46730>

计算任意两个值相加

用函数实现：
def sum_num(a,b):
    return a+b
print(sum_num(1,3))
用lambda实现：
fn1=lambda a,b:a+b
print(fn1(1,3))

3、lambda的参数形式
1、无参数

fn1=lambda :100
print(fn1())
结果为：100

2、一个参数

fn1=lambda a:a
print(fn1("hello world"))
结果为：hello world

3、默认参数（缺省参数）

fn1=lambda a,b,c=100:a+b+c
print(fn1(10,10))
print(fn1(10,10,10))
结果为：
120
30

4、不定长参数(可变参数)

fn1=lambda *args:args   #返回的是元组
print(fn1(1,2,3,4,5))
结果为：
(1, 2, 3, 4, 5)

fn1=lambda **kwargs:kwargs   #返回的是字典
print(fn1(name="tom",age=20))
结果为：
{'name': 'tom', 'age': 20}

4、lambda的应用
1、带判断的lambda

两个数字比大小，谁大返回谁
fn1=lambda a,b:a if a>b else b
print(fn1(4,5))
结果为：5

2、列表数据按照字典key的值进行排序

students=[
    {"name":"tom","age":19},
    {"name": "rose", "age": 22},
    {"name": "jack", "age": 16}
]
#按age值进行降序排序，升序省略reverse这个参数就可以
students.sort(key=lambda i:i["age"],reverse=True)
print(students)
结果为：
[{'name': 'rose', 'age': 22}, {'name': 'tom', 'age': 19}, {'name': 'jack', 'age': 16}]

4、高阶函数

把函数作为参数传入，这样的函数称为高阶函数，高阶函数就是函数式编程的体现。函数式编程就是指这种高度抽象的编程范式。

1、体验高阶函数
在python中,abs()函数可以完成对数字求绝对值；round()函数可以完成对数字的四舍五入计算
需求：任意两个数字，按照指定要求整理数字后再进行求和计算

方法1：普通函数
def add_num(a,b):
    return abs(a)+abs(b)
print(add_num(-3,-5))
方法2：高阶函数
def sum_num(a,b,f):
    return f(a)+f(b)
print(sum_num(-2,3,abs))
print(sum_num(1.6,3.2,round))
方法2的代码更加简洁，f作为函数但却作为一个参数传入，使得函数的灵活性更高

2、内置高阶函数之map

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

需求：计算list1序列中各个数字的2次方

list1=[1,2,3,4,5] #准备列表数据
def func(x):      #准备2次方计算的函数
    return x**2
result=map(func,list1)  #将函数func功能作用于列表list1的每个数据，调用map
print(result)         #打印内存地址
print(list(result))  #想要查看数据，就要转换数据为列表
结果为：
[1,4,9,16,25]

3、内置高阶函数之reduce

reduce(func,lst),其中func必须有两个参数，每次func计算的结果继续和序列的下一个元素做累积计算。reduce()传入的参数func必须接收2个参数

需求：计算list1序列中各个数字的累加和

import functools   #导入模块
list1=[1,2,3,4,5]
def func(a,b):    #定义加法计算的函数，两个参数
    return a+b
result=functools.reduce(func,list1) #功能函数计算的结果和序列的下一个数据做累积计算
print(result)
结果为：15

4、内置高阶函数之filter

filter(func,lst)函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象。如果要转换为列表，可以使用list()来转换

需求：打印列表里的偶数

list1=[1,2,3,4,5,6,7,8,9,10]
def func(i):
    return i%2==0
result=filter(func,list1)
print(result)
print(list(result))

七、文件操作

1、文件操作的作用

读取内容，写入内容，备份内容，移动位置…
文件操作的作用就是把一些内容(数据)存储存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力

2、文件的基本操作

1、打开

在python中，使用open()函数，可以打开一个已经存在的文件，或者新建一个文件

语法如下：

文件对象=open(name,mode)
name:要打开的目标文件名的字符串(可以包含文件所在的具体路径)
mode:设置打开文件的模式(访问模式):只读，写入，追加等

访问模式如下：

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头，这是默认模式
w	只写操作。如果该文件已存在则打开文件，并从头开始编辑，原有内容会被删除；如果该文件不存在，创建新文件
a	追加。文件指针会放在文件的结尾，子女的内容会被写入到已有内容之后
rb	以二进制格式打开一个文件用于只读(带b都是以二进制格式)
r+	打开一个文件用于读写(带+的可读可写) ，没有该文件会报错，文件指针在开头
w+	没有该文件会创建，文件指针在开头，用新内容覆盖原内容
a+	没有文件会新建文件，文件指针在结尾，无法读取数据，因为文件指针后面没有数据

#打开/创建文件open()
f=open("test.txt","w")
#读写操作,write(),read()
f.write("aaa")   #写入内容
#关闭文件，不然会一直占用内存空间，close()
f.close()

结果如下：

2、读写
读
read()

语法：文件对象.read(num)
num表示要从文件中读取的数据的长度(单位是字节)，如果没有传入num,那么就表示读取文件中所有的数据

f=open("test.txt","r")
print(f.read())
f.close()
结果为： #就是test.txt的文件内容
aa
bb
cc
dd
ee

f=open("test.txt","r")
print(f.read(4))
f.close()
结果为：
aa
b
为什么输入的是4个字节，输出的缺是3个字节呢？
因为test.txt文件里换行了，换行符占用一个字节

readline()

readline()一次读取一行内容

f=open("test.txt")
content=f.readline()
print(content)
content1=f.readline()
print(content1)
f.close()
结果为：
aa
bb

3、seek()

用来移动文件指针
语法：文件对象.seek(偏移量，起始位置)
起始位置：
0：文件开头
1：当前位置
2:文件结尾

需求：r:改变文件指针位置，改变读取数据开始位置

f=open("test.txt","r+")
f.seek(2,0)
con=f.read()
print(con)
f.close()
结果为：
aa
bbbb
cccc
dddd

#将文件指针放结尾，读取不出来数据
f=open("test.txt","r+")
f.seek(0,2)
con=f.read()
print(con)
f.close()

对a访问模式来讲，改变文件指针位置，做到可以读取出来数据

f=open("test.txt","a+")
f.seek(0)
con=f.read()
print(con)
f.close()
结果为：
aaaa
bbbb
cccc
dddd

3、文件备份

需求：用户输入当前目录下任意文件名，程序完成对该文件的备份功能(备份文件名为xx[备份]后缀)，例如:test[备份].txt

步骤：
1、接收用户输入的文件名
2、规划备份文件名
3、备份文件写入数据

实现代码如下：

old_name=input("请输入您要备份的文件名：")

index=old_name.rfind(".")  #从右向左查找.
yuan=old_name[:index]  #文件名
type=old_name[index:]   #文件后缀
#有效文件才备份，无效文件如：.txt
if index>0:
    postfix=type
new_name=yuan+"[备份]"+postfix
print(new_name)
#3、备份文件写入数据；
#打开源文件和备份文件，将源文件数据写入到备份文件，关闭文件
old_f=open(old_name,"rb")
new_f=open(new_name,"wb")
#源文件读取，备份文件写入,当读取的数据没有了就终止循环
while True:
    con=old_f.readline()
    if len(con)==0:  #当文件内容读完，为0时，就停止循环
        break
    new_f.write(con)

old_f.close()
new_f.close()

4、文件和文件夹的操作

在python中，文件和文件夹的操作要借助os模块里面的相关模块，具体步骤如下：
1、导入模块
import os
2、使用os模块相关功能
os.函数名( )

1、文件重命名

os.rename(目标文件名，新文件名)

import os
os.rename("1.txt","10.txt")

2、删除文件

remove(“目标文件名”)

import os
os.remove("10.txt")

文件夹操作

1、创建文件夹

import os
os.mkdir("aa")

2、删除文件夹

import os
os.rmdir("aa")

3、获取当前目录

import os
print(os.getcwd())
结果为：
C:\study python\test\day1

4、改变目录路径
需求：在aa目录里创建bb文件夹

import os
#os.mkdir("aa")
os.chdir("aa")
os.mkdir("bb")

5、获取目录列表

import os
print(os.listdir()) #获取某个文件夹下面的所有文件，并且返回一个列表

import os
print(os.listdir("aa")) #获取aa文件夹的所有文件

6、文件夹重命名

将aa目录重命名为cc
import os
os.rename("aa","cc")

7、应用案例
需求：把test文件夹的所有文件命名为"python_xxx"

import os
file_list=os.listdir()   #找到此目录下的所有文件
for i in file_list:
    new_name="python_"+i  #拼接新的名字
    os.rename(i,new_name)  #重命名操作

删除指定字符串：删除"python_"重命名
批量修改文件名，既可添加指定字符串，又能删除指定字符串

import os
flag=2   #1为添加字符串，2为删除字符串，可以自己定义
file_list=os.listdir()
for i in file_list:
    if flag==1:
        new_name="python_"+i
    elif flag==2:
        num=len("python_")
        new_name=i[num:]
    os.rename(i,new_name)