alex python of day3

集合

 # 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)