Day3 Pyhon的六大数据类型

Python3 中有六个标准的数据类型：

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Sets（集合）
• Dictionary（字典）

Number（数字）

Python3 支持 int【整型】、float【浮点型】、bool【布尔型】、complex（复数）。

int（整型）: 如 1

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

float（浮点型）: 如 1.23

      先扫盲 http://www.cnblogs.com/alex3714/articles/5895848.html 
　　浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示

      符号。

bool（int的子类型）:True or False
　　在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把 True 和 False 定义成关键字了，但它们的值还是

      1 和 0，它们可以和数字相加。
complex（复数）:如 1 + 2j
　　复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

注：Python中存在小数字池：-5 ～ 257

 

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

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

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

1 a, b, c, d = 20, 5.5, True, 4+3j
2 print(type(a), type(b), type(c), type(d))

此外还可以用 isinstance 来判断：

1 a= 20
2 data = isinstance(a, int)
3 print(data)

isinstance 和 type 的区别在于：

class A:
    pass

class B(A):
    pass

print(isinstance(A(), A)) # returns True
print(type(A()) == A ) # returns True
print(isinstance(B(), A)) # returns True
print(type(B()) == A )# returns False

区别就是:

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

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

您可以通过使用del语句删除单个或多个对象。。del语句的语法是：del var1[,var2[,var3[....,varN]]]]

eg:

1 var = 5
2 del var
3 print(var)

数值运算

