标签：试题 返回值 bsp 偶数 pre 疑难 交集 st3 iterable
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 是一种数据的表现形式，字典的key 值只要是能hash 的就行，json 的
必须是字符串。
可变不可变指的是内存中的值是否可以被改变，不可变类型指的是对象所在内存块里面的值不可以
改变，有数值、字符串、元组；可变类型则是可以改变，主要有列表、字典。
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
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}
标签：试题 返回值 bsp 偶数 pre 疑难 交集 st3 iterable
原文地址：https://www.cnblogs.com/yang950718/p/10772206.html
