bd2.2 数据类型

二．数据类型

1. 字典

1. 字典
　　dict:字典,字典是一组键(key)和值(value)的组合,通过键(key)进行查找,没有顺序, 使用大括号"{}";
　　应用场景：dict,使用键和值进行关联的数据;


1.1 现有字典 d={'a':24,'g':52,'i':12,'k':33}请按字典中的 value值进行排序？ 
sorted(d.items(),key = lambda x:x[1]) 。
　　In [2]: d={'a':24,'g':52,'i':12,'k':33}
　　In [3]: sorted(d.items(),key = lambda x:x[1])
　　Out[3]: [('i', 12), ('a', 24), ('k', 33), ('g', 52)]

1.2 说一下字典和 json 的区别？
　　字典是一种数据结构,json 是一种数据的表现形式,字典的 key 值只要是能 hash 的就行,json 的必须是字符串。

1.3 什么是可变、不可变类型？
　　可变不可变指的是内存中的值是否可以被改变,不可变类型指的是对象所在内存块里面的值不可以改变,有数值、字符串、元组；可变类型则是可以改变,主要有列表、字典。

1.4 存入字典里的数据有没有先后排序？
　　存入的数据不会自动排序，可以使用 sort 函数对字典进行排序。

1.5 字典推导式？
　　1．d = {key: value for (key, value) in iterable}

1.6 现有字典 d={'a':24，'g':52，'l':12，'k':33}请按字 典中的 value值进行排序？ 
　　1．sorted(d.items()，key = lambda x:x[1])

2. 字符串

2. 字符串
　　str:字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。

2.1 如何理解 Python 中字符串中的\字符？
　　有三种不同的含义：
　　1、转义字符 2、路径名中用来连接路径名 3、编写太长代码手动软换行。

2.2 请反转字符串"aStr"?
　　1. print('aStr'[::-1])

2.3 将字符串"k:1|k1:2|k2:3|k3:4"，处理成 Python 字典：{k:1， k1:2， ... } # 字典里的 K 作为字符串处理

1. str1 = "k:1|k1:2|k2:3|k3:4"
2. def str2dict(str1):
3. 　　dict1 = {}
4. 　　for iterms in str1.split('|'):
5.　　 　　key，value = iterms.split(':')
6.　　 　　dict1[key] = value
7.　　 return dict1

2.4 请按 alist 中元素的 age 由大到小排序
　　1. alist [{'name':'a'，'age':20}，{'name':'b'，'age':30}，{'name':'c'，'age':25}]
　　2. def sort_by_age(list1):
　　3. 　　return sorted(alist，key=lambda x:x['age']，reverse=True)

3. 列表

3. 列表
list:是 Python 中使用最频繁的数据类型，在其他语言中通常叫做数组，通过索引进行查找，使用方括号"[]",
列表是有序的集合。
应用场景：定义列表使用 [ ] 定义，数据之间使用 "，"分割。
列表的索引从 0 开始：索引就是数据在列表中的位置编号，索引又可以被称为下标。
【注意】: 从列表中取值时,如果超出索引范围,程序会产生异常。
IndexError: list index out of range

列表的常用操作：
1．name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
1）增加

列表名.insert(index, 数据)：在指定位置插入数据(位置前有空元素会补位)。
1．# 往列表 name_list 下标为 0 的地方插入数据
2．In [3]: name_list.insert(0, "Sasuke")
3．In [4]: name_list
4．Out[4]: ['Sasuke', 'zhangsan', 'lisi', 'wangwu', 'zhaoliu']
5．# 现有的列表下标是 0-4，如果我们要在下标是 6 的地方插入数据，那个会自动插入到下标为 5 的地方，也就是# 插入到最后
6．In [5]: name_list.insert(6, "Tom")
7．In [6]: name_list
8．Out[6]: ['Sasuke', 'zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'Tom']

列表名.append(数据)：在列表的末尾追加数据(最常用的方法)。
1．In [7]: name_list.append("Python")
2．In [8]: name_list
3．Out[8]: ['Sasuke', 'zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'Tom', 'Python']

列表.extend(Iterable)：将可迭代对象中的元素追加到列表。
1．# 有两个列表 a 和 b a.extend(b) 会将 b 中的元素追加到列表 a 中
2．In [10]: a = [11, 22, 33]
3．In [11]: b = [44, 55, 66]
4．In [12]: a.extend(b)
5．In [13]: a
6．Out[13]: [11, 22, 33, 44, 55, 66]# 有列表 c 和 字符串 d c.extend(d) 会将字符串 d 中的每个字符拆开作为元素插入到列表c
7．In [14]: c = ['j', 'a', 'v', 'a']
8．In [15]: d = "python"
9．In [16]: c.extend(d)
10．In [17]: c
11．Out[17]: ['j', 'a', 'v', 'a', 'p', 'y', 't', 'h', 'o', 'n']


2）取值和修改
取值：列表名[index] ：根据下标来取值。
1．In [19]: name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
2．In [20]: name_list[0]
3．Out[20]: 'zhangsan'
4．In [21]: name_list[3]
5．Out[21]: 'zhaoliu'

修改：列表名[index] = 数据：修改指定索引的数据。
1．In [22]: name_list[0] = "Sasuke"
2．In [23]: name_list
3．Out[23]: ['Sasuke', 'lisi', 'wangwu', 'zhaoliu']

3）删除
del 列表名[index]：删除指定索引的数据。
1．In [25]: name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]# 删除索引是 1 的数据
2．In [26]: del name_list[1]
3．In [27]: name_list
4．Out[27]: ['zhangsan', 'wangwu', 'zhaoliu']

列表名.remove(数据)：删除第一个出现的指定数据。
5．In [30]: name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu", "lisi"]# 删除 第一次出现的 lisi 的数据
6．In [31]: name_list.remove("lisi")
7．In [32]: name_list
8．Out[32]: ['zhangsan', 'wangwu', 'zhaoliu', 'lisi']


列表名.pop()：删除末尾的数据,返回值: 返回被删除的元素。
9．In [33]: name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]# 删除最后一个元素 zhaoliu 并将元素 zhaoliu 返回
10．In [34]: name_list.pop()
11．Out[34]: 'zhaoliu'
12．In [35]: name_list
13．Out[35]: ['zhangsan', 'lisi', 'wangwu']

