基础数据类型

Posted 2020-12-11 q121211z

基础数据类型

出现原因

? 让机器做出一些精准的区分，数字、汉字、英文...。

类型：

• 整数类型(int) : 1、2，3，4，5...；用来计算（+-*/...）。
• 字符串类型(str) : 单引号/双引号引起来的数据称之为字符串。
• 布尔值类型(bool) : 条件判断中使用：判断真假；True / False。
• 列表类型(list) : [1,”Hello”,[1,”2”,3]] 存储大量的数据。
• 元组类型(tuple) : (1,”Hello”,[1,”2”,3]) 存储大量的数据，里面的元素不可变。
• 字典类型(dict) : {“name”:’张三’} 存储大量关联型数据，查询速度非常快。
• 集合类型(set) : 交集，并集，差集。

使用type()查看数据类型。

整数型

int使用

主要用于计算（+-*/等）。
不同的进制之间的转换(十进制、二进制、八进制、十六进制)。

进制转换

1. 进制表示

   二进制用0b加相应数字来表示，8进制用0o加相应数字来表示，16进制用0x加相应数字来表示。即：

• 二进制 ：>>> 0b10 # 代表十进制：2
• 八进制 ：>>> 0o10 # 代表十进制：8
• 十六进制 ：>>> 0x10 # 代表十进制：10
• 十进制 ：>>> 10

2. 进制转换

其它进制转换二进制：bin()

bin(2)  #十进制转换二进制 #   ‘0b10‘
bin(0o10) #八进制转换二进制   # ‘0b1000‘
bin(0xf) #十六进制转换二进制   # ‘0b1111‘

其它进制转换为八进制：oct()

oct(0b101)   # ‘0o5‘
oct(0xf)   # ‘0o17‘
oct(0o123)   # ‘0o123‘

其它进制转换为十六进制：hex()

hex(0o10)   # ‘0x8‘
hex(3)   # ‘0x3‘
hex(0b111)   # ‘0x7‘

其它进制转换为十进制：int()

int(0o10)   # 8
int(0xf)   # 15
int(0b10)   # 2

int.bit_lenth(): 显示数字的有效二进制位数

a = 4
print(a.bit_lenth()) # 3

字符串类型

字符串或串(String)是由数字、字母、下划线组成的一串字符。一般记为 :
s="a1a2···an"(n>=0) 它是编程语言中表示文本的数据类型。

字符串操作

• 加号（+）是字符串连接运算符（字符串拼接）。
• 星号（*）是重复操作（乘法）。

公共方法

• max(str)：返回字符串 str 中最大的字母。
• min(str)：返回字符串 str 中最小的字母。
• len(string)：返回字符串长度。
• count(str, beg= 0,end=len(string)):返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数

切片

python的字串列表有2种取值顺序:

• 从左到右索引默认0开始的，最大范围是字符串长度少1
• 从右到左索引默认-1开始的，最大范围是字符串开头

下标是从 0 开始算起，可以是正数或负数

• str [头下标:尾下标] ：从字符串中截取一段子字符串，下标可以为空表示取到头或尾。
• str[头下标:尾下标] ：获取的子字符串包含头下标，但不包含尾下标的字符。比如:

s = ‘abcdef‘
s[1:5]   # ‘bcde‘

• str[头下标:尾下标:步长] ：截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置，设置步长为 2（间隔一个位置）来截取字符串：

字符串内建函数

序号 方法及描述

• upper()：转换字符串中的小写字母为大写

• isupper()：如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

• lower()：转换字符串中所有大写字符为小写.

• islower()：如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

• startswith(substr, beg=0,end=len(string))：检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

• endswith(suffix, beg=0, end=len(string))：检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.

• replace(old, new [, max])：把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。

• lstrip()：截掉字符串左边的空格或指定字符。

• rstrip()：删除字符串字符串末尾的空格.

• strip([chars])：在字符串上执行 lstrip()和 rstrip()

• split(str="", num=string.count(str))：num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串

• splitlines([keepends])：按照行(‘ ‘, ‘ ‘, ‘)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

• join(seq)：以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

• capitalize()：将字符串的第一个字符（如果是小写字母）转换为大

• title()：返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写istitle()：如果字符串是标题化的(见 title())则返回 True，否则返回 False

• find(str, beg=0 end=len(string))：检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
  rfind(str, beg=0,end=len(string))：类似于 find()函数，不过是从右边开始查找.

• index(str, beg=0, end=len(string))：跟find()方法一样，只不过如果str不在字符串中会报一个异常.
  rindex( str, beg=0, end=len(string))：类似于 index()，不过是从右边开始.

• isalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False

• isalnum()：如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False

