==比較的是數據內容，如果是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)

Python第二周 學習筆記（1）