python面试题--数据类型

数据类型

字典

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

现有字典d={‘a’:24，‘g’:52，‘i’:12，‘k’:33}请按字典中的value
值进行排序？
```
d={‘a’:24，‘g’:52，‘i’:12，‘k’:33}

sorted(d.items()，key = lambda x:x[1])
```
说一下字典和json 的区别？

字典是一种数据结构，json 是一种数据的表现形式，字典的key 值只要是能hash 的就行，json 的
必须是字符串。
什么是可变、不可变类型？

可变不可变指的是内存中的值是否可以被改变，不可变类型指的是对象所在内存块里面的值不可以
改变，有数值、字符串、元组；可变类型则是可以改变，主要有列表、字典。
存入字典里的数据有没有先后排序？
存入的数据不会自动排序，可以使用sort 函数对字典进行排序。
如何理解Python 中字符串中的字符？
1、转义字符2、路径名中用来连接路径名3、编写太长代码手动软换行。
请反转字符串“aStr”

1. print(‘aStr’[::-1])

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

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

请按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)

　　列表

增加

列表名.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']

取值和修改

取值：列表名[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']

删除
```
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]: []

排序

列表名.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]

统计相关

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("找到了....")

循环遍历

使用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)

下面代码的输出结果将是什么？

1. list = ['a'， 'b'， 'c'， 'd'， 'e']
2. print list[10:]




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

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

给定两个列表，怎么找出他们相同的元素和不同的元素?

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)

请写出一段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

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

有如下数组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]

下面这段代码的输出结果是什么？请解释？
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 个函数按照执行效率高低排序
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)')

获取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)

元组和集合
　　　　

tuple:元组，元组将多样的对象集合到一起，不能修改，通过索引进行查找，使用括号”()”;
应用场景：把一些数据当做一个整体去使用，不能修改；
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}