本文隶属于分类

编程语言

推荐文章

广告推荐

技术交流学习或者有任何问题欢迎加群

编程技术交流群 : 154514123 爱上编程      Java技术交流群 : 6128790  Java

标签:学习笔记

深浅拷贝

==比较的是数据内容,如果是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)

标签:学习笔记

原文:http://blog.51cto.com/11281400/2092009

技术交流学习或者有任何问题欢迎加群

编程技术交流群 : 154514123 爱上编程      Java技术交流群 : 6128790  Java

广告推荐

讨论区