第三周

Posted 2020-12-24 ddgjye

集合操作

集合（set）和字典（dict）类似，也是一组key的集合，但不存储value。由于key不能重复，所以在集合中没有重复的key。

list1 = set([1,3,4,5,6,7,9])  #创建一个集合

list2 = set([4,6,0,99,8,4])
注意：集合内部元素显示时是没有顺序的，而且重复元素在set中会被自动过滤。

list1.add(17)  #添加单个元素
list1.update([33,44,11,22])  #添加多个元素

print(list1.pop()) #随机删除一个元素,并打印删除的元素
print(list1.discard(5)) #删除指定元素，但是不会打印出来
print(list1.remove(22)) #删除指定元素，当删除不存在的元素时会报错

print(list1.intersection(list2))  #两个集合的交集，形式一
print(list1 & list2)  #交集，形式二
print(list1.difference(list2))  #差集，在list1不在list2中，形式一
print(list1 - list2)  #差集，形式二
print(list1.union(list2)) #并集，形式一
print(list1 | list2) #并集，形式二

print(list1.symmetric_difference(list2)) #对称差集，在list1或者list2中，不会在两个集合中同时出现，形式一
print(list1 ^ list2)  #对称差集形式二

print(list1.issuperset(list2)) #判断list1是否是list2的父集
print(list2.issubset(list1))   #判断list2是否是list1的子集

文件操作

f = open ("yesterday2",‘r‘,encoding = "utf-8") #文件句柄，以读的方式打开文件
data = f.read()
 print(data)

f = open ("yesterday",‘w‘,encoding = "utf-8")  #写操作，这种写是代表新建一个文件，如果和之前的文件名相同会覆盖之前文件，形成一个空文件，等待写入内容

   f.write(‘hell o world ‘)

　f.write(‘alex‘)　　　　#将两个数据写入文件

f = open ("yesterday",‘a‘,encoding = "utf-8")  #a表示在已有文件后追加信息
f.write("
好好锻炼！
")
f.write("身体棒棒！")   #写入的内容
f.close()   #关闭文件句柄  

print(f.readline())  #打印文件内容第一行
print（f.readlines()） #将文件每一行的内容作为一个元素，将整个文件内容一一个列表的形式打印出来
for i inf.readlines（）:   #遍历文件
    print（i.strip()）   #用strip（）去掉字符串收尾空格和
	的都去掉
练习：打印文件，第十行时打印提示符

f = open ("yesterday2",‘r‘,encoding = "utf-8") #文件句柄
for index,line in enumerate(f.readlines()):
    if index == 9:
        print("----我是分割线----")
        continue
    print(line.strip())

print（f.tell()） #光标的位置
f.seek（） #任意调整光标的位置
f.flush()  #刷新缓冲区
练习：显示进度条

import sys,time
for i in range(20):
    sys.stdout.write("#")
    sys.stdout.flush()  #更新缓冲区
    time.sleep(0.1)
print(‘#‘,end = ‘‘,flush=True)

文件的打开模式
r+模式    #读写模式，读从最开始读，写从文件最末开始写，类似追加内容
w+模式    #写读模式 先清空再写也读不到，因为读是从光标向后读的
a+模式    #追加内容+读文件模式

函数

函数的优点： 1、代码重用  2、保持一致性  3、可扩展
函数的定义：在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。如下
def func(形式参数):
    函数体
    return   #返回值
func(实际参数)   #函数调用
练习

def test03():
    return 0,10,‘hello‘,[‘alex‘,‘lb‘],{‘yeqin‘:‘lb‘}
t3 = test03()
print(‘from test03 return is [%s]:‘%type(t3),t3

注意：定义函数时要确定函数名和参数的个数
     函数的返回值可以是多个值，就是一个元组

函数参数：
1、位置参数：定义了在调用函数时就一定要给出实参的参数 如def func(x,y),x和y两个参数在后面调用该函数时一定要赋予两个实际值来运行函数。
2、默认参数：默认参数必须在所有位置参数的后面；如fun(n1,n2,n3="default");中的n3就是默认参数，n3必须在n2,n1后面，在调用这个函数的时候可以三个参数或者是两个参数，两个参数的时候，默认最后一个参数为n3;
3、关键字参数：在调用的时候，可以直接使用函数中参数的名称，所以这样就在调用的时候就不需要按照指定的位置（可以不按照参数的指定顺序调用）。例如：有函数fun(age,name="Alex",value="no")；
4、非关键可变长参数（元组）：可变长的参数元组必须在位置参数和默认参数的后面，使用的是*来作为元组参数的；它可以吸纳多余的参数，让多余的参数作为一个元素传递给函数，即可以不限定参数的个数；
5、关键字变量参数（字典）：参数被放在一个字典中，字典中的键为参数名，值为相应的参数值。使用的是两个*号：**关键字变量参数必须放在非关键字可变参数的后面，也就是参数的最后面。
如下：

#args:接受N个位置参数，转换成元组形式
def test(*args):
    print(args)
test(1,2,3,4,5)
test(*[1,2,3,4,5])  #args=tuple([1,2,3,4,5])

**kwargs 接受N个关键字参数，转换成字典的形式
def test2(**kwargs):
    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 test4(name,age=18,*args,**kwargs):
    print(name)
    print(age)
    print(args)
    print(kwargs)
    logger("TEST4")

def logger(source):
    print("from %s" % source)
test4(‘alex‘,age=34,sex=‘m‘,hobby=‘tesla‘)

注意：使用关键字参数时，不会打印元组形式。

递归函数：一个函数在函数内部调用本身的函数
特点：必须有一个明确的结束条件
     每进入一层递归时，问题规模有所减小
     递归效率不高，递归层次过多会导致栈溢出
练习：使用递归计算阶乘

def fact(n):
    if n == 1:
        return 1
    return n*fact(n-1)
print(‘fact(1)=‘,fact(1))
print(‘fact(5)=‘,fact(5))
print(‘fact(10)=‘,fact(10))

高阶函数：函数名可以进行赋值
         函数名可以作为参数，也可以作为函数的返回值
如下：

def add(a,b,f):
    return f(a)+f(b)
res = add(3,-6,abs)
print(res)