python 笔记4

1、转置矩阵的实现方法：

#矩阵的转置
jz=[[1,2,3],[4,5,6],[7,8,9]]
print(jz)
for i,row in enumerate(jz):
    for j,col in enumerate(row):
        if i<j:
            jz[i][j],jz[j][i]=jz[j][i],jz[i][j]
print(jz)

 #enumerate的用法：

语法：enumerate(sequence, [start=0])

• sequence -- 一个序列、迭代器或其他支持迭代对象。
• start -- 下标起始位置。

实例：

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']

>>> list(enumerate(seasons)) [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

>>> list(enumerate(seasons, start=1)) # 下标从 1 开始

[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

另一种实现方法：

#矩阵的转置
jz=[[1,2,3],[4,5,6],[7,8,9]]
print(jz)
for i in range(len(jz)):
    for j in range(i):
            jz[i][j],jz[j][i]=jz[j][i],jz[i][j]
print(jz)

不规则矩阵转置的实现：

#不规则长矩阵的转置
jz=[[1,2,3],[4,5,6]]
print(jz)
t=[]
for row in jz:
    for i,col in enumerate(row):
        if len(t)<i+1:  #jz有几列t就要添加多少行
            t.append([])
        t[i].append(col)
print(t)

2、随机产生10个数字(不大于21)，统计重复的数字有几个，分别是什么；统计不重复的数字有几个，分别是什么：

import random
nums=[]
for _ in range(10):
    nums.append(random.randrange(21))
print(nums)
s,d=[],[] #分别用来装相同的那几个数字和不同的那几个数字
lenth=len(nums)
state=[0]*lenth  #用来做标记，标记以及重复的数字的位置

for i in range(lenth): #第一层循环对每一个元素进行遍历
    flag=False   #每一个元素比较前都要重新给flag赋初值
    if state[i]==1:  #如果第i个元素已经重复了，则不用比较了，这取决于后面的state[j]=1和state[i]=1
        continue
    for j in range(i+1,lenth):  #对i后面的每一个元素都要于i位置的元素进行比较
        if state[j]==1:  
            continue
        if nums[i]==nums[j]: 
            flag=True  #重复了，给flag赋值为True，并标记state该位置为1
            state[j]=1  
    if flag:
        s.append(nums[i])
        state[i]=1
    else:
        d.append(nums[i])

print("same Array={0} has {1}".format(s,len(s)))
print("different Array={0} has {1}".format(d,len(d)))

结果：

[14, 3, 9, 12, 7, 9, 11, 17, 11, 17]

same Array=[9, 11, 17] has 3 

different Array=[14, 3, 12, 7] has 4

3、集set

1）、约定：set翻译为集合；collection翻译为集合类型，是一个大概念
2）、set：可变的，无序的，不重复的元素的集合
格式：set（）
　　set(iterable)
iterable不能是可变的类型，如list以及bytearray
如：
s1={[1],(2),1}#会报错，list不能加进去作为其中一个元素，但可以作为单独的元素

　s=set()
　print(type(s))#set
　s={}
　print(type(s))#dict

注：set的元素：set的元素要求必须是可以hash的；目前学过的不可hash的类型有list、set；元素不可以索引，而且set会自动去重
set可以迭代3）、set增加

　　（1）、add（elem）
　　　　增加一个元素到set中
　　　　如果元素存在，就什么都不做
　　（2）、update（*other）
　　　　合并其他元素到set集合中去
　　　　参数others必须是可迭代对象（把这些对象解构然后加进去，去掉重复的）
　　　　就地修改
　　（可迭代对象我们已经知道可以对list、tuple、dict、set、str等类型的数据使用for...in...的循环语法从其中依次拿到数据进行使用，我们把这样的过程称为遍历，也叫迭代。
把可以通过for...in...这类语句迭代读取一条数据供我们使用的对象称之为可迭代对象）
4）、set删除
　　（1）、remove（elem）
　　　　　　从set中移除一个元素
　　　　　　元素不存在，抛出异常KeyError
　　（2）、discard（elem）
　　　　　　从set中移除一个元素
　　　　　　元素不存在，什么都不做
　　（3）、pop（）
　　　　　　移除并返回任意元素，不能有参数
　　　　　　空集返回KeyError异常
　　（4）、clear（）
　　　　　　移除所有元素
　　（哈希值，又称：散列函数是一种从任何一种数据中创建小的数字“指纹”的方法。散列函数把消息或数据压缩成摘要，使得数据量变小，将数据的格式固定下来。
该函数将数据打乱混合，重新创建一个叫做散列值的指纹。散列值通常用一个短的随机字母和数字组成的字符串来代表。好的散列函数在输入域中很少出现散列冲突。
在散列表和数据处理中，不抑制冲突来区别数据，会使得数据库记录更难找到）

set和线性结构
线性结构的查询时间时间复杂度是O（n），即随着数据规模的增大而增加耗时；
set、dict等结构，内部使用hash值作为key，时间复杂度可以做到O（1），而且查询时间和数据规模无关

可hash：
　　数值型int、float、complex；布尔型True、False；字符串string、bytes；tuple、None;
以上都是不可变类型，成为可哈希类型，hashable

set的元素必须是可hash的