集合、函数、、三目运算、lambda、文件操作

1、set集合：

•集合的创建;

set_1 = set() #方法一
set_1 = {‘‘} #方法二

•set是无序，不重复的集合;

set_1 = {‘k1‘,‘k2‘,‘k3‘}
set_1.add(‘k1‘) #往集合set_1中添加元素
set_1 = {‘k1‘,‘k2‘,‘k3‘}

•set也可以直接将字典中的key给过滤出来放在集合中;

dic_1 = {‘k1‘:1,‘k2‘:2}
set_2 = set(a) #将字典a中的键放入集合b中
set_2 = {‘k1‘,‘k2‘}

•集合有如下的操作方法，add、clear、copy、difference、difference_update、discard、intersection、intersection_update、 union、update等

set_1 = {1,2,3,4}
set_2 = {2,3,4,5}
#add,集合中添加元素
set_1.add(5)
set_1 = {1,2,3,4,5}
#clear,清除集合的元素
set_1.clear()
set_1 = set()
#difference,找出两个集合中前一个独有的元素
set_3 = set_1.difference(set_2)
set_3 = {1}
#difference_update,找出两个集合中前一个独有的元素，并且重新赋值给第一个集合
set_1.difference_update(set_2)
set_1 = {1}
#discard,删除集合中的元素
set_1.discard(1)
set_1 = {2,3,4}
#intersection,找出两个集合中的共有元素
set_3 = set_1.intersection(set_2)
set_3 = {2,3,4}
#intersection.update,找出两个集合中的共有元素，并且重新赋值给第一个集合
set_1.intersection_update(set_2)
set_1 = {2,3,4}
#union,将两个集合合并成一个新的集合
set_3 = set_1.union(set_2)
set_3 = {1,2,3,4,5}
#update,更新第一个集合
set_1.update(set_2)
set_1 = {1,2,3,4,5}
#symmetric_difference,取出两个集合的差集
set_3 = set_1.symmetric_difference(set_2)
set_3 = {1,5}
#symmetric_difference_update,取出两个集合的差集，并且重新赋值给第一个集合
set_1.symmetric_difference_update(set_2)
set_1 = {1,5}
#issuperset,判断第一个集合是否为第二个集合的父集，返回True或者False
set_1 = {1,2,3}
set_2 = {2,3}
judge = set_1.issuperset(set_2)
judge = True
#issubset,判断第一个集合是否为第二个集合的子集，返回True或者False
set_1 = {1,2,3}
set_2 = {2,3}
judge = set_2.issubset(set_1)
judge = True
#isdisjoint,判断两个集合是否相交，相交返回False，否则True
set_1 = {1,2,3}
set_2 = {2,3,4}
set_3 = {4,5,6}
judge = set_1.isdisjoint(set_2)
judge = False
judge = set_1.isdisjoint(set_3)
judge = True

•注意：集合set中只能放str，int，tuple，不能放list，dict

2、函数部分：

•函数式编程和面向对象编程的区别：函数式编程将功能代码封装在函数中，进行其它代码的时候可以调用其功能，无序重复；面向对象对函数进行分类和封装，使其发挥更大的功能

•函数的定义

def main(参数): #def是定义函数的关键字，创建函数名为main的函数，
    函数体
    ...
    ...
    返回值

函数体不执行，只有当函数调用的时候函数体才会执行;

•函数中的参数说明

①普通参数，严格按照顺序，将实际参数赋值给形式参数;

②默认参数，必须放在形式参数列表的最后;

③指定参数，将实际参数赋值给指定的形式参数;

④动态参数，

*，默认将传入的参数全部放在tuple中;

**，全部放在字典中

动态参数*：形式参数前加*，表示可以添加n个参数，将这些参数放在一个tuple中;

形式参数和实数参数前面都加*，一个for循环，将每个元素转换到tuple里面;

形式参数前加**，传字典，用指定参数传值

形式参数和实数参数前面都加**，是一个直接的赋值

⑤万能参数，def fa(*a，**b)，一定是*在前，**在后;

#普通参数，实参严格按照书序传递给形参
def send(name,age):
    print(name,‘is‘,age)
send(‘alex‘,‘31‘)
alex is 31 #输出
#默认参数，必须放在形参的末尾
def send(name,age,job=‘it‘,): #默认参数必须放在末尾，否则报错
    print(name,‘is‘,age,‘job is‘,job)
