私信我或关注微信号：猿来如此呀，回复：学习，获取免费学习资源包。

Python数据类型：

字符串' ', " "：

# 字符串基本操作a = 'Life is short, you need Python'a.lower() # 'life is short, you need Python'a.upper() # 'LIFE IS SHORT, YOU NEED PYTHON'a.count('i') # 2a.find('e') # 从左向右查找'e'，3a.rfind('need') # 从右向左查找'need'，19a.replace('you', 'I') # 'Life is short, I need Python'tokens = a.split() # ['Life', 'is', 'short,', 'you', 'need', 'Python']b = ' ---'.join(tokens) # 用指定分隔符把字符串列表组合成新字符串，Life---is---short,---you---need---Pythonc = a + '\n' # 加了换行符，注意+用法是字符串作为序列的用法c.rstrip() # 右侧去除换行符[x for x in a] # 遍历每个字符并生成由所有字符按顺序构成的列表'Python' in a # True# 字符串格式化a = 'I’m like a {} chasing {}.'a.format('dog', 'cars') # 按顺序格式化字符串，'I’m like a dog chasing cars.'b = 'I prefer {1} {0} to {2} {0}'b.format('food', 'Chinese', 'American') # 在大括号中指定参数所在位置 # 貌似这个功能在Python2.6有，在Python3.6没了？# >代表右对齐，>前是要填充的字符，依次输出：# 000001# 000019# 000256for i in [1, 19, 256]: print('The index is {:0>6d}'.format(i))# <代表左对齐，依次输出：# *---------# ****------# *******---for x in ['*', '****', '*******']: progress_bar = '{:-<10}'.format(x) print(progress_bar)for x in [0.0001, 1e17, 3e-18]: print('{:.6f}'.format(x)) # 按照小数点后6位的浮点数格式 print('{:.1e}'.format(x)) # 按照小数点后1位的科学记数法格式 print ('{:g}'.format(x)) # 系统自动选择最合适的格式template = '{name} is {age} years old.'c = template.format(name='Tom', age=8)) # Tom is 8 years old.d = template.format(age=7, name='Jerry')# Jerry is 7 years old.# format在生成字符串和文档的时候非常有用，更多更详细的用法可以参考Python官网：

列表[]，list([])（各种元素，通过下表访问元素，类似C语言的数组）：

# 列表的基本操作有访问，增加，删除，和拼接：a = [1, 2, 3, 4]a.pop() # 把最后一个值4从列表中移除并作为pop的返回值a.append(5) # 末尾插入值，[1, 2, 3, 5]a.index(2) # 找到第一个2所在的位置，也就是1a[2] # 取下标，也就是位置在2的值，也就是第三个值3a += [4, 3, 2] # 拼接，[1, 2, 3, 5, 4, 3, 2]a.insert(1, 0) # 在下标为1处插入元素0，[1, 0, 2, 3, 5, 4, 3, 2]a.remove(2) # 移除第一个2，[1, 0, 3, 5, 4, 3, 2]a.reverse() # 倒序，a变为[2, 3, 4, 5, 3, 0, 1]a[3] = 9 # 指定下标处赋值，[2, 3, 4, 9, 3, 0, 1]b = a[2:5] # 取下标2开始到5之前的子序列，[4, 9, 3]c = a[2:-2] # 下标也可以倒着数（-2表示倒数第二个元素），方便算不过来的人，[4, 9, 3]d = a[2:] # 取下标2开始到结尾的子序列，[4, 9, 3, 0, 1]e = a[:5] # 取开始到下标5之前的子序列，[2, 3, 4, 9, 3]f = a[:] # 取从开头到最后的整个子序列，相当于值拷贝，[2, 3, 4, 9, 3, 0, 1]a[2:-2] = [1, 2, 3] # 赋值也可以按照一段来，并且左右两边长度可以不等，[2, 3, 1, 2, 3, 0, 1]g = a[::-1] # 将a中元素倒序赋值给g，[6, 5, 4, 3, 2, 1, 0]g = a[::-2] # [6, 4, 2, 0]g = a[::1] # 将a中元素正序赋值给g，[0, 1, 2, 3, 4, 5, 6]a.sort()print(a) # 列表内排序，a变为[0, 1, 1, 2, 2, 3, 3]# 列表推导式# 列表推导式的结构是：在一个方括号里，首先是一个表达式，随后是一个 for 子句，然后是零个或更多的 for 或 if 子句。# 返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。 # 示例：squares = [x**2 for x in range(10)] # 推导式print(squares)# 输出是[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]pairs = [(x, y) for x in [1,2,3] for y in [3,1,4] if x!=y] # 推导式print(pairs)# 输出是[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

