【Python基础】2万字-详解Python基础函数,包教包会

2022年05月11日 阅读数:6
这篇文章主要向大家介绍【Python基础】2万字-详解Python基础函数,包教包会,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

👉跳转文末👈 获取做者联系方式,共同窗习进步python

运行环境

python:3.8.3
jupyter-notebook : 6.4.0git

注意:本文案例能够直接在 jupyter-notebook 上运行,但在 PyCharm 上的话须要代码的最后一句加上 print 哦!web



输入输出函数

print()

print() 无疑是咱们使用最多的函数,他能够直接输出、指定间隔/结尾字符、将输出内容保存到指定文件(应用:记录自动化脚本异常信息)等。下面列举它的常见用法。
1️⃣ 直接输出api

print('hello world')
output:hello world

2️⃣ 指定间隔字符sep微信

print('A', 'B', 'C', sep=' Python ')
output:A Python B Python C

3️⃣ 指定结尾字符app

print('hello', 'world', end='Python')
output:hello worldPython

4️⃣ 将输出内容保存到outfile.txt文件中编辑器

print('hello', 'world', sep=' ', file=open('outfile.txt', 'w', encoding='utf-8'))

input()

input() 能够接收用户输入的内容,并以字符串的形式保存。svg

name = input('name:')

在这里插入图片描述
jupyter notebook 上执行的效果可能和别的编辑器不一样,但操做都是输入完后,按 “回车” 便可。函数



获取数据类型

type()

type() 返回指定值的数据类型。学习

type([1, 2])
output:list

isintance()

isintance() 判断传入的值是否为指定类型,返回 True/False

isinstance('Python新视野', str)
output:True


字符串操做

str()

str() 将指定值转为字符串类型。

str(1.23)
output:‘1.23’

eval()

eval() 将字符串转成有效的表达式来求值或者计算结果。能够将字符串转化成列表(list),元组(tuple),字典(dict),集合(set)等。

res = eval("{'name': 'Python'}")
type(res)
output:dict

str.capitalize()

capitalize() 返回字符串中的首字母大写,其他小写的字符串

cap_str = 'python新视野'.capitalize()
cap_str
output:‘Python新视野’

str.center()

center() 返回一个指定宽度的居中字符串,左右部分空余部分用指定字符填充。

  • width:长度
  • fillchar:空余部分填充的字符,默认使用空格
center_str = 'Python新视野'.center(15, "!")
center_str
output:’!!!Python新视野!!!’

str.count()

str.count(sub, start, end) 返回 substr 中出现的次数,能够经过 [start, end] 指定范围,若不指定,则默认查找整个字符串。

  • sub: 子串
  • start: 开始的索引,默认为 0
  • end: 结束的索引,默认为字符串的长度
name = 'python python'
# 第一次按默认范围统计'p'出现的次数,
# 第二次指定start=1,即从第二个字符开始统计。
name.count('p'), name.count('p', 1)
output:(2, 1)

str.find() & str.rfind()

1️⃣ find() 从左往右扫描字符串,返回 sub 第一次出现的下标。能够经过 [start, end] 指定范围,若不指定,则默认查找整个字符串。如最后未找到字符串则返回 -1。

  • sub: 子串
  • start: 开始检索的位置,默认为 0
  • end: 结束检索的位置,默认为字符串的长度
name = 'Python'
# 第一次按默认范围查找'Py'第一次出现的下标
# 第二次指定start=1,即从第二个字符开始查找。
name.find('Py'), name.find('Py', 1)
output:(0, -1)

2️⃣ rfindfind() 的用法类似,只是从右往左开始扫描,即从字符串末尾向字符串首部扫描。

name = 'Python'
name.rfind('Py'), name.rfind('Py', 1)
output:(0, -1)

str.index() & str.rindex()

1️⃣ index()find() 用法相同,惟一的不一样是若是找不到 sub 会报错。

示例 🅰️

