Python3基本数据类型

目录

概述

Python3 中有六个标准的数据类型：

• Number（数字） ### 常用 ###
• String（字符串）### 常用 ###
• List（列表）### 常用 ###
• Tuple（元组）
• Dictionary（字典）### 常用 ###
• Set（集合）

Python3 的六个标准数据类型中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
• string、list 和 tuple 都属于 sequence（序列）。

1. Number（数字）

Python 数字数据类型用于存储数值。数据类型是不允许改变的，这就意味着如果改变数字数据类型的值，将重新分配内存空间。
Python3 支持 int（整型）、float（浮点型）、complex（复数）、bool（布尔）、None（空值）。
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
像大多数语言一样，数值类型的赋值和计算都是很直观的。
内置的 type() 函数可以用来查询变量所指的对象类型。

1.1 int（整型）

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

在32位机器上，整数的位数为32位，取值范围为-231～231-1，即-2147483648～2147483647；

在64位系统上，整数的位数为64位，取值范围为-263～263-1，即-9223372036854775808～9223372036854775807；

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

a=12
b=13
print(a+b)  ### 整型+整型=整型

运行结果如下：

25

1.2 float（浮点型）

浮点型由整数部分与小数部分组成，类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

a=12
b=13
c=3.14
d=2.8
print(a+b)  ### 整型+整型=整型
print(c+d)  ### 浮点型+浮点型=浮点型
print(a+c)  ### 整型+浮点型=浮点型

运行结果如下：

25
5.9399999999999995
15.14

1.3 complex（复数）

复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的复数的实部x和虚部y都是浮点型。
注：Python中存在小数字池：-5 ～ 257

int	float	complex
10	0.0	3.14j
100	15.20	45.j
786	-21.9	9.322e-36j
080	32.3e+18	.876j
-490	-90.	-.6545+0J
-0x260	-32.54e100	3e+26J
0x69	70.2E-12	4.53e-7j

1.4 bool（布尔值）

注意：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
[ 真或假 /Ture或False /1 或 0 ]

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

a=True
print(a)

b=(1==1)
print(b)

c=(1>2)
print(c)

d=a+b+c
print(d)

运行结果如下：

True
True
False
2

1.5 None（空值）

空值是python里的一个特殊的值，用None表示，一般用None填充表格缺失的值，可以使用type()函数来获取某变量的类型。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

a=None
print(a)
print(type(a))

运行结果如下：

None
<class 'NoneType'>

2. String（字符串）

2.1 字符串的书写格式

Python中的字符串用单引号 ’ 或双引号 " 括起来。Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#


a='hello world a'
print(a)
b="hello world b"
print(b)
c="hello\tworld c"
print(c)
d="hello\nworld d"
print(d)
e=r"hello\nworld e"  #r表示取消转义字符串中的所有特殊字符，完全当做文本处理
print(e)

运行结果如下：

hello world a
hello world b
hello	world c
hello
world d
hello\nworld e

2.2 字符串的索引

字符串索引值以 0 为开始值，-1 为从末尾的开始位置。

2.2 字符串的截取

Python 访问子字符串，可以使用方括号来截取字符串。字符串截取的语法格式：

变量[头下标:尾下标]

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

test="abcdef"
print(test,type(test))
print(test,len(test))


print(test[0:-1])   #输出第一个到倒数第二个的所有字符，因为字符串截取时是前闭后开区间
print(test[0])      #输出字符串第一个字符
print(test[2:4])    #输出从第三个开始到第四个的字符
print(test[2:])     #输出从第三个开始的后的所有字符
print(test*2)       #输出字符串两次，也可以写成print(2*test)
print(test+"123")   #连接字符串

运行结果如下：

abcdef <class 'str'>
abcdef 6
abcde
a
cd
cdef
abcdefabcdef
abcdef123

2.3 字符串转义符

在需要在字符中使用特殊字符时，python用反斜杠()转义字符。如下表：