元组()，tuple([])（不能被赋值的列表，类似在列表前修饰const）：

c = (5,) # 如果初始化只包含1个元素的tuple，语法必须明确，必须在元素后加上逗号b = tuple(['3', 4]) # 也可以从列表初始化

集合{}（用于去重，求集合的∪，∩，差）：

A = set([1, 2, 3, 4])B = {3, 4, 5, 6}C = set([1, 1, 2, 2, 2, 3, 3, 3, 3])print(C) # 集合的去重效果，set([1, 2, 3])print(A | B) # 求并集，set([1, 2, 3, 4, 5, 6])print(A & B) # 求交集，set([3, 4])print(A - B) # 求差集，属于A但不属于B的，set([1, 2])print(B - A) # 求差集，属于B但不属于A的，set([5, 6])print(A ^ B) # 求对称差集，相当于(A-B)|(B-A)，set([1, 2, 5, 6])

字典{key:value,key:value}，dict(key=value,key=value)：

# 字典操作a = {'Tom': 8, 'Jerry': 7}print(a['Tom']) # 8b = dict(Tom=8, Jerry=7) # 一种字符串作为键更方便的初始化方式print(b['Tom']) # 8if 'Jerry' in a: # 判断'Jerry'是否在keys里面 print(a['Jerry']) # 7print(a.get('Spike')) # None，通过get获得值，即使键不存在也不会报异常a['Spike'] = 10a['Tyke'] = 3a.update({'Tuffy': 2, 'Mammy Two Shoes': 42})print(a.values()) # dict_values([8, 2, 3, 7, 10, 42])print(a.pop('Mammy Two Shoes')) # 移除'Mammy Two Shoes'的键值对，并返回42print(a.keys()) # dict_keys(['Tom', 'Tuffy', 'Tyke', 'Jerry', 'Spike']) # 字典排序# 使用items()或者iteritems()b = a.items()print(b) # [('Tuffy', 2), ('Spike', 10), ('Tom', 8), ('Tyke', 3), ('Jerry', 7)]from operator import itemgetterc = sorted(a.items(), key=itemgetter(1)) # print(c) # [('Tuffy', 2), ('Tyke', 3), ('Jerry', 7), ('Tom', 8), ('Spike', 10)]d = sorted(a.iteritems(), key=itemgetter(1))print(d) # [('Tuffy', 2), ('Tyke', 3), ('Jerry', 7), ('Tom', 8), ('Spike', 10)]e = sorted(a)print(e) # 只对键排序，['Jerry', 'Spike', 'Tom', 'Tuffy', 'Tyke']# items()可以把字典中的键值对转化成一个列表，其中每个元素是一个tuple# tuple的第一个元素是键，第二个元素是值。变量c是按照值排序，所以需要一个操作符itemgetter，去位置为1的元素作为排序参考，# 如果直接对字典排序，则其实相当于只是对键排序。字典被当作一个普通的可遍历结构使用时，都相当于遍历字典的键。# 另外需要注意的一点是字典是通过哈希表实现的，所以键必须是可哈希的， list不能被哈希，所以也不能作为字典的键，而tuple就可以。

迭代器：

# 上段代码用到了itemgetter()函数，因此这里插入说一下迭代器（iterator）# 迭代器相当于一个函数，每次调用都返回下一个元素# 从遍历的角度来看就和列表没有区别，区别是迭代器占用更少内存# 在Python3中，range()就不再产生一个列表了，而是作为迭代器，xrange()直接没了

Python运算符

+, -, *, /

%: 求余数

and:相当于C++的&

*在对列表操作时相当于复制，例如:

g = [0]3 + [1]4 + [2]*2 # [0, 0, 0, 1, 1, 1, 1, 2, 2]

**: 幂运算符

Python缩进

同一层次代码缩进量相同，建议跨平台跨编辑器缩进用空格，因为有的编辑器tap=2个空格，有的编辑器tap=4个空格

