python包含3种数据类型、分别是_3.Python3数据类型

前言

学习Demo

Python3的数据类型有六种，即其有六个标准的数据类型：

Number(数字)

String(字符串)

List(列表)

Tuple(元组)

Sets(集合)

Dictionary(字典)

一.基本数据类型(Number)

一个程序要运行，就要先描述其算法。描述一个算法应先说明算法中要用的数据，数据以变量或常量的形式来描述。每个变量或常量都有数据类型。Python3的基本数据类型有4种： 整型(int)、浮点型(float)、 布尔型(bool)、complex(复数)。

1.在Python3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

2.像大多数语言一样，数值类型的赋值和计算都是很直观的。

3.内置的 type() 函数可以用来查询变量所指的对象类型。

Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

a, b, c, d = 20, 5.5, True, 4+3j # Python允许你同时为多个变量赋值

print(type(a), type(b), type(c), type(d)) # 输出结果：

此外还可以用 isinstance 来判断类型：

a, b, c, d = 20, 5.5, True, 4+3j

isinstance(a, int) # 输出结果： True

sinstance 和 type 的区别在于：

type()不会认为子类是一种父类类型。

isinstance()会认为子类是一种父类类型。

class A:

pass

class B(A):

pass

isinstance(A(), A) # returns True

type(A()) == A # returns True

isinstance(B(), A) # returns True

type(B()) == A # returns False

1.1 bool(布尔值)

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

此外布尔值可以用and、or和not运算。

not运算是非运算，它是一个单目运算符，把True变成False，False变成True：

>>> True and True

True

>>> True and False

False

>>> False and False

False

>>> 5 > 3 and 3 > 1

True

>>> True or True

True

>>> True or False

True

>>> False or False

False

>>> 5 > 3 or 1 > 3

True

>>> not True

False

>>> not False

True

>>> not 1 > 2

True

1.2 数值运算

Python可以同时为多个变量赋值，如a, b = 1, 2。

一个变量可以通过赋值指向不同类型的对象。

数值的除法(/)总是返回一个浮点数，要获取整数使用//操作符。

在混合计算时，Python会把整型转换成为浮点数。

>>> 5 + 4 # 加法

9

>>> 4.3 - 2 # 减法

2.3

>>> 3 * 7 # 乘法

21

>>> 2 / 4 # 除法，得到一个浮点数

0.5

>>> 2 // 4 # 除法，得到一个整数

0

>>> 17 % 3 # 取余

2

>>> 2 ** 5 # 乘方

32

1.2 del语句删除一些对象引用

del语句的语法是：del var1[,var2[,var3[....,varN]]]]

您可以通过使用del语句删除单个或多个对象。例如：

del var

del var_a, var_b

二.String(字符串)

Python中的字符串用单引号('')或双引号("")括起来，同时使用反斜杠(\)转义特殊字符。

2.1 字符串的截取、拼接

变量[头下标:尾下标]

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

加号 (+) 是字符串的连接符， 星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数。

#!/usr/bin/python3

str = 'Runoob'

print (str) # 输出字符串

print (str[0:-1]) # 输出第一个到倒数第二个的所有字符

print (str[0]) # 输出字符串第一个字符

print (str[2:5]) # 输出从第三个开始到第五个的字符

print (str[2:]) # 输出从第三个开始的后的所有字符

print (str * 2) # 输出字符串两次

print (str + "TEST") # 连接字符串

执行以上程序会输出如下结果：

Runoob

Runoo

R

noo

noob

RunoobRunoob

RunoobTEST

2.2 转义特殊字符

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

>>> print('Ru\noob')

Ru

oob

>>> print(r'Ru\noob')

Ru\noob

>>>

另外，反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行(仅限终端交互模式)。

>>> print('''line1

... line2

... line3''')

line1

line2

line3

注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。

>>> word = 'Python'

>>> print(word[0], word[5])

P n

>>> print(word[-1], word[-6])

n P

2.3 Python中的字符串不能改变

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。

>>> word = 'Python'

>>> word[0] = 'm' #会导致错误

