文章目录

  • 逻辑运算
  • 一个元素的元组
  • setdefault
  • list降维
  • 排序
  • 深拷贝与浅拷贝
  • 交并集
  • is和==


逻辑运算

  • 题目
v1 = 1 or 3 ## >>> 1
v2 = 1 and 3 ## >>> 3
v3 = 0 and 2 and 1 ## >>> 0
v4 = 0 and 2 or 1 ## >>> 1
v5 = 0 and 2 or 1 or 4 ## >>> 1
v6 = 0 or False and 1 ## >>> False
  • 考点
  1. 逻辑运算符

  混合使用的运算顺序：

() => not =>and=>or

  1. or运算符：
a or b

  如果a表示False，那么结果就是b，
  如果a表示True，那么结果就是a。

  1. and运算符：
a and b

  如果a表示为True，那么结果就是b。
  如果a表示为False，结果就是a。

一个元素的元组

  • 题目
a=[1,2,3]
b= [(1),(2),(3)]
c = [(1,).(2,),(3,)]

  问：a，b，c有什么区别?

  a,b里面装的都是int类型数据，c里面装的是元组。

  • 考点
  • ()默认的情况下表示的是优先级。比如说a=(1)，a的类型其实是为int。
  • 如果python中的元组只存储一个数据。那么元组最后一个元素后面必须跟上一个逗号。

setdefault

  • 题目
"""
将列表内的元素， 根据位数合并成字典
例：
    list = [1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536, 4294965646]
    # 输出：
{
1: [1, 2, 4, 8],
2: [16, 32, 64],
3: [128, 256, 512],
4: [1024, 2048, 4096, 8192],
5: [16384, 32768, 65536],
10: [4294965646]
}
"""
  • 考点

setdefault()函数和get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。基本语法如下：

dict.setdefault(key, default=None)
  • key – 查找的键值。
  • default – 键不存在时，设置的默认键值。

setdefault 如果不存在会在原字典里添加一个 key:default_value 并返回 default_value。

get 找不到 key 的时候不会修改原字典，只返回 default_value。

若要修改字典 dic.setdefault(key,default_value) 等同于 dic[key] = dic.get(key,default_value)。

  • 题解
dic = {}
list = [1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536, 4294965646]
for item in list:
    it = str(item)
    if len(it) < 6:
        dic.setdefault(len(it), []).append(item)
    else:
        dic.setdefault(len(it), []).append(item)
print(dic)

list降维

  • 题目
"""
请尽量用简洁的方法把二维数组转换成一维数组
例如：
    转换前：
        list = [[1,2,3], [4,5,6], [7,8,9]]
    转换后：
        list = [1,2,3,4,5,6,7,8,9]
"""
  • 考点
  • 解法1：

  reduce()函数会对参数序列中元素进行累积。

  函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

from functools import reduce
list1 = [[1,2,3], [4,5,6], [7,8,9]]
list2 = list(reduce(lambda x, y: x+y, list1))
  • 解法2：

  使用itertools.chain.from_iterable将多个迭代器进行高效的连接

from itertools import chain
list1 = [[1,2,3], [4,5,6], [7,8,9]]
list2 = list(chain.from_iterable(list1))
  • 解法3：

  利用sum与一个空[ ]相加。

list1 = [[1,2,3], [4,5,6], [7,8,9]]
list2 = sum(list1, [])

排序

  • 题目
"""
将列表按下列规则排序，补全代码：
1. 正数在前，负数在后
2. 正数从小到大
3. 负数从大到小
例如：
    排序前： [-7, -8, 5, 4, 0, -2, -5]
    排序后： [0, 4, 5, -2, -5, -7, -8]
"""
  • 考点

  sorted()函数对所有可迭代的对象进行排序操作。

sort 与 sorted 区别： sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。 list 的
sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数 sorted 方法返回的是一个新的
list，而不是在原来的基础上进行的操作。

  • sorted语法：
sorted(iterable, cmp=None, key=None, reverse=False)

参数说明：

  • iterable：可迭代对象。
  • cmp ：比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
  • key ：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  • reverse：排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

  排序规则有很多项：

  • 题解
list1 = [-7, -8, 5, 4, 0, -2, -5]
res = sorted(list1, key=lambda x: (x < 0, abs(x)))

  在sorted排序的条件中，只要结果为真就往后排序。

深拷贝与浅拷贝

  • 题目
"""
a = [1,2,3,[4,5], 6]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
d.append(10)
c[3].append(11)
d[3].append(12)

请问a,b,c的值为：？
"""
  • 考点

  a=b这一项a与b使用的是同一个list。因为Python中的等号是不拷贝的。

  • c浅拷贝不会copy出list中内存地址指向的数据。
  • d深拷贝会copy出list中存的地址所指向的数据。
  • 题解
import copy
a = [1,2,3,[4,5], 6]
b = a
c = copy.copy(a)
d = copy.deepcopy(a)
d.append(10)
c[3].append(11)
d[3].append(12)

print("a:{}; b:{}; c{} d{}".format(a, b, c, d))

  输出结果为：

a:[1, 2, 3, [4, 5, 11], 6]; 
b:[1, 2, 3, [4, 5, 11], 6]; 
c[1, 2, 3, [4, 5, 11], 6];
d[1, 2, 3, [4, 5, 12], 6, 10]

交并集

  • 题目
"""
给定两个list，A，B 请用python找出A，B中相同的元素，A, B中不相同的元素
"""
  • 考点
# 所有和交并集相关的操作都去找set集合
A = [1,2,3]
B = [2,3,4]

a = set(A)
b = set(B)

print(a & b) # 交集 或者是：a.intersection(b)
print(a ^ b) # 异或 或者是：a.symmetric_difference(b)
print(a | b) # 并集 或者是：a.union(b)
print(a - b) # 差集 或者是：a.difference(b)

  结果：

{2, 3}
{1, 4}
{1, 2, 3, 4}
{1}

  利用set还可以将list中重复的元素去掉。比如：

"""
1，2，3，4，5， 能组合成多少个互不相同且无重复的三位数
"""
list1 = []
nums = {1,2,3,4,5}
for i in range(100, 1000):
    s = set(int(j) for j in str(i))
    if not s - nums:
        list1.append(s)
print(len(list1)) # >>> 125

is和==

  is判断的是内存地址，==判断的是值。

list1 = [1,2,3]
list2 = [1,2,3]
list1 is list2 # >>> False
list1 == list2 # >>> True