python中set函数作用_Python基础之set集合与函数

set集合

集合是一个无序且不重复的元素组合，以大括号表示。使用详情：

>>> b=set(a)>>>type(b)

>>> print(b)

{'hello', 1, 3, 'cc', 'dx'}>>> print(b)

{'hello', 1, 3, 'cc', 'dx'}>>> b.add('world') #添加某元素，参数为元素本身

>>> print(b)

{1, 'world', 'hello', 3, 'cc', 'dx'}

使用说明：

s.add()添加某元素，参数为元素本身

s.clear() 清空集合

>>>b.clear()>>> print(b)

set()

set集合的删除，有三个s.discard(),s.pop(),s.remove()

其中s.discard() 如果集合中无元素，不报错；有元素，就删除

s.pop() 随机删除集合中的某个元素，取到元素后返回元素的值，s.pop()不能加目标元素，故频率略低

s.remove() 删除目标元素，但集合中如无元素，会报错

del 不支持set集合的删除

栗子：

>>> b={'hello', 1, 3, 'cc', 'dx'}>>>type(b)

>>> b.pop('dx')

Traceback (most recent call last):

File"", line 1, in TypeError: pop() takes no arguments (1given)>>>b.pop()　　#随机删除并取到返回值'hello'

>>> print(b)

{1, 3, 'cc', 'dx'}>>> b.remove('cccc')　　#集合中无元素会报错

Traceback (most recent call last):

File"", line 1, in KeyError:'cccc'

>>> b.remove('cc')>>> print(b)

{1, 3, 'dx'}>>> b.discard('cccc')>>> print(b)

{1, 3, 'dx'}>>> b.discard('ccc')　　#集合中无论有无目标元素，均不报错>>> b.discard(1)>>> print(b)

{3, 'dx'}>>>

s.difference(b) 取集合s中有，b中没有的元素，并返回由此元素组成的集合

s.interscetion(b) 交集，两s和b中的交集，返回s,b中都存在的元素组成的集合

new_dict={1:8,2:4,4:2}

old_dict={1:4,2:4,3:2}

new_s=set(new_dict)

old_s=set(old_dict)print(new_s)print(old_s)

in_s=new_s.intersection(old_s)print(in_s)

s_del=new_s.difference(old_dict)print(s_del)

结果：

{1, 2, 4}

{1, 2, 3}

{1, 2}

{4}

s.issubset(b)　　判断s是否是b的子集

s.issuperset(b) 判断s是否是b的父集

栗子：

print(in_s.issubset(new_s))print(new_s.issuperset(in_s))

结果：

True

True

s.intersection_update(b)　　取s和b的交集更新s,s成为新集合，集合为s和b的交集

>>> s={1,2,3,4,56,78}>>> b={7,8,9,67,56,78}>>>s.intersection_update(b)>>> print(s)

{56, 78}>>> print(b)

{67, 7, 8, 9, 78, 56}>>>

s.difference_update(b)　　取s和b的交集，s成为新集合，将交集从s中删除

>>> s={1,2,3,4,56,78}>>> b={7,8,9,67,56,78}>>>b.difference_update(s)>>> print(b)

{67, 7, 8, 9}>>> print(s)

{1, 2, 3, 4, 78, 56}>>>

s.isdisjoint(b)　　判断是否有交集，如果无交集，返回True

>>> print(b)

{67, 7, 8, 9}>>> print(s)

{1, 2, 3, 4, 78, 56}>>>s.isdisjoint(b)

True>>>

s.symmetric_difference(b) 取差集，并创建一个新的集合

>>> s={1,2,3,4,56,78}>>> b={7,8,9,67,56,78}>>>s.symmetric_difference(b)

{1, 2, 67, 3, 4, 7, 8, 9}>>>

s.symmetric_difference_update()　　取差集，并将sf为差集本身赋值为差集本身

>>> s={1,2,3,4,56,78}>>> b={7,8,9,67,56,78}>>>s.symmetric_difference_update(b)>>> print(s)

{1, 2, 3, 4, 67, 7, 8, 9}>>> print(b)

{67, 7, 8, 9, 78, 56}>>>

s.union(b) 并集

>>> print(s)

{1, 2, 3, 4, 67, 7, 8, 9}>>> print(b)

{67, 7, 8, 9, 78, 56}>>>s.union(b)

{1, 2, 3, 4, 67, 7, 8, 9, 78, 56}>>> print(s)

{1, 2, 3, 4, 67, 7, 8, 9}>>> print(b)

