python中astr是啥_python面试题--数据类型-CSDN博客

增加

列表名.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 中的每个字符拆开作为元素插入到列表

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]

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

5. list1 = extendlist(10)

6. list2 = extendlist(123, [])

7. list3 = extendlist('a')

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]

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

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