python初识 - day4

一、集合（set）

　　1.集合的定义

　　　　set 是一个无序的元素集合，支持并、交、差及对称差等数学运算， 但由于 set 不记录元素位置，

　　因此不支持索引、分片等类序列的操作。

　　2.集合的创建

　　　　大括号或 set() 函数可以用来创建集合。 注意:想要创建空集合,你必须使用set() 而不是 {} 。

　　　{}用于创建空字典　　　

1 list = [1,3,2,4,2,5,7]
2 list = set(list) #将列表转成集合，集合用{}表示
3 print(list,type(list))#输出结果为：{1, 2, 3, 4, 5, 7} <class ‘set‘>
4 list2 = set([3,22,5,66,8,10])
5 print(list2,type(list2))#输出结果为：{66, 3, 5, 8, 10, 22} <class ‘set‘>

　　3.集合的添加和删除　

 1 list5 = {1,22,3}
 2 list5.add(33) #添加
 3 print(list5)#输出：{1,3,33,22}
 4 list5.update([0,4,44]) #添加多项
 5 print(list5)#输出：{0, 1, 33, 3, 4, 44, 22}
 6
 7 list5.remove(44) #移除一项
 8 print(list5)#输出：{0, 1, 33, 3, 4, 22}
 9 print(list5.pop())#随机删除
10 print(list5.discard(99))#删除，不存在时返回None,输出：None

　　4.集合的长度

1 list = {0, 1, 33, 3, 4, 22}
2 print(len(list))#集合长度，#输出：6

　　5.集合成员的判断

1 list = {0, 1, 33, 3, 4, 22}
2 print(99 in list) #判断其是否为集合成员，输出：False
3 print(99 not in list) #判断其是否非集合成员，输出：True

　　6.集合间的关系

　　　　集合间的关系包括交、差、并集，子集，对称差集，空集。

 1 list = set( [1,3,2,4,2,5,7])
 2 list2 = set([3,22,5,66,8,10])
 3
 4 #交集
 5 print(list.intersection(list2))#intersection意为交集，结果为{3, 5}
 6 print(list & list2)#结果为{3, 5}
 7
 8 #并集
 9 print(list.union(list2))#union意为联合，结果为{1, 2, 3, 4, 5, 66, 7, 8, 10, 22}
10 print(list | list2) #结果同上
11
12 #差集（一方独有的，另一方无的集合）
13 print(list.difference(list2))#输出：{1, 2, 4, 7}
14 print(list - list2)#输出：{1, 2, 4, 7}
15 print(list2.difference(list))#输出：{8, 66, 10, 22}
16
17 #子集  issubset用于判断一个集合的所有元素是否都包含于另一个集合
18 list3 = set([1,3,5])
19 print(list.issubset(list3))#输出：False,即list不是list3的子集
20 print(list3.issubset(list))#输出：True,即list3是list的子集
21 print(list<= list2)#判断list是否为list2的子集
22
23 #对称差集(等同于两差集之和)
24 print(list.symmetric_difference(list2))#输出：{1, 66, 2, 7, 22, 4, 8, 10}
25 print(list ^ list2) #结果同上
26
27 #空集，若两个列表无交集，返回True,有交集返回False
28 list4 = set([0,11,33])
29 print(list3.isdisjoint(list4))#输出：True,即两个列表无交集
30 print(list.isdisjoint(list2))#输出：False,两个列表有交集

二、文件常用操作

　　1.　文件的创建删除和重命名

1 import os
2 os.mknod("test.txt")             #创建空文件
3 fp = open("test.txt",w)          #直接打开一个文件，如果文件不存在则创建文件
4 os.remove()                         #  函数用来删除一个文件
5 os.rename（old， new）         #重命名
6 os.path.getsize（filename）        #获取文件大小

　　2.目录的创建删除和重命名

1 import os,shutil
2 os.mkdir("file")                   #创建目录
3 os.makedirs（r“c：\python\test”）#创建多级目录
4 os.rename("oldname","newname")   #重命名文件（目录）文件或目录都是使用这条命令
5 os.rmdir("dir")                             #只能删除空目录
6 shutil.rmtree("dir")                        #空目录、有内容的目录都可以删
7 os.chdir("path")                            #转换目录，换路径
8 shutil.copytree("olddir","newdir")  #olddir和newdir都只能是目录，且newdir必须不存在
9 shutil.move("oldpos","newpos")       #移动文件（目录）

