【paddle领航团基础python课程】

python的应用领域

• Web应用开发
• 自动化运维
• 3D游戏开发
• 图形界面开发
• C/S服务端开发
• 科学计算

Python的特点

• 简洁性 实现同样的功能，python代码的行数往往是Java的1/5；
• 易读性
• 可扩展开源性

python运算符优先级

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ThAt64KB-1613528131701)(C:\Users\fylal\AppData\Roaming\Typora\typora-user-images\image-20210208104803672.png)]

基本数据类型

• 整型
• 浮点型
• 字符串 单引号‘ ’或者双引号“ ”括起来的任意文本 也可以三单引号‘’‘ ’‘’和三双引号“”“ ”“”， 三引号的内容可换行，单或双引号的内容不可换行
• bool型 True or Flase
• None 空值

类型转换

• int() 将float型，string型，bool型转为整型
• str() 将int型，float型,bool型转为整型
• bool() 非零为True,0为False
• float 将将int型，string型，bool型转为整型

基本运算符

print(1+2)   # 加法
print(1-2)   # 减法
print(1*2)   # 乘法
print(1/2)   # 除法
print(1//2)  # 整除 (向下取整)
print(1%2)   # 取余数
print(2**2)  # 幂运算

起名法则

标识符由字母，下划线，数字组成，标识符第一个字符不能为数字。

注意：标识符命名不能和关键字名字一样

查看关键字方法：

import keyword
print(keyword.kwlist)

组合数据类型

• 列表 list

list是一种有序的组合，可以随时添加和删除其中的元素。

列表的创建方式：

• 使用中括号
• 调用内置函数list()

list1=[1,2,3,4,5]
list2=['a','b','c','d','a']
list3=['a','d',1,2]
len(list1)   # 求list1的长度
list1[4]     # 取list1下标为4的数，下标从0开始正着数或者从-1倒着数
#********list常用函数***********
list3.append(3) # 在list3的后面添加数字3
# 删除元素
list1.pop()  # 默认弹出最后一个数字，list1的长度减1
list1.pop(4) # 将list1中的下标为4的数弹出
list2.remove('a')    # 移除找到的第一个字符
#切片删除
list2[1:2]=[]
# 插入元素
list2.insert(2, 'ooo')  # 在指定位置添加元素，如果指定的下标不存在，那么就是在末尾添加
# count计数和index查找
print(list2.count('a'))
print(list.index('a'))
print(list2)
#合并list1和list2
list1.extend(list2)   # 合并两个list,list2中仍有元素
#在任意的位置上添加多个元素
list1[1:]=list3
#将列表对象删除
del list1
#修改列表当中的多个值
list2[1:3]=[1,2,3,4,5,6]

list索引、切片

list1 = ['a','b','c','d','e','f']
list1[2]
list1[2:5]

列表的排序

• 调用sort()方法，列表中的所有元素默认从小到大的顺序进行排列，可以指定reverse=True进行降序或升序，原列表改变
• 调用内置函数sorted()，可以指定reverse=True,进行降序排序，产生新的列表对象

list1.sort(reverse=True)
new_list=sorted(list1,reverse=False)

• 元组 tuple

另一种有序列表，tuple和list类似，但tuple一旦初始化就不能修改，无append()、pop()函数,是不可变序列

元组的创建方式

• 直接小括号
• 使用内置函数tuple
• 若元组中只包含一个元素，需要用逗号和小括号，如t=(10,)

元组的遍历

• 利用索引

• 元组是可迭代对象，可使用for…in进行遍历

t=tuple(('python','hello',90))
for item in t:
	print(item)

tuple1=(1,2,3,4,5)
tuple2=('a','b','c','d')
tuple3=('a','d',1,2)
tuple4=tuple(1,2,3,4)
tuple5=tuple(('python',2,3,4)
tuple6='python',2,3,4   
#空元组
t7=()
t8=tuple()
len(tuple1)

• 字典 dict

dict全程dictionary，使用key-value存储，具有极快的查找速度。

是一个无序（无索引位置）可变序列

字典的创建方式：

• 使用花括号：{key:value}
• 使用内置函数dict()，dict(name=‘jack’,age=20) #等号左边是key,右边是value

获取字典的元素

• 使用[]

• 使用get方法

  区别：如果查找键不存在，[]提示报错，而get输出None,不存在时可设置默认值，如print(scores.get(‘小王’，90)) #返回90

获取字典试图的三个方法

• keys():获取字典中所有key
• values():获取字典中所有value
• items():获取字典中所有key,value对

字典元素的遍历

for item in word:
    print(item)        #返回键
    print(word[item])  #返回键所对应的值
    print(word.get(item))  #返回键所对应的值

字典的特点：

• key不能重复，是不可变对象，如key不能为列表
• value能重复

字典生成式：

• 内置函数zip()

  用于将可迭代的对象作为参数，将对象中对应元素打包成一个元组，然后返回由这些元组组成的列表

  items=['Fruist','Books','Others']
  princes=[96,78,85]
  lst=zip(items,princes)
  print(list(lst))
  

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U7vR3v5a-1613528131706)(C:\Users\fylal\AppData\Roaming\Typora\typora-user-images\image-20210212181057627.png)]

