python命令大全及说明文档 python命令大全

转载

mob64ca1412b28c 2023-08-10 08:20:19

文章标签 python命令大全及说明文档 python 文本文件打开文件赋值 文章分类 Python 后端开发

Python指令汇总（二）

四、函数

1.创建与调用函数
2.参数

(1)形参与实参
(2)关键字参数
(3)默认参数
(4)收集参数

3.函数文档
4.global关键字
5.nonlocal关键字
6. lambda表达式
7.filter()与map()

filter()
map()

五、集合与字典

1.字典

(1)创建字典
(2)内置方法

fromkeys()
key()、values()、items()
get()和setdefault()
clear()
copy()
pop()和popitem()
update()

2.集合

(1)创建集合
(2)访问集合
(3)不可变集合
(4)内置方法

逻辑方法
对元素操作

六、文件

1.打开文件
2.文件方法

close()
read()与readline()
tell()与seek()
write()与writelines()

3.模块

(1)OS模块

getcwd()
chdir(path)
listdir(path='.')
mkdir(path)
makedirs(path)
remove(path)、rmdir(path)、removedirs(path)
rename(old, new)
system(command)
walk(path)
实用定义

(2)os.path模块

basename(path)与dirname(path)
join(path1[,path2[,...]])
split(path)与splitext(path)
getsize(file)
getatime(file)、getctime(file)、getmtime(file)
exists(path)、isabs(path)、isdir(path)、isfile(path)、islink(path)、ismount(path)、samefile(path1,path2)

(3)pickle模块

dump(data,file)与load(file)

四、函数

1.创建与调用函数

创建：
def 函数名():
___函数内容

def nihao():
	return 'Hello world'

调用：
函数名()

nihao()
'Hello world'

2.参数

使函数实现个性化
参数写在括号中，如有多个参数，使用括号隔开

>>> def nihao(name):
	print(name + '好')

>>> nihao('你')
你好
>>> nihao('他')
他好

>>> def ai(name1,name2):
	print(name1 + '爱' + name2)

	
>>> ai('我','你')
我爱你

(1)形参与实参

形参指函数创建和定义时小括号里的参数，实参指函数在调用过程中传递进来的参数。

(2)关键字参数

为了防止在使用函数时搞乱参数输入的顺序，导致函数无法按预期实现，可以使用关键字参数

>>> ai('我','你')
我爱你
>>> ai(name2='我',name1='你')
你爱我

(3)默认参数

在定义函数时赋予了默认值的参数

def ai(name1='我',name2='你'):
	print(name1 + '爱' + name2)

>>> ai()
我爱你
>>> ai('他')
他爱你
>>> ai('我','他')
我爱他

(4)收集参数

当要输入的参数数量不确定时，在定义函数时使用收集参数，又称可变参数
使用时只需在参数前加*，实质上是将所有参数打包成一个元组

>>> def test(*params):
	print('有%d个参数'%len(params))
	print('第二个参数是：',params[1])

>>> test('hello','world')
有2个参数
第二个参数是： world

如果在收集参数后还有其他参数需要指定，在调用函数时就应该使用关键参数，否则都会被列入收集参数中。也可以将其他参数都设置为默认参数。

3.函数文档

函数的注释，让其他人更好的理解函数
用三对引号括起来
可以用函数名._ _doc _ _ 和help()函数读取查看

>>> def ai(name1,name2):
	'''name1爱name2
	爱不能随便说
	'''
	print(name1 + '爱' + name2)

	
>>> ai.__doc__
'name1爱name2\n\t爱不能随便说\n\t'
>>> help(ai)
Help on function ai in module __main__:

ai(name1, name2)
    name1爱name2
    爱不能随便说

4.global关键字

在函数内部修改全局变量

>>> count = 10
>>> def example():
	count = 5
	print(count)

	
>>> example()
5
>>> count
10

>>> count = 10
>>> def example():
	global count
	count = 5
	print(count)

	
>>> example()
5
>>> count
5

5.nonlocal关键字