Python控制流

if & elif & else 条件结构：# if结构包括三个关键字：if, elif, elsepets =['dog', 'cat', 'droid', 'fly']for pet in pets: if pet == 'dog': # 狗粮 food = 'steak' # 牛排 elif pet == 'cat': # 猫粮 food = 'milk' # 牛奶 elif pet == 'droid': # 机器人 food = 'oil' # 机油 elif pet == 'fly': # 苍蝇 food = 'sh*t' # ... else: pass # pass 关键字占位用，什么也不做 print(food)# if表达式中的小技巧food = food_for_pet[pet] if pet in food_for_pet else None # 一个if-else常见的行内应用，就是代替三元操作符if -1 < x < 1: # 等效于 if x > -1 and x < 1: print('The absolute value of x is < 1')if x in ['piano', 'violin', 'drum']: # 等效于 if x == 'piano' or x == 'violin' or x =='drum': print("It's an instrument!")food = food_for_pet[pet] if pet in food_for_pet else Nonewhile 循环结构：while(条件): 执行语句for 循环结构（常用）：# 遍历列表a=["aa","bb","cc"]for i in a: print(i)# 常规循环for i in range(0,10): # range(0,10)生成0—9这10个数字 print(i)# 以上两种循环属于for_each风格，C++11中也开始支持这种for循环方式# 不过如果还是需要下标呢？比如遍历一个list的时候，希望把对应下标也打印出来# 这时可以用enumeratenames = ["Rick", "Daryl", "Glenn"]for i, name in enumerate(names): print(i, name)# 当然你也可以通过下标遍历words = ["This", "is", "not", "recommended"]# not pythonicfor i in range(len(words)): print(words[i])break & continue 中断结构：# break 直接全部退出当前循环模块 a=["aa","bb","cc"]for i in a: if (i="bb"): break print(i)# continue 中断当前循环，继续下一次循环a=["aa","bb","cc"]for i in a: if (i="bb"): continue print(i)循环练习，输出乘法口诀表：# 正序打印乘法口诀表for i in range(1,10): for j in range(1,i+1): print(str(i) + "*" + str(j) + "=" +str(i*j), end=" ") # end=" "表示不换行输出，我在双引号间加了一个空格为了美观 print()# 逆序打印乘法口诀表for i in range(1,10): for j in range(i,10): print(str(10-i)+"*" + str(10-j)+ "="+str((10-i)*(10-j)),end=" ") print()

Python函数

def 函数名(参数1,,参数2...): 函数体# 注意点# 默认参数必须放后面，如：def create_a_list(x, y=2, z=3): # 默认参数项必须放后面 return [x, y, z]

lambda匿名函数

# Lambda表达式在Python中是一种匿名函数，lambda关键字后面跟输入参数，然后冒号后面是返回值some_ops = lambda x, y: x + y + x*y + x**y # 形参是x,y，返回x + y + x*y + x^ysome_ops(2, 3) # 2 + 3 + 2*3 + 2^3 = 19

Python生成器（Generator）

# 生成器是迭代器的一种，形式上看和函数很像，只是把return换成了yield# 在每次调用的时候，都会执行到yield并返回值，同时将当前状态保存，等待下次执行到yield再继续：# 从10倒数到0def countdown(x): while x >= 0: yield x x -= 1for i in countdown(10): print(i)# 可以通过next()函数返回下一个值a=countdown(3)print(a.next())print(next(a))print(next(a))print(next(a))# 如果迭代结束就会抛出StopIteration异常

Python模块

import 模块名from 模块名 import 模块中的方法模块的类别：1. Python自带模块（在./python/Lib路径下）2. 第三方模块（pip）3. 自己写的模块（写好*.py放到./python/Lib路径下）

Python文件操作、用pickle序列化、转换为JSON标准格式

