集合与集合操作:
集合也是无序的，主要作用有去重和关系测试。
集合的表示方法为set_2={2,7,9,13,8}
列表转化为集合：list_1=[2,3,4,5,13,4,5]，set_1=set(list_1)#列表可以存在重复元素，集合自动去重。
求交集：set_3=set_1.intersection（set_2）
或者 set_3=set_1&set_2
求并集：set_4=set_1.union（set_2）
或者set_4=set_1|set_2
求差集：set_5=set_1.difference(set_2) #这与set_6=set_2.difference(set_1)不同
或者set_5=set_1-set_2 #set_6=set_2-set_1
求对称差集：set_7=set_1.symmetric_differnce(set_2)#对称差集，相当于set_1和set_2的并集减他们的交集
或者set_7=set_1^set_2
判断是否为子集：set_3.issubset(set_1) #如果set_3是set_1的子集，得到True，反之False
或者set_3<=set_1
判断是否为母集：set_4.issuperset(set_1) #如果set_4是set_1的母集，得到True，反之False
或者set_4>=set_1
判断交集是否为空集：set_5.isdisjoint(set_6) #判断set_1和set_6交集是否为空集，是的话为True
集合添加：添加一个元素:set_1.add(10)
添加多个元素：set_1.update（[7,8,9]）
删除:set_1. remove(8) #删除括号中的元素，不存在会报错
set_1.discard(99) #删除括号中的元素，不存在则不进行操作
集合长度：len（set_1）#集合的长度，即集合中元素的个数
判断元素在不在集合中：0 in set_1 #在的话得到True，不在为False。与列表、字典、文件类似。
判断元素在不在集合中：0 not in set_1 #在的话得到False，不在为True。与列表、字典、文件类似。
print（set_1.pop()）#任意删除一个元素，并返回这个元素
文件操作：
文件操作步骤：打开---》操作----》关闭
#open('template')打开文件
#open('template').read()打开文件并阅读
f=open('template','a',encoding='utf-8')，f为给打开文件内存命名，方便操作。#括号内为（文件名，读写权限：【默认为只读’r'；‘w'为只写、创建文件、原先文件被 覆盖掉；'a'append缩写、追加、可续写、原先文件不被覆盖、不能读，只写在最后；‘r+'为读和追加模式；’w+‘为写和追加模式，创建新文件，可读，内容只能写 在最后面; 'a+'为追加和读模式，f.tell（）一直在最后位置】，指定编码方式）。文件句柄，包含文件名、字符集、硬盘上起始位置.
#f=open('template','rb')#二进制模式打开，只读
{data=f.read()#读完后，光标在最底下
data2=f.read()#从最底下开始读，data2读不到数据}
追加模式下，写：
f.write('But I will practice English since today.\n')#需要换行自行加\n
f.write('Are you kiding?\n')
print(f.readable())#判断文件是否可读
print(f.writable())#判断文件是否可写
f.close() #文件保存
f.readline()#只读文件句柄所在的那一行
f.readlines()#将文本转换成列表，换行符会显示
'''for i in range(5):
print(f.readline())#读前5行'''
第五行不打印，打印’-----我是分割线-------‘method1，其他行照打：
count=0 for line in f:#内存内只存一行，节省空间 count += 1 if count==5: print('我是分割线'.center(50,'-')) continue print(line.strip())#推荐使用 f.close()
print（f.tell()）#打印文件句柄（光标）的位置,按字符个数计算
f.seek（0）#将文件jubing（光标）置回0的位置
f.read(10)#读10个字符，尽量别用
encoding：
print(f.encoding)#打印编码方式
print(f.name)#打印文件名
print(f.isatty())#判断是否为终端设备，比如打印机等
print(f.readable())#判断是否可读
print(f.seekable())#判断句柄是否可置回
print(f.writable())#判断文件是否可写
f.flush()#强制刷新内存，将内存写入硬盘
print(f.closed)#判断文件是否关闭
f.truncate()#括号内不写，默认全删
f.truncate(10)#从头开始截断到10个字符
文件修改：
需要打开两个文件，一个读，一个写，最后将写好的文件将原文件覆盖掉
例如：
Old_f=open('template','r',encoding='utf-8') new_f=open('template3','w',encoding='utf-8') for line in Old_f: if 'woshi' in line: line=line.replace('woshi','哈哈')#替换 new_f.write(line) new_f.flush() Old_f.close() new_f.close()
with用法：
with open('template3','r',encoding='utf-8') as f,\ open('template','r',encoding='utf-8') as new_f:#python开发规范一行不超过80个字符 #不需要关闭，缩进结束自动关闭 pass
字符编码：
所有编码需要通过Unicode进行转换，转成unicode叫decode，unnicode转成其他叫encode。
import sys
print(sys.getdefaultencoding())#打印系统默认编码
s='啦啦队'#默认为unicode编码 print(s.encode('gbk'))#转成了gbk编码，变成了bytes类型 print(s.encode('utf-8'))#转成了utf-8编码，变成了bytes类型 print(s.encode('gb2312').decode('gb2312').encode('utf-8'))#转成了utf-8编码，变成了bytes类型
函数：
面向对象：特征：类---》定义class
面向过程：特征：过程---》定义def，过程不需要return
函数式编程：特征：函数----》定义def，函数需要return
#函数例子 def function1(x,y):#括号内定义变量 '此处添加描述' y=x*y+1 print(x,y)#输出x，y的值 return y#返回值并结束函数 print('contune or not')#这条语句不会运行 def function2(x,y):#括号内定义变量 '此处添加描述' y=x+y+1 print(x,y)#输出x，y的值 return y,1,'hello',['a','b'],{'name':'jack'}#返回值并结束函数,这些都可以返回，存到一个元组当中 #函数没有返回值时，返回None；返回一个值时，返回objec；返回多个值时，返回tuple #过程例子，相当于没有返回值的函数 def process(x,y): '此处添加描述' y=y-x print(x,y) #调用函数和过程 n=function1(2,3)#得出返回值，赋值给n，需要和x，y位置对应，位置参数调用 m=process(n,10)#得到None，没有返回值 z=function2(x=2,y=3)#这样不需要位置对应，关键字参数调用 i=function1(2,y=3)#混用时，位置参数必须写在关键字参数前面，且不能多个实参对应一个形参 print('return of function1 is %d'%n) print('return of function1 is %d'%i) print('return of process is %s'%m) print(z) 过程（函数）作用：1、代码重复利用； 2、可扩展和保持一致性 def function3(x,y=4):#括号内定义变量,此时y为默认参数，不用实参给y赋值时，y=2，赋值时，y=实参 '此处添加描述' y=x*y+1 print(x,y)#输出x，y的值 return y#返回值并结束函数 print('contune or not')#这条语句不会运行 print(function3(1,2)) print(function3(1)) #实参数目不固定，列表参数组 def function4(*args): '形参为元组的示例' x=args[0]-args[1] print(args) return x print(function4(7,2,4))#此时输入实参不固定 print(function4(*[2,1,3,45,5]))#相当于*_tuple=*[2,1,3,45,5],生成元组 #参数组和形参交替使用，参数组必须放后面 def function5(x,*args): print(x) print(args) return 0 print(function5(1,234,5,67,8)) #参数组为字典**kwargs把关键参数，转化为字典的方式key-value，生成字典 def function6(**kwargs): print(kwargs) print(function6(name='Jack',age=23,stature=1.7))#关键字形参转化为key，实参转化为value,参数组只能放最后 print(function6(**{'name':'Jack','age':23,'stature':1.7}))#效果和上一行一样 def function7(name,age=23,*args,**kwargs):#参数与参数组混用，参数组一定放最后面 print(name) print(age) print(args) print(kwargs) function1(1,2)#函数嵌套 return 3 print(function7('wulihui',25,22,'holle','good',habby='play games'))#从上到下执行，调用的函数必须先定义
局部变量和全局变量：
age=23 def change_name(name):#函数内部的变量叫做局部变量，作用域为仅在函数内，local variable print('old name:',name)#print('old name:',name,age)此处可以打印age，可以的到全局变量age的值 name=input('please input newname:')#修改局部变量name print('new name:',name) name=input('name which need to change:')#输入全局变量name change_name(name)#将全球变量name赋值给局部变量name print(name) #这个name为全局变量，找到的是第七行的name，整个程序中都生效的变量，global variable，文件第一级定义 #如何在函数内部修改全局变量 # age=23 # def change_name():#函数内部的变量叫做局部变量，作用域为仅在函数内，local variable # global age,name#声明age,name为全球变量 # age=25 # print('old name:',name) # name=input('please input newname:')#修改全局变量name # print('new name:',name) # name=input('name which need to change:')#输入全局变量name # change_name()#将全球变量name赋值给局部变量name # print(name) #这个name为全局变量，找到的是第七行的name，整个程序中都生效的变量，global variable，文件第一级定义 # print(age) #尽量别在函数里改全局变量，因为函数可能会被引用很多次，全局变量都不知道是哪里改掉的 #字典、列表、集合、类函数里可以改全局变量里的值 name_list=['nvbu','diaocan','luna'] def change_name2(): print(name_list) name_list[0]='ali' print(name_list) change_name2() print(name_list)#打印出['ali', 'diaocan', 'luna'] #当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其他地方全局变量起作用
递归：如果一个函数在内部调用自身，那这个函数就是递归函数
递归特性：
1、具有明确的结束条件。
2、每次进入更深一层递归时，问题规模相比上一次递归有所减少。
3、递归效率不高，递归层数过多会导致栈溢出。
例子：
def half(n): "devide by 2,then round number" print(n) if n>0: n=int(n/3)#int,取整的作用，不四舍五入 return half(n) else: return 0 half(8)
函数式编程：指过函数嵌套进行编程，简洁但是比较难看懂
高阶函数: 将一个函数作为变量或参数，内置到另一个函数当中
例如：
def add(a,b,f): c=f(a)+f(b) return c print(add(2,-3,abs))#f=abs（）