print(5 + 4)  # 加法
print(4.3 - 2) # 减法
print(3*7) # 乘法
print(2/4)  # 除法，得到一个浮点数
print(2 // 4)  # 除法，得到一个整数
print(17 % 3)  # 取余
print(2 ** 5) # 乘方

注意：

• 1、Python可以同时为多个变量赋值，如a, b = 1, 2。
• 2、一个变量可以通过赋值指向不同类型的对象。
• 3、数值的除法（/）总是返回一个浮点数，要获取整数使用//操作符。
• 4、在混合计算时，Python会把整型转换成为浮点数。
• 5、在整数除法中，除法（/）总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 //
• 6、变量在使用前必须先"定义"（即赋予变量一个值），否则会出现错误

总结：数值型的增删改查操作！

随机数函数

随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。

Python包含以下常用随机数函数：

案例演示：

import random
poker = ["A","","","","","","","","","","J","Q","K"]
random.shuffle(poker)
print(poker)
#初次设定随机数种子
random.seed (10)
print(random.random())
#这次没有设定随机数种子,会发现这两次的随机数是不一样的！
print(random.random())

#初次设定随机数种子
random.seed (10)
print(random.random())
#再次次设定随机数种子,会发现这两次的随机数是一样的！
random.seed (10)
print(random.random())

三角函数：

数学常量：

String（字符串）

字符串的定义：它是一个有序的字符的集合，用于存储和表示基本的文本信息，Python中的字符串用单引号(')或双引号(")括起来，同时使用反斜杠(\)转义特殊字符。

特性：按照从左到右的顺序定义字符集合，下标从0开始顺序访问，有序

 注意：

Python 不支持单字符类型，单字符也在Python也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号来截取字符串

字符串的截取的语法格式如下：

变量[头下标:尾下标]

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

#!/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

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

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

输出结果为:

Ru
oob
Ru\noob

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

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

代码：

word = 'Python'
print(word[0], word[5])
print(word[-1], word[-6])

注意：

• 1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
• 2、字符串可以用+运算符连接在一起，用*运算符重复。但是字符串是不能和数值型直接拼接的，如果想要让字符串拼接，就先把数值型转换为字符串：print("dad"+str(123))
• 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
• 4、Python中的字符串不能改变。
• 5、python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间。

字符串格式化输出

name = "alex"
print "i am %s " % name

#输出: i am alex

PS: 字符串是 %s;整数 %d;浮点数%f

字符串常用功能：

• 移除空白【strip(),lstrip(),rstrip()】
• 分割[split()]
• 长度[len()]
• 索引[index()]
• 切片:  变量[头下标:尾下标]  0表示开始的位置，-1表示最后一个字母的位置

字符串的其它函数：

1.#dir()函数可以查看一个对象中可使用的方法和属性
print(dir("ds"))

2.#连接字符串
sStr1 = 'strcat'
sStr2 = 'append'
sStr1 += sStr2
print(sStr1)

3.#比较字符串(==)
print(“aaa”==“bbb” )

4.字符串中的搜索和替换：
S.find(substr, [start, [end]])   #返回S中出现substr的第一个字母的标号，如果S中没有substr则返回-1。start和end作用就相当于在S[start:end]中搜索
S.index(substr, [start, [end]])   #与find()相同，只是在S中没有substr时，会返回一个运行时错误
S.rfind(substr, [start, [end]])   #返回S中最后出现的substr的第一个字母的标号，如果S中没有substr则返回-1，也就是说从右边算起的第一次出现的substr的首字母标号
S.rindex(substr, [start, [end]])
S.count(substr, [start, [end]])    #计算substr在S中出现的次数
S.replace(oldstr, newstr, [count])    #把S中的oldstr替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换
S.strip([chars]) #把S中前后chars中有的字符全部去掉，可以理解为把S前后chars替换为None
S.lstrip([chars])
S.rstrip([chars]) 

5.# 字符串的分割和组合：
# S.split([sep, [maxsplit]]) #以sep为分隔符，把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符
# S.join(seq) #把seq代表的序列──字符串序列，用S连接起来

6.# 字符串中字符大小写的变换：
# S.lower()   #小写
# S.upper()   #大写
# S.swapcase()   #大小写互换
# S.capitalize()   #首字母大写

7.# 字符串的测试函数，这一类函数在string模块中没有，这些函数返回的都是bool值：
# S.startwith(prefix) #是否以prefix开头
# S.endwith(suffix)  #以suffix结尾
# S.isalnum()  #是否全是字母和数字
# S.isalpha()  #是否全是字母
# S.isdigit()  #是否全是数字
# S.isspace() #是否全是空白字符
# S.islower() #S中的字母是否全是小写
# S.isupper() #S中的字母是否便是大写
# S.istitle() #S是否是首字母大写的

8.# 字符串编码和解码的函数(默认是UTF-8编码和解码)：
# S.encode([encoding]) # 其中encoding可以有多种值，比如gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支持。
# S.decode([encoding])

9.# python字符串与数字的转化
# 数字变为字符串 str（）
# 字符串变为数字
print(int(""))
print(float(""))
print(complex(""))
str=bool("")
print(type(str),str)

msg.index('a')  返回a所在字符串的索引

python转义字符

python的字符串运算符

注意：Python三引号

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例如下:

#!/usr/bin/python3

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)

List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

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

列表是写在方括号([])之间、用逗号分隔开的元素列表，列表的数据项不需要具有相同的类型。

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

列表的创建，语法：

name_list = ['alex', 'seven', 'eric']
或
name_list = list(['alex', 'egon', 'eric'])

列表截取的语法格式如下：

变量[头下标:尾下标]

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

加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表

以上实例输出结果：

['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

与Python字符串不一样的是，列表中的元素是可以改变的：

a = [1, 2, 3, 4, 5, 6]
a[0] = 9
a[2:5] = [13, 14, 15]
print(a)
a[2:5] = []   # 删除
print(a)

结果如下:

[9, 2, 13, 14, 15, 6]
[9, 2, 6]

List内置了有很多方法，例如append()、pop()等等，这在后面会讲到。

注意：

• 1、List写在方括号之间，元素用逗号隔开。
• 2、和字符串一样，list可以被索引和切片。
• 3、List可以使用+操作符进行拼接.
• 4、List中的元素是可以改变的。
• 5、List中的元素是有序的。

列表操作：

1.增加、追加：

insert
    功能：在指定索引位置的元素前面插入新的元素
    name = ['sd','dfdf','drer',['sddss','sdsdsd']]
    name.insert(3,'sd')
    返回结果：name
    ['sd', 'dfdf', 'drer', 'sd', ['sddss', 'sdsdsd']]
append
    功能：列表追加元素
    name = ['sd','dfdf','drer']
    name.append('sdsd')
    返回结果：name
            ['sd', 'dfdf', 'drer', 'sdsd']

extend
    功能：追加字符元素或列表元素
    name = ['sd','dfdf','drer',['sddss','sdsdsd']]
    li = ['sd','sdsds',['sd','dffdg',],]
    name.extend('ss')
    返回结果：name
    ['sd', 'dfdf', 'drer', ['sddss', 'sdsdsd'], 's', 's']
    name.extend('d')
    返回结果：name
    ['sd', 'dfdf', 'drer', ['sddss', 'sdsdsd'], 's', 's', 'd']
    name.extend(li)
    返回结果：name
    ['sd', 'dfdf', 'drer', ['sddss', 'sdsdsd'], 's', 's', 'd', 'sd', 'sdsds', ['sd', 'dffdg']]

2.删除指定元素，删除指定的第几个元素，清空

pop
    功能：删除指定索引值的元素,返回值为当前删除的元素的值。不指定索引值，默认删除最后一个元素
    name = ['sd','dfdf','drer',['sddss','sdsdsd']]
    name.pop(3)
    返回结果：'sd'
remove
    功能：删除列表中指定的元素
    name = ['sd','dfdf','drer',['sddss','sdsdsd']]
    name.remove('sd')
    name
    返回结果：['dfdf', 'drer', ['sddss', 'sdsdsd']]

clear
    功能：情况列表元素
    name = ['sd','dfdf','drer']
    name.clear()
    返回结果：name

3.查索引，查，利用切片查

index
    功能：定位列表中某元素
    name = ['sd','dfdf','drer',['sddss','sdsdsd']]
    print(name.index('sd'))
    返回结果：0
    返回结果：name.index('dr')  #当出现某元素不在列表中的时候会直接报错
            Traceback (most recent call last):
              File "<stdin>", line 1, in <module>
            ValueError: 'dr' is not in list

count
    功能：统计列表指定元素个数
    name = ['sd','dfdf','drer',['sddss','sdsdsd']]
    name.count('sd')
    返回结果：1
    li = ['sd','sdsds',['sd','dffdg',],]
    li.count('sd') #只统计第一层的元素个数
    返回结果：1

利用切片查：
    变量[头下标:尾下标]
    索引值以 0 为开始值，-1 为从末尾的开始位置。

4.包含、遍历、反向列表、拷贝【浅拷贝，深拷贝】

#包含、不包含(in ,not in )
list = ['a','b','c']
if 'a' in list:
    print('a in the list')

if 'd' not in list:
    print('d is not in the list')

# for 语句
for i in list:
    print(i)

#reverse() 将列表中的元素逆序
name = ['sd','dfdf','drer',['sddss','sdsdsd']]
name.reverse()
print(name)

# copy(), 功能：浅拷贝，即只拷贝第一层的元素
name = ['sd', 'dfdf', 'drer']
li = ['ssd']
li = name.copy()
print(li)
# copy(), 功能：深拷贝，即只拷贝第一层的元素
name = ['sd', 'dfdf', 'drer', ['sddss', 'sdsdsd']]
li = ['ssd']
li = name.copy()
print(li)

Python包含以下函数

代码演示：

list01 = [1,3,6,2]
tuple01 = tuple((1,2,3))
print(len(list01))
print(max(list01))
print(min(list01))
print(list(tuple01))

 python中的方法：

元组(不可变列表，有序，元素可重复)

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号(())里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：

创建元组：

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

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号，如果不加这个逗号，运行的时候，就会发现而不是一个元组，而是一个数值，可以用type来验证！

              #这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

元组的读取、截取、连接

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。其实，可以把字符串看作一种特殊的元组。

注意：tup[0] = 11 # 修改元组元素的操作是非法的

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表，如下所示：

tuple1=(1,2,3,4,["dfa","adf"])
print(tuple1)
tuple1[4].append("张三")
print(tuple1)

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

tup = ('physics', 'chemistry', 1997, 2000);
del tup;
print(tup)#会报错

注意：

• 1、与字符串一样，元组的元素不能修改。
• 2、元组也可以被索引和切片，方法一样。
• 3、注意构造包含0或1个元素的元组的特殊语法规则。
• 4、元组也可以使用+操作符进行拼接。
• 5、元组中的元素值是不允许修改的，但我们可以对元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
• 6、它只有2个方法，一个是count,一个是index，完毕。

tuple的意义：

 不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来。

 元组运算符：

元组内置函数：

程序练习 

程序：购物车程序

需求:

1. 启动程序后，让用户输入工资，然后打印商品列表
2. 允许用户根据商品编号购买商品
3. 用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
4. 可随时退出，退出时，打印已购买商品和余额

集合：可变/不可变集合

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

1.可变集合

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

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

可变集合的创建：

#创建集合的第一种方式：
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student)   # 输出集合，重复的元素被自动去掉
print(type(student))
#创建集合的第二种方式：
stu = set((1,"",23))
print(stu)
print(type(stu))

不可变集合的创建：

##创建集合的第三种方式：(严格意义上讲第一种和第二种是一致的，都是可变集合)
cons_set = frozenset(['b','h','h','k','o','p','s'])
print(cons_set)
print(type(cons_set))

可变集合的修改：

student = {'Tom', 'Jim', 'Mary', 'Jack', 'Rose'}
student.add("dad")#添加
student.update("abc") #添加 ，将整体拆分，将每一部分都作为集合整体的一部分！
student.remove("Tom") #删除
print(student)

stu = set((1,"",23))
stu.add("python")
stu.update("")
stu.remove(23)
print(stu)

不可变集合的修改：

# 只有可变集合能被修改。试图修改不可变集合会引发异常。
cons_set = frozenset(['b','h','h','k','o','p','s'])
cons_set.add('z')

注意：只有可变集合能被修改。试图修改不可变集合会引发异常。

可变集合与不可变集合的删除：

student = {'Tom', 'Jim', 'Mary', 'Jack', 'Rose'}
del student

stu = set((1,"",23))
del stu

cons_set = frozenset(['b','h','h','k','o','p','s'])
del cons_set

成员关系：

student = {'Tom', 'Jim', 'Mary', 'Jack', 'Rose'}
print('Tom' in student)

stu = set((1,"",23))
print(23 in stu)

cons_set = frozenset(['b','h','h','k','o','p','s'])
print("b" in cons_set)

集合等价、不等价：

#集合是否等价
student = {'Tom', 'Jim', 'Mary', 'Jack', 'Rose'}
stu = set(('Tom', 'Jim', 'Mary', 'Jack', 'Rose'))
print(stu != student)
print(student == stu)

cons_set = frozenset(['b','h','h','k','o','p','s'])
print(student == cons_set)

可变集合与不可变之间的相互转化

#可变集合与不可变之间的相互转化
stu = set(('Tom', 'Jim', 'Mary', 'Jack', 'Rose'))
s = frozenset(stu)
print(type(s))
cons_set = frozenset(['b','h','h','k','o','p','s'])
s = set(cons_set)
print(type(s))

集合操作与关系符号

注意：混合集合类型操作

左右两个操作数的类型不相同(左操作数是 set，右操作数是 frozenset，或相反情况)，则所产生的结果类型与左操作数的类型相同。如下：

student = {'Tom', 'Jim', 'Mary', 'Jack', 'Rose'}
f = frozenset(['c', 'b', 'e', 'h', 'k', 'o', 'p', 's'])

st= student -f
print(st)
print(type(st))

遍历访问集合中的值(可变集合和非可变都支持)

#遍历访问集合中的值(可变集合和非可变都支持)
student = {'Tom', 'Jim', 'Mary', 'Jack', 'Rose'}
for i in student:
     print(i)

字典

字典一种key - value 的数据类型，使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容。

列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的，键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。

语法:

info = {
    'stu1101': "TengLan Wu",
    'stu1102': "LongZe Luola",
    'stu1103': "XiaoZe Maliya",
}

注意：

• 1、字典是一种映射类型，它的元素是键值对。
• 2、字典的关键字必须为不可变类型，且不能重复【so 天生去重】。
• 3、创建空字典使用 { }。
• 4、dict是无序的

Note: string、sets,list和tuple都属于sequence（序列）。

字典的操作：

增加：

info = {
    'stu1101': "TengLan Wu",
    'stu1102': "LongZe Luola",
    'stu1103': "XiaoZe Maliya",
}
info["stu1104"] = "苍井空"
print(info)

修改：

info = {
    'stu1101': "TengLan Wu",
    'stu1102': "LongZe Luola",
    'stu1103': "XiaoZe Maliya",
}
info["stu1101"] = ""
print(info)

删除：

 info = {
     'stu1101': "TengLan Wu",
     'stu1102': "LongZe Luola",
     'stu1103': "XiaoZe Maliya",
 }

 info.pop("stu1101") #标准删除姿势
 print(info)
 del info["stu1102"] #换个姿势删除
 print(info)
 info.popitem()  #随机删除
 print(info)

查找：

info = {
    'stu1101': "TengLan Wu",
    'stu1102': "LongZe Luola",
    'stu1103': "XiaoZe Maliya",
}
#查找：
"stu1102" in info #标准用法
info.get("stu1102")  # 获取
info["stu1102"] #获取，如果一个key不存在，就报错，get不会，不存在只返回None

多级字典嵌套及操作：

 av_catalog = {
     "欧美":{
         "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
         "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
         "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
         "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
     },
     "日韩":{
         "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
     },
     "大陆":{
         "":["全部免费,真好,好人一生平安","服务器在国外,慢"]
     }
 }

 av_catalog["大陆"][""][1] += ",可以用爬虫爬下来"
 print(av_catalog["大陆"][""])

其它操作：

 info = {
     'stu1101': "TengLan Wu",
     'stu1102': "LongZe Luola",
     'stu1103': "XiaoZe Maliya",
 }
 #获取字典的键
 print(info.keys())
 #获取字典的值
 print(info.values())
 #setdefault(key,value)没有对应的键，就添加，否则保持原来的！
 info.setdefault("stu1106","Alex")
 print(info)
 info.setdefault("stu1102","龙泽萝拉")
 print(info)
 b = {1: 2, 3: 4, "stu1102": "龙泽萝拉"}
 #update方法是：没有对应的键就添加，有对应的键就修改
 info.update(b)
 print(info)
 #info.items()会将字典的值以元组列表的形式返回
 print(info.items())

 #通过一个列表生成默认dict,少用吧这个
 data = dict.fromkeys([1,2,3],'testd')
 print(data)

循环遍历：

 info = {
     'stu1101': "TengLan Wu",
     'stu1102': "LongZe Luola",
     'stu1103': "XiaoZe Maliya",
 }
 #方法1
 for key in info:
     print(key,info[key])

 #方法2
 for k,v in info.items(): #会先把dict转成list,数据里大时莫用
     print(k,v)

判断一个键是否在字典中用in或not in,例如：

if “name” in students:print(students["name"])
"age" not in students:print("不存在age")

需要注意的是:字典中不允许使用+,*进行拼接或重复操作！

字典中的方法：

注意：上面的fromkeys()方法的格式是有问题的，正确的格式如下：

dict.fromkeys(seq[, value]))

