python知识点总结(六)

1、说一下你对Python中模块和包的理解。

1、每个Python文件就是一个模块，而保存这些文件的文件夹就是一个包，但是这个作为Python包
的文件夹必须要有一个名为__init__.py的文件，否则无法导入这个包。
2、通常一个文件夹下还可以有子文件夹，这也就意味着一个包下还可以有子包.
3、模块和包解决了Python中命名冲突的问题，不同的包下可以有同名的模块，不同的模块下可以有
同名的变量、函数或类。
4、在Python中可以使用import或from ... import ...来导入包和模块，在导入的时候还可以使用as关键字对包、模块、类、函数、变量等进行别名，从而彻底解决编程中尤其是多人协作团队开发时的命名冲突问题。

2、求结果1

kvps = {"1": 1, "2": 2}
theCopy = kvps  # theCopy {"1":1, "2":2}
kvps["1"] = 5  # kvps {"1":5, "2":2}
sum = kvps["1"] + theCopy["1"]
print(sum)  # 10

3、求结果2

a= [1， 2, 3, [4, 5], 6]
b=a
c = copy.copy(a)
d = copy.deepcopy(a)
b.append(10)
c[3].append(11)
d[3].append(12)
请问a，b，c，d的值为:????


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

print(a)
print(b)
print(c)
print(d)

4、求结果3

将列表按下列规则排序，补全代码
1.正数在前，负数在后
2.正数从小到大
3.负数从大到小
例:
排序前:[7，-8，5， 4，0, -2, -5]
排序后:[0，4，5，7， -2，-5,-8]
请补全代码:

a = [7, -8, 5, 4, 0, -2, -5]
print(sorted(a, key=lambda x: (x < 0, abs(x))))



lst = [[1, 2, 3], [4, 5, 6]]
print([j for i in lst for j in i])

5、求结果4

将列表内的元素，根据位数合并成字典
例:
Lst = [1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768 5536,42949672961
# 输出:
1:[1,2,4,8],
2:[16,32,64],
3:[128,256,512]
4:[1024,2048,4096,8192],
5:[16384,32768,65536]
6:[4294967296]

def func(lst):
    d = defaultdict(list)
    for i in lst:
        d[len(str(i))].append(i)
    return d


lst = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 5536, 42949672961]
print(func(lst))

6、求结果5

有两个字符串列表a和b，每个字符串是由逗号分隔的一些字符
a=[
'a,1'
'b,3,22
c,3,4
b=[
'a,2',
'b,1'
'd,2
按每个字符串的第一个值，合并a和b到c
C=
[
'a,1,2'
'b,3,22,1'
c,3,4'
'd,2'
"""
a = [
    'a,1',
    'b,3,22',
    'c,3,4']
b = [
    'a,2',
    'b,1',
    'd,2']

for b_i in range(len(b)):  # b_i是b中的元素索引
    for a_i in range(len(a)):  # a_i是a中的元素索引
        if b[b_i][0] == a[a_i][0]:
            a[a_i] += b[b_i][1:]  # 让a中的a_i元素拼接上b中剩余的内容
            break
    else:
        # b中的元素不在a中出现
        a.append(b[b_i])
print(a)

7、逻辑运算符

v1 = 1 or 3         
v2 = 1 and 3       
v3 = 0 and 2 and 1
v4 = 0 and 2 or 1
v5 = 0 and 2 or 1 or 4
v6 = 0 or False and 1
print(v1)		1
print(v2)        3
print(v3)       0
print(v4)      1
print(v5)     1
print(v6)     False


print(1 or 2)		1
print(1 and 2)      2
print(1 < (2 == 2))  False
print(1 < 2 == 2)	True

• 1. 优先级：not > and > or
• 2. 对于 a or b 来说，如果 a 为真，那么值为 a，否则为 b；对于 a and b 来说，如果 a 为真，那么值为 b，否则为 a。
• 3. 对于 “1 < (2==2)” 而言，“(2==2)” 结果为 True，即 1，而 ”1 < 1“ 为假，所以结果为 False。
• 4. 对于 “1 < 2==2” 而言， Python 是允许连续比较的，“1 < 2==2” 相当于 ”(1 < 2) and (2==2)“，所以结果为 True。
• 5. 3<4<5结果——》3<4 and 4<5

8、is和==有什么区别？

is：比较的是两个对象的id值是否相等，也就是比较俩对象是否为同一个实例对象。是否指向同一个内存地址

== ： 比较的两个对象的内容/值是否相等，默认会调用对象的eq()方法

9、Python里面如何拷贝一个对象？（赋值，浅拷贝，深拷贝的区别）

赋值（=），就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。

list()：表示创建了一个对象，但是并没有创建引用
d=list()：表示创建了一个对象，并且创建了一个对象的引用
a=b：表示创建了一个对象的引用，但是没有创建对象

浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用（如果用引用的方式修改其中一个对象，另外一个也会修改改变）{1,完全切片方法；2，工厂函数，如list()；3，copy模块的copy()函数}

class Person:
    def __init__(self,name):
        self.name=name

if __name__ == '__main__':
    p1=Person('kobe')
    p2=Person('james')

    l1=[p1,p2]
    p1.name='jorden'
    l2=list(l1)         #浅拷贝
    print(l2[0].name)   #jorden
    print(id(l1))       #2278620394368
    print(id(l2))       #2278620429056

深拷贝：创建一个新的对象，并且递归的复制它所包含的对象（修改其中一个，另外一个不会改变），因此，新对象和原对象没有任何关联。{copy模块的deepcopy()函数}

class Person:
    def __init__(self,name):
        self.name=name

if __name__ == '__main__':
    p1=Person('kobe')
    p2=Person('james')

    l1=[p1,p2]

    l3=copy.deepcopy(l1)
    p1.name='curry'
    print(l3[0].name)       #kobe
    print(id(l1))           #2351425281088
    print(id(l3))           #2351425358080

10、pow(m,n)：求m的n次方

print(pow(2,3))
8

11、round(m,n)：对m保留n位小数

print(round(3.1415926,3))
3.142

12、一条语句把l=[(1,2),(3,4)]转为[(1,3),(2,4)]

l = [(1, 2), (3, 4)]
print(list(zip(l[0], l[1])))

13、sorted：对可迭代对象进行排序，返回的是一个可迭代对象，开辟新的内存空间

ll = [(“qwe”, 20), (“ytr”, 18), (“sdf”, 29),(“adf”, 29),(“cdf”, 29)]
对年龄进行排序

print(sorted(ll, key=lambda x: x[1]))
print(sorted(ll,key=lambda x:(x[1],x[0])))

对年龄进行排序，当年龄相同时，采用姓名进行排序

print(sorted(ll,key=lambda x:(x[1],x[0])))

开辟新的内存空间

list = (2, 24, 8, 6, 35, 7, 22, 30)
print('排序前的元组：', list, id(list))   #排序前的元组： (2, 24, 8, 6, 35, 7, 22, 30) 2754673096736
list1 = sorted(list)
print('排序后的元组：', list1, id(list1))  #排序后的元组： [2, 6, 7, 8, 22, 24, 30, 35] 2754674915072

14、对字典求和时，默认对键求和

x={0:1,2:3,4:5}
print(sum(x)) 
输出6

15、map：映射

a=[1,3,5]
b=[2,4,6]
相乘得到[2,12,30]

l=list(map(lambda x,y:x*y,a,b))