　　3.文件的读写操作（较繁多，以举例子的方式说明）

 1 f1 = open(‘faded‘,‘r‘,encoding=‘utf-8‘) #文件句柄（文件的内存对象，包括文件的起始位置，文件名，字符集等），faded为已创建的文件
 2 print(f1.read()) #只读
 3 for i in range(10): #打印前10行
 4     print(f1.readline().strip()) #每次打印一行，去除空格和换行
 5
 6 f2= open(‘faded2‘,‘w‘,encoding=‘utf-8‘) #只写
 7 f2.write(‘You were the shadow to my light\n你是我生命之光中的一道暗影\nDid you feel us\n你能理解我们吗‘)
 8
 9 f2= open(‘faded2‘,‘a‘,encoding=‘utf-8‘)#‘a‘即 append,追加
10 f2.write(‘\nAnother star\n另一颗行星\nYou fade away\n你逐渐消失‘)
11 #f1.close() #关闭
12 f2.close()
13
14 print(f1.tell())#表示开头位置，结果为：0
15 print(f1.readline()) #打印一行
16 print(f1.tell()) #打印此时光标的位置，结果为：31
17 print(f1.readline()) #打印一行,结果为：You were the shadow to my light
18 print(f1.tell())#打印此时光标的位置，结果为：64
19 print(f1.seek(31))#打印光标返回的位置，结果为：31
20 print(f1.readline())#结果为：You were the shadow to my light
21
22 print(f1.encoding)#打印编码格式，结果为：utf-8
23
24 #print(f2.flush())#实时刷新，无此方法时缓存满了一次刷新到硬盘中
25
26
27 # f2= open(‘faded2‘,‘a‘,encoding=‘utf-8‘)
28 # print(f2.truncate(20))#truncate意为把...截短，此处指从头开始截取20个字符
29 ‘‘‘
30 f2= open(‘faded2‘,‘r+‘,encoding=‘utf-8‘)#文件句柄，读写(可读可写)
31 print(f2.readline())
32 print(f2.readline())
33 f2.write(‘\nqwertyuiop\n‘)
34 f2.write(‘asdfghjkl‘)
35 print(f2.readline())
36 ‘‘‘
37 ‘‘‘
38 f3= open(‘faded3‘,‘w+‘,encoding=‘utf-8‘)#文件句柄，写读
39 f3.write(‘Another dream\n‘)
40 f3.write(‘另外的梦想\n‘)
41 print(f3.tell())
42 print(f3.seek(0))
43 print(f3.readline())
44 ‘‘‘
45 f2= open(‘faded2‘,‘a+‘,encoding=‘utf-8‘)#文件句柄，追加写读
46 f2.write(‘\nWhere are you now\n‘)
47 print(f2.tell())
48 print(f2.seek(0))
49 print(f2.readline())
50 f2.write(‘Another dream\n‘)
51 print(f2.tell())
52 ‘‘‘
53
54 f2= open(‘faded2‘,‘rb‘)#文件句柄，读，二进制文件（文件传输）
55 print(f2.readline()) #输出：b‘Another dream\r\n‘
56 print(f2.readline()) #输出：b‘\xe5\x8f\xa6\xe5\xa4\x96\xe7\x9a\x84\xe6\xa2\xa6\xe6\x83\xb3\r\n‘
57 ‘‘‘
58 ‘‘‘
59 f2= open(‘faded2‘,‘wb‘)#文件句柄，写，二进制文件（文件传输）
60 f2.write(‘Hello python\n‘.encode())#默认utf -8
61 f2.write(‘Hello python\n‘.encode())#默认utf -8
62 f2.close()
63 ‘‘‘
64    

　　4.关于flush(刷新)的一个例子

1 import  sys,time
2 for i in range(60):
3     sys.stdout.write(‘*‘)
4     sys.stdout.flush()
5     time.sleep(0.2)

三、字符编码格式的转换　　

 1 #-*- coding:utf-8 -*- 文件编码
 2 str = ‘我们不忘初心‘
 3 print(str,type(str))#输出：我们不忘初心 <class ‘str‘>
 4 str_utf_gbk = str.encode(‘gbk‘)#encode表编码，unicode转utf-8或gbk要用encode,而utf-8和gbk转unicode要用decode
 5 print(str_utf_gbk,type(str_utf_gbk))#输出：b‘\xce\xd2\xc3\xc7\xb2\xbb\xcd\xfc\xb3\xf5\xd0\xc4‘ <class ‘bytes‘>
 6 print(str_utf_gbk .decode(‘gbk‘))#输出：我们不忘初心(byte->string，decode意为解码)
 7
 8 str2 = ‘我们直面未来‘
 9 #utf-8无需向Unicode转码，直接用encode+最终编码格式即可转为gbk或utf-8
