大家好，我是讯享网，很高兴认识大家。

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') # 2

a.find('e') # 从左向右查找'e'，3

a.rfind('need') # 从右向左查找'need'，19

a.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---Python

c = 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

# 000256

for 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官网：

https://docs.python.org/3/library/string.html

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

# 列表的基本操作有访问，增加，删除，和拼接：

a = [1, 2, 3, 4]

a.pop() # 把最后一个值4从列表中移除并作为pop的返回值

a.append(5) # 末尾插入值，[1, 2, 3, 5]

a.index(2) # 找到第一个2所在的位置，也就是1

a[2] # 取下标，也就是位置在2的值，也就是第三个值3

a += [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 = [x2 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']) # 8

b = dict(Tom=8, Jerry=7) # 一种字符串作为键更方便的初始化方式

print(b['Tom']) # 8

if 'Jerry' in a: # 判断'Jerry'是否在keys里面

print(a['Jerry']) # 7

print(a.get('Spike')) # None，通过get获得值，即使键不存在也不会报异常

a['Spike'] = 10

a['Tyke'] = 3

a.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'的键值对，并返回42

print(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 itemgetter

c = 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, else

pets =['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 None

while 循环结构：

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的时候，希望把对应下标也打印出来

# 这时可以用enumerate

names = ["Rick", "Daryl", "Glenn"]

for i, name in enumerate(names):

print(i, name)

# 当然你也可以通过下标遍历

words = ["This", "is", "not", "recommended"]

# not pythonic

for 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 + xy # 形参是x,y，返回x + y + x*y + x^y

some_ops(2, 3) # 2 + 3 + 2*3 + 2^3 = 19

Python生成器(Generator)

# 生成器是迭代器的一种，形式上看和函数很像，只是把return换成了yield

# 在每次调用的时候，都会执行到yield并返回值，同时将当前状态保存，等待下次执行到yield再继续：

# 从10倒数到0

def countdown(x):

while x >= 0:

yield x

x -= 1

for 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+8

Jerry+7

Tyke+3

with 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-Tom

7-Jerry

3-Tyke

# 序列化

# 把变量从内存中变成可存储或传输的过程称之为序列化

# 在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等

# 反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling

# Python提供了pickle模块来实现序列化

import pickle

d = 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 json

d= 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}

{"name": "Bob", "age": 20, "score": 88}

# 反序列化

# 跟上文一样用loads()或load()方法

d1=json.loads(a)

print(d1)

print(type(d1))

# 控制台输出为：

{'name': 'Bob', 'age': 20, 'score': 88}

# 将Python中的对象(可以先看Python面向对象编程再来看)序列化成JSON对象

import json

class Student(object):

def __init__(self,name='NoOne',age=0,score=0):

self.name=name

self.age=age

self.score=score

s = 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类型解析

# 输出结果为

# 如果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")

# 输出

class1

I am __init__ in class1

My name is keloli My job is student

keloli

I an in class1.myfunc

func1

# 类的继承与重载

# 继承：把某一个或多个类(基类)的特征拿过来

# 重载：在子类(派生类)中多继承来的特征重新定义

# 单继承：父亲可以说话，小儿子继承了父亲，但是减弱了父亲的说话能力

# 父亲类(基类)

class father():

def speak(self):

print("father speak")

# 大儿子类(单继承父亲类)

class son1(father):

pass

s1=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 speak

father speak

mother write

daughter listen

son2 speak

map, reduce和filter(函数式编程)

# map可以用于对可遍历结构的每个元素执行同样的操作，批量操作：

map(lambda x: x2, [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: x2, [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 reduce

res=reduce(lambda x, y: x + y, [1, 2, 3, 4]) # ((1+2)+3)+4=10

print(res)

# filter顾名思义，根据条件对可遍历结构进行筛选

filter(lambda x: x % 2, [1, 2, 3, 4, 5]) # 筛选奇数，[1, 3, 5]

列表生成

# For More :http://www.codebelief.com/article/2017/02/python-advanced-programming-list-comprehensions/

# 列表生成可以非常方便地用来生成列表和迭代器

# 比如上节中map的两个例子和filter的一个例子可以用列表生成重写为

[x2 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)) #

square_dict = {x: x2 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 Process

import 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 os

abspath=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)

参考资料：