一、Python3基础03:基本数据类型

目录

一、Python数据类型简介

二、Python数据类型

1. 数字数据类型

1.1 Python支持的数值类型

1.2 Python内置数据类型转换方法

2. 字符串类型

2.1 创建字符串

2.2 字符串转义

2.3 字符串跨行显示

3. 字符串处理

3.1 提取字符串数据

3.2 字符串拼接

3.3 Python字符串%格式化输出

3.4 f-string方法格式化字符串(python3.6)

3.5 使用等号来拼接运算表达式与结果(python3.8)

4. 列表数据类型

4.1 什么是列表

4.2 创建列表

4.3 修改与删除操作

4.4 截取与拼接操作

4.5 列表嵌套及引用

4.6 列表支持的函数与方法

5. 元组数据类型

5.1 什么是元组

5.2 访问元组数据类型

5.3 删除、修改、和组合操作

5.4 元组的内置函数

6. 字典数据类型

6.1 创建字典类型数据

6.2 新增、修改、删除字典元素

6.3 字典有哪些特性

6.4 字典内置函数与方法

7. 集合数据类型

7.1 创建集合

7.2 操作集合数据

7.3 集合内置的方法


上一篇:02 Python3基础:变量的定义_卡卡6的博客-CSDN博客

一、Python数据类型简介

Python3 有六种标准的数据类型:

(1)Number(数字):int、float、bool、complex(复数类型)

(2)String(字符串):Python中的字符串用单引号 ' 或双引号 " 括起来,同时使用反斜杠\转义特殊字符(自己套自己的时候)

(3)List(列表):List是 Python 中使用最频繁的数据类型,列表可以完成大多数集合类的数据结构实现

(4)Tuple(元组):元组(tuple)与列表类似,不同之处在于元组的元素不能修改。元组写在小括号 () 里,元素之间用逗号隔开,元组中的元素类型也可以不相同

(5)Set(集合):集合是由一个或数个形态各异的大小整体组成的,构成集合的事物或对象称作元素或是成员

(6)Dictionary(字典):字典(dictionary)是Python内置数据类型

二、Python数据类型

1. 数字数据类型

1.1 Python支持的数值类型

(1)整型(int) 通常被称为是整型或整数,是正或负整数,不带小数点。Python3 整型是没有限制大小的,可以当作 Long 类型使用,所以 Python3 没有 Python2 的 Long 类型。

整数可以使用二进制(0b)、八进制(0o)、十进制、十六进制(0x)来表示。

(2)布尔值只有True、False两种值(真和假),要么是True,要么是False,在Python中,可以直接用True、False表示布尔值(首字母大写)。

(3)浮点型(float) 浮点型由整数部分与小数部分组成,浮点型也可以使用科学计数法表示(2.5e2 = 2.5 x  = 250)。

(4)复数( complex) :复数由实数部分和虚数部分构成,可以用a + bj或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型。

示例代码

#!/usr/bin/python3

data1=0b1000010  #二进制

data2=0o102    #八进制

data3=66      #十进制

data4=0x42     #十六进制

float_data=123.456 #浮点数

print ("data1=", data1)

print ("data2=", data2)

print ("data3=", data3)

print ("data4=", data4)

print ("float_data=", float_data)

运行结果:对于整型数据(2/8/16进制),print默认以10进制数打印。

ata1= 66

data2= 66

data3= 66

data4= 66

float_data= 123.456

1.2 Python内置数据类型转换方法

Python提供了很多内置数据类型转换方法,如果需要对数据类型做转换,只需要将数据类型作为函数名传参即可。常用的类型转换函数如下:

int(x)

将x转换为一个整数返回

float(x)

将x转换到一个浮点数

complex(x)

将x转换到一个复数,实数部分为 x,虚数部分为0

complex(x, y)

将x和y转换到一个复数,实数部分为x,虚数部分为y。x和y是数字表达式。

hex(x)

把一个整数转换为十六进制字符串

oct(x)

把一个整数转换为八进制字符串

ord(x)

返回对应的 ASCII 数值或者 Unicode 数值

str(x)

将数字转化为String

bin(x)

将一个数字转为二进制字符串

例如:

#!/usr/bin/python3

a=0x38

print(bin(a))

输出结果:

0b111000

示例代码

#!/usr/bin/python3

int_data="123"

print(int(int_data))  #将字符串转为整数

print(hex(1234))      #将整数1234转换为十六进制字符串

print(oct(1234))      #将整数1234转换为八进制字符串

print(ord('A'))       #返回字符对应的ASCII数值 

f_data="123.456"

print(float(f_data))  #将f_data转换成一个浮点数 

data=6789

print(str(data))      #将data转化为String

运行结果

123

0x4d2

0o2322

65

123.456

6789

注:字符串类型要转成对应的数据类型才可以参与数值计算,例子如下:

dat0=0b1010
dat1=0o12
dat2=10
dat3=0xA
dat4="20.23"
print("dat0", dat0)
print("dat1", dat1)
print("dat2", dat2)
print("dat3", dat3)
print("dat4", dat4-0.23) #报错:TypeError: unsupported operand type(s) for -: 'str' and 'float'
#print("dat4", float(dat4)-0.23) #结果是20.0

2. 字符串类型

2.1 创建字符串

字符串是Python中最常用的数据类型,字符串是以单引号'或双引号"括起来的任意文本,比如: 

#!/usr/bin/python3

str1 = 'Hello World!'

str2 = "i am python"

2.2 字符串转义

如果字符串内部包含'和"可以用转义字符\来转义,比如:

#!/usr/bin/python3

str="\"What\'s your name?\""

print(str)

转义字符\可以转义很多字符,字符\本身也要转义,如果想输出\字符,代码里需要写两个\\,比如:

str="\\"

print(str)

如果字符串里面有很多字符都需要转义,就需要加很多转义符\,为了简化,Python还允许用r'xxxxxxxxxx'表示' xxxxxxxxxx '内部的字符串默认不转义,比如:

#!/usr/bin/python3

str=r'"What is your name?"'

print(str)

2.3 字符串跨行显示

python允许一个字符串跨多行,这个字符串需要用三引号包含起来,字符串中可以包含换行符、制表符以及其他特殊字符。使用这种方法在编写HTML代码或者SQL语句时会特别的方便,不需要频繁的转义。

