python学习笔记（集合的使用文件操作字符编码与转码函数）

Posted 2020-09-27

集合

集合(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 = f.read()
data2 = f.read()
print(data)
print(‘data2‘.center(50,‘-‘),data2)

以上例子中，data和data2读取了2次文件内容，但在屏幕输出时，只显示一次内容。因为文件的操作在读取完之后，指针停留在最后一行，所以data2的赋值，并没有读取到内容。

 

文件基础操作：

以下三种文件打开操作，写入并不兼容读取。有‘r’权限的时候不能写入，有‘w‘权限的时候不能读取，程序会报错。

#读取文件内容
f = open(‘yesterday2.txt‘,‘r‘,encoding=‘utf-8‘) #文件句柄 文件的内存对象
data = f.read()
print(data)
f.close()

#文件只写操作
f = open(‘yesterday2.txt‘,‘w‘,encoding=‘utf-8‘) #文件句柄 文件的内存对象，open可以创建文件，使用写入权限时千万注意
f.write("我爱北京天安门,\\n")
f.write("天安门上太阳升,\\n")
f = open(‘yesterday2.txt‘,‘r‘,encoding=‘utf-8‘)
data = f.read()
print(data)
#查看输出，文件原有内容丢失。证明open ‘w’操作是创建文件。不能乱用。

#文件追加内容
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 = f.read()
print(data)

f.close()

 其他文件打开模式：

文件读写：（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)