从零开始的Linux运维屌丝之路,资源免费分享平台   运维人员首选:简单、易用、高效、安全、稳定、社区活跃的开源软件

27、python函数-内置函数

发布:蔺要红05-07分类: Python



python的len,abs,str可以直接使用、是因为解释器启动的时候就定义好了。
 
内置函数
abs() dict() min() max() bool()
all() any() dir()     vars() hex() slice()
divmod() id() sorted() enumerate() input()
staticmethod()   object() ascii oct()
bin() eval() exec() int() open()
str() isinstance() ord() chr() sum()
bytearray() map() filter() reduce() issubclass()
list() pow() super() bytes() float()
iter() print() tuple() callable() format()
len() property() type() frozenset() range()
classmethod() hash() locals() globals() repr()
zip() compile() reversed __import__() complex()
round() hasattr() delattr setattr() getattr()
memoryview() set      


参考:https://www.runoob.com/python/python-built-in-functions.html 
 
 

abs()函数  取绝对值

 
# -*- coding:utf-8 -*-
def func(x,y):
    return abs(x+y) #abs 取绝对值
print(func(9,-10))

D:\python\python.exe F:/运维笔记/python/函数/函数内置方法.py
1
 

dict()函数  把一个数据转成字典

 
>>> dict()    #函数用于创建一个空字典
{}
>>> dict(a='1',b='2',c='3')  
{'c': '3', 'a': '1', 'b': '2'}
>>> m = dict(a='1',b='2',c='3')        # 传入关键字
>>> m
{'c': '3', 'a': '1', 'b': '2'}

>>> n = dict(zip(['a','b','c'],[1,2,3])) # 映射函数方式来构造字典
>>> n
{'c': 3, 'a': 1, 'b': 2}
>>> L = dict([('a',1),('b',2),('c',3)])   # 可迭代对象方式来构造字典
>>> L
{'c': 3, 'a': 1, 'b': 2}
 


max()函数 返回给固定参数的最大值,参数可以为序列
min()函数 返回给固定参数的最小值,参数可以为序列

 
>>> a = [1,4,5,-1,2]
>>> min(a)
-1
>>> max(a)
5
>>> min(55,30,20)
20
>>> max(55,30,20)
55
 


bool()函数
all()  函数  all(iterable)  元祖或列表

 
>>> help(bool)
Help on class bool in module builtins:

class bool(int)
 |  bool(x) -> bool     
 |  
 |  Returns True when the argument x is true, False otherwise.
 #当参数x为真时,|返回True,否则返回False。
 |  The builtins True and False are the only two instances of the class bool.
 |  The class bool is a subclass of the class int, and cannot be subclassed.
 |  
 |  Method resolution order:
 |      bool
 |      int
 |      object
 |  
>>> bool(False)
False
>>> bool(0)   
False
>>> bool(1)
True
>>> bool(-1)
True
#--------------------------------
>>> all([1,4,5,-1,2])
True
>>> all([1,4,5,-1,2,'0'])  #'0' 为字符串不是 0
True
>>> all([1,4,5,-1,2,'0',0]) #包含0 所以返回False
False
>>> all([1,4,5,-1,2,'0',False])   #包含False 所以返回False
False




#总结all()函数 返回值中包含 0和False包含任意一个即返回False
#判断空列表
>>> bool([])
False
>>> all([])
True
#--------------------------------------------------------------------------
>>> help(all)
Help on built-in function all in module builtins:

all(iterable, /)
    Return True if bool(x) is True for all values x in the iterable.
    
    If the iterable is empty, return True.
 


any()  函数 
iterable 元祖或列表

用于判断给定的可迭代参数 iterable 是否全部为 False,则返回 False,如果有一个为 True,则返回 True。
元素除了是 0、空、FALSE 外都算 TRUE

 
>>> any([1, 4, 5, -1, 2])
True
>>> any([1, 4, 5, 0, 2])
True
>>> any([1, 4, 5, -1, 2])
True
>>> any([0,False])
False
>>> any([0,False,1])  #对于bool()有一个True即返回True
True
#--------------------------------------------------------
>>> help(any)
Help on built-in function any in module builtins:

any(iterable, /)
    Return True if bool(x) is True for any x in the iterable.
    
    If the iterable is empty, return False.
 

