Python学习week3

集合：去重，关系测试，无序存放

lis=[1,3,3,5,9,7]
lis=set(lis)
lis2=set([0,1,3,5,4,2])
print(lis,lis2)
print(lis.intersection(lis2))       #交集
print(lis.union(lis2))      #并集
print(lis.difference(lis2))     #差集  lis中除去lis2元素剩余的元素
print(lis.symmetric_difference(lis2))   #对称差集，返回两个集合中不重复的元素的新集合
lis3={1,3,5}
print(lis3.issubset(lis2))       #判断是否子集，返回True或者False
print(lis.issuperset(lis2))       #判断是否父集，返回True或者False
print(lis.isdisjoint(lis2))     #判断两个集合是否没有交集

集合运算符：

print(lis&lis2)     #交集
print(lis|lis2)     #并集
print(lis-lis2)     #差集
print(lis^lis2)     #对称差集
print(lis3<=lis)    #判断是否是子集
print(lis>=lis3)    #判断是否是父集

集合元素的增删：

print(len(lis))     #长度
print(1 in lis)     #判断元素是否在集合中
lis.add(999)        #增加一个元素
lis.update([10,100,200])      #增加多个元素
lis.remove(100)     #删除一个元素，元素必须包含在集合中，否则报错
lis.discard(101)        #如果集合包含此元素则删除，不包含时do nothing.
print(lis.pop())        #随机删除一个元素并返回

---

文件操作：打开文件，操作文件，关闭文件

f=open('quietnight',encoding='utf-8')　　　　#默认读操作
f.close()

 为了防止忘记关闭文件，使用with语句：

with open('quietnight','r',encoding='utf-8')as f:　　　　#等效于：f=open('quietnight','r',encoding='utf-8')
    print(f.readline())
    print(f.closed)
print(f.closed)
输出：
床前明月光，

False
True

 在with语句内打开文件，with语句结束时文件关闭。

 with可以同时打开多个文件:

with open('quietnight','r',encoding='utf-8')as f1,open('quietnight2','r',encoding='utf-8')as f2:

with open('quietnight','r',encoding='utf-8')as f1,
        open('quietnight2','r',encoding='utf-8')as f2:

 f称为文件句柄，是文件映射在内存中的对象，用来执行对文件的操作

读文件：

f=open('quietnight',encoding='utf-8')
data=f.read()
data2=f.read()
print(data)
print(data2)

 data2为空，f包含文件在硬盘里的起始位置，当使用第一个data=f.read()时，f读取文件并把文件内容赋值给data,此时f指向文件末尾处，所以第二次read读取的内容为空。

读取前3行：

for i in range(3):
    print(f.readline())

读取3-6行：

f=open('quietnight',encoding='utf-8')
for i in range(6):
    if i>1:　　　　　　#i=2时开始打印，是从第三行开始的
        print(f.readline().strip())
    else:
        f.readline()

 readline()每次读取一行。

 readlines()把文件内容每行当成一个元素，形成列表。

f=open('quietnight',encoding='utf-8')
print(f.readlines())

 输出：

