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 = [x**2 for x in range(10)] # 推导式
print(squares)
# 输出是[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 二维列表初始化
2D_list=[ [ 0 for x in range(column) ] for y in range(row) ]
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 + x**y # 形参是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}
<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 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类型解析
# 输出结果为
<__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")
# 输出
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: 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 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的一个例子可以用列表生成重写为
[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 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)