dir() 函数 打印当前程序的所有变量
vars() 函数 打印当前程序所有的变量, 包含变量内容   和dir的区别

 
>>> a = 10
>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a']
>>> vars()
{'__doc__': None, '__spec__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__package__': None, 'a': 10, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__'}
 

hex() 函数 打印16进制
         返回16进制数,以字符串形式表示

 
>>> hex(15)
'0xf'
>>> hex(16)
'0x10'
 

slice() 函数 打印16进制
函数实现切片对象,主要用在切片操作函数里的参数传递(了解即可)

 
>>> s=slice(5)
>>> s
slice(None, 5, None)
>>> l = list(range(10))
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> l[s]
[0, 1, 2, 3, 4]
 


divmod() 函数把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)

 
>>> help(divmod)
Help on built-in function divmod in module builtins:

divmod(x, y, /)
    Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.

>>> 10/3
3.3333333333333335
>>> 10//3
3
#-------------------------------------------
>>> divmod(10,3)
(3, 1)
 


id() 函数用于获取对象的内存地址

 
>>> a = "linyaohong"
>>> id(a)
139897178468400
>>> b = [1,2,3]
>>> id(b)
139897038502856
 


sorted() 函数对所有可迭代的对象进行排序操作


sort 与 sorted 区别:

sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作,无返回值,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作
 

sorted 语法:

sorted(iterable[, cmp[, key[, reverse]]])

参数说明:

  • iterable -- 可迭代对象。
  • cmp -- 比较的函数,这个具有两个参数,参数的值都是从可迭代对象中取出,此函数必须遵守的规则为,大于则返回1,小于则返回-1,等于则返回0。
  • key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
  • reverse -- 排序规则,reverse = True 降序 , reverse = False 升序(默认)
 
>>> a
[5, 7, 6, 3, 4, 1, 2]
>>> a.sort()
>>> a
[1, 2, 3, 4, 5, 6, 7]  #元列表被修改
#-----------------------------
>>> a = [5,7,6,3,4,1,2]
>>> sorted(a)
[1, 2, 3, 4, 5, 6, 7]
>>> a
[5, 7, 6, 3, 4, 1, 2]  #原列表不被改变
#字典是无序的
>>> d = {}
>>> for i in range(10):
...   d[i] = i-50
... 
>>> d
{0: -50, 1: -49, 2: -48, 3: -47, 4: -46, 5: -45, 6: -44, 7: -43, 8: -42, 9: -41}
>>> d.items() #把字典变成列表
dict_items([(0, -50), (1, -49), (2, -48), (3, -47), (4, -46), (5, -45), (6, -44), (7, -43), (8, -42), (9, -41)])
>>> sorted(d.items()) #默认排序
[(0, -50), (1, -49), (2, -48), (3, -47), (4, -46), (5, -45), (6, -44), (7, -43), (8, -42), (9, -41)]
>>> sorted(d.items(),key=lambda x:x[1])
[(0, -50), (1, -49), (2, -48), (3, -47), (4, -46), (5, -45), (6, -44), (7, -43), (8, -42), (9, -41)]
>>> d[0]=188
>>> d
{0: 188, 1: -49, 2: -48, 3: -47, 4: -46, 5: -45, 6: -44, 7: -43, 8: -42, 9: -41}
>>> sorted(d.items(),key=lambda x:x[1])
[(1, -49), (2, -48), (3, -47), (4, -46), (5, -45), (6, -44), (7, -43), (8, -42), (9, -41), (0, 188)]
>>> sorted(d.items(),key=lambda x:x[1],reverse=True) #reverse
[(0, 188), (9, -41), (8, -42), (7, -43), (6, -44), (5, -45), (4, -46), (3, -47), (2, -48), (1, -49)]

 


enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中

 

 

 
seq = ['one', 'two', 'three']
for i,p in enumerate(seq):
    print(i,p)

D:\python\python.exe F:/运维笔记/python/课堂练习题/enumerate.py
0 one
1 two
2 three
products = [['phone1',100],['phone2',200],['phone3',300],['phone4',500],['phone5',500],['phone6',1800]]
while True:
    print("--------商品列表-------")
    for index,p in enumerate(products):
        print("%s: %s %s" %(index,p[0],p[1]))

D:\python\python.exe F:/运维笔记/python/课堂练习题/enumerate.py
--------商品列表-------
0: phone1 100
1: phone2 200
2: phone3 300
3: phone4 500
4: phone5 500
5: phone6 1800
 


input() 函数接受一个标准输入数据,返回为 string 类型


raw_input() 将所有输入作为字符串看待,返回字符串类型。而 input() 在对待纯数字输入时具有自己的特性,它返回所输入的数字的类型( int, float )。
 

注意:input() 和 raw_input() 这两个函数均能接收 字符串 ,但 raw_input() 直接读取控制台的输入(任何类型的输入它都可以接收)。而对于 input() ,它希望能够读取一个合法的 python 表达式,即你输入字符串的时候必须使用引号将它括起来,否则它会引发一个 SyntaxError 。