在内部函数里修改外部函数里局部变量的值

>>> def f1():
	x = 5
	def f2():
		x *= x
		return x
	return f2

>>> f1()()
Traceback (most recent call last):
  File "<pyshell#64>", line 1, in <module>
    f1()()
  File "<pyshell#63>", line 4, in f2
    x *= x
UnboundLocalError: local variable 'x' referenced before assignment

>>> def f1():
	x = 5
	def f2():
		nonlocal x
		x *= x
		return x
	return f2

>>> f1()()
25

6. lambda表达式

创建匿名函数

>>> def f1(x):
	return 2 * x + 1

>>> f1(5)
11

>>> g = lambda x: 2 * x + 1
>>> g(5)
11

7.filter()与map()

filter()

过滤器
有两个参数，第一个参数可以是一个函数，也可以是None。如果是函数，就把第二额可迭代数据里的每一个元素作为函数的参数运算，把返回值为True的值筛选出来；如果是None，则直接把第二个参数中为True的值筛选出来。

>>> list(filter(lambda x:x % 2,range(10)))
[1, 3, 5, 7, 9]

map()

映射
有两个参数，一个是函数，一个是可迭代序列，将序列的每一个元素作为函数的参数进行运算加工，知道可迭代序列的每一个元素都加工完毕，返回所有加工后的元素构成。

