上节课复习：
    1.总结
        可变/不可变：
            可变类型：list,dict
            不可变类型：int,float,str,tuple
         存值的个数：
             存一个值：int,float,str
             存多个值：list,dict,tuple
         访问方式：
             只能通过变量名直接访问：int,float
             可以通过索引访问（有序/序列）：str,list,tuple
             可以通过key访问：dict
            
          for:重复取值
          while:重复做事
   
    2.字符编码
        内存中统一使用unicode,特点是：
            1.兼容万国字符
            2.与其他国家编码都有对应关系
         保证不乱码的关键：
            1.采用的字符编码表能够兼容你要存放的字符
            2.字符用什么编码标准存放的，就该用什么编码标准取解码
      python2:ASCII
      python3:utf-8
      在文件头：
          #coding:gbk
      python3: str类型是unicode编码的
      python2: str类型是unicode.encode('文件头指定的编码')之后的结果
              x=u'你'：存成unicode

今日内容：
    1.集合
    2.文件处理
    3.函数
        1.什么是函数
        2.为何用函数
        3.函数的分类，如何用函数
        4.定义函数
        5.调用函数
        6.形参与实参的详细作用（！！）
        7.函数对象
        8.函数嵌套
        9.名称空间与作用域（！！）

一.集合

类型：
  作用：
    1.去重
    2.关系运算（集合设计之初用于关注群体间的关系，而非个体）
    定义：逗号分隔开多个元素
  注意：
    1.每一个元素都必须是不可变类型
    2.集合内的元素不能重复
    3.集合内元素无序，不支持索引
   
    优先掌握：
    1.集合的定义及注意点
    2.集合的关系运算
    3.len, in， not ,in
    4.for循环遍历集合
    需要掌握：
    1.集合的去重以及局限性
    2.往集合内添加或删除元素，add,update,pop,remove,discard

pythoners=['tom','alex','andy','rocky','lily']
linuxers=['walter','tao','karen','andy','alex']
l=[]
for item in pythoners:
if item in linuxers:
l.append(item)
print (l)

输出： # ['alex', 'andy']

#去重
#局限性：
#1.不能保证原来的顺序
#2.不能针对可变类型去重
l=[1,1,1,1,'andy','tom']
s=set(l)
print(s)
l=list(s)
print(l)

输出：

{1, 'andy', 'tom'}
[1, 'andy', 'tom']

l=[1,1,1,1,'andy','tom']
for item in s:
print(item)

输出：

1
andy
tom

#需求：
#1.列表内的元素有可变类型
#2.去重之后要保证原来的顺序
info=[
{'name':'andy','age':''},
{'name':'tom','age':''},
{'name':'alex','age':''},
{'name':'andy','age':''},
{'name':'andy','age':''}
]
l=[]
for dic in info:
if dic not in l:
l.append(dic)
info=l
print(info)

输出：

[{'name': 'andy', 'age': '18'}, {'name': 'tom', 'age': '23'}, {'name': 'alex', 'age': '36'}, {'name': 'andy', 'age': '20'}]

#关系运算
pythoners={'tom','alex','andy','rocky','lily'}
linuxers={'walter','tao','karen','andy','alex'}

#1.求既报名linux又报名oython的学员名单
print(pythoners&linuxers)
#2.只报名python, 没有报名linux的学员名单，即集合pythoners-linuxers,差集
print(pythoners-linuxers)
#3.只报名linux, 没有报名python的学员名单，即集合linuxers-pythoners,差集
print(linuxers-pythoners)
print(linuxers.difference(pythoners))
#4.求所有报名学员名单，求并集
print(pythoners|linuxers)
print(pythoners.union(linuxers))
#5.求没有同时报名两门课程的学院奖名单，对称差集
print(pythoners^linuxers)

输出：

{'andy', 'alex'}
{'rocky', 'lily', 'tom'}
{'karen', 'walter', 'tao'}
{'karen', 'walter', 'tao'}
{'tao', 'rocky', 'lily', 'tom', 'karen', 'andy', 'walter', 'alex'}
{'tao', 'rocky', 'lily', 'tom', 'karen', 'andy', 'walter', 'alex'}
{'karen', 'tao', 'walter', 'rocky', 'lily', 'tom'}

