python学习笔记（3）

1.集合：

集合是无序的，不重复的数据组合。

作用：1>去重：把一个列表变成集合，自动去重；

　　　2>关系测试：测试两组数据之间的交集，差集，并集等。

创建新集合：

list = {1, 2, 3 ,4, 5}
print(list, type(list))
#列表
list_1 = [1, 2, 3, 4]
list_1 = set(list_1)
print(list_1, type(list_1))
#字典
list_2 = {1: 'one', 2: 'two'}
list_2 = set(list_2)
print(list_2, type(list_2))

input:
{1, 2, 3, 4, 5} <class 'set'>
{1, 2, 3, 4} <class 'set'>
{1, 2} <class 'set'>

有关集合的方法：

1.1.集合运算

list_1 = {1, 3, 5, 6, 7}
list_2 = {1, 2, 3, 4, 5}
list_3 = {1, 3}
list_4 = {2, 4}

#交集
print(list_1.intersection(list_2))    {1, 3, 5}
print(list_2.intersection(list_1))    {1, 3, 5}
print(list_1 & list_2)                {1, 3, 5}

#并集
print(list_1.union(list_2))    {1, 2, 3, 4, 5, 6, 7}
print(list_2.union(list_1))    {1, 2, 3, 4, 5, 6, 7}
print(list_1 | list_2)         {1, 2, 3, 4, 5, 6, 7}

#差集
print(list_1.difference(list_2))   {6, 7}
print(list_2.difference(list_1))   {2, 4}
print(list_1 - list_2)             {6, 7}
print(list_2 - list_1)             {2, 4}

#判断子集
print(list_3.issubset(list_1))   True
print(list_3 <= list_1)          True
 
#判断父集
print(list_1.issuperset(list_3))   True
print(list_1 >= list_3)            True

#对称差集
print(list_1.symmetric_difference(list_2))   {2, 4, 6, 7}
print(list_1 ^ list_2)                       {2, 4, 6, 7}

#没有交集的时候返回True
print(list_1.isdisjoint(list_4))   True

1.2.其余操作

#浅copy
list_5 = list_1.copy()
print(list_5)

#添加
list_3.add(5)   #只能添加一项
print(list_3)
list_4.update([0, 1, 9])  #添加多项
print(list_4)

#删除
list_3.pop()   #任意删除
list_3.remove(1)   #删除给定的任一项
list_3.discard(1)   #删除给定的任一项

#长度
len(list_4)

对于x in [ ]或者x not in [ ]，其中的[ ]可以是列表，集合，字典或者字符串。 

2.文件读写详解

2.1. 文件的读出：其中 r-读写， w-创建新文件覆盖原有的， a-追加， r+ - 读写追加， w+ 写读， b-二进制文件

#直接读取
data = open('test', 'r', encoding='utf-8').read()

#创建句柄（文件句柄对文件进行操作，将在内存中打开的文件赋值）
f = open('test', 'r', encoding='utf-8')
data = f.read()
data2 = f.read()
print(data)
print('--------')
print(data2)   #此处什么也读不到，因为读的第一遍光标在文件末尾

# readline
f = open('test', 'r', encoding='utf-8')
for i in range(2):   #读取前两行
    print(f.readline().strip()) #同时读取了每一行结尾的回车

#readlines
f = open('test', 'r', encoding='utf-8')
for line in f.readlines():
    print(line.strip())

#第三行特殊打印，但这种方式只适用于小文件（直接从硬盘读到内存）
for index, line in enumerate(f.readlines()):
    if index == 2:
        print('********')
        continue
    print(line.strip())

#一行一行的读取，内存中只保存一行（迭代器），这种方式效率很高
count = 0
for line in f:
    count += 1
    if count == 3:
        print('********')
        continue
    print(line.strip())

2.2. 关于文件的方法

#一般文件先写到缓存，到达大小时才会写到硬盘
#f.flush()强制刷新
#这是一个简单的进度条程序
import sys,time
for i in range(20):
    sys.stdout.write("#")  #stdout标准输出（屏幕）
    sys.stdout.flush()
    time.sleep(0.3)

#怎么将光标返回去？
f = open('test', 'w', encoding='utf-8')
print(f.tell())      #打印文件光标的位置
print(f.readline().strip())
print(f.readline().strip())
print(f.tell())
f.seek(0)            #将光标移动到某地方
print(f.readline().strip())
print(f.readline().strip())

#文件的编码
print(f.encoding)

#Return the underlying file descriptor (an integer).
print(f.fileno())

#是否是终端设备
print(f.isatty())

#是否可移动
print(f.seekable())

#是否可读
print(f.readable())

#是否可写
print(f.writable())

#判断是否关闭
print(f.closed)

#清空文件
f.truncate(0)

2.3. with open() as f：执行完后整个程序就关闭

2.4.文件的修改：

　　a. 在硬盘中直接修改会覆盖，所以全部加载到内存中修改，修改完成后写回文件；

　　b.修改后写到新文件（边读边修改边写）。

Because i love you.
So i want to hold you.
Because i love you.
So there is nothing i can do.


f = open('profile','r')
f_new = open('rewrite', 'w')
for line in f:
    if "Because i love you." in line:
        line = line.replace("Because i love you.", "Because you are my life.")
    f_new.write(line)
f.close()
f_new.close()


Because you are my life.
So i want to hold you.
Because you are my life.
So there is nothing i can do.

3.编码

暂略

4.全局变量与局部变量

不要在函数内部修改全局变量。（一般都不会这么干，我只是为了强调下一句）

只有字符串，数字简单的不能被修改，复杂的数据结构比如列表，字典，集合等皆可以被修改。

5.递归

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层　　　　　　 栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

def mil(n):
    print(n)
    if int(n/2) > 0:
        return mil(int(n/2))
    print('---',n)
mil(5)

5
2
1
--- 1