本章内容
1、集合及其运算
2、文件操作
3、字符编码与转码
4、函数与函数式编程
5、局部变量与全局变量
6、递归
7、补充知识点
一、集合及其运算
1、概念:
set集合是一个不重复元素集,用 { } 括起来,元素用 , 隔开,并且集合是无序的,无法通过下标进行索引
2、集合的创建
1 list_1 = [1,2,3,4,5,6,7,8]2 set_1 =set(list_1)3 set_2 = set([2,4,6,8,10])4 print(set_1,set_2)
>>>{1, 2, 3, 4, 5, 6, 7, 8} {8, 2, 10, 4, 6}
3、求集合交集的两种方法
1 set_1 = {1,2,3,4,5,6,7,8}2 set_2 = {2,4,6,8,10}3 print(set_1.intersection(set_2))4 print(set_1 & set_2)
>>>
{8, 2, 4, 6}
{8, 2, 4, 6}
4、求集合并集的两种方法
1 set_1 = {1,2,3,4,5,6,7,8}2 set_2 = {2,4,6,8,10}3 print(set_1.union(set_2))4 print(set_1 | set_2)
>>>
{1, 2, 3, 4, 5, 6, 7, 8, 10}
{1, 2, 3, 4, 5, 6, 7, 8, 10}
5、求集合差集的两种方法
1 set_1 = {1,2,3,4,5,6,7,8}2 set_2 = {2,4,6,8,10}3 print(set_1.difference(set_2))4 print(set_1 - set_2)
>>>
{1, 3, 5, 7}
{1, 3, 5, 7}
6、判断子集关系
1 set_1 = {1,2,3,4,5,6,7,8}2 set_2 = {2,4,6,8,10}3 set_3 = set([1,2,3,4,5,6])4 print(set_1.issubset(set_2))5 print(set_3.issubset(set_1))
>>>
False
True
7、判断父集关系
1 set_1 = {1,2,3,4,5,6,7,8}2 set_2 = {2,4,6,8,10}3 set_3 = {1,2,3,4,5,6}4 print(set_1.issuperset(set_2))5 print(set_1.issuperset(set_3))
>>>
False
True
8、对称差集
1 set_1 = {1,2,3,4,5,6,7,8}2 set_2 = {2,4,6,8,10}3 print(set_1.symmetric_difference(set_2))4 print(set_1 ^ set_2)
>>>
{1, 3, 5, 7, 10}
{1, 3, 5, 7, 10}
9、判断是否没有交集,是则返回True
1 set_1 = {1,2,3,4,5,6,7,8}2 set_2 = {2,4,6,8,10}3 set_3 = {1,2,3,4,5,6}4 print(set_1.isdisjoint(set_3))
>>>False
10、在集合中添加一个元素
1 set_1 = {1,2,3,4,5,6,7,8}2 set_1.add(0)3 print(set_1)
>>>{0, 1, 2, 3, 4, 5, 6, 7, 8}
11、在集合中添加多个元素
1 set_1 = {1,2,3,4,5,6,7,8}2 set_1.update([9,10,11,12,13])3 print(set_1)
>>>{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
12、删除集合中的某一个指定元素,如果该元素不存在,则会报错
1 set_3 = {1,2,3,4,5,6}2 print("set_3:",set_3)3 set_3.remove(5)4 print("set_3:",set_3)
>>>
set_3: {1, 2, 3, 4, 5, 6}
set_3: {1, 2, 3, 4, 6}
13、计算集合的长度
1 set_1 = {1,2,3,4,5,6,7,8}2 print(len(set_1))
>>>8
14、测试某一个元素是否是该集合的成员
1 set_1 = {1,2,3,4,5,6,7,8}2 print(5 inset_1)3 print(5 not in set_1)
>>>
True
False
15、删除并返回任意一个元素
1 set_1 = {1,2,3,4,5,6,7,8}2 print(set_1.pop())
>>>
16、删除一个指定的元素,如果不存在,不会报错
1 set_1 = {1,2,3,4,5,6,7,8}2 set_1.discard(7)3 print(set_1)>>>{1, 2, 3, 4, 5, 6, 8}
二、文件操作
1、文件与文件路径
文件有两个关键属性:“文件名”和“路径”。
路径路径指明了文件在计算机上的位置,包括“绝对路径”和“相对路径”。
1.1 windows上的倒斜杠和Mac os、Linux上的正斜杠
在Windows上,路径书写使用倒斜杠作为文件夹之间的分隔符,但是在Mac os和Linux上使用正斜杠作为文件夹之间的分隔符,如果想要在所有的系统上使用程序,就要考虑这两种情况。
可以使用os.path.join()函数来将文件和路径上的文件夹名字连起来,函数会返回一个文件路径的字符串,包含正确的路径分隔符。
importosprint(os.path.join('user','test.txt'))>>>user\test.txt
1.2 当前工作目录
利用os.getcwd()函数可以获取当前工作路径的字符串,并且通过os.chdir()来改变它。
importos
a=os.getcwd()print(a)
os.chdir("E:")
b=os.getcwd()print(b)>>>C:\Users\pc\Desktop
E:\
1.3 绝对路径和相对路径
绝对路径总是从根文件夹开始。
相对路径是相对于程序的当前工作目录。
对于点(.)和点点(..)文件夹,是用在路径中的特殊名称,“点”用作文件夹名称时表示“当前目录”,“点点”用作文件夹名称时表示父文件夹。
1.4 用os.makedirs()创建新文件夹
importos
os.makedirs(r'E:\test')
1.5 os.path模块
os.path模块中包含了许多与文件名和文件路径相关的函数,比如前面使用的os.path.join()。使用os.path模块的时候,只要导入os模块即可。
1.6 处理绝对路径和相对路径
1.6.1 调用os.path.abspath(path)将返回参数的绝对路径的字符串 【将相对路径转换为绝对路径的简单方法】
1.6.2 调用os.path.isabs(path),判断参数是否为一个绝对路径,如果是返回True。
1.6.3 调用os.path.relpath(path, start)将返回从start路径到path的相对路径的字符串。如果没有设置start,就默认选择当前工作目录为开始路径。
1.6.4 调用os.path.dirname(path)将返回一个字符串,它包含path参数中最后一个斜杠之前的所有内容。
1.6.5 调用os.path.basename(path)将返回一个字符串,它包含path参数中最后一个斜杠之后的所有内容。基本名和文件名一致。
1.6.6 如果同时需要一个路径的目录名称和基本名称,可以调用os.path.split(),获取这两个名字的元组形式。
importosprint(os.path.split(r'E:\computer_code'))>>>('E:\\', 'computer_code')
1.7 查看文件大小和文件夹内容
1.7.1 调用os.path.getsize(path)将返回path参数中文件的字节数。
1.7.2 调用os.listdir(path)将返回文件名字符串的列表,包含path参数中的每一个文件。
importosprint(os.listdir(r'E:'))
>>>
['Tools', 'Soft']
1.8 检查路径有效性
1.8.1 调用os.path.exists(path),如果参数path所指的文件夹或文件存在,则返回True。
1.8.2 调用os.path.isfile(path),如果path存在,且是一个文件,则返回True。
1.8.3 调用os.apth.isdir(path),如果path存在,且是一个文件夹,则返回True。
2、文件读写
2.1 打开并读取文件
data = open("my_file","r",encoding="utf-8").read()
#encoding="utf-8" 用于告诉程序该文件的编码格式
print(data)
如果想要在之后对打开的文件进行下一步操作,最好把这个文件的内存对象赋给一个变量,然后通过这个变量来读取文件的内容,比如:
f = open("my_file","r",encoding="utf-8")
data_1= f.read()
注意:同一个文件在不能同时读取两次,因为第一次读完后,光标被移动到了文件的末尾,如果此时想再次读取文件中的内容,就要把光标移动到前面,这个方法后面会提到。
2.2 写入文件
f = open("my_file","w",encoding="utf-8")
data= f.write("只写模式实际上是创建一个新的文件来覆盖原文件,并在新文件中写入")print(data)
2.3 在文件末尾追加内容
f = open("my_file","a",encoding="utf-8")
data= f.write("追加模式直接在文件末尾写入内容,当文件不存在的时候会创建新文件")
2.4 按行读取文件中的内容
f = open ("my_file","r",encoding="utf-8")print(f.readline())print(f.readline())print(f.readline())
#读取前三行的内容
示例:
利用for 循环和 if 判断读取文件中的每一行,但是跳过第3行
f = open ("my_file","r",encoding="utf-8")for index, line inenumerate(f.readlines()):if index == 3:print("------------")continue
print(line.strip())#.strip()方法用于去除多余的空格
上述问题还可以通过迭代器实现,以减少对内存的使用
f = open ("my_file","r",encoding="utf-8")
count=0for line inf :if count == 3:
count+= 1
continue
print(line.strip())
count+= 1
2.5 tell():返回程序读取了多少个字符
f = open("my_file","r",encoding = "utf-8")print(f.read())print(f.tell())
2.6 seek():将光标移动到指定位置,以解决程序无法同时读取两次文件内容的问题
f = open("my_file","r",encoding = "utf-8")print(f.read())
f.seek(0)print("--------------")print(f.read())
2.7 encoding :返回文件的编码格式
f = open("my_file2","r",encoding = "utf-8")print(f.encoding)
2.8 name :返回文件名
f = open("my_file","r",encoding = "utf-8")print(f.name)
2.9 seekable():判断文件是否可以移动光标
f = open("my_file2","r",encoding = "utf-8")print(f.seekable())
2.10 readable():文件是否可读
f = open("my_file2","r",encoding = "utf-8")print(f.readable())
2.11 writeable():文件是否可写
f = open("my_file2","r",encoding = "utf-8")print(f.writable())
2.12 flush():每执行一次循环就强制将结果写入硬盘,而不是等待缓存结束一次性写入硬盘
importsys, timefor i in range(20):
sys.stdout.write(">")#这种写法不会换行
sys.stdout.flush()
time.sleep(0.1)
2.13 closed :判断文件是否关闭
f = open("my_file2","r",encoding = "utf-8")print(f.closed)
2.14 truncate(): 清空文件
f = open("my_file2","w",encoding = "utf-8")
f.truncate()
2.15 文件读写: r+ (打开原文件进行操作,不会覆盖先前的文件)
f = open("my_file","r+",encoding = "utf-8")print(f.readable())print(f.writable())
2.16 文件写读: w+ (先创建一个文件,再进行操作,会覆盖先前的文件)
f = open("my_file2","w+",encoding = "utf-8")print(f.readable())print(f.writable())
2.17 追加读写: a+
f = open("my_file2","a+",encoding = "utf-8")print(f.readable())print(f.writable())
2.18 以二进制模式读文件
f = open("my_file2","rb")print(f.readable())print(f.writable())
2.19 以二进制模式写入(不是写入二进制内容)
f = open("my_file2","wb")print(f.readable())print(f.writable())
f.write(b"0101")
f.write("你好,世界".encode())#当要写入字符串的时候,要进行转码
2.20 文件修改
文件修改有两种方法:
(1)加载到内存中修改,然后存入文件中 ; (2)修改完写入新的文件中 。
下面利用方法(2)修改文件中的指定内容。
思路:一行一行读,边读边写入另一个新文件中,当找到目标时,将内容修改后写入新文件 。
f_1 = open ("my_file","r",encoding= "utf-8")
f_2= open ("my_file3","w",encoding= "utf-8")for line inf_1:if "你的美一缕飘散" inline:
line= line.replace("你的美一缕飘散","你的美永远不散")
f_2.write(line)
f_1.close()
f_2.close()
2.21 with语句
为了避免文件打开后忘记关闭,可以使用with语句在代码执行完后自动关闭文件
with open ("my_file","r") as f:pass
print(f.closed)#同时打开多个文件
with open ("my_file","r") as obj1, \
open ("my_file2","r") as obj2:pass
三、字符编码与转码
以下部分内容引用自:http://www.cnblogs.com/luotianshuai/articles/5735051.html
如有侵权,联系删除。
1、常见编码:
(1)gb2312:
https://baike.baidu.com/item/%E4%BF%A1%E6%81%AF%E4%BA%A4%E6%8D%A2%E7%94%A8%E6%B1%89%E5%AD%97%E7%BC%96%E7%A0%81%E5%AD%97%E7%AC%A6%E9%9B%86?fromtitle=GB2312&fromid=483170
(2)gb18030:
https://baike.baidu.com/item/gb18030/3204518?fr=aladdin
(3)GBK:
https://baike.baidu.com/item/GBK%E5%AD%97%E5%BA%93?fromtitle=GBK&fromid=481954
(4)ASCII:
https://baike.baidu.com/item/ASCII
(5)unicode:
https://baike.baidu.com/item/Unicode
(6)utf-8:
https://baike.baidu.com/item/UTF-8
2、utf-8 、unicode 和 gbk 之间的互相转换
GBK转换为utf-8的流程:
(1)首先通过decode解码成unicode
(2)再由unicode编码encode成utf-8
3、总结:
(1)所有字符集之间的转换都要经过unicode
(2)GBK和unicode之间必须进行转换后才可以打印对应的内容,而utf-8 和 unicode之间可以不转换直接打印
(3)decode()要告诉机器原来的编码是什么,因为所有的decode都是解码成unicode,而encode()要告诉机器目标编码是什么,因为所有的encode都是从unicode来的
(4)python中的默认数据类型是unicode,与文件编码无关(开头的注释表示文件编码)
(5)python3中的encode不仅转换了编码,还将内容转换成了bytes类型
4、补充:
python中查看默认编码格式的方法
importsysprint(sys.getdefaultencoding())
四、函数与函数式编程
1、函数概念:
(1)数学中的概念:给定一个数集A,假设其中的元素为x。现对A中的元素x施加对应法则f,记作f(x),得到另一数集B。假设B中的元素为y。则y与x之间的等量关系可以用y=f(x)表示。我们把这个关系式就叫函数关系式,简称函数。
(2)python中的概念:函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。函数是逻辑结构化和过程化的一种编程方法
2、函数的定义:
deftest():print("in the test")return 0
用def来定义一个函数。
注意:函数要有返回值,而过程实际上是一个返回值为None的函数。
3、函数的调用:
test()
4、函数的优势:
(1)代码重用:同一个函数可不断的被调用
(2)保持一致性:修改函数中的内容,就可以使每一各调用该函数的地方都跟着改变
(3)可扩展性 :函数可以根据需要进一步扩展
5、函数中return的作用是:结束函数并返回值(return后面的程序不会再执行),返回值可以是一个,也可以是多个内容
deftest1():print("in the test1")deftest2():print("in the test2")return0deftest3():print("in the test3")return {"name":"Mr"},["MR","Python"],1x=test1()
y=test2()
z=test3()print(x,"\n",y,"\n",z)
>>>
in the test1
in the test2
in the test3
None
0
({'name': 'Mr'}, ['MR', 'Python'], 1)
总结:
(1)返回值个数=0 :返回None
(2)返回值个数=1 :返回object
(3)返回值个数>1 :返回tuple
6、函数参数:
(1)形参:全称为“形式参数”是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传递的参数。
(2)实参:实参,actual parameters,全称为"实际参数"是在调用时传递给函数的参数,即传递给被调用函数的值。实参可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须具有确定的值,以便把这些值传送给形参。
(3)位置参数:调用函数时根据函数定义的参数位置来传递参数。
deffunc1(x,y):print("a=",x*2)print("b=",y*2)
func1(2,1)
>>>
a= 4
b= 2
(4)关键字参数:用在函数调用中,通过“键-值”形式加以指定,不需要考虑参数顺序的问题。
deffunc1(x,y):print("a=",x*2)print("b=",y*2)
func1(x=2,y=1)
>>>
a= 4
b= 2
注意:形参和实参必须一一对应,并且关键字参数不能写在位置参数前面
(5)默认参数:默认参数用在定义函数时给函数提供默认值,在调用该函数时,对于默认参数可以传值也可以不传值,但是不管是函数的定义还是调用,所有的位置参数都要放在默认参数前面。
def test(x,y=2):print(x)print(y)
test(1)
test(1,y=3)
>>>
1
2
1
3
(6)可变参数:在定义函数的时候,有时候不确定在调用的时候需要多少个参数,这个时候就可以通过可变参数来实现参数的扩展
第一种: *args
def test(*args): #变量名随意,主要是以*开头来表示参数组
print(args)
test(1,2,3,4,5)
test(*[1,2,3,4,5]) #*args = *[1,2,3,4,5] 传入5个参数
test([1,2,3,4,5]) #*args = [1,2,3,4,5] 传入1个参数(列表)
>>>
(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)
([1, 2, 3, 4, 5],) #注意打印的结果里面有一个逗号,表示这是一个tuple
*args接受N个参数,传入的实参会被放入元组中一起传递给形参args
第二种:**kwargs
def test2(**kwargs):print(kwargs)print(kwargs["name"])print(kwargs["age"])
test2(name= 'MR', age = 18)
test2(**{"name":"Mr","age":"18"})
>>>
{'name': 'MR', 'age': 18}
MR
18
{'name': 'Mr', 'age': '18'}
Mr
18
**kwargs 把N个 关键字 参数转换成字典的方式
(7)关键字参数和可变参数组混合使用
def test3(name,**kwargs):print(name)print(kwargs)
test3("mr",xxx="yyy")
>>>
mr
{'xxx': 'yyy'}
7、函数式编程:
函数式编程是一种“编程范式”,也就是如何编写程序的方法论,主要思想是把运算过程尽量写成一系列嵌套的函数调用。函数式编程的一个特点是:允许把函数本身作为参数传入另一个函数中,还允许返回一个函数!
python对于函数式编程提供部分支持,但是由于python允许使用变量,所以python不是纯粹的函数式编程语言。
8、高阶函数:
变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称为高阶函数
defadd(x,y,f):return f(x) +f(y)
res= add(3,-6,abs)print(res)>>>9
五、局部变量与全局变量
1、局部变量:在函数中定义的变量,它的作用域只在该函数中,在函数外是无法调用的。
2、全局变量:在程序的顶层定义的变量就是全局变量,其作用域为整个程序。
注意:
(1)如果要在函数中定义(修改)全局变量,就要在函数中先声明这个变量是一个全局变量,但是不建议这样做。
global 变量名
(2)只有字符串或者整数这种全局变量不能在函数中修改,而像列表、字典等是可以在函数中修改的。
name = ["MR","ZX","五千"]defchange():
name[1] = "CY"
print(name)
change()print(name)
>>>
['MR', 'CY', '五千']
['MR', 'CY', '五千']
#可以看到列表已经彻底改变了
(3)当全局变量与局部变量重名时,在定义局部变量的子程序内,局部变量起作用,在其他地方全局变量起作用。
六、递归
1、概念:
在函数内部,可以调用其他函数,如果一个函数调用它自己,那么这个函数就叫做递归函数。
2、特性:
(1)必须有一个明确的结束条件,否则就会进入死循环。
(2)每一次进入更深一层递归时,问题的规模就会比上一次递归都应该有所减少
(3)递归的效率不高,递归层次过多会导致栈溢出。
3、实现斐波那契数列
(1)迭代法
deffactorial(n):
result=nfor i in range(1,n):
result*=ireturnresult
number= int (input("请输入一个整数:"))
result=factorial(number)print("%d的阶乘是:%d" % (number,result))
(2)递归法
deffactorial(n):if n==1:return 1
else:return n * factorial(n-1)
number= int (input("请输入一个整数:"))
result=factorial(number)print("%d的阶乘是:%d" % (number,result))
七、补充知识点
1、在程序中添加当前的时间
importtime
time_format= "%Y-%m-%d %X"time_current=time.strftime(time_format)print (time_current)