首页 > 代码库 > python学习笔记（集合的使用、文件操作、字符编码与转码、函数）
python学习笔记（集合的使用、文件操作、字符编码与转码、函数）
集合
集合(set)：把不同的元素组成一起形成集合，是python基本的数据类型。
集合元素(set elements):组成集合的成员
为什么需要集合？
集合的作用
1 .列表去重复数据
按照现有知识的解决思路：先设置空列表，然后使用for寻获，把需要去重的列表的第一个数据放到新列表中，然后依次取出第二个数据，把第二个数据和第一个数据作比较，如果不一样，则存入新列表中；以此类推，每取一次都要和新列表中的数据作对比，不一样的则添加入新列表中。
2. 关系测试
比如有学员同时报了python班和linux班，同时在2个列表中，可以用集合来找出该关系。
列表去重
list_1 =[1,4,5,7,3,6,7,9,9,9,1,3,2,5,11,23,222,234,35,11] list_1 = set(list_1) print(list_1)
查看运行结果，列表在转成集合后去除了重复数据。
注意点：集合也是无序的。
集合的关系测试
list_1 =[1,4,5,7,3,6,7,9,9,9,1]
list_1 = set(list_1)
list_2 = set([2,6,0.66,22,8,4])
# print(list_1,list_2)
#交集
print(list_1.intersection(list_2))
#并集
print(list_1.union(list_2))
#差集 list_1里有，list_2里没有
print(list_1.difference(list_2))
print(list_2.difference(list_1))
#子集
list_3 = set([1,3,7])
print(list_3.issubset(list_1)) #list_3是list_1的子集，返回True
#父集
print(list_1.issuperset(list_3)) #list_1是list_3的父集，返回True
#对称差集
print(list_1.symmetric_difference(list_2))
print("-----------")
list_4 = set([5,6,8])
print(list_3.isdisjoint(list_4)) #判断是否是分离集合，不相交
集合的运算符
list_1 =[1,4,5,7,3,6,7,9,9,9,1] list_1 = set(list_1) list_2 = set([2,6,0.66,22,8,4]) #交集（intersection）：& print(list_1 & list_2) #并集（union）：| print(list_1 | list_2) #差集（difference）：- print(list_1 - list_2) #对称差集（symmetric_difference）：^ print(list_1 ^ list_2)
集合的增删改查
list_1 = set([1,3,5,2,8,11,17]) list_1.add(999) #添加一项 list_1.update([888,777,555]) #添加多项 print(list_1) list_1.remove(888) #删除一项 print(list_1) print(len(list_1)) #集合的长度 list_1 in list_2 #判断list_1是否是list_2的成员 list_1 not in list_2 #判断list_1是否不是list_2的成员 print(list_1.pop()) #任意删除一项 print(list_1.remove(‘ddd‘)) #使用remove时，如果对象不存在，会出现报错信息 print(list_1.discard(‘ddd‘)) #使用discard时，对象不存在也不会报错
文件操作
对文件操作流程：
1. 打开文件，得到文件句柄并赋值给一个变量
2. 通过句柄对文件进行操作
3. 关闭文件
实例一：
f = open(‘yesterday.txt‘,encoding=‘utf-8‘) #文件句柄 文件的内存对象 data = http://www.mamicode.com/f.read()>
以上例子中，data和data2读取了2次文件内容，但在屏幕输出时，只显示一次内容。因为文件的操作在读取完之后，指针停留在最后一行，所以data2的赋值，并没有读取到内容。
文件基础操作：
以下三种文件打开操作，写入并不兼容读取。有‘r’权限的时候不能写入，有‘w‘权限的时候不能读取，程序会报错。
#读取文件内容 f = open(‘yesterday2.txt‘,‘r‘,encoding=‘utf-8‘) #文件句柄 文件的内存对象 data = http://www.mamicode.com/f.read()>
#文件只写操作
f = open(‘yesterday2.txt‘,‘w‘,encoding=‘utf-8‘) #文件句柄 文件的内存对象，open可以创建文件，使用写入权限时千万注意
f.write("我爱北京天安门,\n")
f.write("天安门上太阳升,\n")
f = open(‘yesterday2.txt‘,‘r‘,encoding=‘utf-8‘)
data = http://www.mamicode.com/f.read()>
#文件追加内容
f = open(‘yesterday2.txt‘,‘a‘,encoding=‘utf-8‘) #文件句柄 文件的内存对象
#a = append 追加
f.write("我爱北京天安门2,\n")
f.write("天安门上太阳升2,\n")
f = open(‘yesterday2.txt‘,‘r‘,encoding=‘utf-8‘)
data = http://www.mamicode.com/f.read()>
其他文件打开模式：
文件读写：（r+）
文件写读：（w+）
文件追加读：（a+）
"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）
- rU
- r+U
"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）
- rb
- wb
- ab
实例：
需求：打印歌词文件，跳过第十行不打印，第十行打印分割线。
f = open(‘yesterday.txt‘,‘r‘,encoding=‘utf-8‘)
for index,line in enumerate(f.readlines()): #注意：readlines一次读取文件内容到内存，只适合小文件。
if index == 9:
print("-------------------------")
continue
print(line.strip()) #strip()默认删除空白符（包括‘\n‘, ‘\r‘, ‘\t‘, ‘ ‘)
前一个需求的改进写法：
#高效率方法
f = open(‘yesterday.txt‘,‘r‘,encoding=‘utf-8‘)
count = 0
for line in f: #文件变成迭代器，读取一行删除一行，内存中只占一行内容
if count == 9:
print("-------我是分割线-------")
count +=1
continue
print(line.strip())
count +=1
文件读/写指针操作：
f = open(‘yesterday.txt‘,‘r‘,encoding=‘utf-8‘) print(f.tell()) #返回文件读/写指针当前位置，开始是0 print(f.read(5)) #读取字符数 print(f.tell()) #返回当前指针所在位置，按字符计算 f.seek(0) #让文件读/写指针移到指定位置 print(f.readline()) #文件已回到开头 f.close()
以1个例子说明tell()和seek()函数的作用:
fso = open("a.txt",‘w+‘) #以w+方式，并非a方式打开文件，故文件原内容被清空
print(fso.tell()) #文件原内容被清空，故此时tell()=0
fso.write("abcde\n") #写入文件abcde\n，因为换行\n占两个字符，故共写入7个字符
print(fso.tell()) #此时tell()=7
fso.write("fghwm") #又写入文件fghwm，故此时文件共写入7+5 =12个字符
print(fso.tell()) #此时tell()=12
fso.seek(1, 0) #从起始位置即文件首行首字符开始移动1个字符
print(fso.tell()) #此时tell() =1
print(fso.readline()) #读取当前行，即文件的第1行，但是从第二个字符（tell（）+1）开始读，结果为:bcde。
#若换成for读取整个文件或read读取整个文件则结为bcdefghwm
print(fso.tell()) #因为readline此时tell() =7,
fso.truncate(8) #从写入后文件的首行首字符开始阶段，截断为8个字符，即abcde\nf，即文件的内容为：abcde\nf
print(fso.tell()) #tell() 依旧为7,并为受truncate(8)影响，但是此时文件内容为abcde\nf
print(fso.readline()) #从tell（）+1=8开始读取，读取当前行内容：f
fso.close()
文件操作：flush()实例
flush() 方法是用来刷新缓冲区的，即将缓冲区中的数据立刻写入文件，同时清空缓冲区，不需要是被动的等待输出缓冲区写入。
一般情况下，文件关闭后会自动刷新缓冲区，但有时你需要在关闭前刷新它，这时就可以使用 flush() 方法。
在cmd命令行中才能看到实际测试效果。在命令行中往文本文件中写入数据后，并不是马上就会保存，python会在写满缓存后再一次性写入硬盘。使用了f.flush()代码后，可以马上写入硬盘。
进度条实例：
import sys,time
for i in range(50):
sys.stdout.write("#")
sys.stdout.flush()
time.sleep(0.1)
文件修改实例：
需求：已有Yesterday when I was young这首歌的歌词文件yesterday.txt，修改其中的一句歌词翻译：”肆意的快乐等我享受”改为“肆意的快乐等Alex享受”。
解决方法：一行行读取，遇到符合条件的行后进行修改，然后新建yesterday3.txt文件保存歌词文件。
f = open("yesterday.txt",‘r‘,encoding="utf-8")
f_new = open("yesterday3.txt","w",encoding="utf-8")
for line in f:
if "肆意的快乐" in line:
line = line.replace("肆意的快乐等我享受","肆意的快乐等Alex享受")
f_new.write(line)
f.close()
f_new.close()
with语句
with语句作用，自动关闭文件
with open("yesterday.txt","r",encoding="utf-8") as f:
for line in f:
print(line.strip())
可以用with同时打开多个文件
with open("yesterday.txt","r",encoding="utf-8") as f , open("yesterday3.txt","r",encoding="utf-8") as f2: #官方文档建议每行代码不超过82个字符，所以分行编写
for line in f:
print(line)
字符编码与转码
#-*- coding:utf-8 -*- #python2中需要指定编码类型为：utf-8，python3中默认编码类型为Unicode
ASCII码
GB2312：GB是“国标”两字的拼音首字，2312是标准序号。GB2312编码是第一个汉字编码国家标准，由中国国家标准总局1980年发布，1981年5月1日开始使用。共收录汉字6763个。
GBK：是对GB2312编码的扩展。共收录汉字和图形符号21886个。其中汉字21003个。
GB18030：2000年3月17日发布。是对GBK编码的扩充。收录27484个汉字。
UNICODE（统一码、万国码、单一码）是一种在计算机上使用的字符编码。
Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，规定虽有的字符和符号最少由 16 位来表示（2个字节），即：2 **16 = 65536， 注：此处说的的是最少2个字节，可能更多。
UTF-8：是对Unicode编码的压缩和优化，他不再使用最少使用2个字节，而是将所有的字符和符号进行分类：ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存...
编码实例：
来自于：http://www.cnblogs.com/luotianshuai/articles/5735051.html
python3中：
#!/usr/bin/env python #-*- coding:utf-8 -*- #author luotianshuai tim = ‘天帅‘ #转为UTF-8编码 print(tim.encode(‘UTF-8‘)) #转为GBK编码 print(tim.encode(‘GBK‘)) #转为ASCII编码(报错为什么?因为ASCII码表中没有‘天帅’这个字符集~~) print(tim.encode(‘ASCII‘))
python2中：
因为在python2.X中默认是ASCII编码，你在文件中指定编码为UTF-8，但是UTF-8如果你想转GBK的话是不能直接转的，的需要Unicode做一个转接站点。
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#author luotianshuai
import chardet
tim = ‘你好‘
print chardet.detect(tim)
#先解码为Unicode编码，然后在从Unicode编码为GBK
new_tim = tim.decode(‘UTF-8‘).encode(‘GBK‘)
print chardet.detect(new_tim)
#结果
‘‘‘
{‘confidence‘: 0.75249999999999995, ‘encoding‘: ‘utf-8‘}
{‘confidence‘: 0.35982121203616341, ‘encoding‘: ‘TIS-620‘}
‘‘‘
函数与函数式编程
编程方式：
1. 面向对象：类----->>class
2. 面向过程：过程---->>def
3. 函数式编程：函数---->>def
函数定义：
初中数学函数定义：一般的 ，在一个变化过程中，如果有两个变量x和y，并且对于x的每一个确定的值，y都有唯一确定的值与其对应，那么我们就把x称为自变量，把y称为因变量，y是x的函数。自变量x的取值范围叫做这个函数的定义域。
编程语言中函数定义：函数式逻辑结构化和过程化的一种编程方法。
python中函数定义方法：
#python中函数定义方法：
def test(x):
‘‘‘The function definitions‘‘‘
x +=1
return x
# def：定义函数的关键字
# test：函数名
# ()：内可定义形参
# ‘‘‘‘‘‘：文档描述（非必要，但是强烈建议为你的函数添加描述信息）
# x+=1：泛指代码块或程序处理逻辑
# return：定义返回值
函数式编程就是：先定义一个数学函数，然后按照这个数学模型用编程语言去实现它。
为什么要使用函数：
没有函数的编程只是在写逻辑（功能），想脱离函数，重用你的逻辑，唯一的方法就是拷贝
例子一：
def test1():
print(‘in the test1‘)
with open(‘a.txt‘,‘a+‘) as f:
f.write(‘end action\n‘)
def test2():
print(‘in the test2‘)
with open(‘a.txt‘,‘a+‘) as f:
f.write(‘end action\n‘)
def test3():
print(‘in the test3‘)
with open(‘a.txt‘,‘a+‘) as f:
f.write(‘end action\n‘)
test1()
test2()
test3()
例子二：对以上代码进行优化，并且加入日志时间。使用函数编程方法：
import time
def logger():
time_format = ‘%Y-%m-%d %X‘
time_current = time.strftime(time_format)
with open(‘a.txt‘,‘a+‘) as f:
f.write(‘%s end action\n‘ %time_current)
def test1():
print(‘in the test1‘)
logger()
def test2():
print(‘in the test2‘)
logger()
def test3():
print(‘in the test3‘)
logger()
test1()
test2()
test3()
使用函数的三大优点：
1. 代码重用
2. 保持一致性
3. 可扩展性
函数参数及调用
函数返回值：
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‘}
#return test2 #return可以返回任意类型，也可以是函数
x=test1()
y=test2()
z=test3()
print(x)
print(y)
print(z)
总结：
返回值数=0；返回None
返回值数=1；返回object
返回值数>1；返回tuple
为什么要有返回值？
其他的程序逻辑需要根据返回值进行操作
调用方法：
1. 形参和实参
根据位置一一对应
例一：
def test(x,y):
print(x)
print(y)
test(1,2)
# test(y=2,x=1) #与形参顺序无关
# test(1,2) #位置参数与形参一一对应
test(3,x=1) #程序报错，因为同时给x赋值2次，y没有赋值
例二：
def test(x,y,z):
print(x)
print(y)
print(z)
test(3,y=1,z=6) #这样赋值是允许的
test(3,y=1,6) #位置参数虽然一一对应，但程序会报错。因为关键参数不能出现在位置参数前面。切记。
函数的非固定参数
默认参数：
def test(x,y=2): #y=2是默认参数
print(x)
print(y)
test(1,3)
默认参数特点：调用函数的时候，默认参数非必须传递
默认参数用途：例如连接mysql数据时，可以默认指定端口号：3306
参数组：
1.
def test(*args):
print(args)
test(1,2,3,4,5,5)
test(*[1,2,3,4,5]) # args=tuple([1,2,3,4,5])
2.
# **kwargs：把N个关键字参数，转换成字典的方式
def test2(**kwargs):
print(kwargs)
test2(name=‘alex‘,age=8,sex=‘F‘)
def test3(name,**kwargs):
print(name)
print(kwargs)
test3(‘alex‘,age=18,sec=‘m‘) # 使用关键字方式传入
def test4(name,age=18,**kwargs):
print(name)
print(age)
print(kwargs)
test4(‘alex‘,sex=‘m‘,age=3,hobby=‘tesla‘) #age参数可以在任意位置
3.
def test4(name,age=18,*args,**kwargs):
print(name)
print(age)
print(args) #args接收N个位置参数
print(kwargs) #kwargs接收N个关键字参数
test4(‘alex‘,34,1,2,3,sex=‘m‘,hobby=‘tesla‘) #34传递给age，1,2,3传递给了args
作用域、局部与全局变量
在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其他地方全局变量起作用。
实例一：局部变量、作用域、全局变量的定义
school = "Oldboy edu." #全局变量
def change_name(name):
school = "Mage" #局部变量
print("before change",name,school)
name = "Alex Li" #局部变量，只在函数内生效。这个函数就是该变量的作用域。
age =23
print("after change",name)
name = ‘alex‘
change_name(name)
print(name)
print(school)
实例二：如何在子程序（函数）中修改全局变量。
注意事项：千万不要在函数中改全局变量。容易造成程序逻辑混乱，增加排错难度。
school = "Oldboy edu." #全局变量
def change_name(name):
global school # 在函数中定义全局变量
school = "Mage" #使用global后，school被声明为全局变量
print("before change",name,school)
name = "Alex Li"
print("after change",name)
name = ‘alex‘
change_name(name)
print(name)
print(school)
注意事项二：
字符串和整数类型变量不能在函数中直接更改
列表、字典、集合、类都可以在函数中更改
递归
在函数内部，可以调用其他函数。如果一个函数在内部调用自身，这个函数就是递归函数。
递归特性：
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用时通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
函数式编程介绍
函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。
函数式编程（请注意多了一个“式”字）——Functional Programming，虽然也可以归结到面向对象过程的程序设计，但其思想更接近数学计算。
函数式编程时一种抽象程度很高的编程范式。
定义：
简单说，“函数式编程”是一种“编程范式”（programming paradigm），也就是如何编写程序的方法论。
主要思想是把运算过程尽量写成一系列嵌套的函数调用。
高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
举例：
def add(a,b,f):
return f(a)+f(b)
res = add(3,-6,abs) #abs是绝对值函数
print(res)
python学习笔记（集合的使用、文件操作、字符编码与转码、函数）