转义字符	描述
(在行尾时)	续行符
\	反斜杠符号
’	单引号
"	双引号
\a	响铃
\b	退格(Backspace)
\000	空
\n	换行符
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy 代表的字符，例如：\o12 代表换行，其中 o 是字母，不是数字 0。
\xyy	十六进制数，yy代表的字符，例如：\x0a代表换行
\other	其它的字符以普通格式输出

Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#


#\n  	反斜杠 \ 转义换行符
#\t		反斜杠 \ 转义制表符
test="abcdef\tsnow"
print(test)
print(len(test))

print("---------分隔符----------")

test=r"abcdef\tsnow"
print(test)
print(len(test))

运行结果如下：

abcdef	snow
11
---------分隔符----------
abcdef\tsnow
12

2.4 字符串运算符

转义字符	描述
+	字符串连接
*	重复输出字符串
[]	重复输出字符串
[:]	截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的。
in	成员运算符 - 如果字符串中包含给定的字符返回 True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True
r/R	所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。
%	格式化字符串

2.5 字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

转义字符	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%P	用十六进制数格式化变量的地址

格式化操作符辅助指令:

符号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
<sp>	在正数前面显示空格
#	在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
0	显示的数字前面填充’0’而不是默认的空格
%	‘%%‘输出一个单一的’%’
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki


print ("我叫 %s. 今年 %d 岁!" % ('小明', 10))

运行结果如下：

我叫 小明, 今年 10 岁!

2.6 万恶的字符串拼接

python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空间，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间。

2.7 Unicode 字符串

在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。

在Python3中，所有的字符串都是Unicode字符串。

3. List [列表]

List [列表] 是 Python 中使用最频繁的数据类型。
List [列表] 可以完成大多数集合类的数据结构实现。
List [列表] 中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

3.1 列表的书写格式

List [列表] 是写在方括号 [] 之间、用逗号分隔开的元素列表。

['alex', 'seven', 'eric']
["alex", "seven", "eric"]

3.2 创建列表

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#


test= ['alex', 'seven', 'eric']
print(test,type(test))

test=list(['alex', 'seven', 'eric'])
print(test,type(test))

运行结果如下：

['alex', 'seven', 'eric'] <class 'list'>
['alex', 'seven', 'eric'] <class 'list'>

3.3 更新列表

3.3.1 更改列表某个元素的值

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki

list = ['Google', 'yuki', 1997, 2000]

print("原始列表的第三个元素值为 ", list[2])
list[2] = 1002
print("更改后的第三个元素为 : ", list[2])
print("更改后的列表为 : ", list)

运行结果如下：

原始列表的第三个元素值为 :  1997
更改后的第三个元素为 :  1002
更改后的列表为 :  ['Google', 'yuki', 1002, 2000]

3.3.2 在列表最后添加新的元素

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki

list = ['Google', 'yuki', 1997, 2000]

print("原始列表的长度为： ",len(list))
list.append("hello")
print("更改后的列表的长度为： ", len(list))
print("更改后的列表为 : ", list)

运行结果如下：

原始列表的长度为：  4
更改后的列表的长度为：  5
更改后的列表为 :  ['Google', 'yuki', 1997, 2000, 'hello']

3.3.3 在列表指定位置添加新的元素

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki

list = ['Google', 'yuki', 1997, 2000]

print("原始列表的长度为： ",len(list))
list.insert(3,"我是新添加的第四个元素，我的索引是3")
print("更改后的列表的长度为： ", len(list))
print("更改后的列表为 : ", list)

运行结果如下：

原始列表的长度为：  4
更改后的列表的长度为：  5
更改后的列表为 :  ['Google', 'yuki', 1997, '我是新添加的第四个元素，我的索引是3', 2000]

3.4 删除列表元素

3.4.1 可以使用 remove函数来删除列表的的元素（根据元素内容来删除）

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki

list = ['Google', 'yuki', 1997, 2000]

print("原始列表的第三个元素值为 : ", list[2])
list.remove(1997)
print("删除后第三个元素 : ", list[2])
print("删除元素之后的列表为 : ", list)

