Python3 基本数据类型
python是弱类型语言,弱类型语言有两个特点：
变量无须声明就可以直接赋值，对一个不存在的变量赋值就相当于定义了一个新变量。
变量的数据类型可以随时改变，比如，同一个变量可以一会儿被赋值为整数，一会儿被赋值为字符串。弱类型并不等于没有类型！弱类型是说在书写代码时不用刻意关注类型，但是在编程语言的内部仍然是有类型的。我们可以使用 type() 内置函数类检测某个变量或者表达式的类型。
Python3 中有六个标准的数据类型：
- Number（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
Python3 的六个标准数据类型中：
- 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
1.Number（数字）
Python3 支持 int、float、bool、complex（复数）。
在Python 3里，只有一种整数类型 int。
1.整数类型（int）
整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
在 Python 中，可以使用多种进制来表示整数：
1.十进制形式
我们平时常见的整数就是十进制形式，它由 0~9 共十个数字排列组合而成。使用十进制形式的整数不能以 0 作为开头，除非这个数值本身就是 0。
2.二进制形式
由 0 和 1 两个数字组成，书写时以0b或0B开头。例如，101 对应十进制数是 5。
3.八进制形式
八进制整数由 0~7 共八个数字组成，以0o或0O开头。注意，第一个符号是数字 0，第二个符号是大写或小写的字母 O。
4.十六进制形式
由 0~9 十个数字以及 A~F（或 a~f）六个字母组成，书写时以0x或0X开头，
数字分隔符
为了提高数字的的可读性，Python 3.x 允许使用下划线_作为数字（包括整数和小数）的分隔符。通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。下划线不会影响数字本身的值。
click = 1_301_547
distance = 384_000_000
print("Python教程阅读量：", click)print("地球和月球的距离：", distance)
2.浮点数类型（float）
浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
1.十进制形式
这种就是我们平时看到的小数形式，例如 34.6、346.0、0.346。书写小数时必须包含一个小数点，否则会被 Python 当作整数处理。
2.指数形式
Python 小数的指数形式的写法为：
aEn 或 aen
a 为尾数部分，是一个十进制数；n 为指数部分，是一个十进制整数；E或e是固定的字符，用于分割尾数部分和指数部分。整个表达式等价于 a×10n。
指数形式的小数举例：
- 2.1E5 = 2.1×105，其中 2.1 是尾数，5 是指数。
- 3.7E-2 = 3.7×10-2，其中 3.7 是尾数，-2 是指数。
- 0.5E7 = 0.5×107，其中 0.5 是尾数，7 是指数。
3.复数（Complex）
复数（Complex）是 Python 的内置类型，直接书写即可。换句话说，Python 语言本身就支持复数，而不依赖于标准库或者第三方库。
复数由实部（real）和虚部（imag）构成，在 Python 中，复数的虚部以j或者J作为后缀，具体格式为：
a + bj
a 表示实部，b 表示虚部， 复数的实部a和虚部b都是浮点型。
4.布尔类型（bool）
布尔类型即 True 或 False。
在 Python 中，True 和 False 都是关键字，表示布尔值。
布尔类型特点：
- 布尔类型只有两个值：True 和 False。
- 布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0。
- 布尔类型可以和逻辑运算符一起使用，包括 and、or 和 not。这些运算符可以用来组合多个布尔表达式，生成一个新的布尔值。
- 布尔类型也可以被转换成其他数据类型，比如整数、浮点数和字符串。在转换时，True 会被转换成 1，False 会被转换成 0。
2.字符串（String）
若干个字符的集合就是一个字符串（String）。Python中的字符串必须由双引号" "或者单引号' '包围，具体格式为：
"字符串内容"
'字符串内容'
1.字符串包含引号
当字符串内容中出现引号时，我们需要进行特殊处理，否则 Python 会解析出错，例如：
'I'm a great coder!'
由于上面字符串中包含了单引号，此时 Python 会将字符串中的单引号与第一个单引号配对，这样就会把'I'当成字符串，而后面的m a great coder!'就变成了多余的内容，从而导致语法错误。
对于这种情况，我们有两种处理方案：
在引号前面添加反斜杠\就可以对引号进行转义，让 Python 把它作为普通文本对待，例如：
str1 = 'I\'m a great coder!'
str2 = "引文双引号是\"，中文双引号是“"
print(str1)
print(str2)
如果字符串内容中出现了单引号，那么我们可以使用双引号包围字符串，反之亦然。例如：
str1 = "I'm a great coder!" #使用双引号包围含有单引号的字符串
2.长字符串
Python 长字符串由三个双引号"""或者三个单引号'''包围，语法格式如下：
"""长字符串内容"""
'''长字符串内容'''
在长字符串中放置单引号或者双引号不会导致解析错误。
当程序中有大段文本内容需要定义成字符串时，优先推荐使用长字符串形式，因为这种形式非常强大，可以在字符串中放置任何内容，包括单引号和双引号。
3.字符串拼接
在 Python中拼接字符串很简单，可以直接将两个字符串紧挨着写在一起，具体格式为：
strname = "str1" "str2"
strname 表示拼接以后的字符串变量名，str1 和 str2 是要拼接的字符串内容。使用这种写法，Python 会自动将两个字符串拼接在一起，这种写法只能拼接字符串常量。
如果需要使用变量，就得借助+运算符来拼接，+运算符也能拼接字符串常量。具体格式为：
strname = str1 + str2
很多应用场景中，我们需要将字符串和数字拼接在一起，而 Python 不允许直接拼接数字和字符串，所以我们必须先将数字转换成字符串。可以借助 str() 和 repr() 函数将数字转换为字符串，要转换的对象可以是数字、列表、元组、字典等多种类型的数据。
str() 和 repr() 函数虽然都可以将数字转换成字符串，但它们之间是有区别的：
- str() 用于将数据转换成适合人类阅读的字符串形式。
- repr() 用于将数据转换成适合解释器阅读的字符串形式（Python 表达式的形式），适合在开发和调试阶段使用；如果没有等价的语法，则会发生 SyntaxError 异常。
- str() 保留了字符串最原始的样子，而 repr() 使用引号将字符串包围起来。
- 在 Python 交互式编程环境中输入一个表达式（变量、加减乘除、逻辑运算等）时，Python 会自动使用 repr() 函数处理该表达式。
4.字符串截取
从本质上讲，字符串是由多个字符构成的，字符之间是有顺序的，这个顺序号就称为索引（index）。Python允许通过索引来操作字符串中的单个或者多个字符，比如获取指定索引处的字符，返回指定字符的索引值等。
获取单个字符
知道字符串名字以后，在方括号[ ]中使用索引即可访问对应的字符，具体的语法格式为：
strname[index]
strname 表示字符串名字，index 表示索引值。
Python 允许从字符串的两端使用索引：
当以字符串的左端（字符串的开头）为起点时，索引是从 0 开始计数的；字符串的第一个字符的索引为 0，第二个字符的索引为 1，第三个字符串的索引为 2 ……
当以字符串的右端（字符串的末尾）为起点时，索引是从 -1 开始计数的；字符串的倒数第一个字符的索引为 -1，倒数第二个字符的索引为 -2，倒数第三个字符的索引为 -3
获取多个字符（字符串切片）
使用[ ]除了可以获取单个字符外，还可以指定一个范围来获取多个字符，也就是一个子串或者片段，具体格式为：
strname[start : end : step]
对各个部分的说明：
- strname：要截取的字符串；
- start：表示要截取的第一个字符所在的索引（截取时包含该字符）。如果不指定，默认为 0，也就是从字符串的开头截取；
- end：表示要截取的最后一个字符所在的索引（截取时不包含该字符）。如果不指定，默认为字符串的长度；
- step：指的是从 start 索引处的字符开始，每 step 个距离获取一个字符，直至 end 索引出的字符。step 默认值为 1，当省略该值时，最后一个冒号也可以省略。
3.列表（list）
从形式上看，列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔，如下所示：
[element1, element2, element3, ..., elementn]
格式中，element1 ~ elementn 表示列表中的元素，个数没有限制，只要是 Python 支持的数据类型就可以。从内容上看，列表可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同。（列表它的数据类型为 list）
注意，在使用列表时，虽然可以将不同类型的数据放入到同一个列表中，但通常情况下不这么做，同一列表中只放入同一类型的数据，这样可以提高程序的可读性。
1.创建列表
在 Python 中，创建列表的方法可分为两种
1.使用 [ ] 直接创建列表
使用[ ]创建列表后，一般使用=将它赋值给某个变量，具体格式如下：
listname = [element1 , element2 , element3 , ... , elementn]
其中，listname 表示变量名，element1 ~ elementn 表示列表元素。
另外，使用此方式创建列表时，列表中元素可以有多个，也可以一个都没有，例如：
emptylist = [ ] #这表明，emptylist 是一个空列表。
2.使用 list() 函数创建列表
除了使用[ ]创建列表外，Python 还提供了一个内置的函数 list()，使用它可以将其它数据类型转换为列表类型。例如：
#将字符串转换成列表
list1 = list("hello")
print(list1)
#将元组转换成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2)
#将字典转换成列表
dict1 = {'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3)
#将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4)
#创建空列表
print(list())
运行结果：
['h', 'e', 'l', 'l', 'o']
['Python', 'Java', 'C++', 'JavaScript']
['a', 'b', 'c']
[1, 2, 3, 4, 5]
[]
2.访问列表元素
列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。
使用索引访问列表元素的格式为：
listname[i]
其中，listname 表示列表名字，i 表示索引值。列表的索引可以是正数，也可以是负数。
使用切片访问列表元素的格式为：
listname[start : end : step]
其中，listname 表示列表名字，start 表示起始索引，end 表示结束索引，step 表示步长。
3.删除列表
对于已经创建的列表，如果不再使用，可以使用del关键字将其删除。
实际开发中并不经常使用 del 来删除列表，因为 Python 自带的垃圾回收机制会自动销毁无用的列表，即使开发者不手动删除，Python 也会自动将其回收。
del 关键字的语法格式为：
del listname
其中，listname 表示要删除列表的名称。
4.添加列表元素
1.加号（+）连接列表
列表是序列的一种，所以也可以使用+进行连接，这样就相当于在第一个列表的末尾添加了另一个列表，但是执行效率并不高。请看下面的演示：
language = ["Python", "C++", "Java"]
birthday = [1991, 1998, 1995]
info = language + birthday
print("language =", language)
print("birthday =", birthday)
print("info =", info)
运行结果：
language = ['Python', 'C++', 'Java']
birthday = [1991, 1998, 1995]
info = ['Python', 'C++', 'Java', 1991, 1998, 1995]
2.append()方法添加元素
append() 方法用于在列表的末尾追加元素，该方法的语法格式如下：
listname.append(obj)
其中，listname 表示要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。
请看下面的演示：
l = ['Python', 'C++', 'Java']
#追加元素
l.append('PHP')
print(l)
#追加元组，整个元组被当成一个元素
t = ('JavaScript', 'C#', 'Go')
l.append(t)
print(l)
#追加列表，整个列表也被当成一个元素
l.append(['Ruby', 'SQL'])
print(l)
['Python', 'C++', 'Java', 'PHP']
['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go')]
['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go'), ['Ruby', 'SQL']]
可以看到，当给 append() 方法传递列表或者元组时，此方法会将它们视为一个整体，作为一个元素添加到列表中，从而形成包含列表和元组的新列表。
3.extend()方法添加元素
和 append() 的不同之处在于，extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。
extend() 方法的语法格式如下：
listname.extend(obj)
其中，listname 指的是要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等，但不能是单个的数字。
请看下面的演示：
l = ['Python', 'C++', 'Java']
#追加元素
l.extend('C')
print(l)
#追加元组，元祖被拆分成多个元素
t = ('JavaScript', 'C#', 'Go')
l.extend(t)
print(l)
#追加列表，列表也被拆分成多个元素
l.extend(['Ruby', 'SQL'])
print(l)
运行结果：
['Python', 'C++', 'Java', 'C']
['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go']
['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go', 'Ruby', 'SQL']
4.insert()方法插入元素
append() 和 extend() 方法只能在列表末尾插入元素，如果希望在列表中间某个位置插入元素，那么可以使用 insert() 方法。
insert() 的语法格式如下：
listname.insert(index , obj)
其中，index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。
当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append() 是一样的。
请看下面的演示代码：
l = ['Python', 'C++', 'Java']
#插入元素
l.insert(1, 'C')
print(l)
#插入元组，整个元祖被当成一个元素
t = ('C#', 'Go')
l.insert(2, t)
print(l)
#插入列表，整个列表被当成一个元素
l.insert(3, ['Ruby', 'SQL'])
print(l)
#插入字符串，整个字符串被当成一个元素
l.insert(0, "http://c.biancheng.net")
print(l)
输出结果为：
['Python', 'C', 'C++', 'Java']
['Python', 'C', ('C#', 'Go'), 'C++', 'Java']
['Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']
['http://c.biancheng.net', 'Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']
5.删除列表元素
在 Python列表中删除元素主要分为以下 3 种场景：
- 根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法；
- 根据元素本身的值进行删除，可使用列表（list类型）提供的 remove() 方法；
- 将列表中所有元素全部删除，可使用列表（list类型）提供的 clear() 方法。
1.del：根据索引值删除元素
del 是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。
del 可以删除列表中的单个元素，格式为：
del listname[index]
其中，listname 表示列表名称，index 表示元素的索引值。
del 也可以删除中间一段连续的元素，格式为：
del listname[start : end]
其中，start 表示起始索引，end 表示结束索引。del 会删除从索引 start 到 end 之间的元素，不包括 end 位置的元素。
2.pop()：根据索引值删除元素
Python pop() 方法用来删除列表中指定索引处的元素，具体格式如下：
listname.pop(index)
其中，listname 表示列表名称，index 表示索引值。如果不写 index 参数，默认会删除列表中的最后一个元素，类似于数据结构中的“出栈”操作。
3.remove()：根据元素值进行删除
除了 del 关键字，Python 还提供了 remove() 方法，该方法会根据元素本身的值来进行删除操作。
需要注意的是，remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。
4.clear()：删除列表所有元素
Python clear() 用来删除列表的所有元素，也即清空列表。
6.修改列表元素
1.修改单个元素
修改单个元素非常简单，直接对元素赋值即可。请看下面的例子：
nums = [40, 36, 89, 2, 36, 100, 7]
nums[2] = -26 #使用正数索引
nums[-3] = -66.2 #使用负数索引print(nums)
运行结果：
[40, 36, -26, 2, -66.2, 100, 7]
2.修改一组元素*
Python 支持通过切片语法给一组元素赋值。在进行这种操作时，如果不指定步长（step 参数），Python 就不要求新赋值的元素个数与原来的元素个数相同；这意味，该操作既可以为列表添加元素，也可以为列表删除元素。
下面的代码演示了如何修改一组元素的值：
nums = [40, 36, 89, 2, 36, 100, 7]#修改第 1~4 个元素的值（不包括第4个元素）
nums[1: 4] = [45.25, -77, -52.5]
print(nums)
运行结果：
[40, 45.25, -77, -52.5, 36, 100, 7]
如果对空切片（slice）赋值，就相当于插入一组新的元素：
nums = [40, 36, 89, 2, 36, 100, 7]#在4个位置插入元素
nums[4: 4] = [-77, -52.5, 999]
print(nums)
运行结果：
[40, 36, 89, 2, -77, -52.5, 999, 36, 100, 7]
使用切片语法赋值时，Python 不支持单个值，例如下面的写法就是错误的：
nums[4: 4] = -77
但是如果使用字符串赋值，Python 会自动把字符串转换成序列，其中的每个字符都是一个元素，请看下面的代码：
s = list("Hello")
s[2:4] = "XYZ"
print(s)
运行结果：
['H', 'e', 'X', 'Y', 'Z', 'o']
使用切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相同，例如：
nums = [40, 36, 89, 2, 36, 100, 7]#步长为2，为第1、3、5个元素赋值
nums[1: 6: 2] = [0.025, -99, 20.5]
print(nums)
运行结果：
[40, 0.025, 89, -99, 36, 20.5, 7]
6.查找列表元素
1.index() 方法
index() 方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好使用 count() 方法判断一下。
index() 的语法格式为：
listname.index(obj, start, end)
其中，listname 表示列表名称，obj 表示要查找的元素，start 表示起始位置，end 表示结束位置。
start 和 end 参数用来指定检索范围：
- start 和 end 可以都不写，此时会检索整个列表；
- 如果只写 start 不写 end，那么表示检索从 start 到末尾的元素；
- 如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。
- index() 方法会返回元素所在列表中的索引值。
2.count()方法
count() 方法用来统计某个元素在列表中出现的次数，基本语法格式为：
listname.count(obj)
其中，listname 代表列表名，obj 表示要统计的元素。
如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在。
4.元组（tuple）
元组和列表（list）的不同之处在于：
- 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
- 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。
- 元组的不可变指的是元组所指向的内存中的内容不可变，元组的指向可变。
从形式上看，元组的所有元素都放在一对小括号( )中，相邻元素之间用逗号,分隔，如下所示：
(element1, element2, ... , elementn)
其中 element1~elementn 表示元组中的各个元素，个数没有限制，只要是 Python 支持的数据类型就可以。元组可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且在同一个元组中，元素的类型可以不同。
1.创建元组
Python 提供了两种创建元组的方法
1.使用 ( ) 直接创建
通过( )创建元组后，一般使用=将它赋值给某个变量，具体格式为：
tuplename = (element1, element2, ..., elementn)
其中，tuplename 表示变量名，element1 ~ elementn 表示元组的元素。
在 Python 中，元组通常都是使用一对小括号将所有元素包围起来的，但小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组。
需要注意的一点是，当创建的元组中只有一个字符串类型（或其他类型）的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串。请看下面的代码：
#最后加上逗号
a =("http://c.biancheng.net/cplus/",)
print(type(a))
print(a)
#最后不加逗号
b = ("http://c.biancheng.net/socket/")
print(type(b))
print(b)
运行结果为：
<class 'tuple'>
('http://c.biancheng.net/cplus/',)
<class 'str'>
http://c.biancheng.net/socket/
2.使用tuple()函数创建元组
除了使用( )创建元组外，Python 还提供了一个内置的函数 tuple()，用来将其它数据类型转换为元组类型。
tuple() 的语法格式如下：
tuple(data)
其中，data 表示可以转化为元组的数据，包括字符串、元组、range 对象等。
2.访问元组元素
和列表一样，我们可以使用索引（Index）访问元组中的某个元素（得到的是一个元素的值），也可以使用切片访问元组中的一组元素（得到的是一个新的子元组）。
使用索引访问元组元素的格式为：
tuplename[i]
其中，tuplename 表示元组名字，i 表示索引值。元组的索引可以是正数，也可以是负数。
使用切片访问元组元素的格式为：
tuplename[start : end : step]
其中，start 表示起始索引，end 表示结束索引，step 表示步长。
3.修改元组元素
元组是不可变序列，元组中的元素不能被修改，所以我们只能创建一个新的元组去替代旧的元组。
例如，对元组变量进行重新赋值。
另外，还可以通过连接多个元组（使用+可以拼接元组）的方式向元组中添加新元素。
使用+拼接元组1和元组2以后，元组1 和 元组2 的内容不会发生改变，拼接生成的是一个新的元组。
4.删除元组
当创建的元组不再使用时，可以通过 del 关键字将其删除，例如：
tup = ('Java教程',"http://c.biancheng.net/java/")
print(tup)
del tup
print(tup)
Python 自带垃圾回收功能，会自动销毁不用的元组，所以一般不需要通过 del 来手动删除。
5.字典（dict）
Python 字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。字典类型是 Python 中唯一的映射类型。
字典中，习惯将各元素对应的索引称为键（key），各个键对应的元素称为值（value），键及其关联的值称为“键值对”。
| 主要特征 | 解释 |
|---|---|
| 通过键而不是通过索引来读取元素 | 字典类型有时也称为关联数组或者散列表（hash）。它是通过键将一系列的值联系起来的，这样就可以通过键从字典中获取指定项，但不能通过索引来获取。 |
| 字典是任意数据类型的无序集合 | 和列表、元组不同，通常会将索引值 0 对应的元素称为第一个元素，而字典中的元素是无序的。 |
| 字典是可变的，并且可以任意嵌套 | 字典可以在原处增长或者缩短（无需生成一个副本），并且它支持任意深度的嵌套，即字典存储的值也可以是列表或其它的字典。 |
| 字典中的键必须唯一 | 字典中，不支持同一个键出现多次，否则只会保留最后一个键值对。 |
| 字典中的键必须不可变 | 字典中每个键值对的键是不可变的，只能使用数字、字符串或者元组，不能使用列表。 |
字典的键可以是整数、字符串或者元组，只要符合唯一和不可变的特性就行；字典的值可以是 Python 支持的任意数据类型。
1.创建字典
1.使用 { } 创建字典
由于字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。
使用{ }创建字典的语法格式如下：
dictname = {'key1':'value1', 'key2':'value2', ..., 'keyn':valuen}
其中 dictname 表示字典变量名，keyn : valuen 表示各个元素的键值对。需要注意的是，同一字典中的各个键必须唯一，不能重复。
2.通过 fromkeys() 方法创建字典
Python 中，还可以使用 dict 字典类型提供的 fromkeys() 方法创建带有默认值的字典，具体格式为：
dictname = dict.fromkeys(list，value=None)
其中，list 参数表示字典中所有键的列表（list）；value 参数表示默认值，如果不写，则为空值 None。
knowledge = ['语文', '数学', '英语']
scores = dict.fromkeys(knowledge, 60)
print(scores)
运行结果为：
{'语文': 60, '英语': 60, '数学': 60}
可以看到，knowledge 列表中的元素全部作为了 scores 字典的键，而各个键对应的值都是 60。这种创建方式通常用于初始化字典，设置 value 的默认值。
3.通过 dict() 映射函数创建字典
通过关键字dict和关键字参数创建
dic = dict(name='Jack', age=18, height=180)
print(dic)
# 输出结果：{'name': 'Jack', 'age': 18, 'height': 180}
通过关键字dict和二元组列表创建
lis = [('name', 'Jack'), ('age', 18), ('height', 180)]
dic = dict(lis)
print(dic)
# 输出结果：{'name': 'Jack', 'age': 18, 'height': 180}
通过关键字dict和zip创建
dic = dict(zip('abc', [1, 2, 3]))
print(dic)
# 输出结果：{'a': 1, 'b': 2, 'c': 3}
2.访问字典
列表和元组是通过下标来访问元素的，而字典不同，它通过键来访问对应的值。因为字典中的元素是无序的，每个元素的位置都不固定，所以字典也不能像列表和元组那样，采用切片的方式一次性访问多个元素。
访问字典元素的具体格式为：
dictname[key]
其中，dictname 表示字典变量的名字，key 表示键名。注意，键必须是存在的，否则会抛出异常。
除了上面这种方式外，Python 更推荐使用 dict 类型提供的 get() 方法来获取指定键对应的值。当指定的键不存在时，get() 方法不会抛出异常。
get() 方法的语法格式为：
dictname.get(key[,default])
其中，dictname 表示字典变量的名字；key 表示指定的键；default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None。
当键不存在时，get() 返回空值 None，如果想明确地提示用户该键不存在，那么可以手动设置 get() 的第二个参数，例如：
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('five', '该键不存在') )
3.删除字典
和删除列表、元组一样，手动删除字典也可以使用 del 关键字，例如：
a = dict(two=0.65, one=88, three=100, four=-59)
print(a)
del aprint(a)
Python 自带垃圾回收功能，会自动销毁不用的字典，所以一般不需要通过 del 来手动删除。
4.添加键值对
为字典添加新的键值对很简单，直接给不存在的 key 赋值即可，具体语法格式如下：
dictname[key] = value
对各个部分的说明：
- dictname 表示字典名称。
- key 表示新的键。
- value 表示新的值，只要是 Python 支持的数据类型都可以。
5.修改键值对
Python 字典中键（key）的名字不能被修改，我们只能修改值（value）。
字典中各元素的键必须是唯一的，因此，如果新添加元素的键与已存在元素的键相同，那么键所对应的值就会被新的值替换掉，以此达到修改元素值的目的。
6.删除键值对
如果要删除字典中的键值对，还是可以使用 del 语句。例如：
# 使用del语句删除键值对
a = {'数学': 95, '语文': 89, '英语': 90}
del a['语文']
del a['数学']
print(a)
7.判断字典中是否存在指定键值对
如果要判断字典中是否存在指定键值对，首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符。
a = {'数学': 95, '语文': 89, '英语': 90}
# 判断 a 中是否包含名为'数学'的key
print('数学' in a) # True
# 判断 a 是否包含名为'物理'的key
print('物理' in a) # False
运行结果为：
True
False
6.集合（set）
Python中的集合，和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。
从形式上看，和字典类似，Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔，如下所示：
{element1,element2,...,elementn}
其中，elementn 表示集合中的元素，个数没有限制。
从内容上看，同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误。
并且需要注意的是，数据必须保证是唯一的，因为集合对于每种数据元素，只会保留一份。由于 Python 中的 set 集合是无序的，所以每次输出时元素的排序顺序可能都不相同。
1.创建集合
1.使用 {} 创建
在 Python 中，创建 set 集合可以像列表、元素和字典一样，直接将集合赋值给变量，从而实现创建集合的目的，其语法格式如下：
setname = {element1,element2,...,elementn}
其中，setname 表示集合的名称。
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
2.set()函数创建集合
set() 函数为 Python 的内置函数，其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合。该函数的语法格式如下：
setname = set(iteration)
其中，iteration 就表示字符串、列表、元组、range 对象等数据。如果要创建空集合，只能使用 set() 函数实现。因为直接使用一对 {}，Python 解释器会将其视为一个空字典。
set1 = set("c.biancheng.net")
set2 = set([1,2,3,4,5])
set3 = set((1,2,3,4,5))
print("set1:",set1)
print("set2:",set2)
print("set3:",set3)
运行结果为：
set1: {'a', 'g', 'b', 'c', 'n', 'h', '.', 't', 'i', 'e'}
set2: {1, 2, 3, 4, 5}
set3: {1, 2, 3, 4, 5}
2.访问集合元素
由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素。Python 中，访问集合元素最常用的方法是使用循环结构，将集合中的数据逐一读取出来。
a = {1,'c',1,(1,2,3),'c'}
for ele in a:
print(ele,end=' ')
3.删除集合
和其他序列类型一样，手动函数集合类型，也可以使用 del() 语句。
a = {1,'c',1,(1,2,3),'c'}
print(a)
del(a)
print(a)
4.添加集合元素
set 集合中添加元素，可以使用 set 类型提供的 add() 方法实现，该方法的语法格式为：
setname.add(element)
其中，setname 表示要添加元素的集合，element 表示要添加的元素内容。
需要注意的是，使用 add() 方法添加的元素，只能是数字、字符串、元组或者布尔类型（True 和 False）值，不能添加列表、字典、集合这类可变的数据，否则 Python 解释器会报 TypeError 错误。
还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
s.update( x )
x 可以有多个，用逗号分开。
5.删除集合元素
删除现有 set 集合中的指定元素，可以使用 remove() 方法，该方法的语法格式如下：
setname.remove(element)
使用此方法删除集合中元素，需要注意的是，如果被删除元素本就不包含在集合中，则此方法会抛出 KeyError 错误。如果我们不想在删除失败时令解释器提示 KeyError 错误，还可以使用 discard() 方法，此方法和 remove() 方法的用法完全相同，唯一的区别就是，当删除集合中元素失败时，此方法不会抛出任何错误。
6.frozenset集合
set 集合是可变序列，程序可以改变序列中的元素；frozenset 集合是不可变序列，程序不能改变序列中的元素。set 集合中所有能改变集合本身的方法，比如 remove()、discard()、add() 等，frozenset 都不支持；set 集合中不改变集合本身的方法，fronzenset 都支持。
两种情况下可以使用 fronzenset：
- 当集合的元素不需要改变时，我们可以使用 fronzenset 替代 set，这样更加安全。
- 有时候程序要求必须是不可变对象，这个时候也要使用 fronzenset 替代 set。比如，字典（dict）的键（key）就要求是不可变对象。
需要注意的是，set 集合本身的元素必须是不可变的， 所以 set 的元素不能是 set，只能是 frozenset。
7.集合做交集、并集、差集运算
集合最常做的操作就是进行交集、并集、差集以及对称差集运算
图 1 中，有 2 个集合，分别为 set1={1,2,3} 和 set2={3,4,5}，它们既有相同的元素，也有不同的元素。以这两个集合为例，分别做不同运算的结果如表 1 所示。
| 运算操作 | Python运算符 | 含义 | 例子 |
|---|---|---|---|
| 交集 | & | 取两集合公共的元素 | >>> set1 & set2 |
| 并集 | | | 取两集合全部的元素 | >>> set1 | set2 |
| 差集 | - | 取一个集合中另一集合没有的元素 | >>> set1 - set2 {1,2} >>> set2 - set1 |
| 对称差集 | ^ | 取集合 A 和 B 中不属于 A&B 的元素 | >>> set1 ^ set2 {1,2,4,5}= |
7.bytes类型
字节串（bytes）和字符串（string）的对比：
- 字符串由若干个字符组成，以字符为单位进行操作；字节串由若干个字节组成，以字节为单位进行操作。
- 字节串和字符串除了操作的数据单元不同之外，它们支持的所有方法都基本相同。
- 字节串和字符串都是不可变序列，不能随意增加和删除数据。
bytes 只负责以字节序列的形式（二进制形式）来存储数据，至于这些数据到底表示什么内容（字符串、数字、图片、音频等），完全由程序的解析方式决定。如果采用合适的字符编码方式（字符集），字节串可以恢复成字符串；反之亦然，字符串也可以转换成字节串。
字符串和 bytes 存在着千丝万缕的联系，我们可以通过字符串来创建 bytes 对象，或者说将字符串转换成 bytes 对象。有以下三种方法可以达到这个目的：
- 如果字符串的内容都是 ASCII 字符，那么直接在字符串前面添加
b前缀就可以转换成 bytes。 - bytes 是一个类，调用它的构造方法，也就是 bytes()，可以将字符串按照指定的字符集转换成 bytes；如果不指定字符集，那么默认采用 UTF-8。
- 字符串本身有一个 encode() 方法，该方法专门用来将字符串按照指定的字符集转换成对应的字节串；如果不指定字符集，那么默认采用 UTF-8。
#通过构造函数创建空 bytes
b1 = bytes()
#通过空字符串创建空 bytes
b2 = b''
#通过b前缀将字符串转换成 bytes
b3 = b'http://c.biancheng.net/python/'
print("b3: ", b3)
print(b3[3])
print(b3[7:22])
#为 bytes() 方法指定字符集
b4 = bytes('C语言中文网8岁了', encoding='UTF-8')
print("b4: ", b4)
#通过 encode() 方法将字符串转换成 bytes
b5 = "C语言中文网8岁了".encode('UTF-8')
print("b5: ", b5)
bytes 类也有一个 decode() 方法，通过该方法可以将 bytes 对象转换为字符串。
#通过 decode() 方法将 bytes 转换成字符串
str1 = b5.decode('UTF-8')
print("str1: ", str1)
8.类型转换
Python 数据类型转换可以分为两种：
- 隐式类型转换 - 自动完成
- 显式类型转换 - 需要使用类型函数来转换
1.隐式类型转换
在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预。
我们对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。
2.显式类型转换
在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。 我们使用 int()、float()、str() 等预定义函数来执行显式类型转换。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
| 函数 | 描述 |
|---|---|
| int(x [,base]) | 将x转换为一个整数 |
| float(x)] | 将x转换到一个浮点数 |
| complex(real [,imag]) | 创建一个复数 |
| str(x) | 将对象 x 转换为字符串 |
| repr(x) | 将对象 x 转换为表达式字符串 |
| eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s) | 将序列 s 转换为一个元组 |
| list(s) | 将序列 s 转换为一个列表 |
| set(s) | 转换为可变集合 |
| dict(d) | 创建一个字典。d 必须是一个 (key, value)元组序列。 |
| frozenset(s) | 转换为不可变集合 |
| chr(x) | 将一个整数转换为一个字符 |
| ord(x) | 将一个字符转换为它的整数值 |
| hex(x) | 将一个整数转换为一个十六进制字符串 |
| oct(x) | 将一个整数转换为一个八进制字符串 |