#集合的其他方法：
s1={1,2,3,4,5,}
s1.add(6)
print(s1)
s2={3,4}
s1.difference(s2)
#差集取到后更新s1的值
s1.difference_update(s2)
print (s1)
#删除某个值
s1.discard(2)
print(s1)
#验证是否有共同部分
s3={6,7}
print(s1.isdisjoint(s3))
#删除
print(s1.pop()) #随机删除
s1.discard(33333)#指定元素，若不存在也不报错
s1.remove(333)#指定元素，若不存在则报错
#更新
s1.update('hello')
print(s1)

输出：

{1, 2, 3, 4, 5, 6}
{1, 2, 5, 6}
{1, 5, 6}
False
1
{5, 6}

二.文件处理

1.什么是文件
    文件是操作系统为应用程序或用户提供的一个操作硬盘的虚拟单位
2.为什么要用文件
    应用程序中需要经常将内存的数据永久保存下来，而应用程序又无法直接操作硬盘，只能通过操作系统提供的单位去间接地操作硬盘
3.如何用文件

向操作系统发送打开文件的请求

r:原生打开文件，不转义
f=open(r'D:\tools\a.txt',mode='r')
f=>应用程序中的一个值=>OS打开的文件a.txt=>硬盘中的一块空间

data=f.read()
总结：文件处理步骤
1.打开文件
2.读/写文件
3.关闭文件
上下文自动管理工具,code1运行完后会自动关闭文件并可以同时打开很多文件。
wirh open(r'D:\tools\a.txt',mode='r') as f,\
     open (r'D:\tools\b.txt',mode='r') as f1:
     code1
文件的打开模式：
r:只读模式（默认的）
w:只写模式
a:只追加写

控制操作文件内容模式有两种：（不能单独使用，必须与r,w,a连用）
t:text文本模式（默认的），该模式下操作文件内容的单位都是字符串，该模式只适用于文本文件
    强调：该模式下必须指定encoding="某种字符编码"
b:bytes二进制模式，该模式下操作文件的内容单位都是bytes,该模式适用于所有就类型的文件

#r模式
with open('a.txt',mode='rt',encoding='uth-8') as f:
data1=f.read()
print('First:',data1)
data2=f.read()
print('Second',data2)

 print(f.readable())  
 print(f.writable())  
 f.write('hello')

 line1=f.readline()  
 print(line1,end='')  
 print('===>')  
 line2 = f.readline()  
 print(line2,end='')

 l=f.readlines()  
 print(1,type(1))

输出：

First: 你好啊
aa
wco
Second

#w模式：只写模式
#文件不存在则创建一个空文件，并且文件指针跳到文件的开头
#文件存在，会将内容清空，并且文件指针调用到文件开头
#强调：1.如果每次打开都是重新打开文件，那么文件内容总会被清空
# 2.如果在打开文件不关闭的情况下，连续写入，本次写入会跟着上次写入
with open('b.txt',mode='wt',encoding='utf-8') as f:
print(f.readable)
list=['\naa\n','bb\n','cc\n','dd\n']
f.write('你好')
f.write('我的天')
for line in list: #法一：for写入
f.write(line)
#f.writelines(list) #法二：批量写入

输出：

#a模式：只追加写模式
#文件不存在则
with open('b.txt',mode='at',encoding='utf-8') as f:
print(f.readable())
print(f.writable())
f.write('你好\n')
f.writelines(['aaa\n','bbb\n'])

输出：

False
True

#b模式：bytes二进制模式，该模式下操作文件内容单位都是bytes.
#强调：一定不能指定encoding参数
with open('1.mp4',mode='rb') as f:
data=f.readline()
print(data,type(data))

with open('d.txt',mode='rb') as f:
data=f.read()
print(data,type(data))
res=data.decode('utf-8')
print(res)

with open('d.txt','wb') as f
f.write('hahahahah')

#遍历文件内容的方式
with open('d.txt',mode='rt',encoding='utf-8') as f:
for line in f:
print(line,end='') #取消默认换行符

