注意:部分代码直接复制菜鸟教程
,在本地编辑器里运行
运算符
算术运算符
#!/usr/bin/python3a = 21
b = 10
c = 0c = a + b
print ("1 - c 的值为:", c)c = a - b
print ("2 - c 的值为:", c)c = a * b
print ("3 - c 的值为:", c)c = a / b
print ("4 - c 的值为:", c)c = a % b
print ("5 - c 的值为:", c)# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b
print ("6 - c 的值为:", c)a = 10
b = 5
c = a//b
print ("7 - c 的值为:", c)
比较运算符
#!/usr/bin/python3a = 21
b = 10
c = 0if ( a == b ):print ("1 - a 等于 b")
else:print ("1 - a 不等于 b")if ( a != b ):print ("2 - a 不等于 b")
else:print ("2 - a 等于 b")if ( a < b ):print ("3 - a 小于 b")
else:print ("3 - a 大于等于 b")if ( a > b ):print ("4 - a 大于 b")
else:print ("4 - a 小于等于 b")# 修改变量 a 和 b 的值
a = 5
b = 20
if ( a <= b ):print ("5 - a 小于等于 b")
else:print ("5 - a 大于 b")if ( b >= a ):print ("6 - b 大于等于 a")
else:print ("6 - b 小于 a")
赋值运算符
#!/usr/bin/python3a = 21
b = 10
c = 0c = a + b
print ("1 - c 的值为:", c)c += a
print ("2 - c 的值为:", c)c *= a
print ("3 - c 的值为:", c)c /= a
print ("4 - c 的值为:", c)c = 2
c %= a
print ("5 - c 的值为:", c)c **= a
print ("6 - c 的值为:", c)c //= a
print ("7 - c 的值为:", c)
逻辑运算符
#!/usr/bin/python3a = 10
b = 20if ( a and b ):print ("1 - 变量 a 和 b 都为 true")
else:print ("1 - 变量 a 和 b 有一个不为 true")if ( a or b ):print ("2 - 变量 a 和 b 都为 true,或其中一个变量为 true")
else:print ("2 - 变量 a 和 b 都不为 true")# 修改变量 a 的值
a = 0
if ( a and b ):print ("3 - 变量 a 和 b 都为 true")
else:print ("3 - 变量 a 和 b 有一个不为 true")if ( a or b ):print ("4 - 变量 a 和 b 都为 true,或其中一个变量为 true")
else:print ("4 - 变量 a 和 b 都不为 true")if not( a and b ):print ("5 - 变量 a 和 b 都为 false,或其中一个变量为 false")
else:print ("5 - 变量 a 和 b 都为 true")
身份运算符
#!/usr/bin/python3a = 20
b = 20if ( a is b ):print ("1 - a 和 b 有相同的标识")
else:print ("1 - a 和 b 没有相同的标识")if ( id(a) == id(b) ):print ("2 - a 和 b 有相同的标识")
else:print ("2 - a 和 b 没有相同的标识")# 修改变量 b 的值
b = 30
if ( a is b ):print ("3 - a 和 b 有相同的标识")
else:print ("3 - a 和 b 没有相同的标识")if ( a is not b ):print ("4 - a 和 b 没有相同的标识")
else:print ("4 - a 和 b 有相同的标识")
is 与 == 区别:
is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等。
运算符优先级
数据类型
不可变数据(3 个):Number(数字)、String(字符串)、Tuple(元组)
可变数据(3 个):List(列表)、Dictionary(字典)、Set(集合)
数字(Number)
支持三种不同的数值类型:
-
整型(int) - 通常被称为是整型或整数,是正或负整数,不带小数点。Python3 整型是没有限制大小的,可以当作 Long 类型使用,所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
-
浮点型(float) - 浮点型由整数部分与小数部分组成,浮点型也可以使用科学计数法表示(2.5e2 = 2.5 x 102 = 250)
-
复数( (complex)) - 复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型。
数学函数
随机数函数
三角函数
数学常量
字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 " )来创建字符串。
创建字符串很简单,只要为变量分配一个值即可。例如:
Python 访问字符串中的值
ex:
#!/usr/bin/python3var1 = 'Hello World!'
var2 = "Runoob"print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])
字符串运算符
#!/usr/bin/python3a = "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')
字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式,但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中,字符串格式化使用与 C 中 sprintf 函数一样的语法。
#!/usr/bin/python3print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
三引号
python三引号允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符。实例如下
#!/usr/bin/python3para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
f-string
f-string 是 python3.6 之后版本添加的,称之为字面量格式化字符串,是新的格式化字符串的语法。
之前我们习惯用百分号 (%):
>>> name = 'Runoob'
>>> 'Hello %s' % name
'Hello Runoob'
python3.6之后才有这个f-string
用了这种方式明显更简单了,不用再去判断使用 %s
,还是 %d
。
f-string 格式化字符串以 f
开头,后面跟着字符串,字符串中的表达式用大括号 {}
包起来,它会将变量或表达式计算后的值替换进去,实例如下:
>>> name = 'Runoob'
>>> f'Hello {name}' # 替换变量
'Hello Runoob'
>>> f'{1+2}' # 使用表达式
'3'>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'
字符串内建函数
Python 的字符串常用内建函数如下:
- capitalize() 将字符串的第一个字母变成大写,其他字母变小写
#!/usr/bin/python3str = "this is string Example From Runoob....wow!!!"print ("str.capitalize() : ", str.capitalize())
2. center() 方法返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格
#!/usr/bin/python3str = "[woshishui]"print ("str.center(40, '*') : ", str.center(40, '*'))
3. decode() 方法以指定的编码格式解码 bytes 对象。默认编码为 ‘utf-8’。
#!/usr/bin/python3str = "菜鸟教程";
str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")print(str)print("UTF-8 编码:", str_utf8)
print("GBK 编码:", str_gbk)print("UTF-8 解码:", str_utf8.decode('UTF-8','strict'))
print("GBK 解码:", str_gbk.decode('GBK','strict'))
-
encode() 方法以指定的字符串解码
方法同上 -
count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
str.count(sub, start= 0,end=len(string))
#!/usr/bin/python3str="www.runoob.com"
sub='o'
print ("str.count('o') : ", str.count(sub))sub='run'
print ("str.count('run', 0, 10) : ", str.count(sub,0,10))
结果:
str.count('o') : 3
str.count('run', 0, 10) : 1
列表
序列是 Python 中最基本的数据结构。
序列中的每个值都有对应的位置值,称之为索引,第一个索引是 0,第二个索引是 1,依此类推。
Python 有 6 个序列的内置类型,但最常见的是列表和元组。
列表都可以进行的操作包括索引,切片,加,乘,检查成员。
此外,Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的 Python 数据类型,它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示:
list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']
访问列表中的值
#!/usr/bin/python3list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )
结果
red
green
blue
索引也可以从尾部开始,最后一个元素的索引为 -1,往前一位为 -2,以此类推。
#!/usr/bin/python3list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )
结果:
black
white
yellow
#!/usr/bin/python3nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])
结果:
[10, 20, 30, 40]
#!/usr/bin/python3list = ['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']
更新列表
你可以对列表的数据项进行修改或更新,你也可以使用 append() 方法来添加列表项,如下所示:
#!/usr/bin/python3list = ['Google', 'Runoob', 1997, 2000]print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)
结果:
第三个元素为 : 1997
更新后的第三个元素为 : 2001
更新后的列表 : ['Google', 'Runoob', 'Taobao', 'Baidu']
删除列表元素
#!/usr/bin/python3list = ['Google', 'Runoob', 1997, 2000]print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)
原始列表 : ['Google', 'Runoob', 1997, 2000]
删除第三个元素 : ['Google', 'Runoob', 2000]
Python列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表,* 号用于重复列表。
如下所示:
Python 表达式 | 结果 | 描述 |
---|---|---|
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=" ") | 1 2 3 | 迭代 |
列表截取与拼接
L=['Google', 'Runoob', 'Taobao']
>>> L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>
列表还支持拼接操作:
>>> squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>
嵌套列表
使用嵌套列表即在列表里创建其它列表,例如:
>>> 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'
列表比较
列表比较需要引入 operator 模块的 eq 方法(详见:Python operator 模块):
# 导入 operator 模块
import operatora = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))
Python列表函数&方法
Python包含以下函数:
llmm
序号 | 函数 |
---|---|
1 | len(list)列表元素个数 |
2 | max(list)返回列表元素最大值 |
3 | min(list)返回列表元素最小值 |
4 | list(seq)将元组转换为列表 |
Python包含以下方法:
序号 | 方法 |
---|---|
1 | list.append(obj)在列表末尾添加新的对象 |
2 | list.count(obj)统计某个元素在列表中出现的次数 |
3 | list.extend(seq)在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) |
4 | list.index(obj)从列表中找出某个值第一个匹配项的索引位置 |
5 | list.insert(index, obj)将对象插入列表 |
6 | list.pop([index=-1])移除列表中的一个元素(默认最后一个元素),并且返回该元素的值 |
7 | list.remove(obj)移除列表中某个值的第一个匹配项 |
8 | list.reverse()反向列表中元素 |
9 | list.sort( key=None, reverse=False)对原列表进行排序 |
10 | list.clear()清空列表 |
11 | list.copy()复制列表 |
元组
Python 的元组与列表类似,不同之处在于元组的元素不能修改。
元组使用小括号 ( ),列表使用方括号 [ ]。
元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可
>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d" # 不需要括号也可以
>>> type(tup3)
<class 'tuple'>
创建空元组
tup1 = ()
元组中只包含一个元素时,需要在元素后面添加逗号 , ,否则括号会被当作运算符使用:
>>> tup1 = (50)
>>> type(tup1) # 不加逗号,类型为整型
<class 'int'>>>> tup1 = (50,)
>>> type(tup1) # 加上逗号,类型为元组
<class 'tuple'>
访问元组
#!/usr/bin/python3tup1 = ('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)
修改元组
#!/usr/bin/python3tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')# 以下修改元组元素操作是非法的。
# tup1[0] = 100# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
(12, 34.56, 'abc', 'xyz')
删除元组
#!/usr/bin/python3tup = ('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
元组运算符
元组索引,截取
>>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup[1]
'Runoob'
>>> tup[-2]
'Weibo'
>>> tup[1:]
('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
>>> tup[1:4]
('Runoob', 'Taobao', 'Wiki')
>>>
元组内置函数
关于元组是不可变的
所谓元组的不可变指的是元组所指向的内存中的内容不可变。
>>> 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,绑定到新的对象了,不是修改了原来的对象。
字典
字典是另一种可变容器模型,且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割,每个对之间用逗号(,)分割,整个字典包括在花括号 {} 中 ,格式如下所示:
d = {key1 : value1, key2 : value2, key3 : value3 }
创建字典方式
常用方式
tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}
也可如此创建字典:
tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }
创建空字典
# 使用大括号 {} 来创建空字典
emptyDict = {}# 打印字典
print(emptyDict)# 查看字典的数量
print("Length:", len(emptyDict))# 查看类型
print(type(emptyDict))
输出结果:
{}
Length: 0
<class 'dict'>
访问字典里的值
#!/usr/bin/python3tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}print ("tinydict['Name']: ", tinydict['Name'])
print ("tinydict['Age']: ", tinydict['Age'])
结果:
tinydict['Name']: Runoob
tinydict['Age']: 7
如果用字典里没有的键访问数据,会输出错误如下:
#!/usr/bin/python3tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}print ("tinydict['Alice']: ", tinydict['Alice'])
以上实例输出结果:
Traceback (most recent call last):File "test.py", line 5, in <module>print ("tinydict['Alice']: ", tinydict['Alice'])
KeyError: 'Alice'
修改字典
向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对如下实例:
实例
#!/usr/bin/python3tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}tinydict['Age'] = 8 # 更新 Age
tinydict['School'] = "菜鸟教程" # 添加信息
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
以上实例输出结果:
tinydict['Age']: 8
tinydict['School']: 菜鸟教程
删除字典元素
能删单一的元素也能清空字典,清空只需一项操作。
显式删除一个字典用del命令,如下实例:
清空字段
tinydict.clear() # 清空字典
删除字段
del tinydict # 删除字典
实例
#!/usr/bin/python3
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del tinydict['Name'] # 删除键 'Name'
tinydict.clear() # 清空字典
del tinydict # 删除字典
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
但这会引发一个异常,因为用执行 del 操作后字典不再存在:
Traceback (most recent call last):File "/runoob-test/test.py", line 9, in <module>print ("tinydict['Age']: ", tinydict['Age'])
NameError: name 'tinydict' is not defined
注:del() 方法后面也会讨论。
字典键的特性
字典值可以是任何的 python 对象,既可以是标准的对象,也可以是用户定义的,但键不行。
两个重要的点需要记住:
- 不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住,如下实例:
实例
#!/usr/bin/python3
tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
print ("tinydict['Name']: ", tinydict['Name'])
以上实例输出结果:
tinydict['Name']: 小菜鸟
- 键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行,如下实例:
实例
#!/usr/bin/python3
tinydict = {['Name']: 'Runoob', 'Age': 7}
print ("tinydict['Name']: ", tinydict['Name'])
以上实例输出结果:
Traceback (most recent call last):File "test.py", line 3, in <module>tinydict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'
字典内置函数&方法
内置函数
内置方法
集合
类似redis的无序集合
集合(set)是一个无序的不重复元素序列。
集合中的元素不会重复,并且可以进行交集、并集、差集等常见的集合操作。
可以使用大括号 { } 创建集合,元素之间用逗号 , 分隔, 或者也可以使用 set() 函数创建集合。
创建格式:
parame = {value01,value02,...}
或者
set(value)
以下是一个简单实例:
set1 = {1, 2, 3, 4} # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7]) # 使用 set() 函数从列表创建集合
注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
更多实例演示:
>>> 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'}
添加元素
语法格式如下:
s.add( x )
将元素 x 添加到集合 s 中,如果元素已存在,则不进行任何操作。
实例(Python 3.0+)
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}
还有一个方法,也可以添加元素,且参数可以是列表,元组,字典等,语法格式如下:
s.update( x )
x 可以有多个,用逗号分开。
实例(Python 3.0+)
>>> 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'}
移除元素
s.remove( x )
将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误。
实例(Python 3.0+)
>>> 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)
输出结果:
Runoob
多次执行测试结果都不一样。
set 集合的 pop 方法会对集合进行无序的排列,然后将这个无序排列集合的左面第一个元素进行删除。
计算集合元素个数
len(s)
计算集合 s 元素个数。
实例(Python 3.0+)
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> len(thisset)
### 清空集合
s.clear()
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.clear()
>>> print(thisset)
set()
判断元素是否在集合中存在
x in s
判断元素 x 是否在集合 s 中,存在返回 True,不存在返回 False。
实例(Python 3.0+)
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False
>>>