• isdecimal()：检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

• isdigit()：如果字符串只包含数字则返回 True 否则返回 False..

• isnumeric()：如果字符串中只包含数字字符，则返回 True，否则返回 False

• isspace()：如果字符串中只包含空白，则返回 True，否则返回 False.

• encode(encoding=‘UTF-8‘,errors=‘strict‘)：以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是‘ignore‘或者‘replace‘

• bytes.decode(encoding="utf-8", errors="strict")：Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。

• center(width, fillchar)：返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。

• ljust(width[, fillchar])：返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。

• rjust(width,[, fillchar])：返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串

• swapcase()：将字符串中大写转换为小写，小写转换为大写

• expandtabs(tabsize=8)：把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。

• maketrans()：创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

• translate(table, deletechars="")：根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中

• zfill (width)：返回长度为 width 的字符串，原字符串右对齐，前面填充0

列表类型

• List（列表）：列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。

• 列表用 [ ] 标识，列表是可变容器模型，且可存储任意类型对象。

• 列表中值的切割也可以用 [头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。

列表的增删改查：

a = [‘q‘,‘w‘,‘e‘,‘r‘,‘t‘,‘y‘,‘u‘,‘i‘]         #以下每一个输出，都以此列表为准

查询

print(a[3:6]) #从左往右，取下标为3至5的内容      [‘r‘,‘t‘,‘y‘]
print(a[0:])  #从左往右，取到列表最后        [‘q‘,‘w‘,‘e‘,‘r‘,‘t‘,‘y‘,‘u‘,‘i‘]
print(a[0:-1])  #从左往右，取到列表倒数第二个   [‘q‘,‘w‘,‘e‘,‘r‘,‘t‘,‘y‘,‘u‘]
print(a[0::2])  #从左往右，跳着取，步长为2    [‘q‘, ‘e‘, ‘t‘, ‘u‘]
print(a[4::-2])   #从右往左，下标为4开始取，取到边界，步长为2    [‘t‘, ‘e‘, ‘q‘]
print(a[-2::-1]) #从右往左，倒数第二个开始，取到边界，步长为1   [‘u‘, ‘y‘, ‘t‘, ‘r‘, ‘e‘, ‘w‘, ‘q‘]

增加

• append #默认添加到列表最后的位置
• insert #将是数据输入到列表任意一个位置
• extend #将列表合并到一起，一次添加多个

修改

a[2] = ‘lalala‘   #[‘q‘, ‘w‘, ‘lalala‘, ‘r‘, ‘t‘, ‘y‘, ‘u‘, ‘i‘]
a[1:2] = [‘11‘,‘12‘]   #[‘q‘, ‘11‘, ‘22‘, ‘e‘, ‘r‘, ‘t‘, ‘y‘, ‘u‘, ‘i‘

删除

• remove 内置方法、直接删除、只能删除一个值
  a.remove(‘q‘) #[‘w‘, ‘e‘, ‘r‘, ‘t‘, ‘y‘, ‘u‘, ‘i‘]
• pop 根据索引删除、可以提取出来被删掉的值；括号里为空，默认删除列表最后一项
  b = a.pop(1) # [‘q‘, ‘e‘, ‘r‘, ‘t‘, ‘y‘, ‘u‘, ‘i‘]
  print(b) # w
• del 可以按照索引删除，也可以直接删除列表
  del a[0] # [‘w‘, ‘e‘, ‘r‘, ‘t‘, ‘y‘, ‘u‘, ‘i‘]
  del a # 报错 NameError: name ‘a‘ is not defined

内置函数

• list.count(i) 统计字符i出现的次数
• list.append() 表示向列表中添加一个元素,会添加到列表的末尾
• list.insert() 插入,想列表的某个位置插入一个元素, 前面的元素不变,后面的元素后移
• list.pop() 表示删除一个元素,默认删除最后一个,如果有参数,根据参数删除
• list.remove(m) 移除列表中第一个匹配的m元素，没有会报错
• list.clear() 清空列表中的数据, 变为空列表
• del list[0] 删除列表
• list.Index() 查找该值在列表中的第一次出现的位置，没找到会报错
• list.sort()方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。 reverse方法是将list逆置。
• list.extend() 表示向列表中添加一个列表,会将列表的数据添加在原数据的末尾

sort（list） 和sorted

用List的成员函数sort进行排序，在本地进行排序，不返回副本；用built-in函数sorted进行排序，返回副本，原始输入不变
sort(...)
L.sort(key=None, reverse=False)
sorted(...)
sorted(iterable,key=None, reverse=False)
iterable：是可迭代类型;
key：用列表元素的某个属性或函数进行作为关键字，有默认值，迭代集合中的一项;
reverse：排序规则. reverse = True 降序 或者 reverse = False 升序有默认值。
返回值：是一个经过排序的可迭代类型，与iterable一样。

元组

? 与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tup1 = (‘Google‘, 2, 1997, 2000);
tup2 = "a", "b", "c", "d";   #  不需要括号也可以
type(tup2)  # <class ‘tuple‘>

创建空元组

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

tup1 = (50)   # type(tup1)   <class ‘int‘>  # 不加逗号，类型为整型
tup1 = (50,)   # type(tup1)  <class ‘tuple‘>  # 加上逗号，类型为元组

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

访问元组（切片）

元组可以使用下标索引来访问元组中的值，如下实例:
tup1 = (‘Google‘, ‘Runoob‘, 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print ("tup1[0]: ", tup1[0]) # tup1[0]: Google
print ("tup2[1:5]: ", tup2[1:5]) # tup2[1:5]: (2, 3, 4, 5)

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
tup1 = (12, 34.56);
tup2 = (‘abc‘, ‘xyz‘)

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

可以将元组拼接 创建一个新的元组
tup3 = tup1 + tup2;
print(tup3) # (12, 34.56, ‘abc‘, ‘xyz‘)

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
tup = (‘Google‘, ‘Runoob‘, 1997, 2000)
del tup;
print ("删除后的元组 tup : ",tup)
以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
删除后的元组 tup :
Traceback (most recent call last):
File "test.py", line 8, in
print (tup)
NameError: name ‘tup‘ is not defined

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
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,) 1 2 3 迭代

元组内置函数

序号 方法 描述 实例
1 len(tuple) 计算元组元素个数。 >>> len(tuple1)
2 max(tuple) 返回元组中元素最大值。 >>> max(tuple2)
3 min(tuple) 返回元组中元素最小值。 >>> min(tuple2)
4 tuple(seq) 将列表转换为元组。 >>> tuple1=tuple(list1)

元组是不可变的

所谓元组的不可变指的是元组所指向的内存中的地址不可变。

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 }
• 键(key)必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。一个简单的字典实例：
  dict = {‘Alice‘: ‘2341‘, ‘Beth‘: ‘9102‘, ‘Cecil‘: ‘3258‘}