#文件内指针操作（掌握）
#f.seek：单位统一是字节
#第一个参数：控制移动的字节数
#第二个参数：控制移动的参照物，值可以是0，1，2
#0：参照文件开头(b和t模式都能用)
#1：参照当前位置(只能在b模式用)
#2：参照文件末尾(只能在b模式用)
with open('a.txt','rt',encoding='utf-8') as f:
f.seek(3,0) #单位是字节
print(f.read())
f.read()
f.seek(0,0)
print('第二次',f.read())

输出：

hggg
第二次 ddd
hggg

#参照当前位置
#储备：read(n)
#read的n在t模式下代表字符个数
#read的n在b模式下代表字节个数
#其余都是字节

with open('a.txt','rt',encoding='utf-8') as f:
s=f.read(1)#指针在第三个bytes
print(s)
f.seek(6.0)
print(f.read())

输出：

d
ggg

#文本编辑器修改文件原理：
#优点：修改期间硬盘上同一时刻只有一份数据
#缺点：占用内存过高
with open('a.txt',mode='rt',encoding='utf-8') as f:
data=f.read()
new_data=data.replacce('a','b')
print(new_data)

with open('a.txt',mode='wt',encoding='utf-8') as
f.wirte(new_data)

#一行一行地读，一行一行地改：
#以只读方式打开源文件，以写模式打开一个临时文件
#然后for循环读取一行行内容，每读一行改一行，将修改结果写入临时文件，直至遍历完
#删除源文件，将临时文件重命名为原文件名
#缺点：占用2份硬盘空间
with open('a.txt',mode='rt',encoding='utf-8') as src_f:\
open('.a.txt.swap',mode='rt',encoding='utf-8') as tmp_f:\
for line in src_f:
if 'alex' in line:
line=line.replace('alex','alexsb')
temp_f.write(line)
print(line)
os.remove('a.txt')
os.remove('.a.txt.swap','a.txt')

三.函数
1.什么是函数
    函数是具备某一功能的工具
    函数的使用必须遵循先定义后调用的原则
    事先准备工具的过程即函数的定义
    拿来就用即函数的调用
    函数分为两大类：
        a.内置函数
        b.自定义函数
2.为何要用函数
    2.1 程序的组织结构不清晰，可读性差
    2.2 日积月累，冗余代码太多
    2.3 程序的可扩展性极差
3.怎么用
    1).定义函数：只检测语法，不执行代码
    a.语法
    def 函数名（参数1，参数2，参数3）
        """
        文档注释
        """
        code1
        code2
        code3
        …
        return 返回值
    b.
    c.定义函数的三种方式
        无参函数
        def func1(): #func1=函数的内存地址
            print('hello1')
        有参函数
         def func2(x,y):
            print('hello1')
        空函数
        def func3()
            pass

    2).调用函数
    a.语法：函数名()
    b.调用函数的过程
        i,根据函数名找到函数的内存地址
        ii,函数的内存地址加括号触发函数体代码的运行
    c.调用函数的三种方式
        i,语句
        ii,表达式形式
        iii,当作参数传给其他函数
    3).函数的返回值
       函数体代码运行的一个成果
       什么时候用函数的返回值？
       如何用返回值
       return 值：
       1. 返回值没有类型限制
       2. 返回值没有个数限制
           逗号分隔多个值时，返回一个元组
           没有return,默认返回None

#示范一
def bar():
print('from bar')
def foo():
print('from foo')
bar()
foo()

输出：

from foo
from bar

#示范二
def foo():
print('from foo')
bar()
def bar():
print('from bar')
foo()

输出：

from foo
from bar

#示范三
def foo():
print('from foo')
bar()
foo()
def bar():
print('from bar')

输出：

from foo
from bar

#函数调用:表达式形式
def max(x,y):
if x>y:
return x
else:
return y
res=max(1,2)
print(res)

输出：

2

#函数调用:当作参数传给其他函数
def max(x,y):
if x>y:
return x
else:
return y
res=max(max(1,2),3)
print(res)

输出：

3

#return是函数结束的标志
#函数内可以有多个return,但只要执行一次，函数体则结束
def f1():
print(1)
return 'aa'
print(2)
return 'bb'