运行结果如下：

原始列表的第三个元素值为 :  1997
删除后第三个元素 :  2000
删除元素之后的列表为 :  ['Google', 'yuki', 2000]

3.4.2 可以使用 pop函数来删除列表的的元素（根据元素索引来删除）

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki

list = ['Google', 'yuki', 1997, 2000]

print("原始列表的第三个元素值为 : ", list[2])
list.pop(2)
print("删除后第三个元素为 : ", list[2])
print("删除元素之后的列表为 : ", list)

运行结果如下：

原始列表的第三个元素值为 :  1997
删除后第三个元素为 :  2000
删除元素之后的列表为 :  ['Google', 'yuki', 2000]

3.4.3 还可以使用 del 语句来删除列表的的元素（根据元素索引来删除）

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki

list = ['Google', 'yuki', 1997, 2000]

print("原始列表的第三个元素值为 :", list[2])
del list[2]
print("删除后第三个元素为 : ", list[2])
print("删除元素之后的列表为 : ", list)

运行结果如下：

原始列表的第三个元素值为 :  1997
删除后第三个元素为 :  2000
删除元素之后的列表为 :  ['Google', 'yuki', 2000]

3.5 列表的索引

列表索引值以 0 为开始值，-1 为从末尾的开始位置。

3.6 列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

表达式	描述	结果
len([1, 2, 3])	长度	3
[1, 2, 3] + [4, 5, 6]	拼接	1, 2, 3, 4, 5, 6]
[‘Hi!’] * 4	重复输出	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]
3 in [1, 2, 3]	元素是否存在于列表中	True
for x in [1, 2, 3]: print(x, end=" ")	迭代	123

3.7 列表的截取和拼接

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

biglist=['abcd', 786 , 2.23, 'yuki', 70.2]
print(type(biglist))
print(len(biglist))

print(biglist[0])      #输出列表第一个元素
print(biglist[1:3])    #输出第二个元素、第三个元素
print(biglist[2:-1])   #从第三个元素到倒数第二个元素
print(biglist[3:])     #输出从第四个元素开始的所有元素

tinylist=['name','123']
print(tinylist*2)       #输出两次列表 也可以是2*tinylist
print(biglist+tinylist) #连接列表

运行结果如下：

<class 'list'>
5
abcd
[786, 2.23]
[2.23, 'yuki']
['yuki', 70.2]
['name', '123', 'name', '123']
['abcd', 786, 2.23, 'yuki', 70.2, 'name', '123']

与Python字符串不一样的是，列表中的元素是可以改变的。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#


test = ['alex', 'seven', 'eric']
print(test)

test[1]="yuki"
print(test)

test[0:2]=""
print(test)

test[0:1]=[]
print(test)

运行结果如下：

['alex', 'seven', 'eric']
['alex', 'yuki', 'eric']
['eric']
[]

Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串

如果第三个参数为负数表示逆向读取，以下实例用于翻转字符串：

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#


test = ['a', 'b', 'c','d']
print(test)
# test[0]='a', test[1]='b' ，而 -1 表示最后一个元素 test[-1]='d' ( 与 test[3]='d' 一样)
# test[-1::-1] 有三个参数
# 第一个参数 -1 表示最后一个元素
# 第二个参数为空，表示移动到列表末尾
# 第三个参数为步长，-1 表示逆向
print(test[-1::-1])

运行结果如下：

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

3.8 嵌套列表

使用嵌套列表即在列表里创建其它列表。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki

x=['a', 'b', 'c']
y=[1, 2, 3]
z=[x,y]

print(type(z),z)
print(z[0])
print(z[0][1])

运行结果如下：

<class 'list'> [['a', 'b', 'c'], [1, 2, 3]]
['a', 'b', 'c']
b

4. Tuple（元组）

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

4.1 元组的书写格式

元组写在小括号 () 里，元素之间用逗号隔开。

