python初识 - day4

一、集合（set）

　　1.集合的定义

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

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

　　2.集合的创建

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

　　　{}用于创建空字典　　　

　　　　

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

　　3.集合的添加和删除　

　　　　

 list5 = {1,22,3}
 list5.add(33) #添加
 print(list5)#输出：{1,3,33,22}
 list5.update([0,4,44]) #添加多项
 print(list5)#输出：{0, 1, 33, 3, 4, 44, 22}

 list5.remove(44) #移除一项
 print(list5)#输出：{0, 1, 33, 3, 4, 22}
 print(list5.pop())#随机删除
 print(list5.discard(99))#删除，不存在时返回None,输出：None

　　4.集合的长度

　　　　

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

　　5.集合成员的判断

　　　　

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

　　6.集合间的关系

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

　　　　

 list = set( [1,3,2,4,2,5,7])
 list2 = set([3,22,5,66,8,10])

 #交集
 print(list.intersection(list2))#intersection意为交集，结果为{3, 5}
 print(list & list2)#结果为{3, 5}

 #并集
 print(list.union(list2))#union意为联合，结果为{1, 2, 3, 4, 5, 66, 7, 8, 10, 22}
 print(list | list2) #结果同上

 #差集（一方独有的，另一方无的集合）
 print(list.difference(list2))#输出：{1, 2, 4, 7}
 print(list - list2)#输出：{1, 2, 4, 7}
 print(list2.difference(list))#输出：{8, 66, 10, 22}

 #子集  issubset用于判断一个集合的所有元素是否都包含于另一个集合
 list3 = set([1,3,5])
 print(list.issubset(list3))#输出：False,即list不是list3的子集
 print(list3.issubset(list))#输出：True,即list3是list的子集
 print(list<= list2)#判断list是否为list2的子集

 #对称差集(等同于两差集之和)
 print(list.symmetric_difference(list2))#输出：{1, 66, 2, 7, 22, 4, 8, 10}
 print(list ^ list2) #结果同上

 #空集，若两个列表无交集，返回True,有交集返回False
 list4 = set([0,11,33])
 print(list3.isdisjoint(list4))#输出：True,即两个列表无交集
 print(list.isdisjoint(list2))#输出：False,两个列表有交集

二、文件常用操作

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

　　　　

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

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

　　　　

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

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

　　　　

 f1 = open('faded','r',encoding='utf-8') #文件句柄（文件的内存对象，包括文件的起始位置，文件名，字符集等），faded为已创建的文件
 print(f1.read()) #只读
 for i in range(10): #打印前10行
     print(f1.readline().strip()) #每次打印一行，去除空格和换行 

 f2= open('faded2','w',encoding='utf-8') #只写
 f2.write('You were the shadow to my light\n你是我生命之光中的一道暗影\nDid you feel us\n你能理解我们吗')

 f2= open('faded2','a',encoding='utf-8')#'a'即 append,追加
 f2.write('\nAnother star\n另一颗行星\nYou fade away\n你逐渐消失')
 #f1.close() #关闭
 f2.close()

 print(f1.tell())#表示开头位置，结果为：0
 print(f1.readline()) #打印一行
 print(f1.tell()) #打印此时光标的位置，结果为：31
 print(f1.readline()) #打印一行,结果为：You were the shadow to my light
 print(f1.tell())#打印此时光标的位置，结果为：64
 print(f1.seek(31))#打印光标返回的位置，结果为：31
 print(f1.readline())#结果为：You were the shadow to my light

 print(f1.encoding)#打印编码格式，结果为：utf-8

 #print(f2.flush())#实时刷新，无此方法时缓存满了一次刷新到硬盘中

 # f2= open('faded2','a',encoding='utf-8')
 # print(f2.truncate(20))#truncate意为把...截短，此处指从头开始截取20个字符
 '''
 f2= open('faded2','r+',encoding='utf-8')#文件句柄，读写(可读可写)
 print(f2.readline())
 print(f2.readline())
 f2.write('\nqwertyuiop\n')
 f2.write('asdfghjkl')
 print(f2.readline())
 '''
 '''
 f3= open('faded3','w+',encoding='utf-8')#文件句柄，写读
 f3.write('Another dream\n')
 f3.write('另外的梦想\n')
 print(f3.tell())
 print(f3.seek(0))
 print(f3.readline())
 '''
 f2= open('faded2','a+',encoding='utf-8')#文件句柄，追加写读
 f2.write('\nWhere are you now\n')
 print(f2.tell())
 print(f2.seek(0))
 print(f2.readline())
 f2.write('Another dream\n')
 print(f2.tell())
 '''

 f2= open('faded2','rb')#文件句柄，读，二进制文件（文件传输）
 print(f2.readline()) #输出：b'Another dream\r\n'
 print(f2.readline()) #输出：b'\xe5\x8f\xa6\xe5\xa4\x96\xe7\x9a\x84\xe6\xa2\xa6\xe6\x83\xb3\r\n'
 '''
 '''
 f2= open('faded2','wb')#文件句柄，写，二进制文件（文件传输）
 f2.write('Hello python\n'.encode())#默认utf -8
 f2.write('Hello python\n'.encode())#默认utf -8
 f2.close()
 '''
    

