python非线性结构及算法

python非线性结构

一. 封装和解构

1.1 封装

将多个用逗号 , 分隔开来的值，组合在一起，形成一个新的元组

t0 = (10,20)
t1 = 10,20
x,y = (1,2)
print(type(t0))
print(type(t1))
print("{}+{}={}".format(x,y,x+y))
x,y = t1
print("{}+{}={}".format(x,y,x+y))
运行结果如下：
<class 'tuple'>
<class 'tuple'>
1+2=3
10+20=30

封装说明

封装:

• 将多个值使用逗号分割，组合在一起
• 本质上返回一个元组，只是省略了小括号

1.2.解构

解构就是，把一个list 、tuple 、set 等已经封装起来的类型打开，并且把里面的元素依次赋给标识符。

t = 1, 2, 3 # 这里把这三个元素封装成元组
n1, n2, n3 = t # 把右边元组解构，每个元素依次赋给左边的标识符

n1, n2, n3
(1, 2, 3) # 注意，这里直接用逗号, 连接起来，然后输出，相当于又做了一次封装

print(n1, n2, n3)
1, 2, 3

二.set及操作

python的set和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.

sets 支持 x in set, len(set),和 for x in set。作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持 indexing, slicing, 或其它类序列（sequence-like）的操作。

2.1.比较

se = {11, 22, 33}
be = {22, 55}
temp1 = se.difference(be)        #找到se中存在，be中不存在的集合，返回新值
print(temp1)        #{33, 11}
print(se)        #{33, 11, 22}

temp2 = se.difference_update(be) #找到se中存在，be中不存在的集合，覆盖掉se
print(temp2)        #None
print(se)           #{33, 11},

2.2.删除

se = {11, 22, 33}
se.discard(11)
se.discard(44)  # 移除不存的元素不会报错
print(se)

se = {11, 22, 33}
se.remove(11)
se.remove(44)  # 移除不存的元素会报错
print(se)

se = {11, 22, 33}  # 移除末尾元素并把移除的元素赋给新值
temp = se.pop()
print(temp)  # 33
print(se) # {11, 22}

2.3.取交集

se = {11, 22, 33}
be = {22, 55}

temp1 = se.intersection(be)             #取交集，赋给新值
print(temp1)  # 22
print(se)  # {11, 22, 33}

temp2 = se.intersection_update(be)      #取交集并更新自己
print(temp2)  # None
print(se)  # 22

2.4.判断

se = {11, 22, 33}
be = {22}

print(se.isdisjoint(be))        #False，判断是否不存在交集（有交集False，无交集True）
print(se.issubset(be))          #False，判断se是否是be的子集合
print(se.issuperset(be))        #True，判断se是否是be的父集合

2.5.合并

se = {11, 22, 33}
be = {22}

temp1 = se.symmetric_difference(be)  # 合并不同项，并赋新值
print(temp1)    #{33, 11}
print(se)       #{33, 11, 22}

temp2 = se.symmetric_difference_update(be)  # 合并不同项，并更新自己
print(temp2)    #None
print(se)             #{33, 11}

2.6.取并集

se = {11, 22, 33}
be = {22,44,55}

temp=se.union(be)   #取并集，并赋新值
print(se)       #{33, 11, 22}
print(temp)     #{33, 22, 55, 11, 44}

三.解析式生成器

返回生成器迭代器的函数。 它看起来像一个普通的函数，只是它包含yield表达式，用于生成一系列可用于for-loop的值，或者可以使用next（）函数一次检索一个值

3.1.生成器的构成：

1.语法格式(返回值 for 元素 in 可迭代对象 if条件)
2.列表解析式的中括号换成小括号即可
3.返回一个生成器

g = ("{:04}".format(i) for i in range(1,6))
print(next(g))
for x in g:
    print(x)
print('~~~~~~~~~~~~')
for x in g:
    print(x)
运行结果：
0001
0002
0003
0004
0005

3.2.生成器的next不能回头