('alex', 'seven', 'eric',5558)
("alex", "seven", "eric",772)

4.2 创建元组

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

test=()   #创建空元组
print(test,type(test))

test=(12, 15, 18)
print(test,type(test))
test=tuple((12, 15, 18))
print(test,type(test))

test="a", "b", "c", "d"  #不需要括号也可以
print(test,type(test))

运行结果如下：

() <class 'tuple'>
(12, 15, 18) <class 'tuple'>
(12, 15, 18) <class 'tuple'>
('a', 'b', 'c', 'd') <class 'tuple'>

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

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

test=(20)
print(test,type(test))

test=(21,)
print(test,type(test))

运行结果如下：

20 <class 'int'>
(21,) <class 'tuple'>

4.3 元组脚本操作符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

表达式	描述	结果
len((1, 2, 3))	长度	3
(1, 2, 3) + (4, 5, 6)	拼接	(1, 2, 3, 4, 5, 6)
(‘Hi!’) * 4	重复输出	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)
3 in (1, 2, 3)	元素是否存在于列表中	True
for x in (1, 2, 3): print(x, )	迭代	123

4.4 元组的索引及截取

元组与字符串类似，元祖索引值以 0 为开始值，-1 为从末尾的开始位置，可以进行截取，组合等。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#


big=("abcd",12, 15, 18,"yuki")
print(big)          #输出完整元组
print(big[0])       #输出元组的第一个元素
print(big[1:3])     #输出从第二个元素开始到第三个元素
print(big[2:])      #输出从第三个元素开始的所有元素

small=(123, 'dog')
print(small*2)      #输出两次元组,也可以是2*small
print(big+small)    #连接元组

运行结果如下：

('abcd', 12, 15, 18, 'yuki')
abcd
(12, 15)
(15, 18, 'yuki')
(123, 'dog', 123, 'dog')
('abcd', 12, 15, 18, 'yuki', 123, 'dog')

4.4 元组的修改

元组（tuple）与列表[list]类似，不同之处在于元组的元素不能修改。其实，可以把字符串看作一种特殊的元组。
元组中的元素值虽然是不允许修改的，但我们可以对元组进行连接组合，而且它可以包含可变的对象，比如list列表。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

test1 = (12, 34.56)
test2 = ('abc', 'xyz')

# 以下修改元组元素操作是非法的。
# test1[0] = 100

# 创建一个新的元组
test3 = test1 + test2
print(test3)

运行结果如下：

(12, 34.56, 'abc', 'xyz')

4.5 元组的删除

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

test = (12, 34.56,'abc', 'xyz')
print(test,type(test))
# 以下修改元组元素操作是非法的。
# test[0] = 100

# 删除整个元祖
del test
print("删除后的元组 test : ",test)

以上实例元组被删除后，输出变量会有异常信息，运行结果如下：

(12, 34.56, 'abc', 'xyz') <class 'tuple'>
Traceback (most recent call last):
  File "E:/softwares/python/pythonProject/day20200802/helloWorld.py", line 13, in <module>
    print("删除后的元组 test : ",test)
NameError: name 'test' is not defined

5. Dictionary{字典}

字典（dictionary）是Python中另一个非常有用的可变容器模型，且可存储任意类型对象。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典常常用于高速查找。

5.1 字典的书写格式

字典是一种映射类型，整个字典包括在花括号 {} 中，它是一个无序的 键(key) : 值(value) 的集合。字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号分割， 书写格式如下：

d={key1 : value1, key2 : value2 }

{'name': 'yuki', 'age': 18}

{"name": "yuki", "age": 18}

5.2 创建字典

注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、值可以取任何数据类型，但键必须是不可变的，如字符串，数字，元祖，而不能是列表。
4、创建空字典使用 { }。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

test={}
print(type(test),test)

test={'name': 'yuki', 'age': 18}
print(type(test),test)

test=dict({'name': 'yuki', 'age': 18})
print(type(test),test)

运行结果如下：