字典的创建方式

• 方法一 ：dict1 = dict(((’k1’, ’v1’),(’k2’, ’v2’),(’k3’, ’v3’)))
• 方法二 ：dict2 = dict(k1=v1, k2=v2, k3=v3)
• 方法三 ：dict3 = {’k1’:’v1’,’k2’, ’v2’,’k3’, ’v3’}

访问字典里的值

把相应的键放入到方括号中，如下实例:

dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
print ("dict[‘Name‘]: ", dict[‘Name‘]) # dict[‘Name‘]:  Runoob
print ("dict[‘Age‘]: ", dict[‘Age‘]) # dict[‘Age‘]:  7

如果用字典里没有的键访问数据，会输出错误如下：

dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
print ("dict[‘Alice‘]: ", dict[‘Alice‘])
以上实例输出结果：
Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print ("dict[‘Alice‘]: ", dict[‘Alice‘])
KeyError: ‘Alice‘

修改字典

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

dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}
dict[‘Age‘] = 8               # 更新 Age
dict[‘School‘] = "教程"  # 添加信息
print ("dict[‘Age‘]: ", dict[‘Age‘])  # dict[‘Age‘]:  8
print ("dict[‘School‘]: ", dict[‘School‘]) # dict[‘School‘]:  教程

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。显示删除一个字典用del命令，如下实例：

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 操作后字典不再存在：
Traceback (most recent call last):
  File "test.py", line 9, in <module>
    print ("dict[‘Age‘]: ", dict[‘Age‘])
TypeError: ‘type‘ object is not subscriptable

字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。两个重要的点需要记住：

• 1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
  dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Name‘: ‘小菜鸟‘}
  print ("dict[‘Name‘]: ", dict[‘Name‘]) # dict[‘Name‘]: 小菜鸟
• 2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
  dict = {[‘Name‘]: ‘Runoob‘, ‘Age‘: 7}
  print ("dict[‘Name‘]: ", dict[‘Name‘])
  以上实例输出结果：
  Traceback (most recent call last):
  File "test.py", line 3, in
  dict = {[‘Name‘]: ‘Runoob‘, ‘Age‘: 7}
  TypeError: unhashable type: ‘list‘

字典内置函数&方法

Python字典包含了以下内置函数：
序号 函数及描述 实例

• 1 len(dict) 计算字典元素个数，即键的总数。 >>> len(dict)
• 2 str(dict) 输出字典，以可打印的字符串表示。 >>> str(dict)
• 3 type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 >>>type(dict)

