python面试题--数据类型

数据类型

• 字典

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

1. 现有字典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])

2. 说一下字典和json 的区别？

   字典是一种数据结构，json 是一种数据的表现形式，字典的key 值只要是能hash 的就行，json 的
   必须是字符串。

3. 什么是可变、不可变类型？

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

4. 存入字典里的数据有没有先后排序？
   存入的数据不会自动排序，可以使用sort 函数对字典进行排序。
5. 如何理解Python 中字符串中的\字符？
   1、转义字符2、路径名中用来连接路径名3、编写太长代码手动软换行。
6. 请反转字符串“aStr”

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

7. 将字符串"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

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

　　列表

1. 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)

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

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

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

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

      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)

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

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

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

   13. 下面这段代码的输出结果是什么？请解释？
       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 的值
       随后将被使用。这是因为带有默认参数的表达式在函数被定义的时候被计算，不是在调用的时候被计算。

   14. 将以下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)]

   15. 按执行效率从高到低排列：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)')

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

元组和集合
　　  　　

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

   2. set:set 集合，在Python 中的书写方式的{}，集合与之前列表、元组类似，可以存储多个数据，但
      是这些数据是不重复的。集合对象还支持union(联合), intersection(交), difference(差)和
      sysmmetric_difference(对称差集)等数学运算。

   3. 快速去除列表中的重复元素
      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}