在Python中，推荐用上下文管理器（with-as）来打开文件，IO资源的管理更加安全，而且不用老惦记着给文件执行close()函数# 打开文件file=open(文件地址，操作形式（包括：w:写入,r：读取,b：以二进制形式,a：在文件末尾追加）)# 读出文件file.read()file.readline() # 读取文件的一行# 关闭文件file.close() #打开文件一定要关闭# 写入文件（覆盖原来的）file.write(要写入的数据) # 写入后一定要关闭才能保存# 写入文件（追加写入，不覆盖）# Python文件操作例子FilePath='D:\\Code_hub\\test\\tmp1.txt'data1="data1"data2="data2"# 新建文件：file，写入数据，关闭保存File=open(FilePath,'w')File.write(data1)File.close()# 文件：file，写入数据（会将原来文件内容覆盖），关闭保存File=open(FilePath,'w')File.write(data2)File.close()# 文件：file，写入数据（在原来文件内容后面追加），关闭保存File=open(FilePath,'a')File.write(data2)File.close()# 用上下文管理器（with-as）来打开文件# IO资源的管理更加安全，而且不用惦记着给文件执行close()函数# open()的第一个参数是文件名，第二个参数是模式# 文件的模式一般有四种，读取(r)，写入(w)，追加(a)和读写(r+)# 如果希望按照二进制数据读取，则将文件模式和b一起使用（wb, r+b…）# 现有一文件'name_age.txt'# 文件内容为：Tom+8Jerry+7Tyke+3with open('name_age.txt', 'r') as f: # 打开文件，读取模式 lines = f.readlines() # 一次读取所有行 for line in lines: # 按行格式化并显示信息 name, age = line.rstrip().split('+') # rstrip()：右侧去除换行符；split()：以某符号为分隔符划分字符串 print('{} is {} years old.'.format(name, age))# 执行后结果为：Tom is 8 year old.Jerry is 7 year old.Tyke is 3 year old.# 如果要读取文件内容，并把年龄和名字的顺序交换存成新文件age_name.txt，这时可以同时打开两个文件：with open('name_age.txt', 'r') as fread, open('age_name.txt', 'w') as fwrite: line = fread.readline() while line: name, age = line.rstrip().split('+') fwrite.write('{}-{}\n'.format(age, name)) line = fread.readline()# 此时age_name.txt文件内容为：8-Tom7-Jerry3-Tyke# 序列化# 把变量从内存中变成可存储或传输的过程称之为序列化# 在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等# 反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling# Python提供了pickle模块来实现序列化import pickled = dict(name='Bob', age=20, score=88)a=pickle.dumps(d) # pickle.dumps()方法把任意对象序列化成一个bytes，然后，就可以把这个bytes写入文件print(a)with open('dumps.txt', 'wb') as f: f.write(a)with open('dump.txt', 'wb') as f: pickle.dump(d, f)# 上述两段代码生成的文件dump.txt和dumps.txt内容都是一样的# 反序列化，使用loads()或load()函数a1=pickle.loads(a)print(a1)with open('dump.txt', 'rb') as f: d = pickle.load(f) print(d)# 转换为JSON标准格式# 如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式# 比如XML，但更好的方法是序列化为JSON# 因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输# JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。# Python内置的json模块提供了非常完善的Python对象到JSON格式的转换import jsond= dict(name='Bob',age=20,score=88)a=json.dumps(d) # 使用dumps()方法序列化为JSON，也可以使用dump()print(d)print(type(d))print(a)print(type(a))# 控制台输出为：{'name': 'Bob', 'age': 20, 'score': 88}<class 'dict'>{"name": "Bob", "age": 20, "score": 88}<class 'str'># 反序列化# 跟上文一样用loads()或load()方法d1=json.loads(a)print(d1)print(type(d1))# 控制台输出为：{'name': 'Bob', 'age': 20, 'score': 88}<class 'dict'># 将Python中的对象（可以先看Python面向对象编程再来看）序列化成JSON对象import jsonclass Student(object): def __init__(self,name='NoOne',age=0,score=0): self.name=name self.age=age self.score=scores = Student('Bob', 20, 88)# 默认情况下，dumps()方法不知道如何将Student实例变为一个JSON的{}对象# 可选参数default就是把任意一个对象变成一个可序列为JSON的对象# 我们只需要为Student专门写一个转换函数，再把函数传进去即可def student2dict(std): return { 'name': std.name, 'age': std.age, 'score': std.score }print(json.dumps(s,default=student2dict))# 一般类的实例中都会有一个__dict__属性，它就是一个dict# 可以偷懒一点不写实例转换成dict的函数，直接用__dict__属性print(json.dumps(s,default=lambda obj:obj.__dict__))# JSON对象反序列化成实例# 首先需要将json的dict类型转换为对象类型def dict2student(dicType): return Student(dicType['name'], dicType['age'], dicType['score']) # 这里d[ ]表示从字典取值，刚开头讲过的知识不要忘记json_str = '{"age": 20, "score": 88, "name": "Bob"}' # 注意json对象是str，不要漏写''符号print(json.loads(json_str,object_hook=dict2student))# dict2student返回值为一个对象实例，这样json.loads()解析时就不会使用默认的dict类型解析# 输出结果为<__main__.Student object at 0x0000022F3707D048># 如果dict类型中包含中文字符串，使用json.dumps(obj, ensure_ascii=False)进行序列化，默认ensure_ascii=True，不改成False不能正常显示中文字符

