python学习 day3

一、集合操作

      集合是一个无序的，不重复的数据组合，它的主要作用如下：

          去重，把一个列表变成集合，就自动去重了

          关系测试，测试两组数据之前的交集、差集、并集等关系

####去重，关系测试
list_1 = [1,2,3,4,2,8]
print(list_1,type(list_1))
list_1 = set(list_1)               #先把列表转换为集合。。集合也是无序的
print(list_1,type(list_1))
list_2 = set([2,6,0,66,8])
print(list_1,list_2)

list_3 = set([2,0])

#交集
print(list_1.intersection(list_2))

#并集
print(list_1.union(list_2))

#差集
print(list_1.difference(list_2))
print(list_2.difference(list_1))

#子集
print(list_3.issubset(list_2))

#父集
print(list_2.issuperset(list_3))

#对称差集
print(list_1.symmetric_difference(list_2))      ##两个集合互相都不重合的，取在一块。就是把重复的去掉

print('-----------------------------------')
list_4 = set([100,200])
print(list_2.isdisjoint(list_4))           #若无交集，则返回真

#交集
print(list_1 & list_2)
#并集
print(list_1 | list_2)
#差集
print(list_1 - list_2)
#对称差集
print(list_1 ^ list_2)


#添加
# print(list_1.add('999'))   这种用法错误！！！
list_1.add(999)
print(list_1)
list_1.update([1000,2000])    #添加多个
print(list_1)

#pop  删除一个任意的元素
print('---')
list_1.pop()
print(list_1)
#discard  删掉一个指定的值，若不存在，do nothing
list_1.discard(123)
print(list_1)
#remove  删掉一个指定的值，若不存在，会报错
list_1.remove(123)
print(list_1)

二、文件操作

对文件操作流程

1. 打开文件，得到文件句柄并赋值给一个变量
2. 通过句柄对文件进行操作
3. 关闭文件

打开文件的写法：

   追加

f = open('yesterday2','a',encoding='utf-8')  #文件句柄    'a'attend:追加的意思，在后面写，不可以读

f.write('\nhahahhaha\n')
f.close()
读

f = open('yesterday1','r',encoding='utf-8')     #文件句柄
# for i in range(5):
#     print(f.readline())            
# print(f.readlines())     ##读每一行，存在列表中。故有下面的写法

# for line in f.readlines():
#     print(line)

循环

##   f变成迭代器，循环后从内存删掉
# count = 0
# for line in f:
#     if count == 2:
#         print("---------------分割线--------------")
#         count = count+1
#         continue
#     print(line.strip())   ##去掉空格
#     count = count+1

光标的使用  f.tell()和f.seek()

f = open('yesterday1','r',encoding='utf-8')     #文件句柄
print(f.tell())
print(f.read(8))    #读到第8个字符
print(f.readline())
print(f.readline())
print(f.readline())
print(f.tell())    #查看光标位置，以字符计数
f.seek(0)          #光标回到初始位置
print(f.readline())

####既能读又能写,先读后写（还是很有用的）
# f = open('yesterday1','r+',encoding='utf-8')
# print(f.readline())
# print(f.readline())
# print(f.readline())
# print(f.tell())
# f.write('diao---------------')
# print(f.readline())

####二进制格式写。  encode（）是将str转换为bytes
f = open('yesterday1','wb')
f.write('hello binary\n'.encode())
f.close()

###文件修改。把改后的文件写到新文件里。
f = open('yesterday','r',encoding='utf-8')
f_new = open('yesterday4.bak','w',encoding='utf-8')

for line in f:
    if '肆意的快乐' in line:
        line = line.replace('肆意的快乐等我享受','肆意的快乐等llw享受')
    f_new.write(line)
f.close()
f_new.close()

with open('a.txt','a') as f:                                    ##注意with的用法

三、字符编码与转码
无论是utf-8，还是GBK，相互转换时，都要先decode到unicode，再encode到彼此。

import sys
print(sys.getdefaultencoding())


msg = "我爱北京天安门"
#msg_gb2312 = msg.decode("utf-8").encode("gb2312")
msg_gb2312 = msg.encode("gb2312") #默认就是unicode,不用再decode,喜大普奔
gb2312_to_unicode = msg_gb2312.decode("gb2312")   #gb2312到utf-8，需要先解码成unicode（告诉原来是啥），
                                                 # 然后编码成utf-8（编成啥）