10 print(str2.encode(‘gbk‘),type(str2.encode(‘gbk‘)))#输出：b‘\xce\xd2\xc3\xc7\xd6\xb1\xc3\xe6\xce\xb4\xc0\xb4‘ <class ‘bytes‘>
11 print(str.encode(‘utf-8‘),type(str.encode(‘utf-8‘)))#输出：b‘\xe6\x88\x91\xe4\xbb\xac\xe4\xb8\x8d\xe5\xbf\x98\xe5\x88\x9d\xe5\xbf\x83‘ <class ‘bytes‘>
12
13 utf_gbk = str2.encode(‘gbk‘)#此处无decode方法,用encode(‘gbk‘)即可转为gbk编码
14 print(utf_gbk)#输出：b‘\xce\xd2\xc3\xc7\xd6\xb1\xc3\xe6\xce\xb4\xc0\xb4‘
15
16 byte_string = utf_gbk.decode(‘gbk‘)
17 print(byte_string ,type(byte_string))#输出:我们直面未来 <class ‘str‘>
18
19 gbk_utf = utf_gbk.decode(‘gbk‘).encode(‘utf-8‘)
20 print(gbk_utf,type(gbk_utf)) #输出:b‘\xe6\x88\x91\xe4\xbb\xac\xe7\x9b\xb4\xe9\x9d\xa2\xe6\x9c\xaa\xe6\x9d\xa5‘

四、函数的简单入门

　　1.函数的介绍　　

　　　　函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

　　　　函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

　　2.函数的定义

　　　　你可以定义一个由自己想要功能的函数，以下是简单的规则：

　　　　　　<1>函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。

　　　　　　<2>任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

　　　　　　<3>函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。（虽非必需，但强烈建议写上少量说明文字）

　　　　　　<4>函数内容以冒号起始，并且缩进。

　　　　　　<5>return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

　　　　　　<6>用例子说明:

 1 import time
 2 #f1 = open(‘notebook‘,‘r‘,encoding = ‘utf-8‘)
 3 #函数的好处：代码重用；保持一致性；可扩展性
 4 def add():
 5     ‘‘‘文本追加内容并添加日志时间‘‘‘
 6     time_formate = ‘%y-%m-%d %x‘ #时间的格式
 7     time_current = time.strftime(time_formate)#引用上述的时间格式
 8     with open(‘notebook.txt‘,‘a+‘,encoding=‘utf-8‘) as f:
 9         f.write(‘Time is %s go on\n‘%time_current)
10
11 def test1():
12     ‘‘‘日志一‘‘‘
13     print(‘This is test1‘)
14     add()
15
16 def test2():
17     ‘‘‘日志二‘‘‘
18     print(‘This is test2‘)
19     add()
20
21 def test3():
22     ‘‘‘日志三‘‘‘
23     print(‘This is test3‘)
24     add()
25
26 test1()
27 test2()
28 test3()

　　3.函数参数及调用　　　

 1 ‘‘‘
 2 #return 返回值
 3 def test1():
 4     print(‘test 1‘)
 5
 6 def test2():
 7     print(‘test 2‘)
 8     return 0
 9
10 def test3():
11     print(‘test 3‘)
12     return 1,‘hello‘,[‘hello‘,‘world‘],{‘China‘:‘big‘}
13
14 t1 = test1()
15 t2 = test2()
16 t3 = test3()
17 print(t1,type(t1)) #运行结果：None<class ‘NoneType‘> 返回值为None
18 print(t2,type(t2)) #运行结果：0 <class ‘int‘> 返回值为 0
19 print(t3,type(t3)) #运行结果：(1, ‘hello‘, [‘hello‘, ‘world‘], {‘China‘: ‘big‘}) <class ‘tuple‘> 返回值为 一个元组
20 ‘‘‘
21 #关键字调用与标准调用
22 def test(x,y,z):
23     print(x)
24     print(y)
25     print(z)
26
27 #test(y=1,x=1)#关键字调用，与形参（位置参数）顺序无关
28 #test(2,1)#标准调用与形参一一对应
29 #test(x=3,2,z=4,)  #报错，关键字调用不能在标准调用之前
30 test(2,z=4,y=3) #两者一起使用,输出结果：2 3 4

　　4.函数非固定传参

 1 #默认参数
 2 def test4(x,y=1):  #y=1为默认参数，且必须在形参之后，即（x=1,y）报错
 3     print(x,y)
 4 #test4(2)#输出结果：2 1
 5 test4(3,4)#输出结果：3 4
 6 #默认参数的特点：调用参数时，默认参数非必须传递
 7 #用途：默认安装值；
 8
 9 #参数组（* 参数组名字）,接受N个位置参数,转换成元组的形式