{67, 7, 8, 9, 78, 56}>>>

函数

1.作用域

if 1==1:

name='cc'

print(name)

结果：

cc

对于变量的作用域，执行声明并在内存中存在，该变量就可以在下面的代码中使用。

2.三元运算&三目运算

result = 值1 if 条件 else 值2

如果条件为为真，result=值1，如果条件为假，result=值2

python中的三元运算是以bool值求表达的，if...else...的简写。

name = 'alex' if 1==1 else 'sb'

print(name)

结果：

alex

3.lambda

lambda表达式其实就是一个简单的函数：

deff1(a1):return a1+20f2=lambda a1:a1+20 #同f1

f3=lambda a1,a2:a1+a2+20　　#lambda表达式还可使用多个参数res1=f1(10)

res2=f2(10)print(res1)print(res2)print(f3(20,30))

结果：

30

30

70

4.函数

先上一个比较有意思的发送邮件的函数：

defsendmail():try:importsmtplibfrom email.mime.text importMIMETextfrom email.utils importformataddr

msg= MIMEText('邮件内容', 'plain', 'utf-8')

msg['From'] = formataddr(["武沛齐",'wptawy@126.com'])

msg['To'] = formataddr(["走人",'424662508@qq.com'])

msg['Subject'] = "主题"server= smtplib.SMTP("smtp.126.com", 25)

server.login("wptawy@126.com", "WW.3945.5")

server.sendmail('wptawy@126.com', ['3628905@qq.com',], msg.as_string())

server.quit()except:#发送失败

return "失败"

else:#发送成功

return "cc"ret=sendmail()print(ret)if ret == "cc":print('发送成功')else:print("发送失败")

上面函数中，try...except...else 语句，是用来处理python的异常的，然后用return的值判断发送的结果。

函数的调用：如果设定了return值，可将函数直接赋予一个变量，res=sendmail()即可；如果没有设置return值，直接执行sendmail()即可，当然这是使用习惯问题，想怎么用自己尝试吧：）

在函数中，使用return来中断函数，如果没有指定函数的return值，那么他的默认值是None.

deff1():print(123)#在函数中，一旦执行return，函数执行过程立即终止

return "111"

print(456)

r=f1()print(r)

执行结果为：

123

111[Finishedin 0.1s]

结果中并未打印456。

deff2():print(123)

r=f2()print(r)

结果：

123None

[Finishedin 0.1s]

可见函数默认的return值为None

5.函数参数：

函数参数有多种，可分以下几种：

5.1 普通参数　　特点：严格按照参数的顺序，将实际参数赋值给形式参数

5.2 默认参数　　特点：必须放置在参数列表的最后

5.3 指定参数　　特点：将实际参数赋值给指定的形式参数

5.4 动态参数

特点：1.*args，默认将传入的函数，全部放置在元组中，f1(*[11,22,33,44])

2.**args,默认将传入的函数，全部放置在字典中，f1(**{"kl":"v1", "k2":"v2"})

3.*args,多个参数，自动转化为tuple,普通方式都是放于元组中，成为其中一个参数，实际参数中前面加*，将其中的字符串或者列表中的每个元素挑选出来放在元组中

5.5 万能参数　　特点：*args,**kwargs，而且顺序不能变，**kwargs必须在后面

普通参数、动态参数例子：

s1 = "i am {0}, age {1}".format("alex", 18)　　#普通参数print(s1)

s2= "i am {0}, age {1}".format(*["alex", 18])　　#动态参数print(s2)

结果：

i am alex, age 18i am alex, age18[Finishedin 0.1s]

指定参数、动态参数例子：

s1 = "i am {name}, age {age}".format(name='alex', age=18)　　#指定参数print(s1)

dic= {'name': 'alex', "age": 18}

s2= "i am {name}, age {age}".format(**dic)　　#动态参数print(s2)

结果：

i am alex, age18i am alex, age18[Finishedin 0.1s]

万能参数例子：

def f1(*args, **kwargs):print(args)print(kwargs)

f1(k1="v1")

结果：

()

{'k1': 'v1'}

[Finishedin 0.0s]

动态参数：

def f1(*args):print(args, type(args))

f1(11,22,33,44)

li= [11,22,33,44]

f1(*li)

结果：

(11, 22, 33, 44) (11, 22, 33, 44) [Finishedin 0.1s]

动态参数：

def f(*args):print(type(args),args)

f('alex')

f([1,1,2,3,4,])

f('alex','cc')