除非对 input() 有特别需要,否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。

注意:python3 里 input() 默认接收到的是 str 类型

 
>>> a = input("please input:")
please input:linyaohong
>>> type(a)
<class 'str'>
>>> a = input("please input:")
please input:123  #input输入都为str类型
>>> type(a)
<class 'str'>
>>> a = int(input("please input:"))  #转为int类型
please input:123
>>> type(a)
<class 'int'>
 


oct() 函数将一个整数转换成8进制字符串

oct 语法:    oct(x)
参数说明:    x -- 整数。
返回值:      返回8进制字符串。

 
>>> oct(7)
'0o7'
>>> oct(8)
'0o10'
>>> oct(9)
'0o11'
 


bin()
返回一个整数 int 或者长整数 long int 的二进制表示
语法    :   bin(x)
参数    :   x -- int 或者 long int 数字
返回值  :  字符串

 
>>> bin(0)
'0b0'
>>> bin(1)
'0b1'
>>> bin(2)
'0b10'
>>> bin(3)
'0b11'
 


eval() 函数用来执行一个字符串表达式,并返回表达式的值

语法 :eval(expression[, globals[, locals]])
参数

    expression -- 表达式。
    globals -- 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
    locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
返回值 :返回表达式计算结果

 
>>> f = '1+3/2'
>>> eval(f)
2.5
>>> x = 7
>>> eval('3 * x')
21
>>> eval('3 + x')
10
>>> eval('2 + 2')
4
>>> eval('print("Hello World")') #只能处理单行代码、负载的需要用下文的exec
Hello World
 


exec()函数  执行储存在字符串或文件中的Python语句,相比于 eval,exec可以执行更复杂的 Python 代码。


    需要说明的是在 Python2 中exec不是函数,而是一个内置语句(statement),
    但是Python 2中有一个 execfile() 函数。
    可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能够整合到一个新的 exec() 函数中去了。
语法   :  exec obj
参数   :  obj -- 要执行的表达式。
返回值 :  exec 返回值永远为 None。 而eval返回值为结果、这也是与eval一个重要区别

 
>>> exec('print("Hello World")')
Hello World
# -*- coding:utf-8 -*-
code = '''
def test():
    print("run test")
    print("run test2")
test()
'''
res = exec(code)
print(res)

#D:\python\python.exe F:/运维笔记/python/函数/函数内置方法.py
run test
run test2
None
# -*- coding:utf-8 -*-
res = eval("1+2+3")
res2 = exec("1+2+3")
print("res:",res2)
print("res:",res)
#D:\python\python.exe F:/运维笔记/python/函数/函数内置方法.py
res: None  #区别exec返回永远是None
res: 6     #eval返回值
 


int() 函数用于将一个字符串或数字转换为整型

open() 函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。
       