name = 'Python'
name.index('Py', 0)
output:0

示例 🅱️

name = 'Python'
name.index('Py', 1)
output:ValueError: substring not found

2️⃣ rindex()index() 用法相同,不过是从右边开始查,它的查询与 index() 相同。

name = 'Python'
name.rindex('Py', 0)
output:0

str.isalnum()

isalnum() 判断字符串中是否全部字符都是字母(能够为汉字)或数字,是 True ,否 False,空字符串返回 False

示例 🅰️

'Python新视野'.isalnum()
output:True

示例 🅱️

'Python-sun'.isalnum()
output:False

'-' 是符号,因此返回 False


str.isalpha()

isalpha() 判断字符串中是否全部字符都是字母(能够为汉字),是 True ,否 False,空字符串返回 False

示例 🅰️

'Python新视野'.isalpha()
output:True

示例 🅱️

'123Python'.isalpha()
output:False

其中包含了数字,返回 False


str.isdigit()

isdigit() 判断字符串中是否全部字符都是数字(Unicode数字,byte数字(单字节),全角数字(双字节),罗马数字),是 True ,否 False,空字符串返回 False

示例 🅰️

'四123'.isdigit()
output:False

其中包含了汉字数字,返回 False


示例 🅱️

b'123'.isdigit()
output:True

byte 数字返回 True


str.isspace()

字符串中只包含空格(\n\r\f\t\v),是 True ,否 False,空字符串返回 False

符号 含义
\n 换行
\r 回车
\f 换页
\t 横向制表符
\v 纵向制表符
' \n\r\f\t\v'.isspace()
output:True

str.join()

join(iterable) 以指定字符串做为分隔符,将 iterable 中全部的元素(必须是字符串)合并为一个新的字符串。

','.join(['Python', 'Java', 'C'])
output:‘Python,Java,C’

str.ljust() & str.rjust()

1️⃣ ljust() 返回一个指定宽度左对齐的字符串

  • width:长度
  • fillchar:右部空余部分填充的字符,默认使用空格
ljust_str = 'Python新视野'.ljust(15, "!")
ljust_str
output:‘Python新视野!!!!!!’

2️⃣ rjust() 返回一个指定宽度右对齐的字符串,与 ljust 操做正好相反。

  • width:长度
  • fillchar:左部空余部分填充的字符,默认使用空格
rjust_str = 'Python新视野'.rjust(15, "!")
rjust_str
output:’!!!!!!Python新视野’

str.lower() & str.islower()

1️⃣ lower() 将指定字符串转换为小写。

lower_str = 'Python新视野'.lower()
lower_str
output:‘python新视野’

2️⃣ islower() 判断字符串全部区分大小写的字符是否都是小写形式,是 True ,否 False,空字符串或字符串中没有区分大小写的字符返回 False

'python-sun'.islower()
output:True

'python-sun' 区分大小写的字符有 'pythonsun',而且都是小写,因此返回 True


str.lstrip() & str.rstrip() & str.strip()

1️⃣ lstrip() 会在字符串左侧根据指定的字符进行截取,若未指定默认截取左侧空余(空格,\r,\n,\t等)部分。

name = '+++Python新视野+++'
name.lstrip('+')
output:‘Python新视野+++’

2️⃣ rstrip()lstrip() 用法类似,只是截取右侧的内容。

name = '+++Python新视野+++'
name.rstrip('+')
output:’+++Python新视野’

3️⃣ strip() 实际是 lstrip()rstrip() 的结合,它会截取字符串两边指定的字符。

name = '+++Python新视野+++'
name.strip('+')
output:‘Python新视野’

str.split() & str.splitlines()

1️⃣ str.split(sep=None, maxsplit=-1) 使用 sep 做为分隔符将字符串进行分割,返回字符串中的单词列表。

  • seq: 用来分割字符串的分隔符。None(默认值)表示根据任何空格进行分割,返回结果中不包含空格。
  • maxsplit: 指定最大分割次数。-1(默认值)表示不限制。