字典内置方法：

• dict.keys() ：keys将字典中的键以列表形式返回。
• dict.values() ：values以列表的形式返回字典中的值。
• dict.items() ：将所有的字典项以列表方式返回，列表中项来自（键，值）。
• dict.get() ：get函数可以访问字典中不存在的键，当该键不存在是返回None
• dict.pop() ：删除字典中对应的键
• dict.setdefault() ：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值
• dict.clear() ：清除字典中的所有项
• dict.update() ：用一个字典更新另外一个字典（有则覆盖，无则添加）
• dict.copy() ：返回一个具有相同键值的新字典
• dict.popitem() ：移出字典中的项
• dict.fromkeys() ：使用给定的键建立新的字典，键默认对应的值为None

集合

• 集合（set）是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

• 创建格式：
  parame = {value01,value02,...}
  或者
  set(value)

• 用途：
  去重
  关系测试：交集、并集、差集.....

集合的数学运算

a = set(‘abracadabra‘)
b = set(‘alacazam‘)
a     # {‘a‘, ‘r‘, ‘b‘, ‘c‘, ‘d‘}
a - b : 差集 相当于a.difference(b)  # 集合a中包含而集合b中不包含的元素
{‘r‘, ‘d‘, ‘b‘}
a | b : 并集  相当于a.intersection(b)  # 集合a或b中包含的所有元素
{‘a‘, ‘c‘, ‘r‘, ‘d‘, ‘b‘, ‘m‘, ‘z‘, ‘l‘}
a & b : 交集 相当于a.union(b)  # 集合a和b中都包含了的元素
{‘a‘, ‘c‘}
a ^ b      相当于a.symmetric_difference(b)  # 不同时包含于a和b的元素
{‘r‘, ‘d‘, ‘b‘, ‘m‘, ‘z‘, ‘l‘}

集合推导式(Set comprehension):

a = {x for x in ‘abracadabra‘ if x not in ‘abc‘}
print(a)  # {‘r‘, ‘d‘}

集合的基本操作

1、添加元素

• 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‘}

2、移除元素

• 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 )也是移除集合中的元素，且如果元素不存在，不会发生错误.
thisset = set(("Google", "Runoob", "Taobao"))
thisset.discard("Facebook")  # 不存在不会发生错误
print(thisset) # {‘Taobao‘, ‘Google‘, ‘Runoob‘}

• s.pop() : 可以设置随机删除集合中的一个元素，语法格式如下：

  thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
  x = thisset.pop()
  print(x)  #  Runoob
  

  多次执行测试结果都不一样。set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

3、计算集合元素个数

• len(s)，计算集合 s 元素个数。

thisset = set(("Google", "Runoob", "Taobao"))
len(thisset) # 3

4、清空集合

• s.clear()，清空集合 s。

thisset = set(("Google", "Runoob", "Taobao"))
thisset.clear()
print(thisset) # set()

5、判断元素是否在集合中存在

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

thisset = set(("Google", "Runoob", "Taobao"))
"Runoob" in thisset    # True
"Facebook" in thisset    # False

集合内置方法完整列表

方法 描述

• add() 为集合添加元素
• clear() 移除集合中的所有元素
• copy() 拷贝一个集合
• difference() 返回多个集合的差集
• difference_update() 移除集合中的元素，该元素在指定的集合也存在。
• discard() 删除集合中指定的元素
• intersection() 返回集合的交集
• intersection_update() 返回集合的交集。
• pop() 随机移除元素
• remove() 移除指定元素
• symmetric_difference() 返回两个集合中不重复的元素集合。
• symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
• union() 返回两个集合的并集
• update() 给集合添加元素
• isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
• issubset() 判断指定集合是否为该方法参数集合的子集。
• issuperset() 判断该方法的参数集合是否为指定集合的子集

8、数据类型转换

数据类型的转换，将数据类型作为函数名即可。以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
函数 描述

• int(x [,base]) 将x转换为一个整数
• long(x [,base] ) 将x转换为一个长整数
• float(x) 将x转换到一个浮点数
• complex(real [,imag]) 创建一个复数
• repr(x) 将对象 x 转换为表达式(带引号的)字符串（原形毕露）
• tuple(s) 将序列 s 转换为一个元组
• list(s) 将序列 s 转换为一个列表
• set(s) 转换为可变集合
• dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。
• frozenset(s) 转换为不可变集合
• chr(x) 将一个整数转换为一个字符
• unichr(x) 将一个整数转换为Unicode字符
• ord(x) 将一个字符转换为它的整数值

补充

• ’’,0,(),{},[],set(),None 转换成布尔值时都为False