word = {'apple':'苹果','banana':'香蕉'}
scores = {'小张':100, '小李':80}
grad = {4:'很好',3: '好',2:'中',1:'差',0:'很差'}
scores['小张']
grad[3]
scores['小赵']=60  # 查找字典中是否有小赵，无就添加，有就修改
print(scores.get('小张'))
#删除字典中的key-value
del scores['小张']
#清空字典的元素
scores.clear()
print(scores.key())

• 集合 set

set和dict类似，是一组key的集合，但不存储value。且key不能重复。

集合生成式,将方括号改为花括号

{i*i for i in range(6)}

集合的相关操作

s={1,1,2,3,4}  # 输出：{1，2，3，4}
print(6 in s)   #False
#集合元素的添加操作
s.add(100)   #一次添加一个
s.update({200,300,400})  #一次至少添加一个
s.update((7,8,9))
#集合元素的删除操作
s.remove(100)  #存在即抛出，不存在抛出异常
s.discard(600)   #不做操作
s.pop()    #不能有参数
s.pop(1)  #错误
s.clear()  #清空集合
s1=set(range(6))
# 类型转换
set([1,1,2,3,4])  # 列表→集合
list({1,1,2,3,4}) # 集合→列表
list((1,2,3))     # 元组→列表
#定义空集合
s=set()
#判断集合是否相等
print(s==s1)
#一个集合是否是另一个集合的子集
print(s1.issubset(s))
#一个集合是否是另一个集合的超集
print(s1.issuperset(s))
#两个集合是否含有交集
print(s1.isdisjoint(s))  #有交集为False
#两个集合的交集
print(s1.intersection(s))
print(s1&s)
#并集操作
print(s1.union(s))
print(s1|s)
#差集操作
print(s1.difference(s))
print(s1-s)
#对称差集
print(s1.symmetric_difference(s))
print(s1^s)

流程控制：条件判断和循环

• if语句

  if 条件：
     语句
  else:
  

  多重条件语句

  if 条件：
     语句
  elif 条件：
     语句
  else:
      语句
  

  例子：

  score = 80
  if score < 60:
      print('不及格')
  else:
      print('及格')
  

• while

  number = 1
  while number<10:   # 注意边界条件
      print(number)
      number+=1
  

• for循环

  for循环可以遍历任何序列的项目，如一个列表或者一个字符串

# 打印1到9
for i in range(9):
    print(i+1)
    
fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        
   print( '当前水果 :', fruit)

for letter in 'Python':     # 第二个实例
   print( '当前字母 :', letter)

