集合
# author:"Jason lincoln"
list_1={1,4,5,7,3,6,7,9}
list_1=set(list_1) #把集合变成列表 去重复
list_2=set([2,6,0,66,22,8,4])
print(list_1,type(list_1))
print(list_2)
print(list_1.intersection(list_2)) #交集
print(list_1.union(list_2)) #并集
print(list_1.difference(list_2)) #差集
#子集
list_3=set([1,3,7])
print(list_3.issubset(list_1)) #list_3包含于list_1
print(list_1.issuperset(list_3)) #list_1包含list_1
#对称差集
print(list_1.symmetric_difference(list_2)) #并集然后去掉相同部分
list_4=set([5,7,8])
print(list_3.isdisjoint(list_4)) #有交集返回False没交集返回True
#交集
print(list_1 & list_2)
#并集
print(list_1 | list_2)
#差集
print(list_1 - list_2) # in list_1 but not in list_2
#对称差集
print(list_1 ^ list_2)
集合的基本操作
list_1.add(999) #添加一项 list_1.update([888,777]) #添加多项 print(list_1) print(list_1.remove(777)) #删除 list_1.discard(888) #删除集合里面没有的元素不会报错 print(list_1) print(len(list_1)) print(list_1.pop()) #随机删除然后返回删除的那个数
文件操作
# author:"Jason lincoln"
# author:"Jason lincoln"
#data=open("yesterday",encoding="utf-8").read()
#f=open("yesterday",'r',encoding="utf-8") #文件句柄,只读
#f=open("yesterday2",'w',encoding="utf-8") #建一个新文件
f=open("yesterday",'a',encoding="utf-8") # a==append 追加
#f.trunctate() #清空
#f.truncate(10) #从指定位置开始截断
"""
f.write("\nwhen i was young ,i'd like listen to the radio")
f.write('\n*上太阳升。。。')
f.close()
"""
"""
print(f.readline()) #读一行
#for i in range(5):
#print(f.readline())
#print(f.readlines()) #列表，每行一个元素
for line in f.readlines(): #每循环一行返回一个元素
#print(line)
print(line.strip()) #.strip去掉空格和换行
"""
'''
# low loop
for index,line in enumerate(f.readlines()):
if index==9:
print('-------我是分割线------')
continue
print(line.strip())
'''
# high bige
'''
count=0
for line in f: #迭代器
if count==9:
print('------我------')
print(line.strip())
count+=1
'''
'''
print(f.tell())
print(f.readline())
print(f.readline())
print(f.readline())
print(f.tell()) #打印当前位置
f.seek(5) #回到某个位置
print(f.readline())
print(f.encoding) #打印编码
print(f.fileno()) #一个内存的编号，没什么卵用
f.readable #判断文件是否可读
print(f.flush()) #实时刷新
'''
文件写读和读写
# author:"Jason lincoln"
#f=open("yesterday",'r+',encoding='utf-8') #读写
f=open('yesterday','w+',encoding='utf-8') #写读
#f=open('yesterday','a+',encoding='utf-8') #追加
#f=open("yesterday",'rb') #二进制模式
#f=open("yesterday",'wb')
#f.write('helloiword!\n'.encode())
#f.close()
'''
print(f.readline())
print(f.readline())
print(f.readline())
f.write('------diao--------') #写在后面
print(f.readline())
'''
f.write('--------diao--------1\n')
f.write('--------diao--------1\n')
f.write('--------diao--------1\n')
f.write('--------diao--------1\n')
print(f.tell())
f.seek(10)
print(f.tell())
print(f.readline())
f.write('should be at the behinning of the second line') #不知道没什么鬼，貌似没什么卵用
print(f.readline())
f.close()
#print(f.readline())
进度条——flush的使用
# author:"Jason lincoln"
import sys,time
for i in range(20):
sys.stdout.write('#')
sys.stdout.flush()
time.sleep(0.1)
文件修改
# author:"Jason lincoln"
f=open('yesterday2','r',encoding='utf-8')
f_new=open('yesterday2.bak','w',encoding='utf-8')
for line in f:
if "那时多么幸福的时刻" in line:
line=line.replace('那时多么幸福的时刻','现在也多么幸福的时刻')
f_new.write(line)
f.close()
f_new.close()
字符转编码操作
GBK需要转换为UTF-8格式编程：
1、首先通过编码[decode]转换为Unicode编码
2、然后通过解码[encode]转换为UTF-8的编码
import sys
print(sys.getdefaultencoding())
# author:"Jason lincoln"
s='你好'
#print(s)
s_gbk=s.encode('gbk')
print(s_gbk)
print(s.encode())
gbk_to_utf8=s_gbk.decode('gbk').encode('utf-8') #先转成unicode再转成utf-8
print(gbk_to_utf8)
#print(s.encode('gbk')) #python3默认unicode
# b'\xe4\xbd\xa0\xe5\xa5\xbd' byte类型
with语句
# author:"Jason lincoln"
import sys
#with open('yesterday2','r',encoding='utf-8') as f: #自动关闭文件
with open('yesterday2','r',encoding='utf-8') as f,\
open('yesterday','r',encoding='utf-8') as f2: #打开多个文件，python官方建议一行代码不超过80个字符
for line in f:
print(line)
gb2312转成utf-8再转成gb2312再转成gbk
# author:"Jason lincoln"
#gb2312转成utf-8再转成gb2312再转成gbk
s='你好'
import sys
print(sys.getdefaultencoding())
s_gb2312=s.encode("gb2312")
print(s_gb2312) #gb2312
s_gb2312_to_utf8=s_gb2312.decode('gbk').encode('utf-8')
print(s_gb2312_to_utf8) #utf_8
s_utf8_to_gb2312_again=s_gb2312_to_utf8.decode("utf-8").encode('gb2312')
print(s_utf8_to_gb2312_again) #gb2312
s_gb2312_to_gbk=s_utf8_to_gb2312_again.decode('gb2312').encode('gbk')
print(s_gb2312_to_gbk) #gbk
函数与编程
编程语言中函数的定义 ：函数是逻辑结构化和过程化的一种编程方法。
python中函数定义方法:
def test(x)
"the function definitions"
x+=1
return x
def:定义函数的关键字
test:函数名
():内可定义形参
"":文档描述（非必要，但是强烈建议为你的函数添加描述信息）
x+=1:泛指代码块或程序处理逻辑
return:定义返回值
函数式编程就是：先定义一个数字函数，然后按照这个数字模型用编程语言去实现它。至于具体如何实现和这么做的好处。
函数返回值：
# author:"Jason lincoln"
'''def test1():
print('in the test1')
return 0
x=test1() #函数接收return返回的值。
print(x)
'''
def test1():
print('in the test1')
def test2():
print('in the test2')
return 0
def test3():
print('in the test3')
return 1,'hello',['alex','wupeiqi'],{'name','alex'}
x=test1()
y=test2()
z=test3()
print(x)
print(y)
print(z)
总结：
返回值数=0；返回none
返回值数=1；返回object
返回值数>1;返回tuple
函数的参数及调用
# author:"Jason lincoln"
def test(x,y): #形参
print(x)
print(y)
#test(2,1) #实参 与形参一一对应
test(y=1,x=2) #与形参顺序无关 关键字调用
test(3,y=2) #关键参数不能写在位置前面
默认参数
# author:"Jason lincoln"
#默认参数
def test(x,y=2):
print(x)
print(y)
#test(1)
test(1,3)
#默认参数的特点：调用参数的时候，默认参数非必须传递
非固定参数
# author:"Jason lincoln"
# #非固定参数
# def test(*args): #*args:接收N个位置参数，转换成元组形式
#
# print(args)
#
#
# test(1,2,3,4,5)
# test(*[1,2,4,5,5]) #args=tuple（[1,2,3,4,5]）
# def test1(x,*args):
# print(x)
# print(args)
#
# test1(1,2,3,4,5,6,7)
'''
def test2(**kwargs): #**kwargs把N个关键字参数，转换成字典的方式
print(kwargs)
print(kwargs['name'])
print(kwargs['age'])
print(kwargs['sex'])
test2(name='alex',age=8,sex='F')
test2(**{'name':'alex','age':8,'sex':'F'})
'''
# def test3(name,**kwargs):
# print(name)
# print(kwargs)
# test3('aelx',age=18,sex='m')
'''
def test4(name,age=18,**kwargs): #参数组一定要放在最后
print(name)
print(age)
print(kwargs)
#test4('alex',sex='m',hobby='tesla',age=3)
#test4('alex',3,sex='m',hobby='tesla')
test4('alex',sex='m',hobby='tesla')
'''
def test5(name,age=18,*args,**kwargs):
print(name)
print(age)
print(args)
print(kwargs)
test5('alex',age=34,sex='m',hobby='tesla')
全局变量与局部变量
在子程序中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量和局部变量同名时；
在局部变量的子程序内，局部变量起作用；在其他地方全局变量起作用。
# author:"Jason lincoln"
'''
school='Oldboy edu' #全局变量
def change_name(name):
global school #将局部变量改成全局变量
school='Mage Linux' #局部变量
print('before change',name,school)
name='Alex Li' #这个函数就是这个变量的作用域
age=23
print('after change',name)
print(school)
name='alex'
change_name(name)
print(name,school)
'''
# def change_name():
# global name #尽量不用global
# name='alex'
#
#
# change_name()
# print(name)
school='oldboy edu'
names=['alex','jack','rain'] #列表，字典，集合可以在函数里面改
def change_name():
names[0]='金角大王'
print('inside func',names)
change_name()
print(names)
递归
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就叫递归函数
1.必须有一个明确的结束条件
2.每次进入更深一层递归时，问题的规模相比上次递归都应有所减少
3.递归效率不高，递归层次过多会导致栈溢出
# author:"Jason lincoln"
def calc(n):
print(n)
if int(n/2)>0:
return calc(int(n/2))
print("-->",n)
calc(10)
高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这个函数称之为高阶函数。
# author:"Jason lincoln"
#abs 绝对值函数
def add(a,b,f):
return f(a)+f(b)
res =add(3,-6,abs)
print(res)