三引号可以使用''' 或者 """ 表示。 (三个单引号或者三个双引号)

示例代码:

#!/usr/bin/python3

str = """欢迎\n学习Python"编程语言"[\t]"""

print(str)

运行输出:

欢迎

学习Python"编程语言"[   ]

3. 字符串处理

3.1 提取字符串数据

Python不支持单字符类型,单字符在 Python 中也是作为一个字符串使用,Python可以使用方括号和下标组合来截取指定位置的字符串,取头不取尾,可以理解为数学概念上的区间,如:str[n:m]= [n,m)。缺头表示头为0(为[0, m)),缺尾表示全部取。

实例代码:

#!/usr/bin/python3

str = "欢迎学习Python编程语言"

print("str[1]=", str[1])   #取出字符串里的第一个数据

print("str[2:4]=",str[2:4]) #取出字符串里2~4位置的数据

print("str[4:10]=",str[4:10]) #取出4~10之间的数据

print("str[:10]=",str[:10]) #取出0~10之间的数据

print("str[0:]=",str[0:]) #取出全部数据

运行结果

str[1]= 迎

str[2:4]= 学习

str[4:10]= Python

str[:10]= 欢迎学习Python

str[0:]= 欢迎学习Python编程语言

注:(1)下标从0开始【跟C语言相似】(2)取头不取尾 (3)尾部省略表示全取,头部省略表示从0开始

3.2 字符串拼接

Python支持截取目标字符串的一部分并与其他字符串拼接,对加号是可重载的,实例代码:

#!/usr/bin/python3

str = "欢迎学习Python编程语言"

str = str[:4] +"前端语音"

str = str + "信号处理"

print(str)

运行结果:

欢迎学习前端语音信号处理

3.3 Python字符串%格式化输出

在许多编程语言中都包含有格式化字符串的功能,比如C语言中的格式化输入输出。Python中内置有对字符串进行格式化的操作% 。

格式化字符串时,Python使用一个字符串作为模板,模板中有格式符,这些格式符为真实值预留位置,并说明真实数值应该呈现的格式,注意前后的对应关系

示例代码

#!/usr/bin/python3 

print("My name is %s% ("jonn"))

print("我每天%d点上班,每天晚上去%s散步!" % (8,"附近公园"))

代码里的%代表了格式化操作。

运行输出

My name is jonn

我每天8点上班,每天晚上去附近公园散步!

python字符串格式化符号:

符号

描述

%c

格式化字符及其ASCII码

%s

格式化字符串

%d

格式化整数

%u

格式化无符号整型

%o

格式化无符号八进制数

%x

格式化无符号十六进制数

%X

格式化无符号十六进制数(大写)

%f

格式化浮点数字,可指定小数点后的精度

%e

用科学计数法格式化浮点数

%E

作用同%e,用科学计数法格式化浮点数

%g

%f和%e的简写

%G

%f 和 %E 的简写

%p

用十六进制数格式化变量的地址

格式化操作符辅助指令:

符号

功能

m.n

m 是显示的最小总宽度,n 是小数点后的位数。m和n可以使用*号代替,使用后面的参数替换,一般用于调节显示。

#!/usr/bin/python3 

#*号代替宽度,可以使用后面数据替换

print("My name is %*s" % (10,"jone"))

#直接设置输出宽度为10

print("My name is %10s" % ("jone"))

#精确小数点为4位,输出宽度为10,*代替,可以使用后面数据替换

print("float类型的数据:%*.*f" % (10, 4, 12.34))

#精确小数点为4位,输出宽度为10

print("float类型的数据:%10.4f" % (12.34))

运行结果

My name is       jone

My name is       jone

float类型的数据:   12.3400

float类型的数据:   12.3400

-

实现数据左对齐

#!/usr/bin/python3

print("%10d %d" % (100,200))  #没有左对齐

print("%-10d %d" % (100,200)) #设置左对齐

输出:

       100 200

100        200 #左对齐

+

在正数前面显示加号( + )

print("%d" % (100))

print("%+d" % (100))

print("%+d" % (-100))

运行结果:

100

+100

-100

#

在八进制数前面显示零('0'),在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')

print("%#X" % (0x64))

print("%#X" % (100))

print("%#o" % (100))

运行结果:

0X64

0X64

0o144

0

表示使用0填充左侧多余空格部分。仅对数值起效。

print("%010d" % (100))

运行结果:

0000000100

%

'%%'输出一个单一的'%'

print("%d%%" % (99))

运行结果:

99%

(var)

映射变量(字典参数)

print("%(a)s=%(b)d" % {'a':"data",'b':88})   

输出结果:

data=88

3.4 f-string方法格式化字符串(python3.6)

f-string是python3.6加入标准库的,称为"格式化字符串文字",是新的格式化字符串的语法。

f-string 格式化字符串以f/F开头,后面跟着字符串,字符串中的表达式用大括号 {} 包起来,它会将变量或表达式计算后的值替换进去。

示例代码:

#!/usr/bin/python3

str=f"{10*100+123}"  #填入表达式进行计算

print(str) 

data="jone"

str=f"My name is {data}"  #替换变量

print(str)

运行结果

1123

My name is jone

3.5 使用等号来拼接运算表达式与结果(python3.8)

在python3.6版本中增加了f-strings,可以使用f前缀更方便的格式化字符串,同时还能进行计算。

在3.8版本中只需要增加一个=符号,就可以拼接运算表达式与结果。示例代码如下:

data1=10

data2=20

str=f"{data1+data2+100}"  #python3.6版本

print(str) 

str=f"{data1+data2+100=}" #python3.8版本

print(str)

运行结果

130

data1+data2+100=130

4. 列表数据类型

4.1 什么是列表

(list)列表是Python内置的一种数据类型。列表是Python中最基本的数据结构,是一种有序的集合,可以随时添加和删除其中的元素,列表中的每个元素都分配一个位置索引,第一个索引是0,第二个索引是1,依此类推。

术语“列表值”指的是列表本身,而不是指列表值之内的那些值,列表中的值也称为“表项”,表项用逗号分隔,列表用左方括号开始,右方括号结束,即[]。

列表的数据项不需要具有相同的类型。

列表是用索引来访问每一个位置的元素,索引是从0开始计算的(类似C语言的数组)。

4.2 创建列表

示例代码

#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys
list1 = ["小米", '华为', 1868, 1666]
list2 = [66, 77, 88, 99, 100 ]
list3 = ["a", "b", "c", "d"] 
print ("list1[0]=",list1[0])  #输出列表索引0位置的数据
print ("list1[1]=",list1[1])  #输出列表索引1位置的数据
print ("list2[1:2]=",list2[1:2])#输出列表索引1~2位置的数据
print ("list3[:3]=",list3[:3])#输出列表索引前3位的数据 
print ("list1=",list1) #输出列表1里的全部数据
print ("list2=",list2) #输出列表2里的全部数据
print ("list3=",list3) #输出列表3里的全部数据

运行结果:

list1[0]= 小米
list1[1]= 华为
list2[1:2]= [77]
list3[:3]= ['a', 'b', 'c']
list1= ['小米', '华为', 1868, 1666]
list2= [66, 77, 88, 99, 100]
list3= ['a', 'b', 'c', 'd']

注:(1)下标从0开始【跟C语言相似】(2)取头不取尾 (3)尾部省略表示全取,头部省略表示从0开始

4.3 修改与删除操作

对列表的数据项进行修改,通过[]方括号直接定位索引位置赋值修改即可,使用 del 语句可以删除列表指定位置的数据,也可以直接删除整个列表。

示例代码

#!/usr/bin/python3 

list1 = ["小米", '华为', 1868, 1666]

list2 = [66, 77, 88, 99, 100 ]

list3 = ["a", "b", "c", "d"] 

list1[0]="魅族" #修改列表索引0位置的值

print ("list1[0]=",list1[0])  #输出列表索引0位置的数据

print ("list1[1]=",list1[1])  #输出列表索引1位置的数据

print ("list2[1:2]=",list2[1:2])#输出列表索引1~2位置的数据

print ("list3[:3]=",list2[:3])#输出列表前3个位置的数据 

del list1[3]  #删除列表索引3位置的数据

del list2[2:4] #删除2~3位置的数据

del list3[3] #删除索引3位置的数据

del list3 #可以直接删除整个列表 

print ("list1=",list1) #输出列表1里的全部数据

print ("list2=",list2) #输出列表2里的全部数据

print ("list3=",list3) #输出列表3里的全部数据

运行结果:

list1[0]= 魅族

list1[1]= 华为

list2[1:2]= [77]

list3[:3]= [66, 77, 88]

list1= ['魅族', '华为', 1868]

list2= [66, 77, 100]

Traceback (most recent call last):

  File "g:\python编程入门\02bianliang.py", line 16, in <module>

    print ("list3=",list3) #输出列表3里的全部数据

NameError: name 'list3' is not defined

4.4 截取与拼接操作

列表对加号可重载。

示例代码

#!/usr/bin/python3 

list = ["小米",'华为',1868,1666,111,222,333]

print(list[-1])  #打印列表最后一个数据

print(list[-2])  #打印列表倒数第二个数据

print(list[-3])  #打印列表倒数第三个数据

print(list[1:])  #打印第2个数据开始后面的所有数据 

list=list+[1,2,3]  #列表的拼接

print(list) 

list=['a','b','c',1,2,3]#列表的拼接

print(list)

运行结果

33

222

111

['华为', 1868, 1666, 111, 222, 333]

['小米', '华为', 1868, 1666, 111, 222, 333, 1, 2, 3]

['a', 'b', 'c', 1, 2, 3]

4.5 列表嵌套及引用

类似于C语言的多维数组一样,使用索引嵌套取值即可。

示例代码

#!/usr/bin/python3 

list=[[1,2,3,4], ['a','b','c','d'], [66,77,88,99,100]]

print(list[0][0])

print(list[1][0])

print(list[2][2])

print(list[2][5])

print(list)   #输出列表里所有数据

运行结果:

1

a

88

Traceback (most recent call last):

  File "g:\python编程入门\02bianliang.py", line 6, in <module>

    print(list[2][5])

IndexError: list index out of range

4.6 列表支持的函数与方法

Python包含以下函数:

序号

函数

1

len(list)获取列表元素个数

示例:

list1=[[1,2,3,4],['a','b','c','d'],[66,77,88,99,100]]

list2=["2G","3G","4G","5G"]

print(len(list1)) #得到list1的长度,如果是嵌套列表,只是得到列表的数量,返回值为3

print(len(list1[2])) #得到嵌套列表里指定列表的元素数量,返回值为5

print(len(list2)) #得到列表的元素数量,返回值为4

print(len(list2[2])) #得到列表指定元素字符串数量,返回值为2

print(len(list1[2][1]))

运行:

3

5

4

2

Traceback (most recent call last):

  File "g:\python编程入门\02bianliang.py", line 9, in <module>

    print(len(list1[2][1]))

TypeError: object of type 'int' has no len()

2

max(list)返回列表元素最大值,数值类型就是最大值,字符串类型是最大长度。

示例:

list1=["123","abcdef","456","7890"]

list2=[1,66,88,100,8888]

print(max(list1))  #输出结果:abcdef

print(max(list2))  #输出结果:8888

3

min(list)返回列表元素最小值,数据类型计算最小值,字符串类型计算最小长度

示例:

list1=["123","abcdef","456","7890"]

list2=[1,66,88,100,8888]

print(min(list1))  #输出结果:123

print(min(list2))  #输出结果:1

4

list(seq)将元组转换为列表,参数就是元组。

示例:

buff=(666,"python",'wbyq','jone')  #定义一个元组

list1 = list(buff) #转换为列表

print ("列表索引[1]元素:",list1[1])

print ("列表全部元素:",list1)

str="Hello World"   #定义一个字符串

list2=list(str)    #转换为列表

print("列表全部元素:",list2)

运行结果:

列表索引[1]元素: python

列表全部元素: [666, 'python', 'wbyq', 'jone']

列表全部元素: ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

Python包含以下方法:

序号

方法

1

list.append(obj)在列表末尾添加新的对象

示例:

list=['a','b','c']

list.append('d')

list.append('e')

print ("列表全部元素:",list)

运行结果:

列表全部元素: ['a', 'b', 'c', 'd', 'e']

2

list.count(obj)统计某个元素在列表中出现的次数

示例:

list=['666',"666",'wbyq',"python",123,123,123]

print ("列表里\"666\"出现的次数:",list.count("666"))

print ("列表里\"python\"出现的次数:",list.count("python"))

print ("列表里123出现的次数:",list.count(123))

运行结果:

列表里"666"出现的次数: 2

列表里"python"出现的次数: 1

列表里123出现的次数: 3

3

list.extend(seq)在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)

示例:

list1=[1,2,3,4]

list2=['a','b','c','d']

list3=['南昌','成都','绵阳']

list3.extend(list1) #在list3结尾添加list1

list3.extend(list2) #在list3结尾添加list2

print(list3) #输出list3

运行结果:

['南昌', '成都', '绵阳', 1, 2, 3, 4, 'a', 'b', 'c', 'd']

4

list.index(obj)从列表中找出某个值第一个匹配项的索引位置

index()方法语法:list.index(x[, start[, end]])

参数:

x   查找的对象

start 可选,查找的起始位置(下标)

end 可选,查找的结束位置(下标)

示例:

list=['南昌','成都','绵阳','庐山','鄱阳湖']

print("'绵阳'出现的索引位置:",list.index('绵阳'))  #默认从索引位置开始搜索

print("'鄱阳湖'出现的索引位置:",list.index('鄱阳湖',2)) #设置从第2个元素位置开始搜索

print("'庐山'出现的索引位置:",list.index('庐山',2,4))#设置从第2~4个元素位置之间搜索

运行结果:

'绵阳'出现的索引位置: 2

'鄱阳湖'出现的索引位置: 4

'庐山'出现的索引位置: 3

5

list.insert(index, obj)将对象插入列表指定位置

示例:

list=['南昌','成都','绵阳']

list.insert(0,'自贡') #在第0个索引位置插入数据

list.insert(2,'666')

print(list)

运行结果:

['自贡', '南昌', '666', '成都', '绵阳']

6

list.pop([index=-1])移除列表中的一个元素(默认最后一个元素),并且返回该元素的值,参数填要删除数据的索引值

示例:

list=['南昌','成都','绵阳',"重庆",'上海','北京']

print('现在列表里的值:',list)

print('删除的值:',list.pop(-1))  #填-1默认删除最后的值

print('现在列表里的值:',list)

print('删除的值:',list.pop(2))  #删除指定位置的值

print('现在列表里的值:',list)

运行结果:

现在列表里的值: ['南昌', '成都', '绵阳', '重庆', '上海', '北京']

删除的值: 北京

现在列表里的值: ['南昌', '成都', '绵阳', '重庆', '上海']

删除的值: 绵阳

现在列表里的值: ['南昌', '成都', '重庆', '上海']

7

list.remove(obj)移除列表中某个值,该方法没有返回值,参数是填具体的值。

示例:

list=['南昌','成都','绵阳',"重庆",'上海','北京']

print('现在列表里的值:',list)

list.remove('绵阳')  #删除指定元素

print('现在列表里的值:',list)

list.remove('北京')  #删除指定元素

print('现在列表里的值:',list)

运行结果:

现在列表里的值: ['南昌', '成都', '绵阳', '重庆', '上海', '北京']

现在列表里的值: ['南昌', '成都', '重庆', '上海', '北京']

现在列表里的值: ['南昌', '成都', '重庆', '上海']

8

list.reverse()反向列表中元素,该方法没有返回值,但是会对列表的元素进行反向排序

示例:

list=['1','2','3','4','5']

print('列表原来的值:',list)

list.reverse()  #反向排序列表里的元素

print('反向之后的值:',list)

运行结果:

列表原来的值: ['1', '2', '3', '4', '5']

反向之后的值: ['5', '4', '3', '2', '1']

9

list.sort( key=None, reverse=False)对原列表进行排序

语法: list.sort( key=None, reverse=False)

参数:

key是用来进行比较的元素

reverse 表示排序规则,reverse = True 从大到小,reverse = False 从小到大(默认)

示例:

list=[123,456,12,34,89,45]

print('列表原来的值:',list)

list.sort() #默认从小到大排序

print('从小到大排序之后的值:',list)

list.sort(reverse = True) #默认从小到大排序

print('从大到小排序之后的值:',list)

list=["123","12","1234","1"]

print('列表原来的值:',list)

list.sort() #默认从小到大排序

print('从小到大排序之后的值:',list)

list.sort(reverse = True) #默认从小到大排序

print('从大到小排序之后的值:',list)

运行结果:

列表原来的值: [123, 456, 12, 34, 89, 45]

从小到大排序之后的值: [12, 34, 45, 89, 123, 456]

从大到小排序之后的值: [456, 123, 89, 45, 34, 12]

列表原来的值: ['123', '12', '1234', '1']

从小到大排序之后的值: ['1', '12', '123', '1234']

从大到小排序之后的值: ['1234', '123', '12', '1']

10

list.clear()清空列表所有数据 

示例:

list=[123,456,12,34,89,45]

list.clear()

print(list)

运行结果:

[]

11

list.copy()拷贝整个列表:浅层拷贝

示例:

list1=[123,456,12,34,89,45]

list2=list1.copy()

print(list1)

print(list2)

运行结果:

[123, 456, 12, 34, 89, 45]

[123, 456, 12, 34, 89, 45]

Python列表赋值拷贝,浅拷贝,深拷贝的区别

(1)赋值拷贝也称引用赋值,指向的是同一块内存,所以更改一个,另一个也会发生改变

(2)浅copy():复制一个副本,按道理来说,原值和新复制的变量互不影响。但是浅拷贝也称不完全拷贝,仅限于一维内存拷贝,对于多维的列表,内存是共用的

示例代码:

list1=[123,456,12,34,89,45]

list2=list1  #将list1赋值给list2 相当于引用-别名,指向同一块内存。

list3=list1.copy() #将list1拷贝一份给list3,创建一个新的列表

del list1[1]       #不影响list3,因为一维列表list1被完全拷贝。

print("list1=",list1)

print("list2=",list2)

print("list3=",list3)  #不会发生改变

list1=[[1,2,3],[4,5,6],[7,8,9]]

list2=list1  #将list1赋值给list2 相当于引用-别名

list3=list1.copy() #将list1拷贝一份给list3,创建一个新的列表

del list1[1]       #只是删掉list1的引用,不影响list3对内存块的引用

                    #list1/2/3引用同一个内存块

print("list1=",list1)

print("list2=",list2)

print("list3=",list3)  #不会发生改变

list1=[[1,2,3],[4,5,6],[7,8,9]]

list2=list1       #将list1赋值给list2 相当于引用-别名

list3=list1.copy() #将list1拷贝一份给list3,创建一个新的列表

list1[1][1]=666   #修改值

print("list1=",list1)

print("list2=",list2)

print("list3=",list3)  #发生改变,因为对于多维列表,浅拷贝内存是共用的。

运行结果:

list1= [123, 12, 34, 89, 45]

list2= [123, 12, 34, 89, 45]

list3= [123, 456, 12, 34, 89, 45]

list1= [[1, 2, 3], [7, 8, 9]]

list2= [[1, 2, 3], [7, 8, 9]]

list3= [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

list1= [[1, 2, 3], [4, 666, 6], [7, 8, 9]]

list2= [[1, 2, 3], [4, 666, 6], [7, 8, 9]]

list3= [[1, 2, 3], [4, 666, 6], [7, 8, 9]]

(3) 深拷贝deepcopy:深拷贝也称“完全内存拷贝”,将多维列表中的内容递归的复制一遍,重新存储到另一块新的内存空间,所以深拷贝就不会出现内存共用的情况。深度拷贝需要导入copy模块

list1=[[1,2,3],[4,5,6],[7,8,9]]

list2=list1       #将list1赋值给list2 相当于引用-别名

list3=copy.deepcopy(list1) #深拷贝

list1[1][1]=666   #修改值

print("list1=",list1)

print("list2=",list2)

print("list3=",list3) #不会发生改变

运行结果:

list1= [[1, 2, 3], [4, 666, 6], [7, 8, 9]]

list2= [[1, 2, 3], [4, 666, 6], [7, 8, 9]]

list3= [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

5. 元组数据类型

5.1 什么是元组

Python的元组(tuple)与列表类似,不同之处在于元组(tuple)一旦初始化就不能修改,元组使用小括号,而列表使用方括号。

创建元组只需要在括号中添加元素,并使用逗号隔开,当元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用。

创建元组示例代码:

tuple1=(12,34,56,78,90)

tuple2=('a','b','c','d')

tuple3=('python',)

tuple4=('wbyq')

print(tuple1)

print(tuple2)

print(tuple3)

print("tuple3类型:",type(tuple3))  #元组类型

print("tuple4类型:",type(tuple4))  #不加逗号会识别成字符串类型

运行结果

(12, 34, 56, 78, 90)

('a', 'b', 'c', 'd')

('python',)

tuple3类型: <class 'tuple'>

tuple4类型: <class 'str'>

5.2 访问元组数据类型

元组可以使用下标索引来访问元组中的值,与列表访问方法一样。

示例代码

tuple1=(12,34,56,78,90)

print(tuple1[0])

print(tuple1[:3])

print(tuple1[-1])

print(tuple1[-2])

print(tuple1)

运行结果

12

(12, 34, 56)

90

78

(12, 34, 56, 78, 90)

5.3 删除、修改、和组合操作

Python规定元组中的元素值初始化之后就不允许修改和删除,如果想要删除元组也只能对整个元组进行删除

但是元素不可变有一种特殊情况,当元素是可变对象时。对象内部属性是可以修改的,tuple的不可变限制只是在一个纬度上:元素的类型;tuple的元素所保存的内容(数值或内存地址)是不允许修改的,但地址映射的对象自身是可以修改的。

元组初始化之后,虽然不能对单个元素修改,但是可以对整个元组进行重新赋值修改。

两个以上的元组类型数据可以合成一个新的元组类型数据,不违背原理,这个属于创建一个新的元组类型结构,重新赋值的元组 tup,绑定到新的对象了,不是修改了原来的对象。

删除、合成示例代码:

tuple=(12,34,56,78,90)#tuple[1]=888   无法修改数据、非法操作

#del tuple[1]    无法删除数据、非法操作del数据成员,但是可以删除整个元组 

tuple1=(1,2,3,4)

tuple2=('a','b','c','d')

tuple3=tuple1+tuple2  #组合成一个新的元组数据

print(tuple3)

运行结果

(1, 2, 3, 4, 'a', 'b', 'c', 'd')

修改示例代码:元组中含有列表

list=[1,2,3,4]

tuple=(list,56,78,90)   #将列表当做元组的元素

print("tuple源值=",tuple)

list[0]=666  #修改列表的数据

list[1]=777  #修改列表的数据

del list[2]  #删除列表的数据

print("修改tuple之后的值=",tuple)

运行结果

tuple源值= ([1, 2, 3, 4], 56, 78, 90)

修改tuple之后的值= ([666, 777, 4], 56, 78, 90)

5.4 元组的内置函数

序号

方法及描述

示例代码

1

len(tuple)计算元组元素个数。

tuple1=(12,34,56,78)

tuple2=('python','c++','java','c#','php')

print('tuple1元素数量:',len(tuple1))

print('tuple2元素数量:',len(tuple2))

运行结果:

tuple1元素数量: 4

tuple2元素数量: 5

2

max(tuple)返回元组中元素最大值。

tuple1=(12,34,56,78)

tuple2=('python','c++','java','c#','php')

print('tuple1元素数量:',max(tuple1))

print('tuple2元素数量:',max(tuple2))

运行结果:

tuple1元素数量: 78

tuple2元素数量: python

3

min(tuple)返回元组中元素最小值。

tuple1=(12,34,56,78)

tuple2=('python','c++','java','c#','php')

print('tuple1元素数量:',min(tuple1))

print('tuple2元素数量:',min(tuple2))

运行结果:

tuple1元素数量: 12

tuple2元素数量: c#

4

tuple(seq)将列表类型转换为元组类型。

list=[12,34,56,78]

tup=tuple(list)

print(tup)

运行结果:

(12, 34, 56, 78)

6. 字典数据类型

6.1 创建字典类型数据

字典是Python提供的一种常用数据结构,它用于存放具有映射关系的数据(键-值/key-value),它是一种可变容器模型,可存储任意类型对象,特点是: 元素可以无序,键key必须唯一。

规则:

(1)字典的每个键值对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中 。

(2)字典的创建语法是:  data = {key1 : value1, key2 : value2 }

字典里的键key只能是不可变的数据类型(整型,字符串或者是元组),值values可以是任何数据类型。 

创建字典实例代码:

#创建字典

data={'小米':1999, '华为':3999, '苹果':6999, 888:'python'} 

#访问字典里的值

print("data['小米']=", data['小米'])

print("data['华为']=", data['华为'])

print("data['苹果']=", data['苹果'])

print("data[888]=", data[888]) 

#输出字典里所有键值对

print("data=", data) 

运行结果

data['小米']= 1999

data['华为']= 3999

data['苹果']= 6999

data[888]= python

data= {'小米': 1999, '华为': 3999, '苹果': 6999, 888: 'python'}

6.2 新增、修改、删除字典元素

修改字典的值,使用[]括号指定键的名称直接赋值即可修改。

删除字典可以指定键名称del删除,可以调用clear方法清除字典,可以使用del删除整个字典。

示例代码

# 创建字典

data={'小米':1999,'华为':3999,'苹果':6999,888:'python'} 

# 修改字典数据值

data['小米']=2999

data['华为']=5999

print("data['小米']=", data['小米'])

print("data['华为']=", data['华为']) 

# 增加新的键值对(追加)

data['三星']=7999

data['诺基亚']=1299 

# 输出字典里所有键值对

print("字典里所有值:",data)  

# 删除指定的键

del data['苹果']

print("字典里所有值:",data)  

data.clear() #清空字典

del data #删除字典

运行结果

data['小米']= 2999

data['华为']= 5999

字典里所有值: {'小米': 2999, '华为': 5999, '苹果': 6999, 888: 'python', '三星': 7999, '诺基亚': 1299}

字典里所有值: {'小米': 2999, '华为': 5999, 888: 'python', '三星': 7999, '诺基亚': 1299}

6.3 字典有哪些特性

(1)字典的值可以是任何的python 对象,既可以是标准的对象,也可以是用户定义的,但键只能是不可变的数据类型(整型,字符串或者是元组)。

data={<键名>:<字典数据值>}

示例代码:

#!/usr/bin/python3

# data={<键>:<数据值>}

list=[12,34,56]

tuple=(12,34,56) 

data={list:12345}  #这行代码是错误的,列表的数据可变,不能当做键

data={tuple:12345} #代码正确,元组数据不可变,可以当做键

运行结果分析:

Traceback (most recent call last):

  File "g:\python编程入门\02bianliang.py", line 5, in <module>

    data={list:12345}  #这行代码是错误的,列表的数据可变,不能当做键

TypeError: unhashable type: 'list'

(2)字典的键值是"只读"的,不能对键和值分别进行初始化。

(3)字典支持相互嵌套

示例代码

#!/usr/bin/python3

data={    

    '南昌': {        

            '华东交通大学': {            

                    '计算机与科学技术': 123,            

                '电子信息工程': 456,            

                '汉语言文学': 66,            

                 },       

            '南昌大学': {            

                '计算机与科学技术': 55,            

                '电子信息工程': 128,            

                '汉语言文学': 456,            

                }        

            }, 

    '武汉': {        

            '中南民族大学': {            

                '计算机与科学技术': 56,            

                '电子信息工程': 77,            

                '汉语言文学': 666,            

                },        

            '华中科技大学': {            

                '计算机与科学技术': 567,            

                '电子信息工程': 345,            

                '汉语言文学': 68,            

                }        

            }

    

print("南昌大学专业报考信息:", data['南昌']['南昌大学'])

print("华中科技大学'计算机与科学技术'专业报考人数:%d人" % (data['武汉']['华中科技大学']['计算机与科学技术']))

print("中南民族大学'汉语言文学'专业报考人数:%d人" % (data['武汉']['中南民族大学']['汉语言文学']))

运行结果

南昌大学专业报考信息: {'计算机与科学技术': 55, '电子信息工程': 128, '汉语言文学': 456}

华中科技大学'计算机与科学技术'专业报考人数:567人

中南民族大学'汉语言文学'专业报考人数:666人

6.4 字典内置函数与方法

Python字典包含了以下内置函数:

序号

函数及描述

实例

1

len(dict)

计算字典元素个数,即键的总数。

data1={'小红':23,'小明':67}

data2={'小米':1999,'华为':8999,'苹果':9000}

print('data1中的键值数量:',len(data1))

print('data2中的键值数量:',len(data2))

运行结果:

data1中的键值数量: 2

data2中的键值数量: 3

2

str(dict)

输出字典,以可打印的字符串表示。

data1={'小红':23,'小明':67}

data2={'小米':1999,'华为':8999,'苹果':9000}

print('字典data1里的数据:',str(data1))

print('字典data2里的数据:',str(data2))

运行结果:

字典data1里的数据: {'小红': 23, '小明': 67}

字典data2里的数据: {'小米': 1999, '华为': 8999, '苹果': 9000}

3

type(variable)

返回输入的变量类型,如果变量是字典就返回字典类型,如果变量是字符串就返回字符串类型。

data1={'小红':23,'小明':67}

data2={'小米':1999,'华为':8999,'苹果':9000}

data3=[12,34,56]

data4=1234

data5="str1234"

print('data1类型:',type(data1))

print('data2类型:',type(data2))

print('data3类型:',type(data3))

print('data4类型:',type(data4))

print('data5类型:',type(data5))

运行结果:

data1类型: <class 'dict'>

data2类型: <class 'dict'>

data3类型: <class 'list'>

data4类型: <class 'int'>

data5类型: <class 'str'>

Python字典包含了以下内置方法:

序号

函数及描述

1

clear()删除字典内所有元素

示例:

data={'小红':23,'小明':67}

data.clear()  #清空所有元素

print("data=",data)

运行结果:

data= {}

2

copy()返回一个字典的浅复制

示例:

data1={'小红':23,'小明':67}

data2=data1.copy()  #拷贝副本

print(data1)

print(data2)

运行结果:

{'小红': 23, '小明': 67}

{'小红': 23, '小明': 67}

3

字典 fromkeys() 函数用于创建一个新字典,以序列 seq 中元素做字典的键,value 为字典所有键对应的初始值。

语法:dict.fromkeys(seq[, value])

示例:

val=('小米','华为','苹果') #定义键

data=dict.fromkeys(val)   #不赋值

print("新的字典=",data)    #输出结果

val=('小米','华为','苹果') #定义键

data=dict.fromkeys(val,1900) #赋值

print("新的字典=",data)    #输出结果

data=dict.fromkeys(['南昌','成都','北京'],'1890') #赋值

print("新的字典=",data)  #输出结果

运行结果:

新的字典= {'小米': None, '华为': None, '苹果': None}

新的字典= {'小米': 1900, '华为': 1900, '苹果': 1900}

新的字典= {'南昌': '1890', '成都': '1890', '北京': '1890'}

4

get(key, default=None)返回指定键的值,如果值不在字典中返回default值,default值默认为 None。

示例:

val={'小米':1299,'华为':2999,'苹果':6999} #定义键

print(val.get('小米'))

print(val.get('三星'))

print(val.get('三星','5999'))  #填写默认值

运行结果:

1299

None

5999

5

key in dict:in操作符用于判断键是否存在于字典中,如果键在字典 dict 里返回 true,否则返回 false。

而 not in 操作符刚好相反,如果键在字典 dict 里返回 false,否则返回 true。

查询语法: <要查找的键>  in/not in  <字典名称>

示例:

val={'小米':1299,'华为':2999,'苹果':6999} #定义键

if  '苹果' in val:

    print("键 苹果 存在")

else :

    print("键 苹果 不存在")

if  '三星' in val:

    print("键 三星 存在")

else :

    print("键 三星 不存在")

if  '苹果' not in val:

    print("键 苹果 不存在")

else :

    print("键 苹果 存在")

if  '三星' not in val:

    print("键 三星 不存在")

else :

print("键 三星 存在")

运行结果:

键 苹果 存在

键 三星 不存在

键 苹果 存在

键 三星 不存在

6

items()以列表返回可遍历的(键, 值) 元组数组, 不能直接返回列表,若要返回列表值还需调用list函数。

示例:

val={'小米':1299,'华为':2999,'苹果':6999}

print("字典的值:",val.items())

print("列表形式:",list(val.items()))

运行结果:

字典的值: dict_items([('小米', 1299), ('华为', 2999), ('苹果', 6999)])

列表形式: [('小米', 1299), ('华为', 2999), ('苹果', 6999)]

7

keys()返回一个迭代器,可以使用 list() 来转换为列表,Python2.x 是直接返回列表

示例:

val={'小米':1299,'华为':2999,'苹果':6999}

print("字典的值:",val.keys())

print("列表形式:",list(val.keys()))

运行结果:

字典的值: dict_keys(['小米', '华为', '苹果'])

列表形式: ['小米', '华为', '苹果']

8

setdefault(key, default=None)和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default

参数:

key 查找的键值。

default 键不存在时,设置的默认键值。

返回值:

如果 key 在 字典中,返回对应的值。如果不在字典中,则插入 key 及设置的默认值 default,并返回 default ,default 默认值为 None。

示例:

val={'南昌':"南昌大学",'武汉':"武汉大学",'成都':"成都电子科技大学"}

print("字典的全部值:",val)

print("'南昌'键的值:",val.setdefault('南昌',None))

print("'武汉'键的值:",val.setdefault('武汉',None))

print("'长沙'键的值:",val.setdefault('长沙',None))

print("'桂林'键的值:",val.setdefault('桂林','桂林电子科技大学'))

运行结果:

字典的全部值: {'南昌': '南昌大学', '武汉': '武汉大学', '成都': '成都电子科技大学'}

'南昌'键的值: 南昌大学

'武汉'键的值: 武汉大学

'长沙'键的值: None

'桂林'键的值: 桂林电子科技大学

9

update(dict2) 把字典参数 dict2 的 key/value(键/值)对更新到字典dict里

update()方法语法:dict.update(dict2)

示例:

dict1={'南昌':"南昌大学",'武汉':"武汉大学",'成都':"成都电子科技大学"}

dict2={'桂林':"桂林电子科技大学",'北京':"北京大学",'天津':"南开大学"}

print("字典dict1的全部值:",dict1)

print("字典dict2的全部值:",dict2)

dict1.update(dict2)   #更新字典

print("字典dict1更新之后的值:",dict1)

示例:

字典dict1的全部值: {'南昌': '南昌大学', '武汉': '武汉大学', '成都': '成都电子科技大学'}

字典dict2的全部值: {'桂林': '桂林电子科技大学', '北京': '北京大学', '天津': '南开大学'}

字典dict1更新之后的值: {'南昌': '南昌大学', '武汉': '武汉大学', '成都': '成都电子科技大学', '桂林': '桂林电子科技大学', '北京': '北京大学', '天津': '南开大学'}

10

values()方法返回一个迭代器,可以使用list()来转换为列表,列表为字典中的所有值。

示例:

dict={'南昌':"南昌大学",'武汉':"武汉大学",'成都':"成都电子科技大学"}

print("字典所有值为:",list(dict.values()))

运行结果:

字典所有值为: ['南昌大学', '武汉大学', '成都电子科技大学']

11

pop(key[,default])删除字典给定键 key 所对应的值,返回值为被删除的值。如果要删除的 key 不存在,则需要添加默认值,否则会报错。

语法:pop(key[,default])

参数:

key: 要删除的键值

default: 如果没有 key,返回 default 值

示例:

dict={'南昌':"南昌大学",'武汉':"武汉大学",'成都':"成都电子科技大学"}

print("新字典的值:",dict)

print("删除的值:",dict.pop("南昌"))

print("删除的值:",dict.pop("成都"))

print("删除的值:",dict.pop("桂林","'桂林':NoKey"))

print("现在字典的值:",dict)

运行结果:

新字典的值: {'南昌': '南昌大学', '武汉': '武汉大学', '成都': '成都电子科技大学'}

删除的值: 南昌大学

删除的值: 成都电子科技大学

删除的值: '桂林':NoKey

现在字典的值: {'武汉': '武汉大学'}

12

popitem()方法随机返回并删除字典中的最后一对键和值。

如果字典已经为空,却调用了此方法,就报出KeyError异常。

示例:

dict={'南昌':"南昌大学",'武汉':"武汉大学",'成都':"成都电子科技大学"}

print(dict.popitem())

print(dict.popitem())  

print(dict.popitem()) 

print(dict)

运行结果:

('成都', '成都电子科技大学')

('武汉', '武汉大学')

('南昌', '南昌大学')

{}

7. 集合数据类型

7.1 创建集合

(1)集合也是python中的一种基本数据类型,特点是其中的元素都是不重复的,而且是无序的。

集合分为两种:可变集合set和不可变集合frozenset。

(2)可变集合set:创建非空的集合时,参数必是迭代器类型,比如:列表/字典等,然后转换成无序不重复的集合,所以可以用来去重(去掉重复的元素)

(3)不可变集合frozenset:是不能被改变的,也就是不能插入和删除,类似于元组。

(4)集合是写在花括号{}之间或者set()函数创建集合,用逗号,分隔开。

(5)创建一个空集合必须用set()函数,因为 {} 是用来创建一个空字典。

创建集合示例代码:

#!/usr/bin/python3

set_data1={"Python","C/C++","Java","C#",168,139,"Python","C#"}

print(set_data1)  #打印的数据支持去重功能

print("set_data1类型:",type(set_data1)) 

set_data2={}   #空括号表示字典类型

print("set_data2类型:",type(set_data2)) 

set_data3=set({}) #使用set函数创建集合类型

print("set_data3类型:",type(set_data3)) 

list = ['小米', '华为','华为','小米', 'OPPO']

set_data4=set(list) #使用set函数将列表转为集合类型

print("set_data4类型:",type(set_data4))

print(set_data4)  #打印的数据支持去重功能

运行结果

{'Java', 'C#', 168, 'C/C++', 'Python', 139}

set_data1类型: <class 'set'>

set_data2类型: <class 'dict'>

set_data3类型: <class 'set'>

set_data4类型: <class 'set'>

{'华为', 'OPPO', '小米'}

7.2 操作集合数据

(1) 添加元素

添加元素可以使用add和update方法。语法格式: s.add(x) / s.update( x )

add方法将元素x添加到集合s中,如果元素已存在,则不进行任何操作。

update方法将元素x添加到集合s中,参数可以是列表,元组,字典等。

示例代码:

#!/usr/bin/python3

set_data={"Python","C/C++","Java","C#",168,139,"Python","C#"}

set_data.add("Go")

set_data.add("Python")  #如果元素已存在,则不进行任何操作

print("set_data集合的数据:",set_data)

list={'a','b','c'}

set_data.update(list)

print("set_data集合的数据:",set_data)

运行结果

set_data集合的数据: {'Python', 'Java', 'C/C++', 'Go', 168, 139, 'C#'}

set_data集合的数据: {'Java', 'b', 168, 'a', 139, 'c', 'Python', 'C/C++', 'C#', 'Go'}

(2) 移除元素

将元素从集合里移除有常见3个方法: s.remove(x)、s.discard(x)、s.pop()

remove将元素x从集合s中移除,如果元素不存在,则会发生错误。

discard移除集合中的元素,如果元素不存在,不会发生错误。

pop方法会对集合进行无序的排列,然后将这个无序排列集合的左面第一个元素进行删除,删除是随机的。

#!/usr/bin/python3

set_data={"Python","C/C++","Java","C#","Python","C#","shell","PHP"}

print("原集合数据:",set_data)

#set_data.remove("go")    #删除"Python"元素,如果元素不存在会报错

set_data.remove("Python")

print("现集合数据:",set_data)

set_data.discard("Python")   #删除"Python"元素,如果元素不存在不会报错

set_data.discard("C#")       #删除"Python"元素print("现集合数据:",set_data)

set_data.pop()  #删除是随机的

print("现集合数据:",set_data)

运行结果

原集合数据: {'C#', 'C/C++', 'Java', 'shell', 'PHP', 'Python'}

现集合数据: {'C#', 'C/C++', 'Java', 'shell', 'PHP'}

现集合数据: {'Java', 'shell', 'PHP'}

(3)计算集合元素个数

示例代码

#!/usr/bin/python3

set_data={"Python","C/C++","Java","C#","Python","C#","shell","PHP"}

print("原集合数据:",set_data)

print("原集合数据个数:",len(set_data))

运行结果

原集合数据: {'shell', 'Java', 'C/C++', 'Python', 'C#', 'PHP'}

原集合数据个数: 6

(4)判断元素是否在集合中

语法格式如下:x in s

判断元素 x 是否在集合 s 中,存在返回 True,不存在返回 False。

示例代码

set_data={"Python","C/C++","Java","C#","Python","C#","shell","PHP"}

print("Python" in set_data)

print("wbyq" in set_data)

运行结果:

True

False

7.3 集合内置的方法

方法

描述

add()

为集合添加元素

示例:

set_data={"Python","C/C++","Java","C#","C#"}

print("set_data集合原数据:",set_data)

set_data.add("Go")

set_data.add("Python")  #如果元素已存在,则不进行任何操作print("set_data集合现数据:",set_data)

输出结果:

set_data集合原数据: {'C/C++', 'C#', 'Python', 'Java'}

set_data集合现数据: {'C/C++', 'Go', 'C#', 'Python', 'Java'}

clear()

移除集合中的所有元素

示例:

set_data={"Python","C/C++","Java","C#","C#"}

print("set_data集合原数据:",set_data)

set_data.clear() #清除集合所有数据

print("set_data集合现数据:",set_data)

输出结果:

set_data集合原数据: {'C/C++', 'Python', 'Java', 'C#'}

set_data集合现数据: set()

copy()

拷贝一个集合

示例:

set_data1={"Python","C/C++","Java","C#","C#"}

print("set_data1集合数据:",set_data1)

set_data2=set_data1.copy() #拷贝集合数据

print("set_data2集合数据:",set_data2)

输出结果:

set_data1集合数据: {'Python', 'C#', 'Java', 'C/C++'}

set_data2集合数据: {'Python', 'C#', 'Java', 'C/C++'}

difference()

用于返回集合的差集,即返回的集合元素包含在第一个集合中,但不包含在第二个集合(方法的参数)中。

示例:

x={"Python","C/C++","Java","C#"}

y={"Java","PHP","C#"}

z=x.difference(y)  #返回一个集合,元素包含在集合x,但不在集合y里

print(z)

输出结果:

{'C/C++', 'Python'}

difference_update()

intersection_update() 方法用于获取两个或更多集合中都重叠的元素,即计算交集。

语法格式:set.intersection_update(set1, set2 ... etc)

参数:

set1  必需,要查找相同元素的集合

set2  可选,其他要查找相同元素的集合,可以多个,多个使用逗号 , 隔开

示例:

a={"Python","C/C++","Java","C#"}

b={"Java","PHP","C#"}

c={"Python","Java","C#"}

a.intersection_update(b,c)  #返回多个集合里都存在的数据

print(a)

输出结果:

{'C#', 'Java'}

discard()

删除集合中指定的元素,如果不存在不会报错。

示例:

a={"Python","C/C++","Java","C#"}

print("原集合数据:",a)

a.discard("Python")

print("先集合数据:",a)

a.discard("Python")  #不存在也不会报错

print("先集合数据:",a)

运行结果:

原集合数据: {'C/C++', 'Python', 'C#', 'Java'}

先集合数据: {'C/C++', 'C#', 'Java'}

先集合数据: {'C/C++', 'C#', 'Java'}

intersection()

intersection() 方法用于返回两个或更多集合中都包含的元素,即交集。

difference_update()方法是在原集合上修改,intersection()方法是返回一个新集合

语法:set.intersection(set1, set2 ... etc)

参数

set1 必需,要查找相同元素的集合

set2 可选,其他要查找相同元素的集合,可以多个,多个使用逗号 , 隔开

返回值:返回一个新的集合。

示例:

a={"Python","C/C++","Java","C#"}

b={"Java","PHP","C#"}

c={"Python","Java","C#"}

d=a.intersection(b,c)  #返回多个集合里都存在的数据

print(d)

输出结果:

{'C#', 'Java'}

intersection_update()

intersection_update()方法用于获取两个或更多集合中都重叠的元素,即计算交集。

intersection_update()方法不同于intersection()方法,因为 intersection() 方法是返回一个新的集合,而intersection_update()方法是在原始的集合上移除不重叠的元素。

方法语法:set.intersection_update(set1, set2 ... etc)

参数

set1 必需,要查找相同元素的集合

set2 可选,其他要查找相同元素的集合,可以多个,多个使用逗号 , 隔开

示例:

a={"Python","C/C++","Java","C#"}

b={"Java","PHP","C#"}

c={"Python","Java","C#"}

a.intersection_update(b,c)  #返回多个集合里都存在的数据

print(a)

输出结果:

{'Java', 'C#'}

isdisjoint()

判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。

示例:

a={"Python","C/C++","Java","C#"}

b={"Java","PHP","C#"}

c={"小米","华为","苹果"}

print(a.isdisjoint(b)) #判断b集合中是否有包含集合a的元素,如果不包含返回 True,否则返回 False。

print(a.isdisjoint(c)) #判断c集合中是否有包含集合a的元素,如果不包含返回 True,否则返回 False。

输出结果:

False

True

issubset()

issubset() 方法用于判断集合的所有元素是否都包含在指定集合中,如果是则返回 True,否则返回 False

示例:

a={"Python","C/C++","Java","C#"}

b={"Java","PHP","C#"}

c={"Python","C/C++","Java","C#","Android","Linux"}

print(a.issubset(b))#判断集合a的所有元素是否都包含在集合b中,如果都包含返回 True,否则返回 False

print(a.issubset(c))#判断集合a的所有元素是否都包含在集合c中,如果都包含返回 True,否则返回 False

输出结果:

False

True

issuperset()

issuperset() 方法用于判断指定集合的所有元素是否都包含在原始的集合中,如果是则返回 True,否则返回 False

示例:

a={"Python","C/C++","Java","C#","C#","Android","Linux"}

b={"Java","PHP","C#"}

c={"Python","C/C++","Java"}

print(a.issuperset(b))#判断集合b的所有元素是否都包含在集合a中,如果都包含返回 True,否则返回 False

print(a.issuperset(c))#判断集合c的所有元素是否都包含在集合a中,如果都包含返回 True,否则返回 False

输出结果:

False

True

pop()

随机移除元素

示例:

set_data={"Python","C/C++","Java","C#","C#","Android","Linux"}

print("现集合数据:",set_data)

set_data.pop()  #删除是随机的

print("现集合数据:",set_data)

set_data.pop()  #删除是随机的

print("现集合数据:",set_data)

输出结果:

现集合数据: {'Java', 'C#', 'Linux', 'Android', 'C/C++', 'Python'}

现集合数据: {'C#', 'Linux', 'Android', 'C/C++', 'Python'}

现集合数据: {'Linux', 'Android', 'C/C++', 'Python'}

remove()

移除指定元素

该方法不同于 discard() 方法,因为 remove() 方法在移除一个不存在的元素时会发生错误,而 discard() 方法不会

示例:

set_data={"Python","C/C++","Java","C#","C#","Android","Linux"}

print("现集合数据:",set_data)

set_data.remove("Python")

print("现集合数据:",set_data)

set_data.remove("Java")

print("现集合数据:",set_data)

输出结果:

现集合数据: {'Python', 'Java', 'C/C++', 'C#', 'Linux', 'Android'}

现集合数据: {'Java', 'C/C++', 'C#', 'Linux', 'Android'}

现集合数据: {'C/C++', 'C#', 'Linux', 'Android'}

symmetric_difference()

symmetric_difference() 方法返回两个集合中不重复的元素集合,即会移除两个集合中都存在的元素,返回一个新的集合。

示例:

a={"Python","C/C++","Java","C#","C#","Android","Linux"}

b={"Java","PHP","C#"}

c=a.symmetric_difference(b)

print(c)

输出结果:

{'Android', 'C/C++', 'Python', 'PHP', 'Linux'}

symmetric_difference_update()

移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。

示例:

a={"Python","C/C++","Java","C#","Android","Linux"}

b={"Java","PHP","C#"}

print("原a集合数据:",a)

print("原b集合数据:",b)

#在原始集合 a中移除与 b 集合中的重复元素,并将不重复的元素插入到集合a中

a.symmetric_difference_update(b)

print("现a集合数据:",a)

输出结果:

原a集合数据: {'C#', 'C/C++', 'Python', 'Android', 'Java', 'Linux'}

原b集合数据: {'C#', 'PHP', 'Java'}

现a集合数据: {'C/C++', 'Python', 'Android', 'Linux', 'PHP'}

union()

union()方法返回两个集合的并集,即包含了所有集合的元素,重复的元素只会出现一次。

语法:set.union(set1, set2...)

参数

set1  必需,合并的目标集合

set2  可选,其他要合并的集合,可以多个,多个使用逗号 , 隔开。

示例:

a={"Python","C/C++","Java","C#","Android","Linux"}

b={"Java","PHP","C#"}

c={"X86汇编","ARM汇编"}

print("原a集合数据:",a)

print("原b集合数据:",b)

print("原c集合数据:",c)

d=c.union(a,b)  #合并所有数据,去除重复

print("新d集合数据:",d)

输出结果:

原a集合数据: {'C/C++', 'C#', 'Linux', 'Android', 'Python', 'Java'}

原b集合数据: {'PHP', 'C#', 'Java'}

原c集合数据: {'X86汇编', 'ARM汇编'}

新d集合数据: {'C/C++', 'C#', 'Linux', 'PHP', 'X86汇编', 'Android', 'Python', 'ARM汇编', 'Java'}

update()

update() 方法用于修改当前集合,可以添加新的元素或集合到当前集合中,如果添加的元素在集合中已存在,则该元素只会出现一次,重复的会忽略。

示例:

#!/usr/bin/python3

a={"Python","C/C++","Java","C#","Android","Linux"}

b={"Java","PHP","C#"}

list=["Java","C#","Go","SQL"]

print("原集合a数据:",a)

a.update(b);

a.update(list);

a.update(["HTML"]);

#a.update("MySQL");  

#如何直接添加字符串,会将字符串单个字符拆开加入集合

print("现集合a数据:",a)

输出结果:

原集合a数据: {'C/C++', 'Android', 'Java', 'C#', 'Python', 'Linux'}

现集合a数据: {'Go', 'C/C++', 'Android', 'PHP', 'SQL', 'Java', 'C#', 'Python', 'HTML', 'Linux'}

下一篇:04 Python3基础:运算符_卡卡6的博客-CSDN博客

  • 2
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值