send(‘alex‘,‘31‘)
alex is 31 job is it #输出
#指定参数，将实际参数赋值给形式参数
def send(name,age):
    print(name,‘is‘,age)
send(age=31,name=‘alex‘) #顺序无所谓，指定形参直接赋值
alex is 31 #输出
#动态参数
#第一种，传tuple
def send(*arg): #默认将传入的实参放在tuple中，可以传递n个实参
    print(arg)
send(‘alex‘,31)
(‘alex‘,31) #输出
def send(*arg): #在形参和实参前面同事添加*，表示用for循环每个实参元素到tuple里面
    print(arg)
send(*‘alex‘,31,38)
(‘a‘,‘l‘,‘e‘,‘x‘,31,38) #输出
#第二种，传dict
def send(**arg): #默认将实参放在地点中，实参需要指定键和值
    print(arg)
send(name=‘alex‘,age=31)
{‘name‘:‘alex‘,‘age‘:31} #输出
def send(**arg): #实参直接传一个字典给形参
    print(arg)
dic = {‘name‘:‘alex‘,‘age‘:31}
send(**dic)
{‘name‘:‘alex‘,‘age‘:31} #输出
#万能参数
def send(*arg,**args): #一定是*在前，**再后
    print(arg,args)
dic = {‘name‘:‘alex‘,‘age‘:31}
send(31,32,name = ‘alex‘,age = 31)
(31, 32) {‘age‘: 31, ‘name‘: ‘alex‘} #输出

⑥str.format(*,**)格式化输出，参数传递的是tuple和dict

#第一种，传单个元素
msg = ‘i am {0},age is {1}‘.format(‘alex‘,31)
print(msg)
i am alex,age is 31 #输出
#第二种，传列表
msg = ‘i am {0},age is {1}‘.format(*[‘alex‘,31])
print(msg)
i am alex,age is 31 #输出
#第三种，传指定参数
msg = ‘i am {name},age is {age}‘.format(name=‘alex‘,age=31)
print(msg)
i am alex,age is 31 #输出
#第四种，传字典
msg=‘i am {name},age is {age}‘.format(**{‘name‘:‘alex‘,‘age‘:31})
print(msg)
i am alex,age is 31 #输出

•内存回收机制，def f1();def f1()

def f1():
    ...
def f1():
    ...
f1() #调用f1函数时只会调用后一个

•注意：在函数传递的时候传递的是一个引用还是重新赋值？是引用！

•全局变量的把握

函数体自身的创建的变量只能自己用；函数体可以使用全局变量；所有作用域都可读，先读自己的，自己的没有再读全局的；

在函数局部中想要修改全局变量，global name，对name重新赋值

特殊：列表字典，可修改不可重新赋值，要重新赋值要用global

注意：定义全局变量一定要大写！

3、三目运算（三元运算）：

对if,else的一个简写

#先判断if与else之间的条件是否成立，如果成立则if前面的表达式成立，不成立则else后面的表达式成立
name = ‘alex‘ if 1 == 1 else ‘sb‘
print(name)

4、lambda表达式：只能用一行来表示

f2 = lambda a1 : a1 + 100隐藏return

f2：函数名

a1：形参

剩余为函数体

def f1(a1):

　　return a1 + 100

name = lambda user_name : print(user_name)
name(‘alex‘)
#输出
alex

5、内置函数：

pass

0，None,‘‘,[],(),{}都是False

bool布尔值

utf-8 一个汉字三个字节

gbk 一个汉字二个字节

字符串转换字节用bytes,encoding;表现形式是字节，底层是二进制

字节转化为字符串用str

6、文件操作

•文件操作一般经过如果两种步骤：

打开文件；操作文件

文件句柄 = open(‘文件路径‘,‘模式‘)

将文件句柄定义为f，当操作完成自己自动关闭

•文件的模式有如下几种

r：只读模式;

w:只写模式，每次会重写文件;

x：只写模式，不存在则创建，存在则报错;

a:追加模式，不存在则创建，存在则追加;

rb:表示对字节操作;

wb:表示对字节操作;

xb:表示对字节操作;

ab:表示对字节操作;

注意：当以字节方式打开文件时，你写入该文件的方式也应该是字节

•方便管理上下文的方法：，为了避免文件打开后忘记关闭;

with open(‘文件‘) as f:

　　pass

seek始终以字节的方式去寻找

tell获取当前指针的位置