split_str = 'P y t h o n 新 视 野'
split_str.split(maxsplit=2)
output:[‘P’, ‘y’, ‘t h o n 新 视 野’]

使用默认的空格进行分割,设置最大的分割次数为2


2️⃣ str.splitlines 返回字符串中的行列表,它按照行 ('\r',\n','\r\n') 分隔,返回分隔后的列表。它只有一个参数 keepends 表示是否在结果中保留换行符,False (默认)不保留,True 保留。

示例 🅰️

split_str = 'P\ny\r t h o n 新 视 野'
split_str.splitlines()
output:[‘P’, ‘y’, ’ t h o n 新 视 野’]

示例 🅱️

split_str = 'P\ny\r t h o n 新 视 野'
split_str.splitlines(keepends=True)
output:[‘P\n’, ‘y\r’, ’ t h o n 新 视 野’]

str.startswith() & str.endswith

1️⃣ startswith(prefix[, start[, end]]) 检查字符串是不是以指定子字符串 substr 开头,是 True ,否 False,空字符串会报错。若是指定 startend ,则在指定范围内检查。

startswith_str = 'Python新视野'
startswith_str.startswith('thon', 2)
output:True

从第 3 个字符开始检测


2️⃣ str.endswith(suffix[, start[, end]])startswith 用法相同,不一样之处是检查字符串是否以指定子字符串结尾,是 True ,否 False,空字符串会报错。

endswith_str = 'Python新视野'
endswith_str.endswith('thon', 0, 6)
output:True

从第 1 个字符开始检测,到第 7 个字符结束(不包含第 7 个),注意这里的范围和字符串切片实际上是同样的道理,都是前闭后开。


str.title() & str.istitle()

1️⃣ title() 返回字符串中每个单词首字母大写。

title_str = 'python新视野 python新视野'.title()
title_str
output:‘Python新视野 Python新视野’

2️⃣ istitle() 判断字符串是否知足每个单词首字母大写,是 True ,否 False,空字符串返回 False

'Abc Def  '.istitle()
output:True

str.upper() & str.isupper()

1️⃣ upper() 将指定字符串中字母转换为大写。

upper_str = 'Python新视野'.upper()
upper_str
output:‘PYTHON新视野’

2️⃣ isupper() 判断字符串全部区分大小写的字符是否都是大写形式,是 True ,否 False,空字符串或字符串中没有区分大小写的字符返回 False

'PYTHON-SUN'.isupper()
output:True


列表操做

list()

list() 将可迭代对象转成列表。

示例 🅰️

list((0,1,2)) + list({
   
   0,1,2}) + list('012')
output:[0, 1, 2, 0, 1, 2, ‘0’, ‘1’, ‘2’]

将元组、集合、字符串转换成列表并经过运算符链接。


示例 🅱️

list(range(3))
output:[0, 1, 2]

将可迭代对象转换成列表


list.append()

lst = ['Python', 'Java']
lst.append('C')
lst
output:[‘Python’, ‘Java’, ‘C’]

list.extend()

extend() 在列表的末尾添加可迭代对象(列表、元组、字典、字符串)中的元素来扩展列表。

1️⃣ 追加列表

lst = ['Python', 'Java', 'C']
lst.extend([1, 2, 3])
lst
output:[‘Python’, ‘Java’, ‘C’, 1, 2, 3]

2️⃣ 追加字符串

lst = ['Python', 'Java', 'C']
lst.extend('123')
lst
output:[‘Python’, ‘Java’, ‘C’, ‘1’, ‘2’, ‘3’]

将字符串中的每个字符当作一个元素追加到原列表末尾


3️⃣ 追加集合

lst = ['Python', 'Java', 'C']
lst.extend({
   
   1,2,3})
lst
output:[‘Python’, ‘Java’, ‘C’, 1, 2, 3]

4️⃣ 追加字典

lst = ['Python', 'Java', 'C']
lst.extend({
   
   1: 'b', 2: 'a'})
lst
output:[‘Python’, ‘Java’, ‘C’, 1, 2]

只将字典的 key 值追加到原列表末尾


list.insert()

insert(index, object) 将指定对象插入到列表的 index 位置,本来 index 位置上及 > index 的元素的元素总体后移。

示例 🅰️

lst = ['Python', 'Java', 'C']
lst.insert(1, 'C++')
lst
output:[‘Python’, ‘C++’, ‘Java’, ‘C’]

示例 🅱️

lst = ['Python', 'Java', 'C']
lst.insert(6, 'C++')
lst
output:[‘Python’, ‘Java’, ‘C’, ‘C++’]

index 的值大于列表长度时,会在列表末尾添加。


list.pop()

pop(index=-1) 移除列表中指定位置元素(默认最后一个),而且返回移除元素的值。若指定的 index 值超过列表长度则会报错。

lst = ['Python', 'Java', 'C']
lst.pop(1), lst
output:(‘Java’, [‘Python’, ‘C’])

list.remove(元素)

lst.remove(value) 移除列表中第一次出现的 value ,无返回值,直接修改列表;若是 value 不在列表中则报错。

示例 🅰️

lst = ['Python', 'Java', 'C', 'Python']
lst.remove('Python')
lst
output:[‘Java’, ‘C’, ‘Python’]

只删除了第一次出现的 Python


示例 🅱️

lst = ['Python', 'Java', 'C', 'Python']
lst.remove('HTML')
lst
output:ValueError: list.remove(x): x not in list

HTML 不在列表中,发生错误


list.clear()

list.clear() 移除列表中全部的元素,无返回值。

lst = ['Python', 'Java', 'C']
lst.clear()
lst
output:[]

list.index()

index(value, start, stop) 返回列表中查找的第一个与value匹配的元素下标,可经过 [start, stop) 指定查找范围。

示例 🅰️

lst = ['Python', 'Java', 'C',
	   'Python', 'Python']
lst.index('Python')
output:0

不指定范围,在列表所有元素中查找


示例 🅱️

lst = ['Python', 'Java', 'C',
	   'Python', 'Python']
lst.index('Python', 1, 3)
output:ValueError: ‘Python’ is not in list

指定范围 [1, 3) ,即在[‘Java’, ‘C’]中查找 Python 很明显不存在,发生报错


list.count()

count(value) 返回 value 在列表中出现的次数。若未在列表中找到 value 则返回 0 。

示例 🅰️

lst = ['Python', 'Java', 'C',
	   'Python', 'Python']
lst.count('Python')
output:3

示例 🅱️

lst = ['Python', 'Java', 'C',
	   'Python', 'Python']
lst.count('Py')
output:0

列表中无元素 'Py',返回 0 。


list.reverse()

reverse() 将列表逆序排列,无返回值。

lst = [1, 5, 9, 2]
lst.reverse()
lst
output:[2, 9, 5, 1]

list.sort()

sort() 对列表进行指定方式的排序,修改原列表,该排序是稳定的(即两个相等元素的顺序不会由于排序而改变)。

  • key: 指定可迭代对象中的每个元素来按照该函数进行排序
  • reverse: False 为升序,True 为降序。

示例 🅰️

lst = [1, 5, 9, 2]
lst.sort()
lst
output:[1, 2, 5, 9]

示例 🅱️

lst = ['Python', 'C', 'Java'] 
lst.sort(key=lambda x:len(x), reverse=False)
lst
output:[‘C’, ‘Java’, ‘Python’]

指定 key 计算列表中每一个元素的长度,并按照长度进行升序排序


list.copy()

copy() 对列表进行拷贝,返回新生成的列表,这里的拷贝是浅拷贝,下面会说明为何特地说它是浅拷贝

示例 🅰️

lst = [[1,2,3], 'a' ,'b']
lst_copy = lst.copy()
lst_copy.pop()
lst, lst_copy
output:([[1, 2, 3], ‘a’, ‘b’], [[1, 2, 3], ‘a’])

lst 进行 copy ,而后删除列表 lst_copy 的最后一个元素,此时的 lst 的最后一个元素并未被删除,说明两个列表指向的地址确实不同。


示例 🅱️

lst = [[1,2,3], 'a' ,'b']
lst_copy = lst.copy()
lst_copy[0].pop()
lst_copy.pop()
lst, lst_copy
output:([[1, 2], ‘a’, ‘b’], [[1, 2], ‘a’, ‘b’])

这里执行和上一个示例同样的操做,只是此次再删除一个数据,即列表嵌套的子列表中最后一个元素,观察结果,发现这时不只仅是 lst_copy 的列表发生改变,原列表 lst 中嵌套的字列表也发生了改变。说明两个列表指向的地址不同,但子列表中指向的地址是相同的。


扩展:直接赋值、浅拷贝、深拷贝

(1)直接赋值,传递对象的引用而已。原始列表改变,被赋值的对象也会作相同改变。

(2)浅拷贝,没有拷贝子对象,因此原始数据子对象改变,拷贝的子对象也会发生变化。

(3)深拷贝,包含对象里面的子对象的拷贝,因此原始对象的改变不会形成深拷贝里任何子元素的改变,两者彻底独立。

1️⃣ 先看直接赋值

lst = [1,2,3,[1,2]]
list1 = lst

# --直接赋值--
lst.append('a')
list1[3].append('b')

print(lst,'地址:',id(lst))   
print(list1,'地址:',id(list1))
# [1, 2, 3, [1, 2, 'b'], 'a'] 地址: 2112498512768
# [1, 2, 3, [1, 2, 'b'], 'a'] 地址: 2112498512768

不管 lst 仍是 list1 发生改变,两者都会受到影响。


2️⃣ 浅拷贝须要用到 copy 模块,或者用 list.copy() 效果同样

from copy import copy

lst = [1, 2, 3, [1, 2]]
list2 = copy(lst)

# --浅拷贝--
lst.append('a')
list2[3].append('b')

print(lst,'地址:',id(lst))
print(list2,'地址:',id(list2))
# [1, 2, 3, [1, 2, 'b'], 'a'] 地址: 2112501949184
# [1, 2, 3, [1, 2, 'b']] 地址: 2112495897728

lstlist2 地址不一样,但子列表的地址还是相同的,修改子列表中的元素时,两者都会受到影响。


3️⃣ 深拷贝须要用到 copy 模块中的 deepcopy ,此时两个列表彻底独立。

from copy import deepcopy

lst = [1, 2, 3, [1, 2]]
list3 = deepcopy(lst)

# --深拷贝--
lst.append('a')
list3[3].append('b')

print(lst,'地址:',id(lst))
print(list3,'地址:',id(list3))
# [1, 2, 3, [1, 2], 'a'] 地址: 2112506144192
# [1, 2, 3, [1, 2, 'b']] 地址: 2112499460224

根据结果能够看到修改子列表中的值时,原列表未发生改变。



元组

tuple()

tuple() 将可迭代对象转换成元组。

tuple([0,1,2]) + tuple(range(3)) + tuple({
   
   0,1,2}) + tuple('012')
output:(0, 1, 2, 0, 1, 2, 0, 1, 2, ‘0’, ‘1’, ‘2’)

将可迭代对象转换成列表并经过运算符链接。



字典

dict.clear()

clear() 清除字典的全部内容。

dic = {
   
   'CSDN': 'Dream丶killer',
       '公众号': 'Python新视野'}
dic.clear()
dic
output:{}

dict.fromkeys()

fromkeys() 建立一个新字典,以序列 iterable 中元素作字典的键,value 为字典全部键对应的初始值。

  • iterable: 可迭代对象,新字典的键。
  • value: 可选参数, 设置键序列对应的值,默认为 None
dict.fromkeys(['CSDN', '公众号'],
              'Python新视野')
output:{‘CSDN’: ‘Python新视野’, ‘公众号’: ‘Python新视野’}

dict.get()

get(key, default=None) 根据指定的 key 值查找,若是 key 在字典中,则返回 key 的值,不然为 None

示例 🅰️

dic = {
   
   'CSDN': 'Dream丶killer',
       '公众号': 'Python新视野'}
dic.get('CSDN')
output:‘Dream丶killer’

示例 🅱️

dic = {
   
   'CSDN': 'Dream丶killer',
       '公众号': 'Python新视野'}
print(dic.get('微信'))
output:None

字典中没有 key 等于 '微信',返回 None,jupyter notebook 对于 None 若是不加 print 默认不输出,因此这里加上print 来打印结果


dict.items()

items() 返回视图对象,是一个可遍历的 key/value 对,可使用 list() 将其转换为列表。

示例 🅰️

dic = {
   
   'CSDN': 'Dream丶killer',
       '公众号': 'Python新视野'}
list(dic.items())
output:[(‘CSDN’, ‘Dream丶killer’), (‘公众号’, ‘Python新视野’)]

示例 🅱️

dic = {
   
   'CSDN': 'Dream丶killer',
       '公众号': 'Python新视野'}
for key, value in dic.items():
    print('key: ', key, 'value: ', value)

# key:  CSDN value:  Dream丶killer
# key:  公众号 value:  Python新视野

dict.keys()

keys() 返回一个视图对象,值为字典的 key ,可将其转换成列表。

dic = {
   
   'CSDN': 'Dream丶killer',
       '公众号': 'Python新视野'}
dic.keys()
output:dict_keys([‘CSDN’, ‘公众号’])

dict.setdefault()

setdefault(key, default=None) 若是键不在字典中,则插入值为 None 的键。若是键在字典中,则返回键的值。

示例 🅰️

dic = {
   
   'CSDN': 'Dream丶killer',
       '公众号': 'Python新视野'}
dic.setdefault('CSDN', 'python-sun')
output:‘Dream丶killer’

字典中有 CSDN 这个 key 值,返回 CSDN 对应的值,不须要插入


示例 🅱️

dic = {
   
   'CSDN': 'Dream丶killer',
       '公众号': 'Python新视野'}
dic.setdefault('微信', 'python-sun')
dic
output:{‘CSDN’: ‘Dream丶killer’, ‘公众号’: ‘Python新视野’, ‘微信’: ‘python-sun’}

字典中没有 微信 这个 key 值,返回 None ,执行插入,并根据设置的参数 python-sun 来进行赋值。


dict.update()

dict.update(dict1) 把字典 dict1key/value 对更新到 dict 里,当 dict1key 出如今 dict 中则修改 dict 中的值,若是 key 没有出如今 dict 中,则添加这一对 key/value

dic = {
   
   'CSDN': 'Dream丶killer',
       '公众号': 'Python新视野'}
dic1 = {
   
   'CSDN': 'new_name',
        '微信': 'python-sun'}
dic.update(dic1)
dic
output:{‘CSDN’: ‘new_name’, ‘公众号’: ‘Python新视野’, ‘微信’: ‘python-sun’}

dict.values()

values() 返回一个视图对象,值为字典的 value ,可将其转换成列表。

dic = {
   
   'CSDN': 'Dream丶killer',
       '公众号': 'Python新视野'}
dic.values()
output:dict_values([‘Dream丶killer’, ‘Python新视野’])

dict.pop()

pop() 删除指定 keykey/value ,若是 key 没有找到,则报错。

dic = {
   
   'CSDN': 'Dream丶killer',
       '公众号': 'Python新视野'}
dic.pop('CSDN')
dic
output:{‘公众号’: ‘Python新视野’}

dict.popitem()

popitem() 删除字典中末尾的元素,并返回一个元组的(键,值)对。字典为空则报错。

dic = {
   
   'CSDN': 'Dream丶killer',
       '公众号': 'Python新视野'}
dic.popitem()
output:(‘公众号’, ‘Python新视野’)


集合

set.add()

向集合中添加一个元素,但若是该元素已经出如今集合中,则不起做用。

示例 🅰️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set1.add('python')
set1
output:{‘Dream丶Killer’, ‘Python新视野’, ‘python’, ‘python-sun’}

示例 🅱️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set1.add('python-sun')
set1
output:{‘Dream丶Killer’, ‘Python新视野’, ‘python-sun’}

添加的元素 python-sun 已经出如今集合中,因此 set1 不发生变化


set.clear()

clear() 移除集合中的全部元素。

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set1.clear()
set1
output:set()

set.difference() & set.difference_update()

1️⃣ difference() 返回多个集合的差集,通俗来说就是返回第一个 set 中哪些元素没有在其余 set 中出现。

示例 🅰️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python', 'Dream丶Killer'}
set3 = {
   
   'Python新视野'}
set1.difference(set2, set3)
output:{‘python-sun’}

set1 中的元素只有 python-sun 没有在 set2set3 中出现过,因此以及集合的形式返回 {'python-sun'}


示例 🅱️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python', 'Dream丶Killer'}
set3 = {
   
   'Python新视野', 'python-sun'}
set1.difference(set2, set3)
output:set()

set1 中的元素都在 set2set3 中出现过,因此返回空集合 set()


2️⃣ difference_update() 方法与 difference() 方法的区别在于 difference() 方法返回一个移除相同元素的新集合,而 difference_update() 方法是直接移除原集合中的元素,无返回值。

示例 🅰️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python', 'Dream丶Killer'}
set3 = {
   
   'Python新视野'}
set1.difference_update(set2, set3)
set1
output:{‘python-sun’}

set1 中的元素 Dream丶KillerPython新视野 都有在 set2set3 中出现过,因此从 set1 中移除这些值


示例 🅱️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python', 'Dream丶Killer'}
set3 = {
   
   'Python新视野', 'python-sun'}
set1.difference_update(set2, set3)
set1
output:set()

set1 中的元素都在 set2set3 中出现过,set1 移除全部值后为空集合 set()


set.discard()

discard() 删除集合中指定的元素。若是指定移除的元素不在集合中,则不移除。

示例 🅰️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set1.discard('Dream丶Killer')
set1
output:{‘Python新视野’, ‘python-sun’}

指定的元素存在于 set1 ,将它存 set1 中移除


示例 🅱️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set1.discard('python')
set1
output:{‘Dream丶Killer’, ‘Python新视野’, ‘python-sun’}

指定的元素不在 set1 内,set1 不作改变


set.intersection() & set.intersection_update()

1️⃣ intersection() 返回集合的交集。没有交集则返回空集 set()

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python-sun', 'Dream丶Killer'}
set3 = {
   
   'Python新视野', 'python-sun'}
set1.intersection(set2, set3)
output:{‘python-sun’}

返回 set1set2set3 中同时出现的元素


2️⃣ intersection_update() 方法与 intersection() 方法的区别在于 intersection() 方法将集合的交集做为新集合返回,而 intersection_update() 方法是直接修改原集合中的元素,只保留交集元素,无返回值。

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python-sun', 'Dream丶Killer'}
set3 = {
   
   'Python新视野', 'python-sun'}
set1.intersection_update(set2, set3)
set1
output:{‘python-sun’}

set1 中只有 'python-sun 同时在 set2set3 中出现过,所以移除 set1 中其余元素


set.isdisjoint()

isdisjoint() 判断两个集合是否包含相同的元素,有则返回 False,无则返回 True
示例 🅰️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python-sun', 'Dream丶Killer'}
set1.isdisjoint(set2)
output:False

set1set2 中有两个相同元素,返回 False


示例 🅱️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python'}
set1.isdisjoint(set2)
output:True

set1set2 中无相同元素,返回 True


set.issubset()

set2.issubset(set1) 判断集合 set2 是否为 set1 集合的子集。是则返回 True,不然返回 False

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python-sun', 'Dream丶Killer'}
set2.issubset(set1)
output:True

set2set1 集合的子集,故返回 True ,使用时需注意 set1set2 的位置顺序。若是写成 set1.issubset(set2) 则会返回 False


set.issuperset()

set1.issuperset(set2) 判断集合 set2 是否为 set1 集合的子集。是则返回 True,不然返回 False。它与 issubset() 用法相同,只有参数的位置相反而已。

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python-sun', 'Dream丶Killer'}
set1.issuperset(set2)
output:True

set1.pop()

pop() 移除并返回集合中的任意元素。若是该集合为空集则报错。

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set1.pop()
output:‘python-sun’

set.remove()

remove() 从集合中移除指定的元素,若是该元素不在集合中,则发生报错。

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set1.remove('Dream丶Killer')
set1
output:{‘Python新视野’, ‘python-sun’}

set.symmetric_difference()

symmetric_difference() 返回两个集合中不重复的元素集合,即两个集合的补集,与 ^ 的做用相同。

示例 🅰️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python', 'python-sun', 'Dream丶Killer'}
set1.symmetric_difference(set2)
output:{‘Python新视野’, ‘python’}

示例 🅱️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python',
	    'python-sun',
	    'Dream丶Killer'}