2.4 字符串格式化

符 号

描述

%c

格式化字符及其ASCII码

%s

格式化字符串

%d

格式化整数

%u

格式化无符号整型

%o

格式化无符号八进制数

%x

格式化无符号十六进制数

%X

格式化无符号十六进制数(大写)

%f

格式化浮点数字，可指定小数点后的精度

%e

用科学计数法格式化浮点数

%E

作用同%e，用科学计数法格式化浮点数

%g

%f和%e的简写

%G

%f 和 %E 的简写

%p

用十六进制数格式化变量的地址

2.5 常用函数

#!/usr/bin/python3

# -*- coding: UTF-8 -*-

import base64

s = 'hello world !'

# 1.把字符串的第一个字符大写

print('s.capitalize():',s.capitalize())

# 2.返回一个原字符串居中,并使用空格填充至长度 width 的新字符串

print('s.center(20):',s.center(20))

print('s.center(20,\'*\'):',s.center(20,'*'))

# 3.返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出

# 现的次数

"""

参数1：搜索的子字符串；

参数2：字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0；

参数3：字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

"""

print('s.count(\'l\',0,-1):',s.count('l',0,-1))

# 4.以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的异常,除非

# errors 指定的是 'ignore' 或者'replace'

"""

python3不太一样：因为3.x中字符都为unicode编码，而b64encode函数的参数为byte类型，所以必须先转码

"""

encodestr = base64.b64encode('abcr34r344r'.encode('utf-8'))

"""

1).encodestr: b'YWJjcjM0cjM0NHI=' 结果和我们预想的有点区别，我们只想要获得YWJjcjM0cjM0NHI=

，而字符串被b''包围了。

2).b 表示 byte的意思，我们只要再将byte转换回去就好了

"""

print('encodestr:',encodestr)

encodestr1 = str(encodestr,'utf-8', errors='strict')

print('encodestr1:',encodestr1) # encodestr1: YWJjcjM0cjM0NHI=

decodestr = base64.b64decode(encodestr1.encode('utf-8'))

print('decodestr:',decodestr) # b'abcr34r344r'

print(str(decodestr,'utf-8', errors='strict')) # abcr34r344r

# 5.检查字符串是否以 obj 结束，如果beg或者end指定则检查指定的范

# 围(长度)内是否以obj结束,如果是,返回 True,否则返回 False.

print('\'test\'.endswith(\'t\',4):','test'.endswith('t',0,4))

# 6.把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。

# this is string example....wow!!!

print('this is\tstring example....wow!!!'.expandtabs(15))

# 7.检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范

# 围内，如果是返回开始的索引值，否则返回-1

"""

str -- 指定检索的字符串

beg -- 开始索引，默认为0。

end -- 结束索引，默认为字符串的长度。

注意：检测到一个就会停止

"""

print(s.find('l',0,10))

# 8.跟find()方法一样，只不过如果str不在 string中会报一个异常

print('\'good\'.index(\'0\',0,4):','good'.index('o',0,4))

# 9.如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

# (检测字符串是否由字母和数字组成)

print("'678'.isalnum():",'678'.isalnum())

print("'6a78'.isalnum():",'6a78'.isalnum())

print("'-he66'.isalnum():",'-he66'.isalnum())

# 10.如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False(检测字

# 符串是否只由字母组成)

print("'678'.isalpha():",'678'.isalpha())

print("'6a78'.isalpha():",'6a78'.isalpha())

print("'gegge'.isalpha():",'gegge'.isalpha())

# 11.如果 string 只包含十进制数字则返回 True 否则返回 False)

# 注意:定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可。

print("'678'.isdecimal():",'678'.isdecimal())

print("'678a'.isdecimal():",'678a'.isdecimal())

print("'0x124ad'.isdecimal():",'0x124ad'.isdecimal())

# 12.如果 string 只包含数字则返回 True 否则返回 False.

print("'678'.isdigit():",'678'.isdigit())

print("'678t'.isdigit():",'678t'.isdigit())

# 13.如果 string 中只包含数字字符，则返回 True，否则返回 False