列表名.pop(index)：删除指定索引的数据，返回被删除的元素。
14．In [36]: name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]# 删除索引为 1 的数据 lisi
15．In [37]: name_list.pop(1)
16．Out[37]: 'lisi'
17．In [38]: name_list
18．Out[38]: ['zhangsan', 'wangwu', 'zhaoliu']

列表名.clear()：清空整个列表的元素。
19．In [40]: name_list = ["zhangsan", "lisi", "wangwu", "zhaoliu"]
20．In [41]: name_list.clear()
21．In [42]: name_list
22．Out[42]: []

4）排序
列表名.sort()：升序排序 从小到大。
23．In [43]: a = [33, 44, 22, 66, 11]
24．In [44]: a.sort()
25．In [45]: a
26．Out[45]: [11, 22, 33, 44, 66]

列表名.sort(reverse=True)：降序排序 从大到小。
27．In [46]: a = [33, 44, 22, 66, 11]
28．In [47]: a.sort(reverse=True)
29．In [48]: a
30．Out[48]: [66, 44, 33, 22, 11]

列表名.reverse()：列表逆序、反转。
31．In [50]: a = [11, 22, 33, 44, 55]
32．In [51]: a.reverse()
33．In [52]: a
34．Out[52]: [55, 44, 33, 22, 11]

5）统计相关
len(列表名)：得到列表的长度。
35．In [53]: a = [11, 22, 33, 44, 55]
36．In [54]: len(a)
37．Out[54]: 5

列表名.count(数据)：数据在列表中出现的次数。
38．In [56]: a = [11, 22, 11, 33, 11]
39．In [57]: a.count(11)
40．Out[57]: 3

列表名.index(数据)：数据在列表中首次出现时的索引，没有查到会报错。
41．In [59]: a = [11, 22, 33, 44, 22]
42．In [60]: a.index(22)
43．Out[60]: 1

if 数据 in 列表： 判断列表中是否包含某元素。
44．a = [11, 22, 33, 44 ,55]
45．if 33 in a:
46． print("找到了....")

6）循环遍历
使用 while 循环：
1. a = [11, 22, 33, 44, 55]
2.
3. i = 0
4. while i < len(a):
5. 　　print(a[i])
6. 　　i += 1
使用 for 循环：
1. a = [11, 22, 33, 44, 55]
2. for i in a:
3. 　　print(i)


3.1 下面代码的输出结果将是什么？
1. list = ['a'， 'b'， 'c'， 'd'， 'e']
2. print list[10:]
下面的代码将输出[]，不会产生IndexError错误。就像所期望的那样，尝试用超出成员的个数的index来获取某个列表的成员。
例如，尝试获取 list[10]和之后的成员，会导致 IndexError。然而，尝试获取列表的切片，开始的 index 超过了成员个数不会产生 IndexError，而是仅仅返回一
个空列表。这成为特别让人恶心的疑难杂症，因为运行的时候没有错误产生，导致 bug 很难被追踪到。


3.2 写一个列表生成式，产生一个公差为 11 的等差数列
　　1. print([x*11 for x in range(10)])

3.3 给定两个列表，怎么找出他们相同的元素和不同的元素? 
1. list1 = [1，2，3]
2. list2 = [3，4，5]
3. set1 = set(list1)
4. set2 = set(list2)
5. print(set1&set2)
6. print(set1^set2)