set1 ^ set2
output:{‘Python新视野’, ‘python’}

结果与上面相同


set.symmetric_difference_update()

set1.symmetric_difference_update(set2) 移除 set1 中在 set2 相同的元素,并将 set2 集合中不一样的元素插入到 set1 中。简单来讲就是把 set1set2 的补集赋值给 set1

示例 🅰️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python',
		'python-sun',
		'Dream丶Killer'}
set1.symmetric_difference_update(set2)
set1
output:{‘Python新视野’, ‘python’}

示例 🅱️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python',
		'python-sun',
		'Dream丶Killer'}
set1 = set1 ^ set2
set1
output:{‘Python新视野’, ‘python’}

set.union()

union() 返回多个集合的并集。与 | 的做用相同。

示例 🅰️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python',
		'python-sun',
		'Dream丶Killer'}
set3 = {
   
   'ABC'}
set1.union(set2, set3)
output:{‘ABC’, ‘Dream丶Killer’, ‘Python新视野’, ‘python’, ‘python-sun’}

示例 🅱️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set2 = {
   
   'python',
		'python-sun',
		'Dream丶Killer'}
set3 = {
   
   'ABC'}
set1 | set2 | set3
output:{‘ABC’, ‘Dream丶Killer’, ‘Python新视野’, ‘python’, ‘python-sun’}

set.update()

update() 使用自己和其余的联合来更新集合。

示例 🅰️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set1.update([1,2,3])
set1
output:{1, 2, 3, ‘Dream丶Killer’, ‘Python新视野’, ‘python-sun’}

示例 🅱️

set1 = {
   
   'Dream丶Killer',
        'Python新视野',
        'python-sun'}
set1 = set1 | set([1,2,3])
set1
output:{1, 2, 3, ‘Dream丶Killer’, ‘Python新视野’, ‘python-sun’}

使用 | 也能够达到相同的效果。



对于刚入门 Python 或是想要入门 Python 的小伙伴,能够经过下方小卡片联系做者,一块儿交流学习,都是重新手走过来的,有时候一个简单的问题卡好久,但可能别人的一点拨就会恍然大悟,由衷的但愿你们可以共同进步。另有整理的近千套简历模板,几百册电子书等你来领取哦!

也能够直接加本人微信,备注:【交流群】,我拉你进Python交流群👇🏻

👇🏻 关注小卡片,回复“交流群”,一块儿学习Python👇🏻