Python异常处理

# 异常处理格式：try: 程序except Exception as 异常名称: 异常处理部分# 注意：try和except的缩进是在对应的同一层次Python异常处理例子：# 捕获异常，输出异常并结束try: for i in range(10): print(i) if(i==4): print(unknown)except Exception as err: print(err)# 捕获异常，输出异常并继续下一次循环for i in range(10): try: print(i) if(i==4): print(unknown) except Exception as err: print(err)

Python面向对象编程

# Python中的类的概念和其他语言相比没什么不同# 比较特殊的是protected和private在Python中是没有明确限制的# 一个惯例是用单下划线开头的表示protected，用双下划线开头的表示private# Python中定义一个类class class1: """Class A""" # 类定义中紧跟着类名字下一行的字符串叫做docstring， # 可以写一些用于描述类的介绍，如果有定义则通过“类名.__doc__”访问 print('class1') # 构造函数，用关键字“__init__” # 在实例化对象时，构造函数被自动调用，一般用于初始化变量 # self：在类中的方法，第一个参数必须是self  def __init__(self,name,job): print('I am __init__ in class1') print('My name is '+ name+' My job is '+job) # 定义属性，一定要用self.属性名 self.myname=name self.myjob=job # 定义类中的方法： def myfunc(self,funcName): print('I an in class1.myfunc') print(funcName)# 在实例化类时传入参数给构造函数a=class1("keloli","student")print(a.myname)a.myfunc("func1")# 输出class1I am __init__ in class1My name is keloli My job is studentkeloliI an in class1.myfuncfunc1# 类的继承与重载# 继承：把某一个或多个类（基类）的特征拿过来# 重载：在子类（派生类）中多继承来的特征重新定义# 单继承：父亲可以说话，小儿子继承了父亲，但是减弱了父亲的说话能力# 父亲类（基类）class father(): def speak(self): print("father speak")# 大儿子类（单继承父亲类）class son1(father): passs1=son1()s1.speak()# 多继承：父亲可以说话，母亲可以写字，# 女儿继承了父亲和母亲，还可以听# 母亲类（基类）class mother(): def write(self): print('mother write')# 女儿类（多继承父亲和母亲）class daughter(father,mother): def listen(self): print('daughter listen')dau=daughter()dau.speak()dau.write()dau.listen()# 重载# 小儿子类重载父亲类，减弱了父亲的说话能力class son2(father): def speak(self): print('son2 speak')s2=son2()s2.speak()# 输出father speakfather speakmother writedaughter listenson2 speak

map, reduce和filter（函数式编程）