https://www.linyaohong.com/blog/python/137.html
str() 函数将对象转化为适于人阅读的形式 (字符串类型https://www.linyaohong.com/blog/python/109.html

 


ord() 函数  显示ASCII码中的位置
chr() 函数  与ord相反、显示对应位置的ASCII码

 
>>> ord("a")
97
>>> ord("L")
76
#---------------
>>> chr(97)
'a'
>>> chr(76)
'L'
 


sum() 函数 求和计算

 
>>> a = [3,-1,0,2,6]
>>> a
[3, -1, 0, 2, 6]
>>> sum(a)
10
>>> sum([0,1,2]) 
3
>>> sum((2, 3, 4), 1) 
10
>>> sum([0,1,2,3,4],2) 
12


bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256

 
>>> s
'Linyaohong'
>>> s = s.encode('utf-8')
>>> s
b'Linyaohong'
>>> s[0]
76
>>> s=bytearray(s)
>>> s
bytearray(b'Linyaohong')
>>> s[0]
76
>>> s[0]=77   #在原id(s)内存地址修改s的值、了解即可、大字节修改的时候用到
>>> s
bytearray(b'Minyaohong')
>>> s.decode()
'Minyaohong'
 


map() 会根据提供的函数对指定序列做映射

第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表

 
>>> map(lambda x: x*x,[1,2,3,4,5])
<map object at 0x7fd9fa275ac8>
>>> list(map(lambda x: x*x,[1,2,3,4,5]))
[1, 4, 9, 16, 25]
>>> list(map(lambda x: x*1,[1,2,3,4,5]))
[1, 2, 3, 4, 5]
>>> list(map(lambda x: x*2,[1,2,3,4,5]))
[2, 4, 6, 8, 10]
>>> list(map(lambda x: x**x,[1,2,3,4,5]))
[1, 4, 27, 256, 3125]
 


filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回由符合条件元素组成的新列表。

该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判,然后返回 True 或 False,最后将返回 True 的元素放到新列表中

 
>>> list(filter(lambda x: x>3,[1,2,3,4,5]))
[4, 5]
>>> list(filter(lambda x: x<2,[1,2,3,4,5]))
[1]

#过滤出列表中的所有奇数
# -*- coding: UTF-8 -*-
def test(n):
    return n % 2 == 1
newlist = list(filter(test, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
print(newlist)
print(test(3))
#D:\python\python.exe F:/运维笔记/python/函数/函数内置方法.py
[1, 3, 5, 7, 9]
True
 

reduce() 函数会对参数序列中元素进行累积。
函数将一个数据集合(链表,元组等)中的所有数据进行下列操作:用传给 reduce 中的函数 function(有两个参数)先对集合中的第 1、2 个元素进行操作,得到的结果再与第三个数据用 function 函数运算,最后得到一个结果

 

 
>>> sum([1+2+3+4+5])
15

>>> import functools
>>> functools.reduce(lambda x,y:x+y,[1,2,3,4,5],)
15
>>> functools.reduce(lambda x,y:x+y,[1,2,3,4,5],1)
16
>>> functools.reduce(lambda x,y:x+y,[1,2,3,4,5],4)
19
 
# map  filter reduce  三剑客
 


list() 方法用于将元组转换为列表

 
>>> a = (123, 'xyz', 'zara', 'abc')
>>> s = list(a)
>>> s
[123, 'xyz', 'zara', 'abc']
 


pow() 方法返回 xy(x的y次方) 的值

 
#----x**y
>>> pow(2,4)
16
>>> pow(2,5)
32
>>> type(pow(2,5))
<class 'int'>
#--- x**y%z
>>> pow(2,5,3)
2
 


float() 函数用于将整数和字符串转换成浮点数

 
>>> float(1)
1.0
>>> type(float(1))
<class 'float'>
>>> type(1)
<class 'int'>

 


print() 方法用于打印输出,最常见的一个函数。

     print 在 Python3.x 是一个函数,但在 Python2.x 版本不是一个函数,只是一个关键字

 
>>> s = 'Hello My name is Lin\n from Linyi'
>>> print(s)   #print默认最后会换行
Hello My name is Lin
from Linyi
>>> 
>>> print(s,end='!')  
Hello My name is Lin
from Linyi!>>>       #最后为 ! 没有换行,
#------------------sep分割符----------------
>>> print('Linyaohong','Dingqiaoli',sep='-')
Linyaohong-Dingqiaoli
>>> print('Linyaohong','Dingqiaoli',sep='|')
Linyaohong|Dingqiaoli

# -*- coding:utf-8 -*-
msg = "又回到最初的起点"
f = open("test.txt","w")
print(msg,"记忆中你青涩的脸",sep='|',end="",file=f)
print(msg,"记忆中你青涩的脸",sep='|',end="",file=f)
#
D:\python\python.exe F:/运维笔记/python/函数/函数内置方法.py 

又回到最初的起点|记忆中你青涩的脸又回到最初的起点|记忆中你青涩的脸 #无换行
 


tuple() 函数将列表转换为元组

 
>>> tuple([1,2,3,4])
(1, 2, 3, 4)
>>> tuple({1:"a",2:"b"}) #针对字典 会返回字典的key组成的tuple
(1, 2)
>>> tuple((1,2,3,4))     #元组会返回元组自身
(1, 2, 3, 4)
 


callable() 函数    用于检查一个对象是否是可调用的。如果返回 True,object 仍然可能调用失败;但如果返回 False,调用对象 object 绝对不会成功。

    对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True

 
#如果给了一个变量,是否为 函数可以用callable来判断
>>> a = [1,3,4,5]
>>> def f():
...   pass
...   
>>> callable(f) #f函数可以调用
True
>>> callable((a)) #不可调用
False
 


Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数,位置可以不按顺序

 
print("网站名:{name}, 地址 {url}".format(name="蔺要红", url="www.linyaohong.com"))

# 通过字典设置参数
site = {"name": "蔺要红", "url": "www.linyaohong.com"}
print("网站名:{name}, 地址 {url}".format(**site))

# 通过列表索引设置参数
my_list = ['蔺要红', 'www.linyaohong.com']
print("网站名:{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

#D:\python\python.exe F:/运维笔记/python/函数/函数内置方法.py
网站名:蔺要红, 地址 www.linyaohong.com
网站名:蔺要红, 地址 www.linyaohong.com
网站名:蔺要红, 地址 www.linyaohong.com
 


len() 方法返回对象(字符、列表、元组等)长度或项目个数

 
>>> len("Lin Yao")
7
>>> len([1,2,3])
3
>>> len([1,2,3,4])
4


type() 函数如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象

isinstance() 与 type() 区别:

  • type() 不会认为子类是一种父类类型,不考虑继承关系。

  • isinstance() 会认为子类是一种父类类型,考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()

 
>>> type(1)
<class 'int'>
>>> type('1')
<class 'str'>
>>> type('lin')
<class 'str'>
>>> type({1:'Lin'})
<class 'dict'>
>>> x = 1
>>> type(x) == int  #判断类型是否相等
True
 


isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()
语法:isinstance(object, classinfo)
如果对象的类型与参数二的类型(classinfo)相同则返回 True,否则返回 False

 
>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list))    # 是元组中的一个返回 True
True


 


frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素

 
>>> m = {1,3,5,0} 
>>> m.discard(0)  #删除集合里的内容
>>> m
{1, 3, 5}
>>> n = frozenset(m)  #创建不可变集合
>>> n
frozenset({1, 3, 5})   
 


range() 函数可创建一个整数列表,一般用在 for 循环中

 
>>> range(10)
range(0, 10)
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  #创建一个列表
>>> list(range(1,7))
[1, 2, 3, 4, 5, 6]

>>> list(range(1,7,3)) #步长3
[1, 4]

>>> range(0)
range(0, 0)

>>> list(range(0)) #空列表
[]


 


locals() 函数会以字典类型返回 当前名称空间  
局部变量。
对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True


globals()
函数会以字典类型返回  当前名称空间    全局变量

 
>>> locals()
{'__doc__': None, '__spec__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__package__': None, 'a': 10, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__'}
>>> def f():  #定义个函数
...   n = 3
...   print(locals())
... 
>>> f()
{'n': 3}  #结果只显示局部变量
 


repr() 函数将对象转化为供解释器读取的形式
      返回一个对象的 string 格式

 
>>> m = {'name': 'linyaohong', 'job': 'Linux'}
>>> repr(m)
"{'name': 'linyaohong', 'job': 'Linux'}"
>>> n={12,4}
>>> repr(n)
'{4, 12}'

 


zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存

我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,
利用 * 号操作符,可以将元组解压为列表

 
>>> a
[1, 3, 4, 5, 6]
>>> b
['a', 'b', 'c']
>>> list(zip(a,b))     # 元素个数与最短的列表一致
[(1, 'a'), (3, 'b'), (4, 'c')]  


reversed() 函数用于反向列表中元素

>>> a
[1, 3, 4, 5, 6]
>>> reversed(a)
<list_reverseiterator object at 0x7f5e8cb7e6d8>
>>> list(reversed(a))  #顺序反转
[6, 5, 4, 3, 1]
 


complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。

如果第一个参数为字符串,则不需要指定第二个参数

 
>>> complex(3,4)
(3+4j)
>>> complex(1)
(1+0j)
 


hasattr() 函数用于判断对象是否包含对应的属性
如果对象有该属性返回 True,否则返回 False

 
#待整理
 


round() 方法返回浮点数x的四舍五入值

 
>>> round(1.23124)
1
>>> round(1.23124,2) #保留两位小数
1.23
>>> round(1.00034,2)
1.0
 


hash() 用于获取取一个对象(字符串或者数值等)的哈希值

 
>>> hash('test') #字符串
8933756011063461259
>>> hash(str([1,2,3,4]))  #
5939916305192472534
>>> hash(str(sorted({"a":1}))) #字典
752435292895533396
 


set() 函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等

返回新的集合对象

 
>>> a = [1,2,3,4,5] #把列表变成集合
>>> set(a)
{1, 2, 3, 4, 5}
>>> m = set('hong')
>>> n = set('google')
>>> m,n
({'o', 'n', 'g', 'h'}, {'o', 'l', 'e', 'g'})
>>> m
{'o', 'n', 'g', 'h'}
>>> n
{'o', 'l', 'e', 'g'}
>>> m & n #交集
{'o', 'g'}
>>> m | n  #并集
{'n', 'h', 'l', 'g', 'o', 'e'}
>>> m - n #差集
{'n', 'h'}


 
温馨提示如有转载或引用以上内容之必要,敬请将本文链接作为出处标注,如有侵权我会在24小时之内删除!

欢迎使用手机扫描访问本站