参数

• seq -- 字典键值列表。
• value -- 可选参数, 设置键序列（seq）的值。

返回值

该方法返回列表。

代码演示：

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

dict = dict.fromkeys(seq)
print("New Dictionary : %s" %  str(dict))

dict = dict.fromkeys(seq, 10)
print("New Dictionary : %s" %  str(dict)

程序练习

程序: 三级菜单

要求:

1. 打印省、市、县三级菜单
2. 可返回上一级
3. 可随时退出程序

 menu = {
     '北京':{
         '海淀':{
             '五道口':{
                 'soho':{},
                 '网易':{},
                 'google':{}
             },
             '中关村':{
                 '爱奇艺':{},
                 '汽车之家':{},
                 'youku':{},
             },
             '上地':{
                 '百度':{},
             },
         },
         '昌平':{
             '沙河':{
                 '老男孩':{},
                 '北航':{},
             },
             '天通苑':{},
             '回龙观':{},
         },
         '朝阳':{},
         '东城':{},
     },
     '上海':{
         '闵行':{
             "人民广场":{
                 '炸鸡店':{}
             }
         },
         '闸北':{
             '火车战':{
                 '携程':{}
             }
         },
         '浦东':{},
     },
     '山东':{},
 }

 exit_flag = False
 current_layer = menu

 layers = [menu]

 while not  exit_flag:
     for k in current_layer:
         print(k)
     choice = input(">>:").strip()
     if choice == "b":
         current_layer = layers[-1]
         #print("change to laster", current_layer)
         layers.pop()
     elif choice not  in current_layer:continue
     else:
         layers.append(current_layer)
         current_layer = current_layer[choice]

三级菜单文艺青年版

叨叨+作业：

为什么会查询速度会快呢？因为他是hash类型的，那什么是hash呢？

哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值，这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母，随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入，在计算上是不可能的，所以数据的哈希值可以检验数据的完整性。一般用于快速查找和加密算法

dict会把所有的key变成hash 表，然后将这个表进行排序，这样，你通过data[key]去查data字典中一个key的时候，python会先把这个key hash成一个数字，然后拿这个数字到hash表中看没有这个数字， 如果有，拿到这个key在hash表中的索引，拿到这个索引去与此key对应的value的内存地址那取值就可以了。

上面依然没回答这样做查找一个数据为什么会比列表快，对不对？ 呵呵，等我课上揭晓。