　　4.关于文件打开模式的几点参照

　　　　

 w：以写方式打开，
 a：以追加模式打开 (从 EOF 开始, 必要时创建新文件)
 r+：以读写模式打开
 w+：以读写模式打开 (参见 w )
 a+：以读写模式打开 (参见 a )
 rb：以二进制读模式打开
 wb：以二进制写模式打开 (参见 w )
 ab：以二进制追加模式打开 (参见 a )
 rb+：以二进制读写模式打开 (参见 r+ )
 wb+：以二进制读写模式打开 (参见 w+ )
 ab+：以二进制读写模式打开 (参见 a+ )

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

　　　　

 import  sys,time
 for i in range(60):
     sys.stdout.write('*')
     sys.stdout.flush()
     time.sleep(0.2)

三、字符编码格式的转换　　

　　　　

 #-*- coding:utf-8 -*- 文件编码
 str = '我们不忘初心'
 print(str,type(str))#输出：我们不忘初心 <class 'str'>
 str_utf_gbk = str.encode('gbk')#encode表编码，unicode转utf-8或gbk要用encode,而utf-8和gbk转unicode要用decode
 print(str_utf_gbk,type(str_utf_gbk))#输出：b'\xce\xd2\xc3\xc7\xb2\xbb\xcd\xfc\xb3\xf5\xd0\xc4' <class 'bytes'>
 print(str_utf_gbk .decode('gbk'))#输出：我们不忘初心(byte->string，decode意为解码)

 str2 = '我们直面未来'
 #utf-8无需向Unicode转码，直接用encode+最终编码格式即可转为gbk或utf-8
 print(str2.encode('gbk'),type(str2.encode('gbk')))#输出：b'\xce\xd2\xc3\xc7\xd6\xb1\xc3\xe6\xce\xb4\xc0\xb4' <class 'bytes'>
 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'>

 utf_gbk = str2.encode('gbk')#此处无decode方法,用encode('gbk')即可转为gbk编码
 print(utf_gbk)#输出：b'\xce\xd2\xc3\xc7\xd6\xb1\xc3\xe6\xce\xb4\xc0\xb4'

 byte_string = utf_gbk.decode('gbk')
 print(byte_string ,type(byte_string))#输出:我们直面未来 <class 'str'>

 gbk_utf = utf_gbk.decode('gbk').encode('utf-8')
 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>用例子说明:

　　　　　　　　

 import time
 #f1 = open('notebook','r',encoding = 'utf-8')
 #函数的好处：代码重用；保持一致性；可扩展性
 def add():
     '''文本追加内容并添加日志时间'''
     time_formate = '%y-%m-%d %x' #时间的格式
     time_current = time.strftime(time_formate)#引用上述的时间格式
     with open('notebook.txt','a+',encoding='utf-8') as f:
         f.write('Time is %s go on\n'%time_current)

 def test1():
     '''日志一'''
     print('This is test1')
     add()

 def test2():
     '''日志二'''
     print('This is test2')
     add()

 def test3():
     '''日志三'''
     print('This is test3')
     add()

 test1()
 test2()
 test3()

