Python指令汇总（二）

四、函数

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']

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

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’二进制模式

在学习《小甲鱼零基础学习python》过程中总结而来，仅供个人参考