3.4 请写出一段 Python 代码实现删除一个 list 里面的重复元素?
比较容易记忆的是用内置的 set：
1. l1 = ['b'，'c'，'d'，'b'，'c'，'a'，'a']
2. l2 = list(set(l1))
3. print l2
如果想要保持他们原来的排序：
用 list 类的 sort 方法：
1. l1 = ['b'，'c'，'d'，'b'，'c'，'a'，'a']
2. l2 = list(set(l1))
3. l2.sort(key=l1.index)
4. print l2
也可以这样写：
1. l1 = ['b'，'c'，'d'，'b'，'c'，'a'，'a']
2. l2 = sorted(set(l1)，key=l1.index)
3. print l2

也可以用遍历：
1. l1 = ['b', 'c', 'd', 'b', 'c', 'a', 'a']
2. l2 = []
3. for i in l1:
4. 　　if not i in l2:
5. 　　　　l2.append(i)
6. 　　　　print l2

3.5 给定两个 list A ,B，请用找出 A ,B 中相同的元素，A ,B 中不同的元素
A、B 中相同元素：print(set(A)&set(B))
A、B 中不同元素：print(set(A)^set(B))

3.6 有如下数组 list = range(10)我想取以下几个数组，应该如何切片？
1. [1，2，3，4，5，6，7，8，9]
2. [1，2，3，4，5，6]
3. [3，4，5，6]
4. [9]
5. [1，3，5，7，9]
答：
1. [1:]
2. [1:7]
3. [3:7]
4. [-1]
5. [1::2]


3.7 下面这段代码的输出结果是什么？请解释？1. def extendlist(val, list=[]):
2. 　　list.append(val)
3. 　　return list
4.
5. list1 = extendlist(10)
6. list2 = extendlist(123, [])
7. list3 = extendlist('a')
8.
9. print("list1 = %s" %list1)
10. print("list2 = %s" %list2)
11. print("list3 = %s" %list3)
输出结果：
12. list1 = [10, 'a']
13. list2 = [123]
14. list3 = [10, 'a']
新的默认列表只在函数被定义的那一刻创建一次。当 extendList 被没有指定特定参数 list 调用时，这组 list 的值
随后将被使用。这是因为带有默认参数的表达式在函数被定义的时候被计算，不是在调用的时候被计算。


3.8.将以下 3 个函数按照执行效率高低排序
1. def f1(lIn):
2. 　　l1 = sorted(lIn)
3. 　　l2 = [i for i in l1 if i<0.5]
4. 　　return [i*i for i in l2]
5.
6.
7. def f2(lIn):
8. 　　l1 = [i for i in l1 if i<0.5]
9. 　　l2 = sorted(l1)
10. 　return [i*i for i in l2]
11.
12.
13. def f3(lIn):
14. 　　l1 = [i*i for i in lIn]
15. 　　l2 = sorted(l1)
16. 　　return [i for i in l1 if i<(0.5*0.5)]
按执行效率从高到低排列：f2、f1 和 f3。要证明这个答案是正确的，你应该知道如何分析自己代码的性能。Python
中有一个很好的程序分析包，可以满足这个需求。
1. import random
2. import cProfile
3. lIn = [random.random() for i in range(100000)]
4. cProfile.run('f1(lIn)')
5. cProfile.run('f2(lIn)')
6. cProfile.run('f3(lIn)')

3.9 获取 1~100 被 6 整除的偶数？
1. def A():
2. 　　alist = []
3. 　　for i in range(1，100):
4. 　　　　if i % 6 == 0:
5. 　　　　alist.append(i)
6. 　　last_num = alist[-3:]
7. 　　print(last_num)

 

4. 元组
tuple:元组，元组将多样的对象集合到一起，不能修改，通过索引进行查找，使用括号"()";
应用场景：把一些数据当做一个整体去使用，不能修改；
5. 集合
set:set 集合，在 Python 中的书写方式为{}，集合与之前列表、元组类似，可以存储多个数据，但
是这些数据是不重复的。集合对象还支持 union(联合), intersection(交), difference(差)和
sysmmetric_difference(对称差集)等数学运算.
快速去除列表中的重复元素
1．In [4]: a = [11,22,33,33,44,22,55]
2．
3．In [5]: set(a)
4．Out[5]: {11, 22, 33, 44, 55}
交集：共有的部分
1．In [7]: a = {11,22,33,44,55}
2．In [8]: b = {22,44,55,66,77}
3．In [9]: a&b
4．Out[9]: {22, 44, 55}
并集：总共的部分
1．In [11]: a = {11,22,33,44,55}
2．In [12]: b = {22,44,55,66,77}
3．In [13]: a | b
4．Out[13]: {11, 22, 33, 44, 55, 66, 77}
差集：另一个集合中没有的部分
1．In [15]: a = {11,22,33,44,55}
2．In [16]: b = {22,44,55,66,77}
3．In [17]: b - a
4．Out[17]: {66, 77}
对称差集(在 a 或 b 中，但不会同时出现在二者中)
1．In [19]: a = {11,22,33,44,55}
2．In [20]: b = {22,44,55,66,77}
3．In [21]: a ^ b
4．Out[21]: {11, 33, 66, 77}

 

 

-