• for循环扩展

  对list_1操作，对每一个数加1

  #方法一：
  list_1=[1,2,3,4,5]
  list_2=[]
  for i in range(len(list_1)):
      list_2[i]+=1
  print(list_2)
  
  #方法二：
  list_2=[n+1 for n in list_1]
  print(list_2)
  
  
  

  判断list_1中的奇数

  #方法一：
  for i in range(len(list_1)):
      if list_1[i]%2==1:
          list_2.append(list_1[i])
  print(list_2)
  #方法二：
  list_2=[n for n in list_1 if n%2==1]
  

  在list_A 但是不在list_B中

  list_A = [1,3,6,7,32,65,12]
  list_B = [2,6,3,5,12]
  [n for n in list_A for n not in list_B
  

• break vs continue

  使用break语句来完全终止循环

  使用continue语句直接跳到循环的下一次迭代

  例子：

  # 查找list_1 中的数字
  list_1 = [1,6,3,2,8,4]
  for number in list_1:
      if number == 3:
          print('找到了！')
          break  
          
  # 打印1-10中的偶数 
  for i in range(10):
      num = i+1
      if num%2 == 0:
          print(num)
      else:
          continue
  

字符串进阶

• 字符串索引、切片

  切片：[起始：结束：步长]，默认值：截取方向为从左往右，起始为0，结束为字符串结尾元素，步长为1。切片范围为左闭右开。包含左范围，不包含有范围。

  注：当步长为-1时，截取方向为从右往左

  name = 'hello world!'
  name[1]  
  name[-4]     # 结果为r
  name[1:4]    # 结果为ell
  name[::-1]   # 结果为!dlrow olleh
  name[3:]     # 结果为lo world!
  name[8:2:-1] # 结果为row ol
  

• 字符串常用函数

  count 计数功能

  my_string = 'hello_world'
  my_string.count('o')
  # 查看帮助
  help(my_string.count)
  

  find 查找功能

  返回从左第一个指定字符的索引，找不到返回-1

  my_string = 'hello_world'
  my_string.find('o')    # 查找字符串第一次出现的位置，不存在，返回-1
  my_string.rfind('o')  #查找字符串最后一次出现的位置
  

  
`index 查找`
  
返回从左第一个指定字符的索引，找不到报错
  
  ```python
  my_string = 'hello_world'
  my_string.index('o') #查找字符串第一次出现的位置，不存在，抛出异常
my_string.rindex('o') #查找字符串第一次出现的位置，不存在，抛出异常
  

以某字符开头或结尾startswith()、endswith()

my_string = 'hello_world'
my_string.startswith('hello')  # 是否以hello开始
my_string.endswith('world')   # 是否以world结尾

split 字符串的拆分

按照指定的内容进行分割

my_string = 'hello_world'
my_string.split('_')

字符串的替换

从左到右替换指定的元素，可以指定替换的个数，默认全部替换

my_string = 'hello_world_world_world'
my_string.replace('_',' ')
my_string.replace('world','world'.upper(),2)  # 换前两个
#将列表或元组中的字符串合并成一个字符串
lst=['hello','java','python']
print('|'.join(lst))
t=('hello','java','python')
print(''.join(t))

字符串标准化

默认去除两边的空格、换行符之类的，去除内容可以指定,从字符串的左边开始劈分，默认劈分字符是空格，返回值是一个列表，可通过参数sep指定劈分符，maxsplit指定最大劈分次数。

my_string = ' hello world\n'
my_string.strip()  # 结果为hello world，
s='hello|world|python'
print(my_string.split())  #从字符串左边开始分割
print(s.split(sep='|'))
print(s.split(sep='|',maxsplit=1))
print(s.split(sep='|'))
print(my_string.rsplit())  #从字符串右边开始分割
#右分割同左分割，方向相反

字符串的大小写转换操作

upper() #把字符串中所有字符都转成大写字母

lower() #把字符串中所有字符都转成小写字母

swapcase() # 把字符串中所有大写字符转为小写，小写转为大写

capitalize() #把第一个字符转换为大写，把其余字符转换为大写

title() #把每个单词的第一个字符转换为大写，每个单词的剩余字符转换为小写

字符串的变形

my_string = 'hello_world'   
my_string.upper()  # 所有字母大写
my_string.lower()  # 所有字母小写
my_string.capitalize() # 首字母大写

字符串的原始值显示

print(ord('a'))   #97
print(chr(97))    #a

字符串切片

s='hello,python'
s1=s[:5]   #切片结果不包括5
s2=s[-6::1]	#切到字符串最后一个位置，同列表
s3='!'
newstr=s1+s2+s3

字符串的格式化输出

%

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EtXHU14N-1613528131712)(C:\Users\fylal\AppData\Roaming\Typora\typora-user-images\image-20210208121022991.png)]

accuracy=80/123
print('我的模型正确率为',accuracy,'!')

accuracy=80/123
print('我的模型正确率为%s' %accuracy)

name='Merry'
hight=170
score_math=95
score_english=89
print('大家好!我叫%s,我的身高是%d cm,数学成绩%.2f分，英语成绩%d分' %(name,hight,score_math,score_english))

format

指定了:s，则只能穿字符串值，如果传其他类型值不会自动转换

当不指定类型时，可以传任何类型

print('大家好！，我叫{:s},我的身高是{:d}cm,数学成绩{:.2f}分，英语成绩{}分'.format(name,int(hight),score_math,score_english))

print('Hello,{0},成绩提升了{1:0.1f},百分比{2:0.1f}%'\
     .format('小明',6,80.5))

print('Hello,{name:},成绩提升了{score:.1f}分，百分比为{percent:.2f}%'.format(name='小明',score=6,percent=80.5))

f-string

name='Merry'
hight=170.5
score_math=95
score_english=89
print(f"大家好！我叫{name},我的身高{hight:.3f}cm,数学成绩{score_math}分，英语成绩{score_english}分")

字符串的编码与解码

str='你好呀！'
print(s.encode(encoding='GBK'))  #一个中文占两个字节
print(s.encode(encoding='UTF-8'))  #一个中文占三个字节
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK'))  #解码编码格式必须与编码相同

函数的创建和调用

• 函数的创建

  def 函数名([输入参数]):

  ​ 函数体

  ​ return xxx

• 函数的调用

  函数名([实际参数])

• 函数传参

  如果参数是不可变对象，则形参不会改变实参的值

  如果参数为可变对象，如列表，则形参的值会改变实参。

  def fun(arg1, arg2):
      print(arg1)
      print(arg2)
      arg1=100
      arg2.append(10)
      print('arg1',arg1)
      print('arg2',arg2)
  
  n1=10
  n2=[1,2,3]
  n=fun(n1,n2)
  print('n1',n1)
  print('n2',n2)
  

• 函数返回值

  当函数有多个返回值时，结果为元组

  def Num(num):
      odd=[]
      even=[]
      for i in num:
          if i%2:
              odd.append(i)
          else:
              even.append(i)
      return odd,even
  list=[1,2,3,4,5,6,7,8,9]
  print(Num(list))
  #结果：([1, 3, 5, 7, 9], [2, 4, 6, 8])
  

• 函数的参数定义

  • 函数定义默认值参数

    函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参

def fun(a,b=10):
    print(a+b)
sum=fun(20)
#结果：30

• • 个数可变的位置参数(在函数定义中只能有一个)

    • 定义函数时，可能无法事先确定传递的位置参数的个数，使用可变位置参数
    • 使用*定义个数可变的位置参数
    • 结果为一个元组

    def fun(*args):
        print(args)
    fun(10)
    fun(10,20,30)
    

• • 个数可变的关键字形参(在函数定义中只能有一个)
    • 定义函数时，无法事先确定传递的关键字实参的个数，使用可变的关键字形参
    • 使用**定义个数可变的关键字形参
    • 结果为一个字典

def fun(**args):
    print(args)
fun(a=10)
fun(a=10,b=20,c=30)

函数定义过程当中，参数的顺序：常规形参→位置可变参数→关键字可变的参数

若要将列表中的每一个数传递给函数定义时的参数，则需要将列表转化为位置实参

若要将字典中的每一个数传递给函数定义时的参数，则需要将列表转化为关键字实参

def fun(a,b,c):
    print('a=',a)
    print('b=',b)
    print('c=',c)
   lst=[10,20,30]
fun(lst)    #出错
fun(*lst)	#转化为位置实参
dic={'a':11,'c'=12,'d':13}
fun(dic)	#出错
fun(**dic)	#转化为关键字实参
fun

函数定义时形参的顺序

def fun(a,b,*,c,d,**args):
    pass
def fun1(*args,**args1):
    pass
def fun2(a,b=10,*args,**args2):
    pass

• 变量的作用域

  局部变量：在函数内定义并使用的变量，只在函数内部有效，若要变全局变量，需使用global声明

  全局变量：函数体外定义的变量，可作用于函数内外。

• 递归函数

  • 含义：如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数

  • 组成部分：递归调用与递归终止条件

  • 调用过程：每递归调用一次函数，都会在栈内存分配一个栈帧；每执行完一次函数，都会释放相应的空间。

  • 优缺点：缺点：占用内存多，效率低下；有点：思路和代码简单

• python异常处理机制

  try:
      ...  #可能会出异常的代码
      ...
  except  xxx(异常类型):
      ... #异常处理代码，报错后执行的代码
  

  • 多个except结构

  捕获异常的顺序按照先子类后父类顺序

  try:
      ...  #可能会出异常的代码
      ...
  except  Exception1(异常类型):
      ... #异常处理代码，报错后执行的代码
  except  Exception2:
      ...
  except BaseException:
      ...
  

  • try…except…else结构

    如果try中没有抛出异常，则执行else块，如果有异常，则执行except块

try:
    ...  #可能会出异常的代码
    ...
except  xxx(异常类型):
    ... #异常处理代码，报错后执行的代码
else:
    ...

• • try…except…else…finally结构

finally块无论是否发生异常都会被执行，能常用来释放try块中申请的资源。

使用traceback模块打印异常信息

import traceback
try:
    num=10/0
except:
    traceback.print_exe()

面向对象和面向过程：

面向过程：如做煎蛋，需要一步一步的来，准备鸡蛋，油等…

面向对象：如：直接在美团上点外卖就行

面向对象：宏观；面向过程：微观

类：

类的组成：

（1）类属性：直接写在类里面的变量，称为类属性

（2）实例方法：类里面定义的函数

（3）静态方法：用@staticmethod修饰的叫静态方法，静态方法中不允许有self

（4）类方法：用@calssmethod修饰的叫类方法，类方法中要有一个cls默认参数

初始化方法：

class Student:     #类名：首字母得大写
    place='云南'    #实例属性
  #初始化方法
	def __init__(self,name,age):
        self.name=name	#实体属性
        self.age=age
  #实例化方法
	def eat(self):
        print('学生在吃饭...')
 #静态方法
	@staticmethod
    def method():
        print('使用了静态方法')
#类方法
	@classmethod
    def cm(cls):
        print('使用了类方法')

对象的创建又称类名的实例化

stu1=Student('张三'，20)
print(stu1.name)
#调用类中方法：
stu1.eat()
#或
Student.eat(stu1)

类的使用方式：

#类属性使用方式
print(stu1.place)
#或
print(Student.place)
#修改
Student.place='四川'
#类方法使用方式   直接用类名调用
Student.cm()
#静态方法使用方式 直接用类名调用
Student.method()

动态绑定属性和方法

stu2=Student('李四'，30)
#动态绑定属性 stu1有这个属性，stu2没有这个属性
stu1.gender='男'
#动态绑定方法
def show():
    print('定义在类之外的，称函数')
stu1.show=show 
stu1.show()

面向对象的三大特征

（1）封装：将属性和方法包装到类对象中。属性和方法私有：在方法名和属性名前加“__“两根下划线

（2）继承：提高代码的复用性

（3）多态：提高程序的可扩展性和可维护性

继承

• 语法格式

  class 子类类名(父类1，父类2...):
      pass
  

• 如果一个类没有继承任何类，则默认继承object

• python支持多继承

• 定义子类时，必须在其构造函数中调用父类的构造函数

class Person(object):    #父类的object可写可不写
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)
class Student(Person):
    def __init__(self,name,age,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no
    def info(self):
        super().info()
        print('学号：',self.stu_no)
class Teacher(Person):
    def __init__(self,name,age,teach_year):
        super().__init__(name,age)
        self,teach_year=teach_year
stu=student('张三'，20，’10001‘)
teacher=Teacher('李四'，34，10)
stu.info()  #调用重写的方法
teacher.info()  #调用父类的方法

方法重写

如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其进行重新编写。

子类重写后的方法可以通过super().xxx()调用父类中被重写的方法

object类

• object类是所有类的父类。
• 内置函数dir()可以查看指定对象所有属性
• Object有一个__ str __()方法，用于返回一个对于”对象的描述“。

class Student:
    def __init__(self,name,age):
        self.name-name
        self.age=age
    def __str__(self):
        return '我的名字是'.format(self.name,self.age)
stu=student('张三'，20)
print(dir(stu))
print(stu)      #默认调用__str__方法

多态

特殊属性和方法

#特殊属性
print(stu1.__dict__)
print(Student.__dict__)
print(stu1.__class__)  #输出对象所属的类
print(Student.__bases__)  #Student类的父类类型的元素
print(Student.__base__)  #输出最近的父类
print(Student.__mro__)	#类的层次结构
print(Student.__subclasses__())  #求子类列表
#特殊方法
a=20
b=100
print(a+b)
print(a.__add__(b))  #结果一样
class Student:
    def __init__(self,name):
        self.name=name
    def __add__(self,other):
        return self.name+other.name
    def __len__(self):
        return self.name
stu1=Student('张三')
stu1=Student('李四')
print(stu1+stu2)
#或
stu1.__add__(stu2)

模块

• 模块英文：Modules

• 函数与模块的关系：一个模块中包含N多个模块

• 在Python中，一个扩展名为.py的文件就是一个模块

• 模块的好处：

  方便其他程序和脚本导入并使用

  避免函数名与变量名冲突

  提高代码的可维护性

  提高代码的可重复性

自定义模块

• 创建模块

  新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同

• 导入模块

import 模块名称 [as 别名]

from 模块名称 import 函数/变量/类

自定义模块

# calc.py
def add(a,b):
    return a+b

# example.py
import calc  #此处若报错，则点击文件夹右键Make Directory as中的sources Root
print(calc.add(10,20))
#或者
from calc import add
print(add(10,20))

以主程序形式运行

#calc.py
def add(a,b):
    return a+b
if __name__=='__main__':  #只有当点击calc.py时，才会执行此句语句
    print(add(10,20))
    
#example.py
from calc import add
print(add(100,20))   #结果：120

Python中的包

• 包是一个分层次的目录结构，它将一组功能相近的模块组织在一个包下

• 作用：

  代码规范

  避免模块名称冲突

• 包与目录的区别

  包含__ init __.py文件的目录称为包

  目录里通常不包含__ init __.py文件

• 包的导入

  import 包名.模块名 [as 别名]
  

  注意：

  使用import导入时，只能是包名或者模块名

  使用from…import导入时，可以是模块名，也可以是函数名

  import 包名
  import 模块名
  from 包名 import 模块名
  from 包名.模块名 import 函数名
  from 模块名 import 函数名
  

Python中常用的内置模块

import sys
import time
import urllib.request   #爬虫时会使用
print(sys.getsizeof(24))  #获取对象所占大小
print(time.time())
print(time.localtime(time.time()))
print(urllib.request.urlopen('http://www.baidu.com').read())

编码格式

Python的解释器使用的是Unicode(内存)

.py文件在磁盘上使用UTF-8存储（外存）

python文件默认为UTF-8

若要修改，在文件开头加上#encoding：dbk/utf-8…

文件的读写原理

• 文件的读写俗称”IO操作“

• 内置函数open()创建文件对象

  file=open('a.txt','r')
  print(file.readlines())  #生成列表
  file.close()
  

• 文件的类型

  • 文本文件：存储的是普通”字符“文本，默认unicode字符集，可使用记事本打开。
  • 二进制文件：以”字节”进行存储，无法用记事本打开，如：MP3音频文件，jpg图片

file=open('b.txt','w')
file.write('Python') #生成列表
file.close()
file=open('b.txt','a')
file.write('Python') #生成列表
file.close()
src_file=open('a.png','rb')
target_file=open('copya.png','wb')
target_file.write(src_file.read())
target_file.close()
src_file.close()

• 文件对象的常用方法

• with语句（上下文管理器）

  with语句可以自动管理上下文资源，不论什么原因跳出with块，都能确保文件正确的关闭，以此来达到释放资源的目的。

• os模块，与操作系统相关的一个模块

import os
os.system('calc.exe')
#直接调用可执行文件
os.startfile('C:\\Program Files\\Microsoft Office\\root\\Office16\\EXCEL.exe')

• os模块操作目录相关函数

import os
print(os.getcwd())
print(os.listdir('路径'))
os.mkdir('路径','目录名')
os.mkdirs('A/B/C')  #A里面包含B，B里面包含C
os.rmdir('删除目录')
os.removedies('A/B/C')
os.chdir('更改的路径')
print(os.getcwd())

• os.path模块操作目录相关函数

import os.path
print(os.path.abspath('文件或目录'))
print(os.path.exists('文件或目录'))
print(os.path.split('路径+文件')) #将文件所在的路径与文件拆分
print(os.path.splitext('文件'))  #将文件与后缀名拆分
print(os.path.basename('路径'))

例子1：获取当前目录下的所有python文件

import os
path=os.getcwd()
lst=os.listdir(path)
for filename in lst:
    if filename.endswith('.py'):
        print(filename)

例子2：递归遍历目录

newdir目录下有1.py、2.py、subdir文件夹，subdir文件夹有sub1.py

import os
path=os.getcwd()
lst_files=os.walk(path)
for dirpath,dirname,filename in lst_files:
    print(dirpath)
    print(dirname)
    print(filename)
    print('---------------')
    for dir in dirname:
        print(os.path.join(dirpath,dir))
        print('----------')
    for file in filename:
        print(os.path.join(dirpath,file))
        print('----------')