第二章---变量赋值与标准数据类型
目录：
（一）变量赋值与多个变量赋值
（二）标准数据类型
（1）Numbers（数字）
（2）String（字符串）
（3）List（列表）
（4）Tuple（元组）
（5）Dictionary（字典）
（三）集合
（四）Python数据类型转换
正文：
（一）变量赋值与多个变量赋值
Python 中的变量赋值不需要类型声明。每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
等号 = 用来给变量赋值。等号 = 运算符左边是一个变量名，等号 = 运算符右边是存储在变量中的值
1 counter = 100 # 赋值整型变量 2 miles = 1000.0 # 浮点型 3 name = "John" # 字符串 4 5 print counter 6 print miles 7 print name
多个变量赋值：
a = b = c = 1
创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。
a, b, c = 1, 2, "john"
两个整型对象 1 和 2 分别分配给变量 a 和 b，字符串对象 "john" 分配给变量 c。
（二）标准数据类型
在内存中存储的数据可以有多种类型。例如，一个人的年龄可以用数字来存储，他的名字可以用字符来存储。
Python 定义了一些标准类型，用于存储各种类型的数据。Python有五个标准的数据类型：
- Numbers（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Dictionary（字典）
（1）Numbers（数字）
(A).创建和删除数字对象
数字数据类型用于存储数值。他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。当你指定一个值时，Number 对象就会被创建：
var1 = 1 var2 = 10
您也可以使用del语句删除一些对象的引用。del语句的语法是：
del var1[,var2[,var3[....,varN]]]
您可以通过使用del语句删除单个或多个对象的引用。例如：
del var del var_a, var_b
(B).Python 支持三种不同的数值类型：
- 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
- 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
- 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
一些数值类型的实例：
- 长整型也可以使用小写 l，但是还是建议您使用大写 L，避免与数字 1 混淆。Python使用 L 来显示长整型。
- Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。
注意：long 类型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 类型数据溢出后会自动转为long类型。在 Python3.X 版本中 long 类型被移除，使用 int 替代。
（C）使用十六进制和八进制来代表整数：
>>> number = 0xA0F # 十六进制 >>> number 2575 >>> number=0o37 # 八进制 >>> number 31
（D）Python 数字类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
-
int(x) 将x转换为一个整数。
-
float(x) 将x转换到一个浮点数。
-
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
-
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
>>> a = 1.0 >>> int(a) 1
（E）Python 数字运算
Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的值。
表达式的语法很直白： +, -, * 和 /, 和其它语言（如Pascal或C）里一样。例如：
>>> 2 + 2 4 >>> 50 - 5*6 20 >>> (50 - 5*6) / 4 5.0 >>> 8 / 5 # 总是返回一个浮点数 1.6 注意：在不同的机器上浮点运算的结果可能会不一样。 在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // ： >>> 17 / 3 # 整数除法返回浮点型 5.666666666666667 >>> >>> 17 // 3 # 整数除法返回向下取整后的结果 5 >>> 17 % 3 # ％操作符返回除法的余数 2 >>> 5 * 3 + 2 17 注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。 >>> 7//2 3 >>> 7.0//2 3.0 >>> 7//2.0 3.0 >>> 等号 = 用于给变量赋值。赋值之后，除了下一个提示符，解释器不会显示任何结果。 >>> width = 20 >>> height = 5*9 >>> width * height 900 Python 可以使用 ** 操作来进行幂运算： >>> 5 ** 2 # 5 的平方 25 >>> 2 ** 7 # 2的7次方 128 变量在使用前必须先"定义"（即赋予变量一个值），否则会出现错误： >>> n # 尝试访问一个未定义的变量 Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'n' is not defined 不同类型的数混合运算时会将整数转换为浮点数： >>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5 在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。例如： >>> tax = 12.5 / 100 >>> price = 100.50 >>> price * tax 12.5625 >>> price + _ 113.0625 >>> round(_, 2) 113.06 此处， _ 变量应被用户视为只读变量。
（F）数学函数，随机数函数，三角函数，数学常量
参考：https://www.runoob.com/python3/python3-number.html
（2）String（字符串）
（A）创建字符串
表示文本的数据类型。我们可以使用引号( ' 或 " )来创建字符串。字符串或串(String)是由数字、字母、下划线组成的一串字符。一般记为 :
s = "a1a2···an" # n>=0
（B）访问字符串中的值
python的字串列表有2种取值顺序:
- 从左到右索引默认0开始的，最大范围是字符串长度少1
- 从右到左索引默认-1开始的，最大范围是字符串开头
如果你要实现从字符串中获取一段子字符串的话，可以使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。
比如:
>>> s = 'abcdef' >>> s[1:5] 'bcde'
加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- str = 'Hello World!' print str # 输出完整字符串 print str[0] # 输出字符串中的第一个字符 print str[2:5] # 输出字符串中第三个至第六个之间的字符串 print str[2:] # 输出从第三个字符开始的字符串 print str * 2 # 输出字符串两次 print str + "TEST" # 输出连接的字符串
结果：
Hello World! H llo llo World! Hello World!Hello World! Hello World!TEST
Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
（C）字符串更新
你可以截取字符串的一部分并与其他字段拼接
#!/usr/bin/python3 var1 = 'Hello World!' print ("已更新字符串 : ", var1[:6] + 'Runoob!') 以上实例执行结果 已更新字符串 : Hello Runoob!
（D）转义字符
在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。如下表：
（E）字符串运算符
#!/usr/bin/python3 a = "Hello" b = "Python" print("a + b 输出结果：", a + b) print("a * 2 输出结果：", a * 2) print("a[1] 输出结果：", a[1]) print("a[1:4] 输出结果：", a[1:4]) if( "H" in a) : print("H 在变量 a 中") else : print("H 不在变量 a 中") if( "M" not in a) : print("M 不在变量 a 中") else : print("M 在变量 a 中") print (r'\n') print (R'\n')
以上实例输出结果为： a + b 输出结果： HelloPython a * 2 输出结果： HelloHello a[1] 输出结果： e a[1:4] 输出结果： ell H 在变量 a 中 M 不在变量 a 中 \n \n
（F）字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
#!/usr/bin/python3 print ("我叫 %s 今年 %d 岁!" % ('小明', 10)) 以上实例输出结果： 我叫 小明 今年 10 岁!
（G）三引号
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
#!/usr/bin/python3 para_str = """这是一个多行字符串的实例 多行字符串可以使用制表符 TAB ( \t )。 也可以使用换行符 [ \n ]。 """ print (para_str) 以上实例执行结果为： 这是一个多行字符串的实例 多行字符串可以使用制表符 TAB ( )。 也可以使用换行符 [ ]。
（H）字符串内建函数
https://www.runoob.com/python3/python3-string.html
（3）List（列表）
（A）访问列表中的值
List（列表） 是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用 [ ] 标识，是 python 最通用的复合数据类型。列表中值的切割也可以用到变量 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
加号 + 是列表连接运算符，星号 * 是重复操作。如下实例：
#!/usr/bin/python # -*- coding: UTF-8 -*- list = [ 'runoob', 786 , 2.23, 'john', 70.2 ] tinylist = [123, 'john'] print list # 输出完整列表 print list[0] # 输出列表的第一个元素 print list[1:3] # 输出第二个至第三个元素 print list[2:] # 输出从第三个开始至列表末尾的所有元素 print tinylist * 2 # 输出列表两次 print list + tinylist # 打印组合的列表
结果：
['runoob', 786, 2.23, 'john', 70.2] runoob [786, 2.23] [2.23, 'john', 70.2] [123, 'john', 123, 'john'] ['runoob', 786, 2.23, 'john', 70.2, 123, 'john']
list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"] # 读取第二位 print ("list[1]: ", list[1]) # 从第二位开始（包含）截取到倒数第二位（不包含） print ("list[1:-2]: ", list[1:-2]) 以上实例输出结果： list[1]: Runoob list[1:-2]: ['Runoob', 'Zhihu']
（B）更新列表
你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项 #!/usr/bin/python3 list = ['Google', 'Runoob', 1997, 2000] print ("第三个元素为 : ", list[2]) list[2] = 2001 print ("更新后的第三个元素为 : ", list[2]) 以上实例输出结果： 第三个元素为 : 1997 更新后的第三个元素为 : 2001
（C）删除列表
可以使用 del 语句来删除列表的的元素，如下实例： 实例(Python 3.0+) #!/usr/bin/python3 list = ['Google', 'Runoob', 1997, 2000] print ("原始列表 : ", list) del list[2] print ("删除第三个元素 : ", list) 以上实例输出结果： 原始列表 : ['Google', 'Runoob', 1997, 2000] 删除第三个元素 : ['Google', 'Runoob', 2000] 注意：我们会在接下来的章节讨论 remove() 方法的使用
（D）列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
（E）列表截取与拼接
（F）嵌套列表
使用嵌套列表即在列表里创建其它列表，例如： >>>a = ['a', 'b', 'c'] >>> n = [1, 2, 3] >>> x = [a, n] >>> x [['a', 'b', 'c'], [1, 2, 3]] >>> x[0] ['a', 'b', 'c'] >>> x[0][1] 'b'
（G）列表函数&方法
https://www.runoob.com/python3/python3-list.html
（4）Tuple（元组）
（A）创建元组
元组是另一个数据类型，类似于 List（列表）。元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
#!/usr/bin/python # -*- coding: UTF-8 -*- tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 ) tinytuple = (123, 'john') print tuple # 输出完整元组 print tuple[0] # 输出元组的第一个元素 print tuple[1:3] # 输出第二个至第四个（不包含）的元素 print tuple[2:] # 输出从第三个开始至列表末尾的所有元素 print tinytuple * 2 # 输出元组两次 print tuple + tinytuple # 打印组合的元组
结果：
('runoob', 786, 2.23, 'john', 70.2)
runoob
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('runoob', 786, 2.23, 'john', 70.2, 123, 'john')
以下是元组无效的，因为元组是不允许更新的。而列表是允许更新的：
#!/usr/bin/python # -*- coding: UTF-8 -*- tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 ) list = [ 'runoob', 786 , 2.23, 'john', 70.2 ] tuple[2] = 1000 # 元组中是非法应用 list[2] = 1000 # 列表中是合法应用
>>>tup1 = ('Google', 'Runoob', 1997, 2000) >>> tup2 = (1, 2, 3, 4, 5 ) >>> tup3 = "a", "b", "c", "d" # 不需要括号也可以 >>> type(tup3) <class 'tuple'> 创建空元组 tup1 = () 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用： 实例(Python 3.0+) >>>tup1 = (50) >>> type(tup1) # 不加逗号，类型为整型 <class 'int'> >>> tup1 = (50,) >>> type(tup1) # 加上逗号，类型为元组 <class 'tuple'> 元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
（B）访问元组
元组可以使用下标索引来访问元组中的值。
#!/usr/bin/python3 tup1 = ('Google', 'Runoob', 1997, 2000) tup2 = (1, 2, 3, 4, 5, 6, 7 ) print ("tup1[0]: ", tup1[0]) print ("tup2[1:5]: ", tup2[1:5])
以上实例输出结果： tup1[0]: Google tup2[1:5]: (2, 3, 4, 5)
（C）修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。
#!/usr/bin/python3 tup1 = (12, 34.56) tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。 # tup1[0] = 100 # 创建一个新的元组 tup3 = tup1 + tup2 print (tup3) 以上实例输出结果： (12, 34.56, 'abc', 'xyz')
（D）删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。
tup = ('Google', 'Runoob', 1997, 2000) print (tup) del tup print ("删除后的元组 tup : ") print (tup)
以上实例元组被删除后，输出变量会有异常信息，输出如下所示： 删除后的元组 tup : Traceback (most recent call last): File "test.py", line 8, in <module> print (tup) NameError: name 'tup' is not defined
（E）元组运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
（F）元组索引，截取
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
运行实例如下： >>> L = ('Google', 'Taobao', 'Runoob') >>> L[2] 'Runoob' >>> L[-2] 'Taobao' >>> L[1:] ('Taobao', 'Runoob')
（G）关于元组是不可变的
所谓元组的不可变指的是元组所指向的内存中的内容不可变。 >>> tup = ('r', 'u', 'n', 'o', 'o', 'b') >>> tup[0] = 'g' # 不支持修改元素 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>> id(tup) # 查看内存地址 4440687904 >>> tup = (1,2,3) >>> id(tup) 4441088800 # 内存地址不一样了 从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。
（H）元组内置函数
https://www.runoob.com/python3/python3-tuple.html
（5）Dictionary（字典）
（A）创建字典
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
字典是另一种可变容器模型，且可存储任意类型对象。 字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示： d = {key1 : value1, key2 : value2 } 键必须是唯一的，但值则不必。 值可以取任何数据类型，但键必须是不可变的，如字符串，数字。 一个简单的字典实例： dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'} 也可如此创建字典： dict1 = { 'abc': 456 } dict2 = { 'abc': 123, 98.6: 37 }
#!/usr/bin/python
# -*- coding: UTF-8 -*-
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
print dict['one'] # 输出键为'one' 的值
print dict[2] # 输出键为 2 的值
print tinydict # 输出完整的字典
print tinydict.keys() # 输出所有键
print tinydict.values() # 输出所有值
输出结果为：
This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'runoob'}
['dept', 'code', 'name']
['sales', 6734, 'runoob']
（B）访问字典里的值
把相应的键放入到方括号中，如下实例: 实例 #!/usr/bin/python3 dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} print ("dict['Name']: ", dict['Name']) print ("dict['Age']: ", dict['Age'])
以上实例输出结果： dict['Name']: Runoob dict['Age']: 7
（C）修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例: #!/usr/bin/python3 dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} dict['Age'] = 8 # 更新 Age dict['School'] = "菜鸟教程" # 添加信息 print ("dict['Age']: ", dict['Age']) print ("dict['School']: ", dict['School'])
以上实例输出结果： dict['Age']: 8 dict['School']: 菜鸟教程
（D）删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。 显示删除一个字典用del命令，如下实例： 实例 #!/usr/bin/python3 dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} del dict['Name'] # 删除键 'Name' dict.clear() # 清空字典 del dict # 删除字典 print ("dict['Age']: ", dict['Age']) print ("dict['School']: ", dict['School']) 但这会引发一个异常，因为用执行 del 操作后字典不再存在：
（E）字典键的特性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
#!/usr/bin/python3 dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'} print ("dict['Name']: ", dict['Name']) 以上实例输出结果： dict['Name']: 小菜鸟
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
#!/usr/bin/python3 dict = {['Name']: 'Runoob', 'Age': 7} print ("dict['Name']: ", dict['Name'])
以上实例输出结果： Traceback (most recent call last): File "test.py", line 3, in <module> dict = {['Name']: 'Runoob', 'Age': 7} TypeError: unhashable type: 'list'
（F）字典内置函数&方法
https://www.runoob.com/python3/python3-dictionary.html
（三）集合
（1）创建集合
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
parame = {value01,value02,...}
或者
set(value)
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False
>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}
（2）集合的基本操作
（A）添加元素
语法格式如下：
s.add( x )
将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。 >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.add("Facebook") >>> print(thisset) {'Taobao', 'Facebook', 'Google', 'Runoob'}
还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
s.update( x )
x 可以有多个，用逗号分开。 >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.update({1,3}) >>> print(thisset) {1, 3, 'Google', 'Taobao', 'Runoob'} >>> thisset.update([1,4],[5,6]) >>> print(thisset) {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'} >>>
（B）移除元素
语法格式如下：
s.remove( x )
将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
>>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.remove("Taobao") >>> print(thisset) {'Google', 'Runoob'} >>> thisset.remove("Facebook") # 不存在会发生错误 Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'Facebook' >>> 此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示： s.discard( x ) 实例(Python 3.0+) >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.discard("Facebook") # 不存在不会发生错误 >>> print(thisset) {'Taobao', 'Google', 'Runoob'} 我们也可以设置随机删除集合中的一个元素，语法格式如下： s.pop() 脚本模式实例(Python 3.0+) thisset = set(("Google", "Runoob", "Taobao", "Facebook")) x = thisset.pop() print(x) 输出结果： $ python3 test.py Runoob 多次执行测试结果都不一样。 set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
（C）计算集合元素个数
语法格式如下： len(s)
计算集合 s 元素个数。 >>> thisset = set(("Google", "Runoob", "Taobao")) >>> len(thisset) 3
（D）清空集合
语法格式如下： s.clear() 清空集合 s。 实例(Python 3.0+) >>> thisset = set(("Google", "Runoob", "Taobao")) >>> thisset.clear() >>> print(thisset) set()
（E）判断元素是否在集合中存在
语法格式如下： x in s 判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。 实例(Python 3.0+) >>> thisset = set(("Google", "Runoob", "Taobao")) >>> "Runoob" in thisset True >>> "Facebook" in thisset False >>>
（G）集合内置方法完整列表
https://www.runoob.com/python3/python3-set.html
（四）Python数据类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
https://www.runoob.com/python/python-variable-types.html