<class 'dict'> {}
<class 'dict'> {'name': 'yuki', 'age': 18}
<class 'dict'> {'name': 'yuki', 'age': 18}

5.3 访问字典里的值

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#


test={'name': 'yuki', 'age': 18}
print(test['name'])
print(test['age'])
#print(test['gender']) #如果用字典里没有的键访问数据，会报错
print(test.get('gender')) #如果用字典里没有的键访问数据，用get方法访问不会报错，返回None

运行结果如下：

yuki
18
None

5.4 修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#


test={'name': 'yuki', 'age': 18}
print(test,type(test),len(test))

test['age']=35   #更新键age的值
print(test,type(test),len(test))

test['gender']='female'  #添加键gender并赋值
print(test,type(test),len(test))

print(test.keys())  #输出字典所有键
print(test.values())  #输字典出所有值

运行结果如下：

{'name': 'yuki', 'age': 18} <class 'dict'> 2
{'name': 'yuki', 'age': 35} <class 'dict'> 2
{'name': 'yuki', 'age': 35, 'gender': 'female'} <class 'dict'> 3
dict_keys(['name', 'age', 'gender'])
dict_values(['yuki', 35, 'female'])

5.5 清空、删除字典（元素）

能删单一的元素也能清空字典，清空只需一项操作。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#


test={'name': 'yuki', 'age': 35, 'gender': 'female'}
print(test,type(test),len(test))

del test['name']   #删除字典的键 'name'
print(test,type(test),len(test))

test.clear()      #清空整个字典,但字典还存在，只不过是空字典
print(test,type(test),len(test))

del test   # 删除字典，字典不存在了
#print(test,type(test),len(test))   #会报错

运行结果如下：

{'name': 'yuki', 'age': 35, 'gender': 'female'} <class 'dict'> 3
{'age': 35, 'gender': 'female'} <class 'dict'> 2
{} <class 'dict'> 0

6. Set{集合}

Set{集合} 是一个无序的不重复元素序列，构成集合的事物或对象称作元素或是成员。
Set{集合}基本功能是进行成员关系测试和删除重复元素。

6.1 集合的书写格式

a={'Google', 'Taobao', 18, 'Facebook', 'Zhihu', 'Baidu'}

b=set(['Google', 'Taobao', 18, 'Facebook', 'Zhihu', 'Baidu'])

6.2 创建集合

可以使用大括号 { } 或者 set() 函数创建集合。
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

test={'Google', 'Taobao', 18, 'Facebook', 'Zhihu', 'Baidu'}
print(test,type(test))

test=set({'Google', 'Taobao', 18, 'Facebook', 'Zhihu', 'Baidu'})
print(test,type(test))

test=set([1,0,2,2,4,5,5,6,7,6])
print(test,type(test))

运行结果如下：

{'Zhihu', 'Google', 'Taobao', 18, 'Facebook', 'Baidu'} <class 'set'>
{18, 'Facebook', 'Zhihu', 'Google', 'Taobao', 'Baidu'} <class 'set'>
{0, 1, 2, 4, 5, 6, 7} <class 'set'>

6.3 给集合添加元素

add(self,element ) 将某元素 添加到集合中，如果元素已存在，则不进行任何操作。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

set1={'a', 'b', 'c', 'd', 'e', 5,12.5}
print(type(set1),set1)

set1.add('f')
print(type(set1),set1)

运行结果如下：

<class 'set'> {'d', 5, 'a', 'c', 12.5, 'e', 'b'}
<class 'set'> {'d', 5, 'a', 'c', 12.5, 'e', 'f', 'b'}

update(self,element ) 也可以添加元素，element 可以有多个，用逗号分开，且参数可以是列表，元组，字典，集合等。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

set1={'a', 'b', 'd', 'e', 5}
print(type(set1),set1)

set1.update('g','h')    #添加多个字符串元素
print(type(set1),set1)

set1.update(['u',3])    #添加列表元素
print(type(set1),set1)

set1.update((1,9.2))      #添加元组元素
print(type(set1),set1)

