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

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

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

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

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

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

#普通参数，实参严格按照书序传递给形参
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‘} #输出

#第一种，传单个元素
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():
    ...
f1() #调用f1函数时只会调用后一个

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

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

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