　　3.函数参数及调用　　　

　　　　

 '''
 #return 返回值
 def test1():
     print('test 1')

 def test2():
     print('test 2')
     return 0

 def test3():
     print('test 3')
     return 1,'hello',['hello','world'],{'China':'big'}

 t1 = test1()
 t2 = test2()
 t3 = test3()
 print(t1,type(t1)) #运行结果：None<class 'NoneType'> 返回值为None
 print(t2,type(t2)) #运行结果：0 <class 'int'> 返回值为 0
 print(t3,type(t3)) #运行结果：(1, 'hello', ['hello', 'world'], {'China': 'big'}) <class 'tuple'> 返回值为 一个元组
 '''
 #关键字调用与标准调用
 def test(x,y,z):
     print(x)
     print(y)
     print(z)

 #test(y=1,x=1)#关键字调用，与形参（位置参数）顺序无关
 #test(2,1)#标准调用与形参一一对应
 #test(x=3,2,z=4,)  #报错，关键字调用不能在标准调用之前
 test(2,z=4,y=3) #两者一起使用,输出结果：2 3 4

　　4.函数非固定传参

　　　　

 #默认参数
 def test4(x,y=1):  #y=1为默认参数，且必须在形参之后，即（x=1,y）报错
     print(x,y)
 #test4(2)#输出结果：2 1
 test4(3,4)#输出结果：3 4
 #默认参数的特点：调用参数时，默认参数非必须传递
 #用途：默认安装值；

 #参数组（* 参数组名字）,接受N个位置参数,转换成元组的形式
 def test1(x,*args):  #形参数目不固定时，用*args接受
     print(x)
     print(args)

 test1(0,3,5,6,6) #输出：0   (3,5,6,6)
 test1(*[1,2,4,5,5])# 传递列表,输出：1  (2,4,5,5)

 #字典的传递（**kwargs），接受N个关键字参数，转换成字典的形式
 def test2(**kwargs):
     print(kwargs)
     print(kwargs['name'])
     print(kwargs['sex'])

 test2(name='hyt',age=18,sex='girl') #输出：{'age': 18, 'sex': 'girl', 'name': 'hyt'}
 test2(**{'name':'sc','age':'','sex':'boy'})#输出同上

 #默认函数，参数组，字典同时传递
 def test3(name,age=19,*args,**kwargs):
     print(name) #输出一：hyt    输出二：sc
     print(age) #输出一：18      输出二：20
     print(args) #输出一:(('sex', 'girl'), {'game': 'yys'})  输出二：()
     print(kwargs)#输出一：{}    输出二：{'game': 'lol', 'sex': 'boy'}

 test3('hyt',18,('sex','girl'),{'game':'yys'})#测试一,关键字参数必须在位置参数之后
 test3('sc',20,sex='boy',game='lol') #测试二，关键字参数必须在位置参数之后

　　

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

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

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

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

　　　　　　

 school = 'BeiDaQingNiao' #全局变量
 age = 18 #全局变量
 def change_age(age):
     #global school  #声明全局变量，已有此全局变量时则修改，没有则创建，但不建议使用！
     print('before_age:',age) #结果：before_age: 18
     school = 'oldBoy'
     age = 20  #局部变量，这个函数就是它的作用域
     print('after_age:',age) #结果：after_age: 20
     print('school_jubu:',school)

 change_age(age)
 print(age) #结果：18
 print('school_quanju:',school)

 #一般情况下，不能在修改函数里修改局部变量为全局变量，如数字，字符，字符串，但列表，字典，集合，类可以改
 mes = ['sc','boy',20]
 def change_mes(mes):
     mes[0] = 'hyt'
     mes[1] = 'girl'
     mes[2] = ''
     print('change inside:',mes)  #输出结果：change inside: ['hyt', 'girl', '18']
 change_mes(mes)
 print('ouside:',mes)  #输出结果：ouside: ['hyt', 'girl', '18']

　　6.函数递归和高阶函数

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

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

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

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

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

　　　　 <3>实例如下：　　　　　

　　　　　　

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

　　　　

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

　　　　　　　　这种函数就是高阶函数。　　　

　　　　　　

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

　

　　以上有部分内容摘自菜鸟教程和脚本之家，详情请戳

　　　　菜鸟教程：http://www.runoob.com/python/python-functions.html

　　　　脚本之家：http://www.jb51.net/article/48001.htm