gb2312_to_utf8 = msg_gb2312.decode("gb2312").encode("utf-8")
m = gb2312_to_utf8.decode('utf-8')         #gb2312_to_utf8是utf-8，二进制bytes，转换为str，需要decode

print(msg)
print(msg_gb2312)
print(gb2312_to_unicode)
print(gb2312_to_utf8)
print(m)

    结果：

utf-8
我爱北京天安门
b'\xce\xd2\xb0\xae\xb1\xb1\xbe\xa9\xcc\xec\xb0\xb2\xc3\xc5'
我爱北京天安门
b'\xe6\x88\x91\xe7\x88\xb1\xe5\x8c\x97\xe4\xba\xac\xe5\xa4\xa9\xe5\xae\x89\xe9\x97\xa8'
我爱北京天安门

四、函数

参数！！！

# def test(x,y):
#     print(x)
#     print(y)
# test(y=2,x=1)  #关键参数，与形参顺序无关
# test(1,2)      #位置参数，与形参一一对应

# def test(x,y,z):
#     print(x)
#     print(y)
#     print(z)
# test(2,3,z=4)     #关键参数是不能写到位置参数前面的

# def test(x,y=9,z=1):  #默认参数特点：调用函数时候，默认参数非必须传递
#     print(x)           
#     print(y)
#     print(z)
# test(3)

###参数组，可以传递多个实参，放到一个元组里
###   *args接收N个位置参数,转换成元组
# def test(*args):         ####  *代表一种功能
#     print(args)
#
# test(1,2,3,4,5)                  #输出（1,2,3,4,5）
# test((1,2,3,4,5))                #输出（（1，2,3,4,5））
# test(*[1,2,3,4,5])               #输出（1，2,3,4,5）
# test([1,2,3,4,5])                #输出（[1，2,3,4,5]）

# def test1(x,*args):
#     print(x)
#     print(args)
# test1(1,2,3,4,5,6,7,)

###把N个    关键字参数，     转换为字典的方式  (关键字参数很重要！！！)
def test2(**kwargs):
    print(kwargs)
    print(kwargs['name'])
test2(a=88,name='alex',age='23',sex='F')
test2(**{'name':'alex','age':'23'})

# def test3(name,**kwargs):
#     print(name)
#     print(kwargs)
# test3('alex',a=5,age='23')

###def test4(name, **kwargs,age=18):   ##不可以！！！
def test4(name,age=9,*args,**kwargs):   ##函数形参有参数组参数时，   参数组参数，一定放在最后
    print(name)
    print(age)
    print(args)
    print(kwargs)
test4('alex',90,3,4,sex='m',hobby='tesla')

局部变量

def change_name(name):
    school = 'Mage Linux'
    print('before name',name,school)
    name = 'ALEX'            #这个函数就是name和age变量的作用域，形参name是个局部变量
    age = 23
    print('after name',name)
#
name = 'alex'
change_name(name)
print(name)        ###函数里面改掉了，外面没有改掉，打印还是alex
print(school)

names = ['alex','Jack','Rain']
def change_name():                   ####列表，字典，集合，类等在函数都可以改
    print(names)                     ####单个变量，字符串等 不可以改
    names[0] = '金角大王'             ##类似C语言理解，它们传进函数（或者在函数中调用），传的都是地址，是可以修改的
    print(names)

change_name()
print(names)

递归、高阶函数

###递归函数特性：
#1.必须有明确的结束条件(不然最多只能递归999层)
#2.每次进入更深一层时，问题规模相比上次递归都应有所减少
#3.递归效率不高，递归层次过多会导致栈溢出


# def calc(n):
#     print(n)
#     if int(n/2)>0:
#         return calc(int(n/2))
#     print('-->',n)
# calc(10)



###高阶函数  把函数本身当作一个参数，传递给另一个函数
def add(a,b,f):
    return f(a)+b

res = add(-3,4,abs)
print(res)

转载于:https://www.cnblogs.com/llw-/p/10800622.html