set1.update({'name':'yuki'})     #添加字典元素
print(type(set1),set1)

set1.update({'suno',100})    #添加集合元素
print(type(set1),set1)

运行结果如下：

<class 'set'> {5, 'b', 'd', 'a', 'e'}
<class 'set'> {5, 'b', 'd', 'a', 'g', 'h', 'e'}
<class 'set'> {3, 5, 'b', 'd', 'a', 'g', 'h', 'u', 'e'}
<class 'set'> {1, 3, 5, 'b', 9.2, 'd', 'a', 'g', 'h', 'u', 'e'}
<class 'set'> {1, 3, 5, 'b', 9.2, 'name', 'd', 'a', 'g', 'h', 'u', 'e'}
<class 'set'> {1, 3, 100, 5, 'b', 9.2, 'name', 'd', 'a', 'g', 'h', 'u', 'suno', 'e'}

6.4 移除集合里面的元素

remove(self,element ) 将某个元素从集合中移除，如果元素不存在，则会发生错误。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

set1={'a', 'b', 'c', 'd', 'e', 5,12.5}
print(type(set1),set1)

set1.remove(5)
print(type(set1),set1)

set1.remove('r')
print(type(set1),set1)

运行结果如下：

<class 'set'> {'c', 5, 12.5, 'b', 'd', 'e', 'a'}
<class 'set'> {'c', 12.5, 'b', 'd', 'e', 'a'}
Traceback (most recent call last):
  File "E:/softwares/python/pythonProject/day20200802/helloWorld.py", line 12, in <module>
    set1.remove('r')
KeyError: 'r'

discard(self,element ) 方法也是移除集合中的元素，且如果元素不存在，不会发生错误。

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

set1={'a', 'b', 'c', 'd', 'e', 5,12.5}
print(type(set1),set1)

set1.discard(5)
print(type(set1),set1)

set1.discard('r')
print(type(set1),set1)

运行结果如下：

<class 'set'> {'e', 5, 12.5, 'b', 'd', 'a', 'c'}
<class 'set'> {'e', 12.5, 'b', 'd', 'a', 'c'}
<class 'set'> {'e', 12.5, 'b', 'd', 'a', 'c'}

6.5 清空、删除集合（元素）

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

set1={'a', 'b', 'd', 'e', 5}
print(type(set1),set1)

set1.clear()   #清空集合（元素）,但集合还是存在，只不过是空集合
print(type(set1),set1)

del set1  #删除集合,集合不存在，下面的语句会报错
# print(type(set1),set1)

运行结果如下：

<class 'set'> {'b', 'e', 5, 'd', 'a'}
<class 'set'> set()

6.6 集合成员测试

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

test={'Google', 'Taobao', 18, 'Facebook', 'Zhihu', 'Baidu'}
print(test,type(test))

#成员测试
if "Facebook" in test:
    print("Facebook在集合中")
else:
    print("Facebook不在集合中")

if "facebook" in test:
    print("facebook在集合中")
else:
    print("facebook不在集合中")

运行结果如下：

{'Google', 'Zhihu', 'Facebook', 18, 'Taobao', 'Baidu'} <class 'set'>
Facebook在集合中
facebook不在集合中

6.7 集合运算

#!/usr/bin/python
# -*- coding:utf-8 -*-
# created by yuki
#

aset={'a', 'b', 18, 'c', 'd', 'e'}
bset={'f', 'b', 13, 'c'}


print(aset-bset)     # aset 和 bset 的差集
print(bset-aset)     # bset 和 aset 的差集

print(aset|bset)     # aset 和 bset 的并集

print(aset&bset)     # aset 和 bset 的交集

print(aset^bset)     # aset 和 bset 中不同时存在的元素

运行结果如下：

{'e', 18, 'a', 'd'}
{'f', 13}
{'e', 'c', 'b', 13, 'f', 18, 'a', 'd'}
{'c', 'b'}
{'e', 13, 'f', 18, 'a', 'd'}