>>> list(map(lambda x:x * 2,range(10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

五、集合与字典

1.字典

(1)创建字典

直接创建

dict1 = {'1*1':1,'2*2':4,'3*3':9}
dict1
{'1*1': 1, '2*2': 4, '3*3': 9}

empty = {}
empty
{}
type(empty)
<class 'dict'>

使用dict()

dict1 = dict((('A',65),('B',66),('C',67),('D',68),('E',69)))
dict1
{'A': 65, 'B': 66, 'C': 67, 'D': 68, 'E': 69}

dict1 = dict(A = 65,B = 66,C = 67,D = 68,E = 69)
dict1
{'A': 65, 'B': 66, 'C': 67, 'D': 68, 'E': 69}

dict1 = dict(zip(['one','two','three'],[1,2,3]))
dict1
{'one': 1, 'two': 2, 'three': 3}

给键赋值
如果键不存在，创建一个新的键并赋值；如果键存在，则改写键对应的值

dict1
{'one': 1, 'two': 2, 'three': 3}
dict1['four'] = 4
dict1
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
dict1['four'] = 'IV'
dict1
{'one': 1, 'two': 2, 'three': 3, 'four': 'IV'}

(2)内置方法

fromkeys()

创建并返回一个新的字典，它有两个参数，第一个参数是字典的键，第二个参数是可选的，是传入建对应的值，如果不提供，那么默认是None

dict1 = {}
dict1.fromkeys((1,2,3))
{1: None, 2: None, 3: None}
dict2 = {}
dict2.fromkeys((1,2,3),'Number')
{1: 'Number', 2: 'Number', 3: 'Number'}
dict3 = {}
dict3.fromkeys((1,2,3),('one','two','three'))
{1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}

fromkeys()方法并不会把三个值分别赋给各个键，而是整体赋值

key()、values()、items()

keys()返回字典中所有的键，values()返回字典中所有的值，items()返回字典中所有的键值对

dict1 = {}
dict1 = dict1.fromkeys(range(6),'你好')
dict1.keys()
dict_keys([0, 1, 2, 3, 4, 5])
dict1.values()
dict_values(['你好', '你好', '你好', '你好', '你好', '你好'])
dict1.items()
dict_items([(0, '你好'), (1, '你好'), (2, '你好'), (3, '你好'), (4, '你好'), (5, '你好')])

get()和setdefault()

访问字典项时，可以直接访问，输入键会返回对应的值。当输入的键不存在时，会发生错误

dict1
{'one': 1, 'two': 2, 'three': 3}
dict1['one']
1
dict1['four']
Traceback (most recent call last):
  File "<input>", line 1, in <module>
KeyError: 'four'

get()也是用来访问字典项，但如果输入的键不存在，不会报错，而是返回None。如果希望找不到是返回对应的值，可以在第二个参数设置对应的默认返回值

dict1.get('two')
2
dict1.get('four')
dict1.get('four','没有')
'没有'

setdefault()方法与get()方法有些类似，但setdefault()在字典中找不到相应的键时会自动添加

dict1
{1: 'one'}
dict1.setdefault(1)
'one'
dict1.setdefault(2)
dict1
{1: 'one', 2: None}

clear()

清空一个字典
清空一个字典也可以通过为变量名赋值一个空字典的方法进行，但有一定的弊端

dict1
{'one': 1}
dict2 = dict1
dict2
{'one': 1}
dict1.clear()
dict1
{}
dict2
{}

dict2 = dict1
dict1
{'one': 1}
dict2
{'one': 1}
dict1 = {}
dict1
{}
dict2
{'one': 1}

当试图通过将dict1指向一个空字典来达到清空效果时，原来的字典并没有真正被清空。

copy()

复制字典，而不是指向一个字典

dict1 = {'one':1}
dict2 = dict1.copy()
id(dict1)
59300232
id(dict2)
59300752
dict1['one'] = '一'
dict1
{'one': '一'}
dict2
{'one': 1}

pop()和popitem()

pop()是给定键弹出一个对应的值，popitem()则是弹出一个项

dict1 = {1:'one',2:'two',3:'three',4:'four'}
dict1.pop(2)
'two'
dict1
{1: 'one', 3: 'three', 4: 'four'}
dict1.popitem()
(4, 'four')
dict1
{1: 'one', 3: 'three'}

popitem()是随机弹出，无法指定项，也不是弹出最后一项，因为在字典中项没有顺序

update()

将另一个字典中的键值对更新到字典中

dict1
{1: 'one', 2: None}
dict1.update({2:'two'})
dict1
{1: 'one', 2: 'two'}

2.集合

用大括号将数据括起来但不体现映射特性就是集合，集合会把所有重复的数据清理掉。集合是无序的，不能索引集合中的某个元素

a = {1,2,3,4,5,6,3,5,2,1,9,'你好','你好','我好'}
a
{1, 2, 3, 4, 5, 6, '我好', 9, '你好'}
a[2]
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: 'set' object is not subscriptable

(1)创建集合

创建集合可以使用{}把所有元素括起来，也可以使用set()

set1 = {1,2,3,4}
set2 = set([1,2,3,4])
set1 == set2
True

(2)访问集合

由于集合中元素无序，所以不能像序列那样用下标进行访问，但可以使用迭代方法把集合中的数据依次读取

set1
{1, 2, 3, 4}
for each in set1:
    print(each,end = ' ')    
1 2 3 4

也可以使用 in 和 not in 判断一个元素是否在集合中存在

1 in set1
True
5 in set1
False
6 not in set1
True

(3)不可变集合

使用frozenset()函数可以使集合像元组一样不能随意地增加删除集合中的元素

set1 = frozenset({1,2,3,4,5,6})
set1.add(7)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'

(4)内置方法

逻辑方法

s.issubset(t)
子集测试：s是否是t的子集

s = {1,2,3}
t = {1,2,3}
s.issubset(t)
True
t = {1,2,4}
s.issubset(t)
False

s.issuperset(t)
超集测试：s是否是t的超集

t = {1,2,3}
s = {1,2,3}
s.issuperset(t)
True
t = {1,2,4}
s.issuperset(t)
False

s.union(t)
合并操作

s
{1, 2, 3}
t
{1, 2, 4}
s.union(t)
{1, 2, 3, 4}

s.intersection(t)
交集操作

s
{1, 2, 3}
t
{1, 2, 4}
s.intersection(t)
{1, 2}

s.difference(t)
差分操作：在s中存在，但在t中不存在的元素

s
{1, 2, 3}
t
{1, 2, 4}
s.difference(t)
{3}

s.symmetric_difference
对称差分操作：s或t中的元素，但不是s和t共有的元素

s
{1, 2, 3}
t
{1, 2, 4}
s.symmetric_difference(t)
{3, 4}

s.copy
返回s的拷贝（浅复制）

t = s.copy()
t
{1, 2, 3}
s
{1, 2, 3}

对元素操作

s.update(t)
将t中的元素添加到s中

s
{1, 2, 3}
t
{1, 2, 4}
s.update(t)
s
{1, 2, 3, 4}

s.intersection_update(t)
交集修改操作：s中仅包括s和t中共有的元素

s
{1, 2, 3}
t
{1, 2, 4}
s.intersection_update(t)
s
{1, 2}

s.difference_update(t)
差修改操作：s中仅包括属于s但不属于t的元素

s
{1, 2, 3}
t
{1, 2, 4}
s.difference_update(t)
s
{3}

s.symmetric_difference_update(t)
对称差分修改操作：s中包括仅属于s或仅属于t的元素

s
{1, 2, 3}
t
{1, 2, 4}
s.symmetric_difference_update(t)
s
{3, 4}

s.add(obj)
加操作

s = {1,2,3}
s.add(4)
s
{1, 2, 3, 4}

s.remove(obj)
删除操作：将obj从s中删除，如果s中不存在obj，将引发异常

s
{1, 2, 3, 4}
s.remove(4)
s
{1, 2, 3}
s.remove(4)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
KeyError: 4

s.discard(obj)
丢弃操作：将obj从s中删除，如果s中不存在obj，无事发生

s
{1, 2, 3}
s.discard(3)
s
{1, 2}
s.discard(3)
s
{1, 2}

s.pop()
弹出操作：移除并返回s中的一个元素

s = {1,2,3}
s.pop()
1
s
{2, 3}

s.clear
清除操作：清除s中的所有元素

s
{2, 3}
s.clear()
s
set()

六、文件

1.打开文件

使用open()来打开文件并返回文件对象：
open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
第一个参数是要打开的文件名，第二个参数指定文件打开模式（默认rt）

打开模式	执行操作
‘r’	以只读方式打开文件（默认）
‘w’	以写入的方式打开文件，会覆盖已存在的文件
‘x’	如果文件已经存在，使用此模式打开将引发异常
‘a’	以写入模式打开，如果文件存在，则在末尾追加写入
‘b’	以二进制模式打开文件
‘t’	以文本模式打开（默认）
‘+’	可读写模式（可添加到其他模式中使用）
‘U’	通用换行符支持

使用总结

确定要打开的文件存在（不存在使用会报错）
1、只读文本文件 r
2、只读非文本文件 rb
3、既读又写 r+或rb+
不确定要打开的文件是否存在。如果不存在，创建并打开；如果存在，打开并替换内容
1、只写文本文件 w
2、只写非文本文件 wb
3、既读又写 w+或wb+
不确定要打开的文件是否存在。如果不存在，创建并打开；如果存在，追加写入
1、只写文本文件 a
2、只写非文本文件 ab
3、既读又写 a+或ab+

2.文件方法

close()

关闭文件
因为在python中有垃圾收集机制，忘记关闭文件并不会造成十分严重的后果，但为了防止意外断电等的发生，还是要即使关闭文件

read()与readline()

读取文件
read以字节为单位进行读取，如果不设置参数，，会将全部内容读取

f = open('D:/pycharm/prj/面朝大海春暖花开.txt')
f.read(5)
'从明天起，'
f.read()
'做一个幸福的人\n喂马、劈柴，周游世界\n从明天起，关心粮食和蔬菜\n我有一所房子，面朝大海，春暖花开\n\n从明天起，和每一个亲人通信\n告诉他们我的幸福\n那幸福的闪电告诉我的\n我将告诉每一个人\n\n给每一条河每一座山取一个温暖的名字\n陌生人，我也为你祝福\n愿你有一个灿烂的前程\n愿你有情人终成眷属\n愿你在尘世获得幸福\n我只愿面朝大海，春暖花开'

readline在文件中读取一整行，就是从文件指针的位置开始向后读取，直到遇到换行符（\n）结束

f.seek(4,0)
4
f.read(1)
'天'
f.readline()
'起，做一个幸福的人\n'

tell()与seek()

seek()方法可以调整文件指针的位置，有两个参数，第一个参数表示偏移的字节数，第二个参数表示原本位置，0代表文件起始位置，1代表当前位置，2代表文件末尾。因此想让指针指到文件起始处，只需使用seek(0,0)
要注意的是，如果文件中有中文，一个汉字占用两个字节，如果使用seek方法时将指针放到了一个汉字中间，之后再read时就会出现错误
tell()方法返回当前文件指针的位置

f.tell()
26
f.seek(0,0)
0
f.tell()
0
f.seek(10,0)
10
f.tell()
10

另外注意，只有使用b打开的文件，才可以在seek方法中使用1,2，否则会报错，如下：

f.seek(10,1)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
io.UnsupportedOperation: can't do nonzero cur-relative seeks

write()与writelines()

write()方法将字符串写入文件中，writelines()方法将字符串序列seq写入文件中，seq是一个返回字符串的可迭代对象

f = open('D:/pycharm/prj/面朝大海春暖花开.txt','a+')
f.write('你好你好')
4
f.seek(0,0)
0
f.read()
'从明天起，做一个幸福的人\n喂马、劈柴，周游世界\n从明天起，关心粮食和蔬菜\n我有一所房子，面朝大海，春暖花开\n\n从明天起，和每一个亲人通信\n告诉他们我的幸福\n那幸福的闪电告诉我的\n我将告诉每一个人\n\n给每一条河每一座山取一个温暖的名字\n陌生人，我也为你祝福\n愿你有一个灿烂的前程\n愿你有情人终成眷属\n愿你在尘世获得幸福\n我只愿面朝大海，春暖花开你好你好'

a = ['窗前明月光','疑是地上霜']
f.writelines(a)
f.seek(0,0)
0
f.read()
'从明天起，做一个幸福的人\n喂马、劈柴，周游世界\n从明天起，关心粮食和蔬菜\n我有一所房子，面朝大海，春暖花开\n\n从明天起，和每一个亲人通信\n告诉他们我的幸福\n那幸福的闪电告诉我的\n我将告诉每一个人\n\n给每一条河每一座山取一个温暖的名字\n陌生人，我也为你祝福\n愿你有一个灿烂的前程\n愿你有情人终成眷属\n愿你在尘世获得幸福\n我只愿面朝大海，春暖花开你好你好窗前明月光疑是地上霜'

3.模块

(1)OS模块

使用前记得import os

getcwd()

返回当前工作目录

os.getcwd()
'D:\\pycharm\\p31'

chdir(path)

改变工作目录

os.chdir('D:\\pycharm\\p30')
os.getcwd()
'D:\\pycharm\\p30'

listdir(path=’.’)

列举指定目录中的文件名，默认参数是’.’，代表根目录，也可以使用’. .'代表上一层目录

os.listdir()
['.idea', 'my_liat.pkl', 'venv']

python命令大全及说明文档 python命令大全_python命令大全及说明文档

mkdir(path)

os.mkdir('test')
os.listdir()
['.idea', 'my_liat.pkl', 'test', 'venv']
os.mkdir('test')
Traceback (most recent call last):
  File "<input>", line 1, in <module>
FileExistsError: [WinError 183] 当文件已存在时，无法创建该文件。: 'test'

makedirs(path)

os.makedirs(r'test\test1')
os.listdir('test')
['test1']
os.makedirs(r'test\test1')
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  File "D:\python\lib\os.py", line 221, in makedirs
    mkdir(name, mode)
FileExistsError: [WinError 183] 当文件已存在时，无法创建该文件。: 'test\\test1'

remove(path)、rmdir(path)、removedirs(path)

remove()用于删除文件
rmdir()用于删除单层目录，如目录非空则抛出异常
removedir()用于删除多层目录，从子目录到父目录逐层尝试删除，如目录非空则抛出异常

rename(old, new)

将文件old重命名为new

system(command)

运行系统的shell命令

os.system('calc')
0

python命令大全及说明文档 python命令大全_python命令大全及说明文档_02

walk(path)

遍历路径下所有子目录，将结果返回一个三元组（路径，[包含目录]，[包含文件]）

for i in os.walk('D:\\1111111'):
...    print(i)
...    
('D:\\1111111', ['Knives.Out.2019.1080p.BluRay.x264-YOL0W', 'Perfect.Strangers.2016.720p.BluRay.x264.WiKi', 'Singer.2020.S08.1080p.WEB-DL.H264.AAC-TJUPT'], ['La.La.Land.2016.1080p.BluRay.DTS-ES.x264-NCmt.mkv', 'vedioList.txt'])
('D:\\1111111\\Knives.Out.2019.1080p.BluRay.x264-YOL0W', [], ['knives.out.2019.1080p.bluray.x264-yol0w.mkv'])
('D:\\1111111\\Perfect.Strangers.2016.720p.BluRay.x264.WiKi', ['Sample'], ['Perfect.Strangers.2016.720p.BluRay.x264.WiKi.md5', 'Perfect.Strangers.2016.720p.BluRay.x264.WiKi.mkv', 'Perfect.Strangers.2016.720p.BluRay.x264.WiKi.nfo'])
('D:\\1111111\\Perfect.Strangers.2016.720p.BluRay.x264.WiKi\\Sample', [], ['Perfect.Strangers.2016.720p.BluRay.x264.WiKi.Sample.mkv'])
('D:\\1111111\\Singer.2020.S08.1080p.WEB-DL.H264.AAC-TJUPT', [], ['Singer.2020.S08E02.1080p.WEB-DL.H264.AAC-TJUPT.mp4', 'Singer.2020.S08E03.1080p.WEB-DL.H264.AAC-TJUPT.mp4'])

实用定义

os.curdir 指代当前目录(’.’)
os.pardir 指代上一级目录(’. .’)
os.sep 输出操作系统特定的路径分隔符（Windows下为“\\”,Linux下为“/”）
os.linesep 当前平台使用的行终止符（Windows下为“\r\n”,Linux下为“\n”）
os.name 指代当前使用的操作系统（包括‘posix’，‘nt’，‘mac’，‘os2,’，‘ce’，‘java’）

(2)os.path模块

basename(path)与dirname(path)

前者去掉目录路径，单独返回文件名；后者去掉文件名，单独返回目录路径

join(path1[,path2[,…]])

将各部分组合成一个路径名

split(path)与splitext(path)

split：分割文件名与路径，返回(f_path,f_name)元组。即使完全使用目录而没有文件名，该函数也会把最后一个目录与之前的目录分离，不会去区分目录与文件名
splitext：分离文件名与扩展名，返回(f_name,f_extension)元组

getsize(file)

返回文件的尺寸，单位为字节

getatime(file)、getctime(file)、getmtime(file)

分别为返回文件最近的访问时间、创建时间与最新的修改时间，返回值均为浮点型秒数，可以使用time模块的gmtime()（格林威治天文台时间）与localtime()（当地时间）函数换算

exists(path)、isabs(path)、isdir(path)、isfile(path)、islink(path)、ismount(path)、samefile(path1,path2)

分别为判断指定路径是否存在；指定路径是否为绝对路径；指定路径是否存在且是一个目录；指定路径是否存在且是一个文件；指定路径是否存在且是一个符号链接；指定路径是否存在且是一个挂载点；两个路径是否指向同一个文件

符号链接在Windows中就是快捷方式，挂载点在Windows中就是盘符（如C，D，E）

(3)pickle模块

dump(data,file)与load(file)

dump将数据永久保存到文件中，load将文件中的数据加载
打开文件时必须用’b’二进制模式

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：微博技术架构分析新浪微博架构师

下一篇：jquery treegrid jquery treegrid 0.3.0

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