print("'678'.isnumeric():",'678'.isnumeric())

print("'678t'.isnumeric():",'678t'.isnumeric())

# 14.如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是

# 小写,则返回 True，否则返回 False(检测字符串是否由小写字母组成)

print("'test'.islower():",'test'.islower())

print("'Test'.islower():",'Test'.islower())

# 15.如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大

# 写，则返回 True，否则返回 False

print("'test'.isupper():",'test'.isupper())

print("'TEST'.isupper():",'TEST'.isupper())

# 16.如果 string 中只包含空格，则返回 True，否则返回 False

print("' '.isspace():",' '.isspace())

print("'This is string example....wow!!!'.isspace():",

'This is string example....wow!!!'.isspace())

# 17.如果 string 是标题化的(见 title())则返回 True，否则返回 False

print("'This Is A Test'.istitle():",'This Is A Test'.istitle())

print("'This is a test'.istitle():",'This is a test'.istitle())

# 18.以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串(将序

# 列中的元素以指定的字符连接生成一个新的字符串)

seq = ("r", "u", "n", "o", "o", "b") # 字符串序列

print ("'-'.join(seq):",'-'.join(seq))

print ("''.join(seq):",''.join(seq))

# 19.len() 方法返回对象(字符、列表、元组等)长度或项目个数

print("len('hello'):", len('hello'))

# 20.返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

print("'hello'.ljust(20,'*'):", 'hello'.ljust(20,'*'))

# 21.转换 string 中所有大写字符为小写

print("'HELLO'.lower():", 'HELLO'.lower())

# 22.转换 string 中的小写字母为大写

print("'hello'.upper():", 'hello'.upper())

# 23.截掉 string 左边的字符

print("' hello'.lstrip(' '):", ' hello'.lstrip(' '))

print("'88888hello'.lstrip(' '):", ' hello'.lstrip('8'))

# 24.maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，

# 第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标

"""

maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，

第一个参数是字符串，表示需要转换的字符;

第二个参数也是字符串表示转换的目标。

两个字符串的长度必须相同，为一一对应的关系。

注：Python3.4已经没有string.maketrans()了，取而代之的是内建

函数: bytearray.maketrans()、bytes.maketrans()、str.maketrans()

"""

# 以下实例展示了使用maketrans() 方法将所有元音字母转换为指定的数字

intab = "aeiou"

outtab = "12345"

trantab = str.maketrans(intab, outtab)

str = "this is string example....wow!!!"

print (str.translate(trantab))

# 25.返回字符串 str 中最大的字母

print("max('abjzkqp'):", max('abjzkqp'))

# 26.返回字符串 str 中最小的字母

print("min('abjzkqp'):", min('abjzkqp'))

# 27.返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

print("'world'.zfill(20):", 'world'.zfill(20))

# 28.翻转 string 中的大小写

print("'WorLd'.swapcase()：", 'WorLd'.swapcase())

# 29.返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())

print("'this is a test'.title():", 'this is a test'.title())

# 30.把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.

print("'this is a test'.replace('s','q',3):", 'this is a test'.replace('s','q',3))

# 31.类似于find()函数,不过是从右边开始查找(返回字符串最后一次出现的位置，如果没有匹配项则

# 返回-1)

"""

str -- 查找的字符串

beg -- 开始查找的位置，默认为0

end -- 结束查找位置，默认为字符串的长度。

"""

print("'hello'.rfind('l',0,5):", 'hello'.rfind('l',0,5))

# 32.类似于index(),不过是从右边开始(返回子字符串str在字符串中最后出现的位置,如果没有匹配的

# 字符串会报异常)

print("'hello'.rindex('l',0,5):", 'hello'.rindex('l',0,5))

# 33.返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

print("'test'.rjust(20,'*'):", 'test'.rjust(20,'*'))

# 34.删除 string 字符串末尾的指定字符(默认为空格)

print("'world*****'.rstrip('*'):", 'world*****'.rstrip('*'))

# 35.在string上执行lstrip()和rstrip()(用于移除字符串头尾指定的字符(默认为空格))