g = (x for x in range(10) if x % 2)
#取奇数1,3,5,7,9 first=1 second=3 val=4 下一个为5
first = next(g)
second = next(g)
val = first + second
print(val)
print(next(g))
运行结果：
4
5

四.迭代器

迭代器的定义：

表示数据流的对象。 重复调用迭代器的next （）方法（会返回流中的连续项。直到没有数据可以返回时抛出StopIteration异常错误。可以把这个数据流看做一个有序序列，但我们无法提前知道这个序列的长度。同时，Iterator的计算是惰性的，只有通过next()函数时才会计算并返回下一个数据。

from collections import Iterator
print(isinstance("abc",Iterator))
print(isinstance("()",Iterator))
print(isinstance((x for x in range(2)),Iterator))

算法知识补充

一.选择排序法

nums = [1, 9, 8, 5, 6, 7, 4, 3, 2]
length = len(nums)
print(length, ' | ', nums)
count_iter = 0
count_swap = 0


for i in range(length - 1):
    maxindex = i
    for j in range(i+1, length):
        count_iter += 1
        if nums[maxindex] < nums[j]:
            maxindex = j
    
    if i != maxindex:
        nums[i], nums[maxindex] = nums[maxindex], nums[i]
        count_swap += 1
print(nums)
print(count_iter, count_swap)

二.优化后的选择排序法（一次循环确定最大值和最小值）

nums = [1, 9, 8, 5, 6, 7, 4, 3, 2]

nums = [1,1,1,1,1,2]

length = len(nums)
print(length, ' | ', nums)
count_iter = 0
count_swap = 0

# 1 9 2
for i in range(length//2): # length - 1
    maxindex = i # 假设
    minindex = -i - 1 #-1 - i#length - 1 - i
    
    for j in range(i+1, length - i):
        count_iter += 1
        if nums[maxindex] < nums[j]:
            maxindex = j
        if nums[minindex] > nums[-j-1]:
            minindex = -j - 1 #j
    
    #print("~~~~~", maxindex, minindex)
    if nums[maxindex] == nums[minindex]:
        break
    
    if i != maxindex:
        nums[i], nums[maxindex] = nums[maxindex], nums[i]
        count_swap += 1 # 交换过，i对应数应该是最大数
        if i - length == minindex: # 交换后，如果有影响，则修正minindex
            minindex = maxindex - length
    
    if minindex != -i-1 and nums[minindex] != nums[-i-1]: #and minindex != length - 1 - i:
        nums[-i-1], nums[minindex] = nums[minindex], nums[-i-1]
        count_swap += 1
    
print(nums)
print(count_iter, count_swap)

三。求素数

按照定义，从1 开始 到 n-1都没有找到整除它的数，就是质数

import datetime

start = datetime.datetime.now()
n = 100000
#print(2)
count = 1

for x in range(3, n, 2):
    for i in range(3, int(x**0.5)+1, 2):
        if x % i == 0:
            break
    else:
        count += 1
        #print(x)

delta = (datetime.datetime.now() - start).total_seconds()
print(count)
print(delta)
print('-' * 30)

孪生素数

 5 孪生素数
import datetime

start = datetime.datetime.now()
n = 100000
#print(2, 3, 5)
count = 3

x[j+1] = a + 1

x = 7
step = 4
while x < n:
    if x % 5 != 0: 
        #print(x) # 测试是不是质数
        for i in range(3, int(x**0.5)+1, 2):
            if x % i == 0:
                break
        else:
            count += 1
            #print(x)

    x += step # 7
    step = 4 if step==2 else 2
    
    
delta = (datetime.datetime.now() - start).total_seconds()
print(count)
print(delta)
print('-' * 30)

求转置矩阵

lst=[[1,2,3],[4,5,6]]
mn= [[0 for i in range(len(lst))] for j in range (len(lst[0]))]
for  i,a in enumerate(lst):
    for j,b in enumerate(a):
        mn[j][i]=lst[i][j]
print(mn)
            

感谢大家支持：

欢迎志同道合的朋友：成为小灰灰的朋友