10 def test1(x,*args):  #形参数目不固定时，用*args接受
11     print(x)
12     print(args)
13
14 test1(0,3,5,6,6) #输出：0   (3,5,6,6)
15 test1(*[1,2,4,5,5])# 传递列表,输出：1  (2,4,5,5)
16
17 #字典的传递（**kwargs），接受N个关键字参数，转换成字典的形式
18 def test2(**kwargs):
19     print(kwargs)
20     print(kwargs[‘name‘])
21     print(kwargs[‘sex‘])
22
23 test2(name=‘hyt‘,age=18,sex=‘girl‘) #输出：{‘age‘: 18, ‘sex‘: ‘girl‘, ‘name‘: ‘hyt‘}
24 test2(**{‘name‘:‘sc‘,‘age‘:‘20‘,‘sex‘:‘boy‘})#输出同上
25
26 #默认函数，参数组，字典同时传递
27 def test3(name,age=19,*args,**kwargs):
28     print(name) #输出一：hyt    输出二：sc
29     print(age) #输出一：18      输出二：20
30     print(args) #输出一:((‘sex‘, ‘girl‘), {‘game‘: ‘yys‘})  输出二：()
31     print(kwargs)#输出一：{}    输出二：{‘game‘: ‘lol‘, ‘sex‘: ‘boy‘}
32
33 test3(‘hyt‘,18,(‘sex‘,‘girl‘),{‘game‘:‘yys‘})#测试一,关键字参数必须在位置参数之后
34 test3(‘sc‘,20,sex=‘boy‘,game=‘lol‘) #测试二，关键字参数必须在位置参数之后

　　5.函数局部变量和作用域　　　

　　　　<1>.在程序一开始定义的变量称为全局变量；在子程序中定义的变量称为局部变量。

　　　　<2>全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

      <3>当全局变量与局部变量重名时，在定义局部变量的子程序内，局部变量起作用，在其它地方全局变量起作用。　　　<4>下面用例子说明：

 1 school = ‘BeiDaQingNiao‘ #全局变量
 2 age = 18 #全局变量
 3 def change_age(age):
 4     #global school  #声明全局变量，已有此全局变量时则修改，没有则创建，但不建议使用！
 5     print(‘before_age:‘,age) #结果：before_age: 18
 6     school = ‘oldBoy‘
 7     age = 20  #局部变量，这个函数就是它的作用域
 8     print(‘after_age:‘,age) #结果：after_age: 20
 9     print(‘school_jubu:‘,school)
10
11 change_age(age)
12 print(age) #结果：18
13 print(‘school_quanju:‘,school)
14
15 #一般情况下，不能在修改函数里修改局部变量为全局变量，如数字，字符，字符串，但列表，字典，集合，类可以改
16 mes = [‘sc‘,‘boy‘,20]
17 def change_mes(mes):
18     mes[0] = ‘hyt‘
19     mes[1] = ‘girl‘
20     mes[2] = ‘18‘
21     print(‘change inside:‘,mes)  #输出结果：change inside: [‘hyt‘, ‘girl‘, ‘18‘]
22 change_mes(mes)
23 print(‘ouside:‘,mes)  #输出结果：ouside: [‘hyt‘, ‘girl‘, ‘18‘]

　　6.函数递归和高阶函数

　　　　<1>递归函数：在函数内部，可以调用其它函数，如果一个函数在内部调用自己本身，则称为递归函数。

　　　　<2>递归的三个主要特性：

　　　　 　--->1.必须有一个明确的结束条件

　　　　　 --->2.每次递归进入更深一层时，问题规模都应比上次递归有所减少

         --->3.递归的效率不高，递归层次过多会导致溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，　　　　　　 每当进如一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无线的，所以，　　　　　　递归调用的次数过多，会导致栈溢出）

　　　　 <3>实例如下：　　　　　

1 def recur(n):
2     print(‘list:‘,n)
3     if int(n/2) > 0:
4         return recur(int(n/2)) #递归调用
5     print(‘the_last:‘,n) #输出：1
6 recur(12)

　　　　<4>高阶函数：变量可以指向函数，函数的参数能接受变量，那么一个函数就可以接收另一个函数作为参数，

　　　　　　　　这种函数就是高阶函数。　　　

1 def add(x,y,f):
2     return f(x)+f(y)
3 res = add(-4,-8,abs) #abs为参数的内置函数
4 print(‘the result:‘,res)#输出结果：the result: 12

　　以上有部分内容摘自菜鸟教程，详情请戳http://www.runoob.com/python/python-functions.html