# map可以用于对可遍历结构的每个元素执行同样的操作，批量操作：map(lambda x: x**2, [1, 2, 3, 4]) # [1, 4, 9, 16]map(lambda x, y: x + y, [1, 2, 3], [5, 6, 7]) # [6, 8, 10]# 在Python3种输出上述结果result1=list(map(lambda x: x**2, [1, 2, 3, 4]) ) # [1, 4, 9, 16]print(result1)result2(map(lambda x, y: x + y, [1, 2, 3], [5, 6, 7])) # [6, 8, 10]print(result2)# reduce则是对可遍历结构的元素按顺序进行两个输入参数的操作# 并且每次的结果保存作为下次操作的第一个输入参数，还没有遍历的元素作为第二个输入参数# 这样的结果就是把一串可遍历的值，减少（reduce）成一个对象from functools import reduceres=reduce(lambda x, y: x + y, [1, 2, 3, 4]) # ((1+2)+3)+4=10print(res)# filter顾名思义，根据条件对可遍历结构进行筛选filter(lambda x: x % 2, [1, 2, 3, 4, 5]) # 筛选奇数，[1, 3, 5]列表生成# For More : 列表生成可以非常方便地用来生成列表和迭代器# 比如上节中map的两个例子和filter的一个例子可以用列表生成重写为[x**2 for x in [1, 2, 3, 4]] # [1, 4, 9 16][sum(x) for x in zip([1, 2, 3], [5, 6, 7])] # [6, 8, 10]# zip()函数可以把多个列表关联起来，这个例子中，通过zip()可以按顺序同时输出两个列表对应位置的元素对# 有一点需要注意的是，zip()不会自动帮助判断两个列表是否长度一样，所以最终的结果会以短的列表为准# 想要以长的列表为准的话可以考虑itertools模块中的izip_longest()[x for x in [1, 2, 3, 4, 5] if x % 2] # [1, 3, 5]# 如果要生成迭代器只需要把方括号换成括号，生成字典也非常容易：iter_odd = (x for x in [1, 2, 3, 4, 5] if x % 2)print(type(iter_odd)) # <type 'generator'>square_dict = {x: x**2 for x in range(5)} # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}至于列表生成和map/filter应该优先用哪种，这个问题很难回答，不过Python创始人Guido似乎不喜欢map/filter/reduce，他曾在表示过一些从函数式编程里拿来的特性是个错误。

Python 多线程

# 进程由一个或多个线程组成，在单核CPU中采用各个任务交替执行的方法达到任务并行处理的效果# 多进程和多线程的程序涉及到同步、数据共享的问题，编写起来更复杂# 廖雪峰老师这个章节讲解比较详细from multiprocessing import Processimport os# 子进程要执行的代码def run_proc(name): print('Run child process %s (%s)...' % (name, os.getpid()))if __name__=='__main__': print('Parent process %s.' % os.getpid()) p = Process(target=run_proc, args=('test',)) print('Child process will start.') p.start() p.join() print('Child process end.')

Python OS模块

# OS模块常用函数import osabspath=os.path.abspath('') # 显示当前目录的绝对路径print('abspath: ',abspath)FileName1=os.path.basename(__file__) # 获取当前代码所在文件的文件名，包含后缀FileName2=FileName1.split('.')[-2] # 获取当前代码所在文件的文件名，通过'.'分割字符串，[-1]是文件后缀，[-2]是文件名newpath=os.path.join(abspath,'mkdir_test') # 在某目录下创建新目录，先将新路径表示出来 # 把两个路径合成一个时，不要直接拼字符串，而要通过os.path.join()函数 # 这样可以正确处理不同操作系统的路径分隔符print('newpath: ',newpath)try: # 与文件相关操作可能会出现路径错误等异常，所以使用'try-except'语句对 os.mkdir(newpath) # 创建目录except Exception as err:  print(err) try: DelatePath='D:\\Code_hub\\test\\16\\aa' os.rmdir(DelatePath) # 删除目录 print('Delate:',DelatePath,'success!') except Exception as err: print(err)FilePath='D:\\Code_hub\\test\\16\\text.py'SplitPath=os.path.split(FilePath) # 一个路径拆分为两部分，后一部分总是最后级别的目录或文件名print(SplitPath)SplitextPath=os.path.splitext(FilePath) # 得到文件扩展名print(SplitextPath)# print(type(SplitextPath))print(SplitextPath[0])print(SplitextPath[1]) # 建议使用print(SplitextPath[-1])如果你要获取文件拓展名# 注意：OS模块不提供复制文件的函数，原因是复制文件并非由操作系统提供的系统调用# shutil模块提供了copyfile()的函数# 你还可以在shutil模块中找到很多实用函数，它们可以看做是os模块的补充# 列出当前目录下的所有目录及文件FatherPath='D:\\Code_hub\\test'for x in os.listdir(FatherPath): print(x)# 列出当前目录下的所有目录及文件for x in os.listdir('.'): print(x)# 列出所有.py文件for x in os.listdir('.'): if os.path.isfile(x) and os.path.splitext(x)[-1]=='.py': print(x)

私信我或关注微信号：猿来如此呀，回复：学习，获取免费学习资源包。

来源网络，侵权删除