前言

学习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)) # 输出结果： <class 'int'> 
<class 'float'> <class 'bool'> <class 'complex'>

此外还可以用 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 字符串格式化

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 <module>
    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))  # <class 'dict'>
# 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 <module>
    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 <module>
    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}