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('----------')