Python基础之set集合与函数

set集合

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

>>> b=set(a)
>>> type(b)
<class ‘set‘>
>>> 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)
<class ‘set‘>
>>> b.pop(‘dx‘)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: pop() takes no arguments (1 given)
>>> b.pop()　　#随机删除并取到返回值
‘hello‘
>>> print(b)
{1, 3, ‘cc‘, ‘dx‘}
>>> b.remove(‘cccc‘)　　#集合中无元素会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
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表达式其实就是一个简单的函数：

def f1(a1):
    return a1+20
f2=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.函数

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

def sendmail():
    try:
        import smtplib
        from email.mime.text import MIMEText
        from email.utils import formataddr
        msg = MIMEText(‘邮件内容‘, ‘plain‘, ‘utf-8‘)
        msg[‘From‘] = formataddr(["武沛齐",‘[email protected]‘])
        msg[‘To‘] = formataddr(["走人",‘[email protected]‘])
        msg[‘Subject‘] = "主题"

        server = smtplib.SMTP("smtp.126.com", 25)
        server.login("[email protected]", "WW.3945.5")
        server.sendmail(‘[email protected]‘, [‘[email protected]‘,], 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.

def f1():
    print(123)
    # 在函数中，一旦执行return，函数执行过程立即终止
    return "111"
    print(456)

r = f1()
print(r)

执行结果为：

123
111
[Finished in 0.1s]

结果中并未打印456。

def f2():
    print(123)

r = f2()
print(r)

结果：

123
None
[Finished in 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 18
i am alex, age 18
[Finished in 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, age 18
i am alex, age 18
[Finished in 0.1s]

万能参数例子：

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

f1(k1="v1")

结果：
()
{‘k1‘: ‘v1‘}
[Finished in 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) <class ‘tuple‘>
(11, 22, 33, 44) <class ‘tuple‘>
[Finished in 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‘)

结果：
<class ‘tuple‘> (‘alex‘,)
<class ‘tuple‘> ([1, 1, 2, 3, 4],)
<class ‘tuple‘> (‘alex‘, ‘cc‘)
<class ‘tuple‘> ([1, 2, 4, 6, 8], ‘alex‘)
<class ‘tuple‘> (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,age 18
I am cc,age 32
I am cc,age 21
I am chengc,age 17

动态参数、指定参数：

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} <class ‘dict‘>
{‘kk‘: {‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘}} <class ‘dict‘>
{‘k2‘: ‘v2‘, ‘k1‘: ‘v1‘} <class ‘dict‘>
[Finished in 0.1s]

默认参数：

def send(ooxx,content,xx):
    print(ooxx,content,xx)
    return 0
send(‘water‘,‘sdsdf‘,‘ddd‘)

结果：
water sdsdf ddd
[Finished in 0.1s]

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

def send(ooxx,content,xx=‘bye‘):
    print(ooxx,content,xx)
    return 0
send(‘water‘,‘sdsdf‘,‘exe‘)

结果：
water sdsdf exe
[Finished in 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‘}
[Finished in 0.1s]

6. 函数参数的传递

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

def f(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：

def f(a1):
    a1.append(9999)
name=[12,3,4,5]
f(name)
print(name)

结果：　　#注意这个改变了，但f()中为参数，
[12, 3, 4, 5, 9999]
[Finished in 0.1s]

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

def f(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]
def f():
    global NAME_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]
def f():
    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 <module>
    res=f()
  File "/Users/shane/PycharmProjects/Py_study/Base/S3/s3.py", line 36, in f
    NAME_LI.append(‘chengc‘)
UnboundLocalError: local variable ‘NAME_LI‘ referenced before assignment

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

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

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

时间： 2024-08-23 15:53:22

Python基础之set集合与函数的相关文章

Python基础中的集合，函数——06

集合 python中的集合由不同的元素组成(去重,没有重复的元素) s = set('hello') print(s) #结果是: s = {'h', 'o', 'e', 'l'} 集合中的元素是无序排列的每个元素必须是不可变类型(如:数字.字符串.元组) 增加集合元素 s.add(3) 清空集合 s.clear() 删除集合元素 s.pop()#随机删除 s.remove(3)#指定删除,不存在该元素时删除会报错 s.discard(3)#指定删除,不存在该元素时不会报错集合的关系运算

python 全栈 python基础（十三）匿名函数与内置函数

一.匿名函数 1.定义: 匿名函数顾名思义就是指:是指一类无需定义标识符(函数名)的函数或子程序. 2.语法格式:lambda 参数:表达式 lambda语句中,开头先写关键字lambda,冒号前是参数,可以有多个,用逗号隔开:冒号右边的为表达式,需要注意的是只能有一个表达式.由于lambda返回的是函数对象(构建的是一个函数对象),所以需要定义一个变量去接收. 3.注意点:lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值.lambda 函数不能包含命令,包含

python基础知识（集合）

在python中集合set是一种基本数据的类型,它有可变集合(set())和不可变集合(frozenset)两种.创建集合set.集合set添加.集合删除.交集.并集.差集的操作都是非常实用的方法,接下来将介绍结合的相关知识. 一.集合特点 1.类似字典dict,但是只有key却没有value值: 2.集合的存储没有固定的顺序 3.由于集合里面的元素不能重复所以集合一般用来去重二.集合的定义常见的有两种方法 1.直接定义类似字典但是没有value值,例如 set1={"openatck&qu

Python 全栈开发二 python基础字符串字典集合

一.字符串 1,在python中,字符串是最为常见的数据类型,一般情况下用引号来创建字符串. 1 >>ch = "wallace" 2 >>ch1 = 'wallace' 3 >>ch2 = ''' 4 wallace 5 wallace 6 wallace 7 ''' 8 #以上三种引号都可以定义一字符串, 9 #三引号定义的字符串可以换行注意:字符串是不可变的数据类型,关于可变与不可变将会在后文解释. 2,转义字符在python中有一些字符是

3.python基础补充（集合，collection系列，深浅拷贝）

一.集合 1.集合(set): 把不同的元素组成一起形成集合,是python基本的数据类型.集合元素(set elements):组成集合的成员 python的set和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算. sets 支持 x in set, len(set),和 for x in set.作

python基础（八）：函数

函数就是将一些语句集合在一起的部件,他们能够不止一次的程序中运行,函数还能够计算出一个返回值,并能够改变作为函数输入的参数.而这些参数在代码运行时每次都不同.以函数的形式去编写一个操作可以使它成为一个广泛的应用工具. 基本格式: def 函数名: 函数体 return 返回值定义和调用定义函数按照前面的基本格式定义函数,调用函数时要使用函数名加括号来调用函数,括号中可以包含一个或多个参数.这些参数将会传递给函数头部的参数名. #定义 def test(x,y): return x*y #调用

Python基础(五)：变量、函数和类

现在的编程思想的核心都是面向对象,而变量.函数和类就是面向对象的基础, 类类是一些具有相似属性和功能的对象集合,如果我们把类比作制作手机的模具,那么通过这个模具,我们可以生产出大批量具有相同功能和属性的手机. 定义类的关键字:class 所有的class默认继承于object,我们来写一个手机类, class Phone(object): pass 注意:括号里的object可以省略. 那么如何通过类创建一个实例对象呢?如下: phone_01 = Phone() 函数函数是一个功能点的具体

Python基础知识（2）——函数

Python函数全球变量 < 局部变量传参方法: 位置传参和关键字传参(常用关键字传参) 函数里定义参数默认值需放在最后错误的 Def func_name(arg=100,arg1,arg2,arg,3): 正确的 Def func_name(arg1,arg2,arg,3,arg=100): 可变位置函数(所谓的可变是指传参数量可变)Def func_name(*arg): 打包-->元组可变关键字函数 Dfe func_name(**kwarg): 打包--&g

Python基础（6）_函数

一为何要有函数? 不加区分地将所有功能的代码垒到一起,问题是: 代码可读性差代码冗余代码可扩展差如何解决? 函数即工具,事先准备工具的过程是定义函数,拿来就用指的就是函数调用结论:函数使用必须是:先定义,后调用 python中函数定义方法: def test(x): "The function definitions" x+=1 return x def:定义函数的关键字 test:函数名 ():内可定义形参 "":文档描述(非必要,但是强烈建议为你的函数