print("'***test***'.strip('*'):", '***test***'.strip('*'))

# 36.根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中

"""

able -- 翻译表，翻译表是通过 maketrans() 方法转换而来。

deletechars -- 字符串中要过滤的字符列表。

"""

bytes_tabtrans = bytes.maketrans(b'abcdefghijklmnopqrstuvwxyz',

b'ABCDEFGHIJKLMNOPQRSTUVWXYZ')

print(b'runoob'.translate(bytes_tabtrans, b'o')) # 转换为大写，并删除字母o

# 37.检查字符串是否是以obj开头，是则返回True，否则返回False。如果beg和end 指定值，则在指定范

# 围内检查

print("'test'.startswith('t',0,4):", 'test'.startswith('t',0,4))

# 38.以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串

"""

str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。

num -- 分割次数。

"""

str = "this is string example....wow!!!"

print(str.split( )) # ['this', 'is', 'string', 'example....wow!!!']

print(str.split('i',1)) # ['th', 's is string example....wow!!!']

print(str.split('w')) # ['this is string example....', 'o', '!!!']

# 39.按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，

# 如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符

# ['ab c', '', 'de fg', 'kl']

print('ab c\n\nde fg\rkl\r\n'.splitlines())

# ['ab c\n', '\n', 'de fg\r', 'kl\r\n']

print('ab c\n\nde fg\rkl\r\n'.splitlines(True))

# 40.有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把字

# 符串string分成一个3元素的元组 (string_pre_str,str,string_post_str)

# ,如果 string 中不包含str 则 string_pre_str == string.

# 根据指定的分隔符将字符串进行分割

"""

如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，

第二个为分隔符本身，第三个为分隔符右边的子串

"""

str6 = "https://www.baidu.com/"

print(str6.partition("://"))

# 41.类似于 partition()函数,不过是从右边开始查找

print(str6.rpartition("://"))

三.空值(None)。

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

四. List(列表：有序可变)

List(列表) 是 Python 中使用最频繁的数据类型。与Objective-C中的NSMutableArray类似。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表(所谓嵌套)。

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

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

4.1 创建列表：

# 方法一：

ame_list = ['alex', 'seven', 'eric']

# 方法二：

name_list ＝ list(['alex', 'seven', 'eric'])

4.2 常用函数：

#!/usr/bin/python3

# -*- coding: UTF-8 -*-

import copy

a = 89

b = '6'

ame_list = [68, 68, 58, 108945, 1, 75, 69] # 列表1

temp_list = [55, 75, 452, 7856, 4553, 45354, 54] # 列表2

temp_list1 = ['b','y','q','a','k','z','p','b' ] # 列表3

tup1 = ('Google', 'Runoob', 1997, 2000) # 元组

# 1.列表元素个数

print(len(ame_list))

# 2.返回列表元素最大值

print(max(ame_list))

# 3.返回列表元素最小值

print(min(ame_list))

# 4.将元组转换为列表

print(list(tup1))

# 5.在列表末尾添加新的对象

ame_list.append(a)

print(ame_list)

# 6.统计某个元素在列表中出现的次数

print(ame_list.count(68))

# 7.在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)

(ame_list.extend(temp_list))

print(ame_list)

# 8.从列表中找出某个值第一个匹配项的索引位置

print(ame_list.index(1,0,6)) # 参数:value，起始位置，结束位置

print(ame_list.index(75)) # 无起始值则遍历所有value

# 9.将对象插入列表

'''

共有如下5种场景：

场景1：index=0时，从头部插入obj

场景2：index > 0 且 index < len(list)时，在index的位置插入obj

场景3：当index < 0 且 abs(index) < len(list)时，从中间插入obj，

如: -1 表示从倒数第1位插入obj; -2 表示从倒数第2位插入obj

场景4：当index < 0 且 abs(index) >= len(list)时，从头部插入obj

场景5：当index >= len(list)时,从尾部插入obj

'''

ame_list.insert(2,198) # 参数：插入位置，插入值

print(ame_list)

