Python第二周 学习笔记

Posted 2020-10-28

深浅拷贝

---

==比较的是数据内容，如果是True意义为内容相同，引用并不同
=操作执行后，前后两个元素的引用地址相同

浅拷贝

copy() -> List

返回一个新的列表
引用类型只拷贝引用地址

深拷贝

完全拷贝。包括引用类型

from copy import deepcopy
lst2=deepcopy.(lst)

随机数

---

import random

randint(a, b)

返回[a, b]之间的整数,闭区间

choice(seq)

从非空序列的元素中随机挑选一个元素，比如

random.choice(range(10))

，从0到9中随机挑选一个整数。

random.choice([1,3,5,7])

randrange ([start,] stop [,step])

从指定范围内，按指定基数递增的集合中获取一个随机数，基数
缺省值为1。

random.randrange(1,7,2) 

前闭后开

random.shuffle(list) ->None

就地打乱列表元素

sample(population, k)

从样本空间或总体（序列或者集合类型）中随机取出k个不同的元素，返回
一个新的列表

元组

---

有序的元素集合

初始化：

t=tuple()
t=()
t=(1,)

元组查询与列表类似

元组元素不可修改

注意：
对于包含复杂对象的元组，其指向复杂对象的引用地址不可更改，但复杂对象的数据内容可更改

namedtuple

from collections import namedtuple
Point=namedtuple(‘Point‘,[‘x‘, ‘y‘])
#Point=namedtuple(‘Point‘,‘x y‘) 第二种写法
p1=Point(11，12)
print(p1.x,p1.y)

部分源码：

if isinstance(field_names, str):
    field_names = field_names.replace(‘,‘, ‘ ‘).split()
field_names = list(map(str, field_names))
typename = str(typename)

字符串

---

习题解析：

---

1.运用数组实现求10万以内质数：

prime = [2]
for i in range(3,100000,2):
    flag = False
    up = int(i**0.5)+1
    for j in prime:
        if i % j == 0:
            flag = False
            break
        if j >= up:
            flag = True
            break    
    if flag:
        prime.append(i)
print(len(prime))

2.杨辉三角：

方法一（1）迭代后首尾加元素1：

n=6
pre=[[1]]
for i in range(n):
    line=pre[i]
    temp=[1]
    for j in range(i):
        temp.append(line[j]+line[j+1])
    temp.append(1)
    pre.append(temp)
print(pre)

方法一（2）：

n = 6
pre = [1]
for i in range(n):
    temp = [1]
    for j in range(i):
        temp.append(pre[j] + pre[j + 1])
    temp.append(1)
    print(pre)
    pre = temp

方法二 列表前后或后补元素0迭代：

n=6
pre=[1]
for i in range(1,n):
    pre.append(0)
    newline=[]
    for j in range(i+1):
        var=pre[j-1]+pre[j]
        newline.append(var)
    print(newline)
    pre=newline

方法三（1）提前创建好宽度合适、充满1的列表，将计算的结果替换列表中对应位置的数，

采用对称性一次循环将对称的两个元素一并替换：

n=6
triangle=[]
for i in range(n):
    temp=[1]*(i+1)
    for j in range(1,i//2+1):
        var=triangle[j-1]+triangle[j]
        temp[j]=var
        if i!=2*j:
            temp[-j-1]=var
    triangle=temp
    print(temp)

方法三（2）：

n = 6
triangle = []
for i in range(n):
    temp = [1] * (i + 1)
    triangle.append(temp)
    for j in range(1,i // 2 + 1):
        var = triangle[i - 1][j - 1] + triangle[i - 1][j]
        temp[j] = var
        if i != 2 * j:
            temp[- j - 1] = var
    print(temp)
    pre = temp

方法四 只开辟最大长度的一个充满1的列表，加入一个临时变量存储替换的元素，

参与下一次计算，采用对称性，注意更改对称元素时，其索引值需加入一个偏移量，

输入时对列表切片：

n = 6
triangle = [1] * n
for i in range(n):
    temp = 1
    for j in range(1,i // 2 + 1):
        var = temp + triangle[j]
        temp = triangle[j]
        triangle[j] = var
        if i != j * 2:
            triangle[- j - (n - i)] = var
    print(triangle[: i + 1])

冒泡法排序

时间复杂度O(n**2)

方法一：

lst=[9,8,7,6,5,4,3,2,1]
cnt=0
cnt_swap=0
for i in range(len(lst)-1):
    for j in range(len(lst)-i-1):
        cnt+=1
        if lst[j]>lst[j+1]:
            lst[j],lst[j+1] = lst[j+1],lst[j]
            cnt_swap+=1
print(lst,cnt,cnt_swap)

方法二(优化)：

优化点:如果当一个内循环结束后，并没有发生元素交换的操作，则剩下的元素已经是顺序的了，无需再往下执行

#lst = [9,8,7,6,5,4,3,2,1]
#lst = [1,2,3,4,6,5,7,8,9]
lst = [2,1,3,4,5,6,7,8,9]
cnt = 0
cnt_swap = 0
for i in range(len(lst) - 1):
    flag = False 
    for j in range(len(lst) - i - 1):
        cnt += 1
        if lst[j] > lst[j + 1]:
            lst[j],lst[j + 1] = lst[j + 1],lst[j]
            flag = True
            cnt_swap += 1
    if not flag:
        break
print(lst,cnt,cnt_swap)