f([1,2,4,6,8,],'alex')

f(*[12,4,6,7,],'alex')

结果： ('alex',) ([1, 1, 2, 3, 4],) ('alex', 'cc') ([1, 2, 4, 6, 8], 'alex') (12, 4, 6, 7, 'alex')

s1='I am {0},age {1}'.format('chengc',18)print(s1)

s2='I am {0},age {1}'.format(*['cc',32,])print(s2)

s3='I am {name},age {age}'.format(name='cc',age=21)print(s3)

s4='I am {name},age {age}'.format(**{'name':'chengc','age':17})print(s4)

结果：

I am chengc,age18I am cc,age32I am cc,age21I am chengc,age17

动态参数、指定参数：

def f1(**args):print(args, type(args))

f1(n1="alex", n2=18)

dic= {'k1': "v1", "k2":"v2"}

f1(kk=dic)

dic= {'k1': "v1", "k2":"v2"}

f1(**dic)

结果：

{'n1': 'alex', 'n2': 18} {'kk': {'k2': 'v2', 'k1': 'v1'}} {'k2': 'v2', 'k1': 'v1'} [Finishedin 0.1s]

默认参数：

defsend(ooxx,content,xx):print(ooxx,content,xx)return0

send('water','sdsdf','ddd')

结果：

water sdsdf ddd

[Finishedin 0.1s]

默认参数必须放在最后，默认参数也可被实际参数覆盖

def send(ooxx,content,xx='bye'):print(ooxx,content,xx)return0

send('water','sdsdf','exe')

结果：

water sdsdf exe

[Finishedin 0.1s]

万能参数：

def f(*args,**kwargs):print(args)print(kwargs)

f(12,4,5,6,k1='v1',k2='v2')　　#注意，k1 k2未带引号

结果：

(12, 4, 5, 6)

{'k1': 'v1', 'k2': 'v2'}

[Finishedin 0.1s]

6. 函数参数的传递

函数参数传递时用的是引用，举个栗子：

deff(a1):

a1.append(9999)

li=[12,3,4,5]

f(li)print(li)

结果：　　　　#注意，已将li列表增加了9999元素，

[12, 3, 4, 5, 9999]

参数引用栗子1：

NAME_LI=[1,2,3,4]

def f():

NAME_LI.append('chengc')

# global NAME_LI

# NAME_LI={'k1':'V1'}

print(NAME_LI)

res=f()

print(res)

print(NAME_LI)

结果：　　#参数引用，已修改

[1, 2, 3, 4, 'chengc']

None

[1, 2, 3, 4, 'chengc']

上面的例子和参数的引用是一码事，栗子2：

deff(a1):

a1.append(9999)

name=[12,3,4,5]

f(name)print(name)

结果：　　#注意这个改变了，但f()中为参数，

[12, 3, 4, 5, 9999]

[Finishedin 0.1s]

跟下面的效果也一样，栗子3：

deff(name):

name.append(9999)

name=[12,3,4,5]

f(name)print(name)

结果：

[12, 3, 4, 5, 9999]

7. 函数的全局变量

全局变量，在所有函数中的的作用域都可读，全局变量一般用全部大写命名，比如NAME,AGE等。

在作用域中，如果想对全局变量重新赋值，需要用“global”关键字。

需要特殊注意的一点：如果全局变量的类型为列表字典等，可修改，但不可以重新赋值。（与global无关），栗子2里有。

栗子1：

NAME_LI=[1,2,3,4]deff():globalNAME_LI

NAME_LI={'k1':'V1'}print(NAME_LI)

res=f()print(res)print(NAME_LI)

结果：

{'k1': 'V1'}

None

{'k1': 'V1'}

说明：global可改全局变量

栗子2：

NAME_LI=[1,2,3,4]deff():

NAME_LI.append('chengc')

NAME_LI={'k1':'V1'}print(NAME_LI)

res=f()print(res)print(NAME_LI)

结果：

File"/Users/shane/PycharmProjects/Py_study/Base/S3/s3.py", line 42, in res=f()

File"/Users/shane/PycharmProjects/Py_study/Base/S3/s3.py", line 36, inf

NAME_LI.append('chengc')

UnboundLocalError: local variable'NAME_LI' referenced before assignment

报错了！说明：作用域中，既使用了全局变量，又想对全局变量重新赋值，是不被允许的。

8. 函数执行时，如果有多次同样函数名称的def，以最后一次定义的为准。

这个理解起来简单，都是按顺序执行的，所以就不列例子了。