# 10.移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值

print(ame_list.pop(-1)) # -1代表最后一个元素

print(ame_list)

# 11.移除列表中某个值的第一个匹配项

ame_list.remove(68)

print(ame_list)

# 12.反向列表中元素

ame_list.reverse()

print(ame_list)

# 13.对原列表进行排序 list.sort([func])

ame_list.sort() # func 可选参数, 如果指定了该参数会使用该参数的方法进行排序。

print(ame_list)

# 14.复制列表( copy() 函数用于复制列表，类似于 a[:])。

new_list1 = copy.copy(temp_list1) # 要导入copy类import copy

new_list2 = copy.deepcopy(temp_list1)

print(new_list1)

print(new_list2)

# 15.清空列表 (clear() 函数用于清空列表，类似于 del a[:]。)

new_list2.clear() # clear()函数3.x以上版本才有，2.x无

print(new_list2)

五. Tuple(元组：有序不可变)

不可变列表类似Objective-C中的NSArray，初始化如下：

#!/usr/bin/python3

# -*- coding: UTF-8 -*-

# 方法一：

ages = (11, 22, 33, 44, 55)

# 方法二：

ages = tuple((11, 22, 33, 44, 55))

5.1 访问元组

#!/usr/bin/python3

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)

5.2 删除元组

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

#!/usr/bin/python3

tup = ('Google', 'Runoob', 1997, 2000)

print (tup)

del tup;

print ("删除后的元组 tup : ")

print (tup) # 以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

"""

('Google', 'Runoob', 1997, 2000)

Traceback (most recent call last):

删除后的元组 tup :

File "/Users/ysf/Desktop/Python/package1/LYDictionary.py", line 11, in

print (tup) # 以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

NameError: name 'tup' is not defined

"""

5.3 注意点

注意点一：

# 但是，要定义一个只有1个元素的tuple，如果你这么定义：

>>> t = (1)

>>> t

# 输出结果是：1

"""

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产

生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。所以，只有1个元素的

tuple定义时必须加一个逗号(,)来消除歧义：

"""

>>> t = (1,)

>>> t

# 输出结果是：(1,)

注意点二：“可变的”tuple：

>>> t = ('a', 'b', ['A', 'B'])

>>> t[2][0] = 'X'

>>> t[2][1] = 'Y'

>>> t

# 输出结果是：('a', 'b', ['X', 'Y'])

"""

这个tuple定义的时候有3个元素，分别是'a'，'b'和一个list。不是说tuple一旦定义后就不可变了吗？怎么

后来又变了？表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开

始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即

指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

所以说要创建一个内容也不变的tuple，那就必须保证tuple的每一个元素本身也不能变。

"""

六. Dictionary(字典可变)

字典是另一种可变容器模型，且可存储任意类型对象，在其他语言中也称为map，使用键-值(key-value)存储，具有极快的查找速度。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

6.1 dict的实现原理

为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。

第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。

dict就是第二种实现方式，给定一个名字，比如'Michael'，dict在内部就可以直接计算出Michael对应的存放成绩的“页码”，也就是95这个数字存放的内存地址，直接取出来，所以速度非常快。这种key-value存储方式，在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。

6.2 特性及常用函数

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。(键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行)

一个key只能对应一个value，所以多次对一个key放入value，后面的值会把前面的值覆盖

如果key不存在，dict就会报错

#!/usr/bin/python3

# -*- coding: UTF-8 -*-

# 1.字典初始化

dict1 = {'name': 'sam', 98.6: 37, 'sex': '男', 'height': 188, 'car': '路虎'}

dict2 = {'name': 'sam', 98.6: 37, 'sex': '男', 'height': 188}

print("dict1: ", dict1)

# 2.访问字典里的值

print("dict1['name']: ", dict1['name'])

# 3.避免key不存在的错误，有两种办法，一是通过in判断key是否存在；二是通过dict提供的get()方法，如

#果key不存在，可以返回None，或者自己指定的value：

print("age in dict1: ", 'age' in dict1) # 方法一

