【Python】Python知识点总结

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]

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)

参考资料:

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏IT笔记

聊聊Servlet、Struts1、Struts2以及SpringMvc中的线程安全

很多初学者,甚至是工作1-3年的小伙伴们都可能弄不明白?servlet Struts1 Struts2 springmvc 哪些是单例,哪些是多例,哪些是...

592140
来自专栏JAVA技术站

JFinal一行代码搞定增删改,要的就是快 原

首先需要重写getModel方法,但是这有个问题,重写之后的方法和getModel的参数有点冲突,所以选择不重写,另外写个方法占且叫getBaseModel吧,...

7710
来自专栏python3

习题18:命名,变量,代码,函数

1. 首先告诉python创建一个函数,使用的命令是def,也就是定义(define)的意思

9220
来自专栏java 成神之路

Java Timer 定时任务实现原理及缺陷分析

41580
来自专栏用户2442861的专栏

Java多线程学习(吐血超详细总结)

http://blog.csdn.net/evankaka/article/details/44153709

5.3K20
来自专栏微信公众号:Java团长

详解Java类的生命周期

最近有位细心的朋友在阅读笔者的文章时,对java类的生命周期问题有一些疑惑,笔者打开百度搜了一下相关的问题,看到网上的资料很少有把这个问题讲明白的,主要是因为目...

11720
来自专栏架构师小秘圈

shell脚本极简教程

一,shell题记 不懂shell的程序员不是好程序员,学习shell是为了自动化,使用自动化可以非常有效的提高工作效率。没有一个大公司不要求linux的基本技...

45660
来自专栏Python入门

30个Python程序员需要知道的编程技巧,可以让你的工作事半功倍!

在上面代码中,赋值的右侧形成了一个新元组,而左侧则立刻将该(未被引用的)元组解包到名称<a>和<b>。

8300
来自专栏JAVA高级架构

Java内存区域与虚拟机类加载机制

一、Java运行时数据区域 ? 1、程序计数器   “线程私有”的内存,是一个较小的内存空间,它可以看做当前线程所执行的字节码的行号指示器。Java虚拟机规范...

36680
来自专栏微信公众号:Java团长

Java虚拟机类加载机制

看到这个题目,很多人会觉得我写我的java代码,至于类,JVM爱怎么加载就怎么加载,博主有很长一段时间也是这么认为的。随着编程经验的日积月累,越来越感觉到了解虚...

10920

扫码关注云+社区

领取腾讯云代金券