['床前明月光，
', '疑是地上霜。
', '举头望明月，
', '低头思故乡。']

 循环输出（效率低下）：

f=open('quietnight',encoding='utf-8')
for line in f.readlines():
    print(line.strip())　　　　#如果不加strip()，每个line元素的结尾处有
换行，输出会隔一行

  输出：

床前明月光，
疑是地上霜。
举头望明月，
低头思故乡。

f=open('quietnight',encoding='utf-8')
for line in f.readlines():
    print(line)

输出结果（隔行输出）：
床前明月光，

疑是地上霜。

举头望明月，

低头思故乡。

 第3行不输出：

f=open('quietnight',encoding='utf-8')
for index,line in enumerate(f.readlines()):
    if index==2:
        print('-----分割线-----')
        continue
    print(line.strip())

 输出结果：

床前明月光，
疑是地上霜。
-----分割线-----
低头思故乡。

enumerate(list)可以用于for循环，每次获取列表元素的index和元素本身。

lis=[0,2,4,6,8]
for i in enumerate(lis):
    print(i)
输出：
(0, 0)
(1, 2)
(2, 4)
(3, 6)
(4, 8)

lis=[0,2,4,6,8]
for i,j in enumerate(lis):
    print(i,j)
输出：
0 0
1 2
2 4
3 6
4 8

使用readlines方法读取文件，程序会把硬盘上的文件内容全部读取到内存中，速度慢并且浪费资源。

高效读取文件的方法：

f=open('quietnight',encoding='utf-8')
for i in f:　　　　#f不再是列表，内存读取一行打印后就释放
    print(i)

---

写文件：

f=open('quietnight','a',encoding='utf-8')
f.write('
春江花月夜')

 ‘a’代表以写的操作方式打开文件，如果'quietnight'文件不存在则创建并写入内容，存在时把要写的内容加入到文件末尾处。

f=open('quietnight','w',encoding='utf-8')
f.write('
春江花月夜')

 ‘w’也是写操作，如果'quietnight'文件不存在则创建并写入内容，如果存在则覆盖原内容。相当于创建新文件。

f.write('
春江花月夜')把要写的内容加入到文件末尾处。

'r'       open for reading (default)
    'w'       open for writing, truncating the file first
    'x'       create a new file and open it for writing
    'a'       open for writing, appending to the end of the file if it exists
    'b'       binary mode
    't'       text mode (default)
    '+'       open a disk file for updating (reading and writing)
    'U'       universal newline mode (deprecated)

---

其他文件操作方法：

f=open('quietnight','r',encoding='utf-8')
print(f.tell())     #输出当前光标位置
print(f.read(5))        #读五个字符
print(f.tell())     #utf-8编码方式下，一个汉字占三个字节，所以输出为15。（0+15）
f.seek(0)       #用于将f光标重新定位，f.seek(0)是把光标移到初始位置
print(f.encoding)       #编码方式，注意encoding后面没有括号,encoding是f的参数，没有括号，方法才有括号
print(f.fileno())       #python调用操作系统的IO接口来打开文件，接口同时为python和其他程序打开文件，fileon()方法返回当前文件编号
print(f.seekable())     #判断当前文件是否可以移动光标，某些设备文件不能移动光标
print(f.closed)     #判断文件是否已经关闭

f=open('quietnight','a',encoding='utf-8')
f.truncate(20)

 截取保留文件的前20个字节，无论光标f位置在哪，都从文件起始位置截取

f.flush()

 文件读写具有缓存机制，默认内存到缓存再到硬盘。缓存满了后一次性存储到硬盘，并非逐行从内存到硬盘。flush()方法用于强制把文件内容从内存实时存储到硬盘。

可以用来实现进度条功能：

import sys,time
for i in range(10):
    sys.stdout.write('*')       #打印‘*’后不换行，print（）会默认换行
    sys.stdout.flush()      #flush()使得‘*’立即输出打印，不会保存在缓冲区
    time.sleep(0.5)     #sleep()用于将程序暂停0.5秒

---

读写文件：r+

f=open('quietnight','r+',encoding='utf-8')
print(f.readline())
f.write('-----分割线-----')　　　　#无论光标当前位置在哪，都写在文件末尾处，只有用seek()方法定位光标时，才能写入修改信息。

 写读文件：w+   　　仍然会把原文件覆盖，相当于创建新文件。

二进制文件格式：rb　　　　网络传输。python3里网络传输只能用二进制。

---

 修改文件内容：创建新文件，把要修改的地方写入新文件

f=open('quietnight','r',encoding='utf-8')
f2=open('jingyesi','w',encoding='utf-8')
for line in f:
    if '举头' in line:
        line=line.replace('举头','举头举头举头')
    f2.write(line)
f.close()
f2.close()

---

 字符编码

 ASCII:英文一个字节，不能存中文

GBK,GB2312：中文编码方式

 unicode:英文、中文都占两个字节，万国码，兼容很多编码，是不同语言编码转换的桥梁。python3默认按照Unicode存储代码。

 utf-8（ unicode的扩展集）:可变长字符编码，英文字符按照ASCII码存储，中文三个字节存储。

字符编码转码：A语言编码转换为Unicode，再转换为B语言编码。

---

 函数：代码重用，可扩展。

程序自上而下执行，在调用函数之前需要先定义。函数体内可以调用其他函数。

 过程：没有返回值的函数

面向过程的编程方法：很多个过程组合成程序。

无返回值时，返回none;

返回数字时，接收数字；

返回多个类型的值时，接收元组。

def test1():
    print('in test 1')
def test2():
    print('in test 2')
    return 0
def test3():
    print('in test 3')
    return 1,'chengdu',('chengdu','sichuan'),{'sichuan':'chengdu'}
x=test1()
y=test2()
z=test3()
print(x)
print(y)
print(z)

输出：
in test 1
in test 2
in test 3
None
0
(1, 'chengdu', ('chengdu', 'sichuan'), {'sichuan': 'chengdu'})    #元组

含参函数的调用：

def test(x,y,z):
    print(x,y,z)
test(1,2,3)      #位置调用
test(y=5,x=4,z=6)       #关键字调用
test(7,z=8,y=9)       #混合调用

 test(1,y=2,3)  　　报错，关键字调用不能在位置调用之前。

默认参数：

def test(x,y,z=3):
    print(x,y,z)
test(1,2)

 参数组1：把多个位置参数转变为元组。一个*，参数名一般用args

def test(*args):　　　　#形参名是args，*是功能代号
    print(args)
test(1,2,3)
test(*[1,2,3])　　　　#*args=*[1,2,3] -->args=[1,2,3],输出变成元组，忘记这种用法
输出元组：
(1, 2, 3)
(1, 2, 3)

 混合参数1：位置参数+参数组，参数组写在最后

def test(a,*args):
    print(a,args)
test(1,2,3,4)
输出：
1 (2, 3, 4)

混合参数2：默认参数+参数组，默认参数可以放在参数组之后。

def test(*args,a=111):
    print(a,args)
test(1,2,3,4)
输出：
111 (1, 2, 3, 4)

参数组2： 把多个关键字参数转变为字典。两个*，参数名一般用kwargs.

两种调用方式如下：

def test2(**kwargs):
    print(kwargs)
test2(name='刚田武',age=22,weight=150)
test2(**{'name':'刚田武','age':22})　　　　#忘记这种用法
输出： 
{'age': 22, 'name': '刚田武', 'weight': 150}
{'age': 22, 'name': '刚田武'}

  混合参数1：位置参数+参数组

def test2(a,**kwargs):
    print(a,kwargs)
test2('panghu',name='刚田武',age=22,weight=150)
输出：
panghu {'name': '刚田武', 'age': 22, 'weight': 150}

 混合参数2：位置参数+默认参数+参数组 (参数组只能写在最后)

def test(a,age=18,**kwargs):
    print(a,age,kwargs)
test('panghu',name='刚田武',age=22,weight=150)
输出：
panghu 22 {'weight': 150, 'name': '刚田武'}

 混合参数3：位置参数+默认参数+*参数组+**参数组

def test(a,age=18,*args,**kwargs):
    print(a)
    print(age)
    print(args)
    print(kwargs)
test('panghu',name='刚田武',age=22,weight=150)
输出：
panghu
22
()
{'weight': 150, 'name': '刚田武'}

---

全局变量与局部变量：

全局变量在程序的最外层定义，作用于整个程序；

局部变量在函数内部定义，只作用于函数。

当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

不要在函数中改变全局变量，更不能在函数中定义全局变量。

字符串和整数不能在函数内修改，但是列表、字典可以在函数内修改。

Name='gangtianwu'       #全局变量
def change(name):       #函数改变不了全局变量
    print("before change:",name)
    name=name.upper()
    print('after change:',name)
change(Name)
print(Name)
输出：
before change: gangtianwu
after change: GANGTIANWU
gangtianwu

如果需要在函数内改变全局变量，使用global：如果函数外部有此全局变量则改变，如果没有则创建并当成全局变量，在调用此函数后此全局变量才可以访问。（尽量避免使用global）

Name='gangtianwu'
sex='male'
def change(name):
    global sex         #可以改变全局变量sex
    sex='female'
    print("before change:",name)
    name=name.upper()
    print('after change:',name)
change(Name)
print(Name)
print(sex)
输出：
before change: gangtianwu
after change: GANGTIANWU
gangtianwu
female    

---

递归函数：函数在内部调用自己。

特性：1、必须有明确的结束条件；2、每次进入更深一层递归时，问题规模相比上次递归都应有所减少；3、递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

（https://www.cnblogs.com/alex3714/articles/5740985.html）

def cal(n):
    print(n)
    if int(n/2)==0:
        return n
    return cal(int(n/2))
a=cal(10.5)
输出：
10.5
5
2
1

高阶函数：实参是函数的函数。

Python内置函数：

https://docs.python.org/3/library/functions.html?highlight=built#ascii