python学习笔记
该笔记是学习马士兵python视频课程过程中记录的笔记
胶水语言，对大数据分析、人工智能提供大力支持
print函数
将数据输出到文件
fp=open('d:/text.txt','a+')
print('helloworld',file=fp)
fp.close()
不进行换行 ,
print('hello','world','python')
转义字符
\r 是回到这一行的行首
\b 是退格
不希望转义字符起作用要使用r或者R
二进制
8 bit 就是8个位置 也就是 字节byte
1024 byte = 1kb 千字
1024Kb=1024MB 兆字节
1024MB=1GB 吉字节
1024GB=1TB 太字节
8个bit 对应256中符号，也就是ASCII 字符码表 前128个是固定的符号，后128个是留给其他国家使用的
# 打印unicode表中0x4e0e 对应的字符
print(chr(0x4e0e))
# 打印与的unicode值
print(hex(ord('与')))
Python中的保留字
import keyword
print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
python是严格区分大小写的
变量
标识：表示对象所存储的内存地址 id(obj)
类型：type(obj)
值：print(obj)
name='david'
print('标识',id(name))
print('类型',type(name))
print('值',name)
标识 2401313458528
类型 <class 'str'>
值 david
数据类型
-
int
二进制0b 十六进制0x 八进制0o
-
float 相加或相减有一定的不准确性
n1 = 1.1 n2 = 2.2 print(n1+n2) 3.3000000000000003 -
boolean 简写bool
-
str
不可变的字符序列，可以使用'' "" """ 三引号可以分布在连续的多行显示
类型转换
str()
int()
将str转成int时，字符串为小数串报错 例如 int('1.11'),字符串必须是整数
float() 整数在末尾会加 .0
注释
- 单行 #
- 多行 ''' '''
-
coding:gbk 中文编码声明注释，python3不需要写了
input函数
present=input('请输入xxx')
present类型是str的
运算符
位运算符：将数据转成二进制进行计算
&
|
<< 高位溢出舍弃，低位补零
>> 低位溢出舍弃，高位补零
运算符优先级
分支结构
if xxx:
pass
elif xxx:
pass
else:
pass
条件表达式
其实就是if else 的简写：有点像三元表达式
语法结构 x if 判断条件 else y
n1 = 1
n2 = 2
print(n1 if n1 > n2 else n2)
循环
内置函数range()
r = range(10)
r 是迭代器 是range(0,10)
list(r) 是0-9
默认步长是1
包左不包右
range(start,end,step)
for-in 循环 遍历 必须是可迭代对象 string、序列
else
while:
else:
当循环没有碰到break或者continue时，会执行else中得代码
列表list
创建list方法,可以混存，可以重复
lst=['hello','world',98]
lst2=list(['hello','world',98])
lst3=[]
获取指定元素的索引index()
lst=['hello','world',98,'hello']
print(lst.index('hello'))
0
lst=['hello','world',98,'hello']
print(lst.index('hello',1,4))
3
索引
分为正向和父向
n个元素：正向是0 - n-1
逆向是 -n - -1
切片操作[start : end : step]
包左不包右
当step为负数时：start是最后一个元素 end是第一个元素 反过来了
lst[7:1:-1]
判断是否存在 item in/not in lst
list 添加元素
append()
extend(lst) 添加至少一个元素
insert()
切片 也就是替换 把切掉的替换成新的 lst[1:]=lstnew
删除操作
remove() 移除第一个
pop() 移除最后一个，也可根据索引移除
切片删除 lst[1:3]=[] 使用空列表对它替换
lst.clear()
del lst 霸道
修改
修改元素
切片替换
排序
- 调用sort() 可以指定reverse=True 进行降序 排序 lst.sort(reverse=True) 在源列表进行操作
- 调用内置函数 sorted() ,可以指定reverse=True 产生一个新的列表对象原列表不发生改变 newlist=sorted(lst)
列表生成式
newlist = [i*i for i in range(1,10)]
字典
可变序列（可以进行增删改），字典是一个无序的序列
存储位置不是按照放的先后顺序，是hash(key)
创建字典
dict1={"sss":"asdf"}
dict2=dicts(name='jack',age=20)
dict3={}
获取value
1---- []
value1 = dict1['key'] # 没有会抛异常
2---- get()
value2 = dict1.get('key') # 没有返回None
value2 = dict.get('nokey','默认值') # 没有回返回默认值
key的判断
key in/not in dicts 返回true/false
字典元素的删除
del dicts['key']
字典元素新增
dicts['newkey']=value
字典的视图操作
dicts = {'chen': 31, 'dong': 32}
print(dicts.keys())
print(type(dicts.keys()))
print(list(dicts.keys()))
print(dicts.values())
print(type(dicts.values()))
print(list(dicts.values()))
print(dicts.items())
print(type(dicts.items()))
print(list(dicts.items()))
dict_keys(['chen', 'dong'])
<class 'dict_keys'>
['chen', 'dong']
dict_values([31, 32])
<class 'dict_values'>
[31, 32]
dict_items([('chen', 31), ('dong', 32)])
<class 'dict_items'>
[('chen', 31), ('dong', 32)]
遍历
for item in dicts:
print(dicts.get(item))
print(dicts[item])
字典生成式
items=['fruits','books','others']
prices=[99,98,97]
newdict = {item.upper():price for item,price in zip(items,prices)}
print(newdict)
{'FRUITS': 99, 'OTHERS': 97, 'BOOKS': 98}
将字符串转换为字典形式，不是用dict函数，而是用eval函数
a = '{"id":"e325dc8f59320bb85c6d0324da56565e","url_token":"bu-xiang-lian-ai-49","name":"不想恋爱"}'
d = eval(a)
print(d)
print(d['id'])
元组
元组是不可变序列，没有增删改和生成式
创建
t=('Python','hello',9)
t=tuple(('Python','hello',9))
t=(10,)
集合
属于可变类型，集合是没有value的字典，也是无序的,不允许重复
创建
s={'Python','hello',9}
s=set(range(6))
s=set((1,2,3,4,'hello'))
s=set('Python') 是 {'p','y','t','h','o','n'} 无序的
空集合
s=set()
新增
s.add()
s.update({xxx,yyy,zzz}) 至少添加一个元素 能放集合、列表、元组
删除
s.remove() 没有会抛异常
s.discard() 不会抛异常
s.pop() 删除任意元素，删谁是随机的
s.clear() 清空集合
集合之间关系
s={10,20,30,40}
s2={30,40,10,20,50}
s3={60,70}
print(s==s2) # 是相等的
# 子集
print(s.issubset(s2))
print(s2.issubset(s))
# 超集
print(s2.issuperset(s))
# 判断有没有交集 为false 是有交集
print(s.isdisjoint(s3))
集合的数学操作
s1 = {10, 20, 30, 50}
s2 = {20, 30, 40, 50, 60}
# 交集操作
print(s1.intersection(s2))
print(s1 & s2)
# 并集操作
print(s1.union(s2))
print(s1 | s2)
# 差集操作
print(s1.difference(s2))
print(s1-s2)
# 对称差集操作
print(s1.symmetric_difference(s2))
print(s1 ^ s2)
集合生成式
{i*i for i in range(1,10)}
列表生成器的[] 改成{} 就行了
字符串
是不可变序列
驻留机制
>>> s1=''
>>> s2=''
>>> s1 is s2
True
>>> s1='%'
>>> s2='%'
>>> s1 is s2
True
>>> s1='abc%'
>>> s2='abc%'
>>> s1 is s2
False
>>> s1==s2
True
>>> s1='abcx'
>>> s2='abcx'
>>> s1 is s2
True
>>> a='abc'
>>> b='ab'+'c'
>>> c=''.join(['ab','c'])
>>> a is b
True
>>> a is c
False
>>> a=-5
>>> b=-5
>>> a is b
True
>>> a=-6
>>> b=-6
>>> a is b
False
>>> import sys
>>> a='abc%'
>>> b='abc%'
>>> a is b
False
>>> a=sys.intern(b)
>>> a is b
True
注：再交互模式是这样，如果再ide中，都会对字符串做特殊处理，都是返回True
查询
index() 查找子串第一次出现位置，不存在抛出异常
rindex() 查找子串最后一次出现位置，不存在抛出异常
find() 查找子串第一次出现位置，不存在返回-1
rfind() 查找子串最后一次出现位置，不存在返回-1
大小写转换
upper()
lower()
swapcase() 原来的大写变小写，小写变大写
capitalize() 把字符串第一个字符变大写，其他小写
title() 把单词第一个字符大写，其他小写
字符串内容对齐
s1='hello,Python'
# 居中对齐 字符不写，默认使用空格填充
print(s1.center(20,'*'))
# 左对齐
print(s1.ljust(20,'*'))
# 右对齐
print(s1.rjust(20,'*'))
# zfill 直接一个参数，右对齐，使用0填充
print(s1.zfill(20))
****hello,Python****
hello,Python********
********hello,Python
00000000hello,Python
劈分
split 从左侧开始劈分
s1='hello world Python'
lst=s1.split()
print(lst)
s1='hello|world|Python'
print(s1.split('|'))
# 指定最大劈分次数
print(s1.split('|',maxsplit=1))
['hello', 'world', 'Python']
['hello', 'world', 'Python']
['hello', 'world|Python']
rsplit 从右侧开始劈分
s1='hello world Python'
lst=s1.rsplit()
print(lst)
s1='hello|world|Python'
print(s1.rsplit('|'))
# 指定最大劈分次数
print(s1.rsplit('|',maxsplit=1))
['hello', 'world', 'Python']
['hello', 'world', 'Python']
['hello|world', 'Python']
判断
# 判断是否是合法的标识符字符串 字母数字下划线
s='hello_python1234'
print(s.isidentifier())
# 判断指定的字符串是否全部由空白字符组成(回车、换行、水平制表符等)
s='\r\n \t '
print(s.isspace())
# 判断字符串全由字母组成
s='abcdefg'
print(s.isalpha())
# 判断字符串全部由十进制数字组成
s='1234'
print(s.isdecimal())
# 判断字符串全部由数字组成包括中文数字
s='123四一'
print(s.isnumeric())
# 由字母和数字组成包括中文数字
s='abc134四'
print(s.isalnum())
替换
# 替换
s='hello,Python'
print(s.replace('Python','Java'))
s1='hello,Python,Python,Python'
print(s1.replace('Python','Java',2))
hello,Java
hello,Java,Java,Python
合并
# join 将列表和元组合并成一个新的字符串
lst=['hello','java','Python']
print('|'.join(lst))
print(','.join(lst))
print(''.join(lst))
# join 一个字符串
print('*'.join('Python'))
# P*y*t*h*o*n
#join 元组
tuple1=('hello','java','Python')
print('|'.join(tuple1))
print(','.join(tuple1))
print(''.join(tuple1))
hello|java|Python
hello,java,Python
hellojavaPython
P*y*t*h*o*n
hello|java|Python
hello,java,Python
hellojavaPython
字符串比较
# >,>=,<,<=,==,!=
print('apple'>'app')
print('apple'=='apple')
比的是ord('字符') ASII码
'''
== 与is 的区别
==比较的是value
is 比较的是id()是否相等
'''
切片
# 字符串是不可变的没有增删改的操作，切片会产生新的对象[start:end:step]
s='hello,Python'
print(s[:5])
print(s[6:])
print(s[::2])
hello
Python
hloPto
格式化字符串
# % 作为占位符 加 元组
'''
%s 字符串
%i或%d 整数
%f 浮点数
'''
name='chen'
age=20
print('我叫%s,年龄%d' % (name,age))
'''
%10d 10指的宽度
%.3f 保留3为小数
%10.3f 宽度和精度都指定
'''
# 使用{} 作为占位符 .format
print('我叫{0},年龄{1}'.format(name,age))
'''
{0:.3} 表示一共是3位数
{0:.3f} 表示3位小数 0指的是第几个占位符可以省略
{0:10.3f} 长度精度都规定
'''
# 使用f-string 这是3.7以后才有的
print(f'my name is {name}')
编码转换
# 编码 encode
s='天涯共此时'
print(s.encode(encoding='GBK')) # 一个中文占两个字节
print(s.encode(encoding='UTF-8')) # 一个中文占三个字节
# 解码 byte.decode
byte=b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
print(byte.decode(encoding='GBK'))
函数
创建和调用
# 函数的创建
def calc(a,b): # 这里的a,b叫形参
return a+b
# 函数的调用
result=calc(1,2) # 这里的1,2 叫实参
print(result)
传参
- 位置传参：按照顺序
- 关键字传参: 按照形参的名称
def fun(arg1, arg2):
print('arg1', arg1)
print('arg2', arg2)
arg1 = 100
arg2.append(10)
print('arg1', arg1)
print('arg2', arg2)
n1=11
n2=[11,22,33]
fun(n1,n2)
print('n1',n1)
print('n2',n2)
'''
在函数调用过程中，进行参数的传递
如果是不可变对象，在函数体的修改不会影响实参的值
如果是可变对象，在函数体的修改会影响实参的值
'''
返回多个值时，结果为元组
def fun(num):
odd=[]
even=[]
for i in num:
if i%2:
odd.append(i)
else:
even.append(i)
return odd,even
print(fun([10,29,34,23,44,53,55]))
'''
1 如果函数没有返回值不用写return
2 如果是1个，直接返回
3 如果是多个，返回的结果为元组
'''
([29, 23, 53, 55], [10, 34, 44])
默认值参数
def fun(a,b=100):
print(a,b)
fun(200)
fun(200,300)
# 实际print函数有个end='\n'的默认值
print('hello')
print('world')
print('hello',end='\t')
print('world')
个数可变的位置参数
- 定义函数时，可能无法事先确定传递的位置实参的个数，使用可变的位置参数
- 使用* 定义个数可变的位置形参
- 结果为一个元组
def fun(*args):
print(args)
fun('a')
fun(10,20,30)
fun('10',2,'a')
'''
可变的位置参数只能有一个
'''
('a',)
(10, 20, 30)
('10', 2, 'a')
个数可变的关键字形参
- 定义函数时，无法事先确定传递的关键字实参的个数时，使用可变的关键字形参
- 使用** 定义
- 结果为一个字典
def fun(**args):
print(args)
fun(a=10)
fun(a=10,b='a')
'''
可变的关键字只能有一个
'''
{'a': 10}
{'a': 10, 'b': 'a'}
注：在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，个数可变的位置形参，放在个数可变的关键字形参之前
def fun(*args1,**args2):
pass
# 1 将序列中的每个元素都转换为位置参数
def fun(a, b, c):
print(a, b, c)
lst = [1, 'a', '2']
fun(*lst)
# 2 将字典中的每个键值对都转换为关键字实参
def fun(a, b, c):
print(a, b, c)
dicts = {'a': '100', 'b': 200, 'c': 'abc'}
fun(**dicts)
需求： c和d只能使用关键字实参传递,在c前面加一个单独的*号
def fun(a,b,*,c,d):
pass
重点: 函数定义时形参的顺序问题
def fun(a,b,*,c,d,**args)
def fun(*args,**args2)
def fun(a,b=10,*args,**args2)
变量的作用域
def fun(a, b): # a,b是形参，也相当于局部变量
c = a+b # c是局部变量
return c
# a,b,c 不能再函数体外使用
name = 'chen' # name 为全局变量
def fun2():
print(name)
fun2()
# 函数内部定义的变量，使用global声明，这个变量实际就变成了全局变量
def fun3():
global d
d = 'helo world'
fun3()
print(d)
异常
try:
n1 = int(input('请输入一个整数'))
n2 = int(input('请输入一个整数'))
result = n1/n2
print(result)
except ZeroDivisionError:
print('除数不能为0')
except ValueError:
print('不是整数')
except BaseException as e:
print(e)
try:
n1 = int(input('请输入一个整数'))
n2 = int(input('请输入一个整数'))
result = n1/n2
print(result)
except ZeroDivisionError:
print('除数不能为0')
except ValueError:
print('不是整数')
except BaseException as e:
print(e)
else:
print('result:',result) # 如果try没有抛出异常，则执行else
finally:
print('永远会显示')
使用traceback模块打印异常信息
import traceback
try:
print('1.----------------')
num=10/0
except:
traceback.print_exc()
类
创建
class Student: #单词首字母大写
pass
# 不实例化也会开辟内存：叫类对象
类的组成
- 类属性
- 实例方法
- 静态方法
- 类方法
class Student:
# 类属性
native_pace = '天津'
# 构造方法
def __init__(self, name, age):
self.name = name # self.name 称为实例属性
self.age = age
# 实例方法：比函数多一个self
def eat(self):
print('吃饭')
# 静态方法 不允许写self
@staticmethod
def sm():
print('静态方法')
# 类方法 : 要求第一个参数是cls
@classmethod
def cm(cls):
print('类方法')
对象的创建
stu1=Student('chen',32) # 实例对象中有一个类指针，指向类对象Student
print(stu1.name,stu1.age) #实例属性
stu1.eat() #实例方法
Student.eat(stu1)
类属性
类中方法外得变量称为类属性，被该类得所有对象所共享
print(Student.native_pace)
print(stu1.native_pace) # 实例对象中有一个类指针，指向类对象Student
Student.native_pace='山东'
print(Student.native_pace)
print(stu1.native_pace)
天津
天津
山东
山东
类方法
Student.cm()
静态方法
Student.sm()
动态绑定属性和方法
stu1 = Student('chen', 30)
# 动态属性
stu1.sex = '男'
print(stu1.name, stu1.age, stu1.sex)
def show():
print('动态方法')
stu1.show = show
stu1.show()
面向对象得三大特征
-
封装:提高程序安全性
-
继承:提高代码复用性
-
多态:提高程序的可扩展性和可维护性
封装
私有变量在前面加两个_ ,但是python不是强制的，是靠自觉性，可以使用 对象._类名__变量名 访问到
看一个对象有哪些方法和属性使用dir(对象)
继承
Python支持多继承，默认继承object类
class Person(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, score):
super().__init__(name,age)
self.score = score
class Teacher(Person):
def __init__(self, name, age, teachyear):
super().__init__(name,age)
self.teachyear = teachyear
方法重写
class Person(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, score):
super().__init__(name,age)
self.score = score
# 重写
def info(self):
super().info()
print(self.score)
stu1 = Student('chen',20,300)
stu1.info()
object类
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
# 从object类继承来的
def __str__(self):
return 'i am {0},my age is {1}'.format(self.name, self.age)
stu = Student('chen', 32)
print(stu.__str__()) # 返回一个对象的描述 ,可以重写这个方法
print(stu) # 等同于上一行
多态
# python是动态语言，那它怎么实现多态呢?
class Animal(object):
def eat(self):
print('动物会吃')
class Dog(Animal):
def eat(self):
print('狗吃肉')
# 使用这个方法实现多态
def fun(obj):
obj.eat()
fun(Dog())
java 是静态语言
特殊属性
class A:
pass
class B:
pass
class C(A, B):
def __init__(self, name, age):
self.name = name
self.age = age
c1=C('chen',32)
print(c1.__dict__) # 实例对象的属性字典
print(C.__dict__) # 类对象的属性和方法
print(c1.__class__) # 对象所属的类
print(C.__bases__) # 类的父类类型的元组
print(C.__base__) # 类的第一个父类类型
print(C.__mro__) # 查看类继承的层次结构
print(A.__subclasses__()) # 查看A的子类
{'age': 32, 'name': 'chen'}
{'__module__': '__main__', '__doc__': None, '__init__': <function C.__init__ at 0x000002426FFA8268>}
<class '__main__.C'>
(<class '__main__.A'>, <class '__main__.B'>)
<class '__main__.A'>
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
[<class '__main__.C'>]
特殊方法
# 重写 + __add__
class Student:
def __init__(self,name):
self.name=name
def __add__(self,other):
return self.name+other.name
stu1=Student('chen')
stu2=Student('dong')
print(stu1+stu2)
print(stu1.__add__(stu2))
# 重写 __len__ 可以输出len(obj)
class Student:
def __init__(self,name):
self.name=name
def __add__(self,other):
return self.name+other.name
def __len__(self):
return len(self.name)
stu1=Student('chen')
print(len(stu1))
# __new__ 用于创建对象 __init__ 对创建的对象进行初始化
class Person(object):
def __new__(cls, *args, **kwargs):
print('__new__被调用了,cls的id值为{0}'.format(id(cls)))
obj = super().__new__(cls)
print('创建对象的id为:{0}'.format(id(obj)))
return obj
def __init__(self, name, age):
print('__init__被调用了,self的id值为{0}'.format(id(self)))
self.name = name
self.age = age
print('object这个类对象的id为:{0}'.format(id(object)))
print('Person这个类对象的id为:{0}'.format(id(Person)))
p1 = Person('chen', 22)
print('p1这个Person类的实例对象的id:{0}'.format(id(p1)))
object这个类对象的id为:1803922640
Person这个类对象的id为:3032958261048
__new__被调用了,cls的id值为3032958261048
创建对象的id为:3032957438272
__init__被调用了,self的id值为3032957438272
p1这个Person类的实例对象的id:3032957438272
浅拷贝
Python的拷贝一般都是浅拷贝，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象
class Cpu:
pass
class Disk:
pass
class Computer:
def __init__(self,cpu,disk):
self.cpu=cpu
self.disk=disk
import copy
# 浅拷贝
computer1=Computer(Cpu(),Disk())
computer2=copy.copy(computer1)
print(id(computer1))
print(id(computer2))
print(id(computer1.cpu))
print(id(computer2.cpu))
2392556444024
2392556444360
2392556443800
2392556443800
深拷贝
使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象
class Cpu:
pass
class Disk:
pass
class Computer:
def __init__(self,cpu,disk):
self.cpu=cpu
self.disk=disk
import copy
# 深拷贝
computer1=Computer(Cpu(),Disk())
computer2=copy.deepcopy(computer1)
print(id(computer1))
print(id(computer2))
print(id(computer1.cpu))
print(id(computer2.cpu))
2008354528672
2008354527664
2008354527440
2008354528616
2
模块
- 模块的英文为Modules
- 一个模块可以包含N多个函数、类
- 在Python中一个扩展名为.py的文件就是一个模块
- 使用模块的好处
- 方便其他程序和脚本引入并使用
- 避免函数名和变量名冲突
- 提高代码的可维护性
- 提高代码的可重用性
模块的导入
- import 模块名称 [as 别名]
- from 模块名称 import 函数/变量/类
以主程序形式运行
def add(a, b):
return a+b
# 如果别的模块引用这个py，下面的代码不会执行
if __name__ == "__main__":
print(add(1,2))
包
使用import 方式进行导入时，只能跟包名或模块名
使用from...import 方式可以导入包、模块、函数、变量
Python中常用的内置模块
安装使用第三方模块
pip install schedule 定时模块
import schedule
def job():
print('哈哈--------')
schedule.every(3).seconds.do(job)
while True:
schedule.run_pending()
编码格式
# .py 文件默认使用的utf-8
'''
使用 #encoding=GBK 可以修改.py文件的编码格式
'''
print('你好中国')
文件读写
内置函数open()创建文件对象
语法：file=open(filename [,mode,encoding])
- mode 默认为只读
- encoding 默认为GBK
file = open('a.txt','r',encoding='utf-8')
print(file.readlines())
file.close()
['中国\n', '美丽']
常用的文件打开模式
文件对象的常用方法
with语句：上下文管理器
with open('a.txt','rb') as file:
pass
# 它会自动关闭file
目录操作
- os模块与os.path模块对于目录进行操作
import os
# 打开记事本
os.system('notepad.exe')
# 直接调用可执行文件
os.startfile('路径exe')
import os
path=os.getcwd()
lst_files=os.walk(path)
# print(lst_files)
for dirpath,dirname,filename in lst_files:
# print('1',dirpath)
# print('2',dirname)
# print('3',filename)
# print('----------------')
# 所有的dir
for dir in dirname:
print(os.path.join(dirpath,dir))
# 所有的filename
for file in filename:
print(os.path.join(dirpath,file))
浙公网安备 33010602011771号