print("age in dict1: ", dict1.get('age')) # 方法二 默认值为None

print("age in dict1: ", dict1.get('age', -1)) # 方法二 自定义value

# 4.和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

print("dict1.setdefault: ", dict1.setdefault('Taobao', '淘宝'))

# 5.删除一个key

print("dict1.pop('name'): ", dict1.pop('name'))

print("dict1: ", dict1)

# 6.计算字典元素个数，即键的总数。

print("len(dict1): ", len(dict1))

# 7.输出字典，以可打印的字符串表示。

print("str(dict1): ", str(dict1))

# 8.返回输入的变量类型，如果变量是字典就返回字典类型。

print("type(dict1): ", type(dict1)) #

# 9.删除字典内所有元素

dict2.clear()

print("dict2: ", dict2)

# 10.返回一个字典的浅复制

print("dict1.copy(): ", dict1.copy())

# 11.以列表返回可遍历的(键, 值)元组数组

print("dict1.items(): ", dict1.items())

# 12.以列表返回一个字典所有的键

print("dict1.keys(): ", dict1.keys())

# 13.以列表返回字典中的所有值

print("dict1.values(): ", dict1.values())

# 14.把字典dict1的键/值对更新到dict2里

dict2.update(dict1)

print("dict2.update(dict1)后dict2的值: ", dict2)

# 15.删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

dict1.pop('car')

print("dict1: ", dict1)

# 16.随机返回并删除字典中的一对键和值(一般删除末尾对)。

dict2.popitem()

print("dict2: ", dict2)

# 17.创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

seq = ('name', 'age', 'sex')

dict3 = dict.fromkeys(seq)

print("新的字典为 : %s", str(dict3)) # 全部key的value都默认赋值为：None

dict4 = dict.fromkeys(seq, 10) # 全部key的value都赋值为：10

print("新的字典全部key的value都赋值为：10 : %s", str(dict4))

# 18.键用列表会报错

dict5 = {['Name']: 'Runoob','Age': 7}

"""

Traceback (most recent call last):

File "/Users/ysf/Desktop/Python/package1/LYDictionary.py", line 30, in

dict = {['Name']: 'Runoob', 'Age': 7}

TypeError: unhashable type: 'list'

"""

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

print("dict1['job']: ", dict1['job'])

"""

Traceback (most recent call last):

File "/Users/ysf/Desktop/Python/package1/LYDictionary.py", line 63, in

print("dict1['job']: ", dict1['job'])

KeyError: 'job'

"""

6.3 dict和list的优缺点

和list比较，dict有以下几个特点：

查找和插入的速度极快，不会随着key的增加而变慢；

需要占用大量的内存，内存浪费多。

list优缺点：

查找和插入的时间随着元素的增加而增加；

占用空间小，浪费内存很少。

总结：所以，dict是用空间来换取时间的一种方法。dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。

这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)。要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key：

七. Set(无序不重复元素集合)

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。总结：set和dict的唯一区别仅在于没有存储对应的value。

7.1 Set特性

集合(set)是一个无序不重复元素的序列。

基本功能是进行成员关系测试和删除重复元素。

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

7.2 创建Set

# 方法一：

parame = {value01,value02,...}

# 方法二：

set(value)

7.3 基本用法

#!/usr/bin/python3

# -*- coding: UTF-8 -*-

# 1.创建一个set，需要提供一个list作为输入集合,重复元素在set中自动被过滤

s = set([1, 1, 2, 2, 3, 3]) # {1, 2, 3}

# 2.通过add(key)方法可以添加元素到set中，可以重复添加，但只有第一次有效果

s.add(4) # {1, 2, 3, 4}

s.add(4) # {1, 2, 3, 4}

# 3.通过remove(key)方法可以删除元素

s.remove(4) # {1, 2, 3},不能移除不存在的key

# 4.set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集

# 等操作：

s1 = set([1, 2, 3])

s2 = set([2, 3, 4])

print("s1 & s2: ", s1 & s2) # {2, 3}

print("s1 | s2: ", s1 | s2) # {1, 2, 3, 4}