第四周python笔记 Python封装结构哈希查找杨辉三角冒泡排序

知识点:浅拷贝字符串封装解构集合 ipython 哈希查找与线性查找

代码实现:杨辉三角冒泡排序

list复制是浅拷贝

简单类型新开地址拷贝数值

引用类型只拷贝引用直接拷贝地址

深拷贝简单类型与引用类型都新开地址拷贝完全独立

字符串

不可变对象 Unicode类型

用引号表示 '' "" ''' ''' """ """

引号内支持输入 \t \n \r 等转义符

可以用\转义或者在引号前加r显示转义符本身

如 s7 = R"c:\windows\nt" 表示s7的字符串内容为c:\windows\nt 引号前加r可取消对转义符\n的识别

字符串

与元组类似支持单个字符索引以及字符迭代

例如len(s7)表示字符串s7的长度 s7[0]表示s7的第一个字符 s7[-1]表示s7的最后一个字符

支持中文

s1='中国'

for I in si:

print(i)

"string".join(iterable) -> str

使用string作为分隔符,将可迭代对象连接起来

可迭代对象本身元素都是字符串

返回一个新字符串

lst = ['1','2','3']

print("\"".join(lst)) # 分隔符是双引号(用\对双引号做了转义也可用' " '.join(lst)表示)

print(" ".join(lst))#用空格分隔

print("\n".join(lst))#用换行符分隔即一个元素占一行

print(r"\n".join(lst))#用\n分隔

lst = ['1',['a','b'],'3']

print(" ".join(lst))#此步骤会报错因为['a','b']是列表并不是字符串可用map函数先将列表lst内的所有元素全转化为字符串此时['a','b']就被转化为字符串

print(" ".join(map(str,lst)))

字符串分割

split(sep=None, maxsplit=-1) -> list of strings

从左至右

sep 指定分割字符串，默认情况下空白字符串作为分隔符

maxsplit 指定分割的次数，-1 表示遍历整个字符串

s1 = "I'm \ta super student."

s1.split()#默认状态会去除空白字符 只保留单词不指定maxsplit会分割所有单词

s1.split(' ')单独指定空格作为分隔符同上

s1.split('s')#单独指定s作为分隔符同样会去除空白字符只保留单词

s1.split('super')#同上

s1.split(' ',maxsplit=2)#单独指定最大分割次数为2 超过不报错

s1.split('\t',maxsplit=2)#单独指定\t作为分隔符且最大分割次数为2

rsplit 则是从右向左分割

url='https://mirror.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Windows-x86_64.exe'

filename=url.split('/')[-1]

filename=url.rsplit('/',maxsplit=1)[-1]

hostname=url.rsplit('/')[2]

splitlines([keepends]) -> list of strings

按照行来切分字符串

keepends 指的是是否保留行分隔符

行分隔符包括\n、\r\n、\r等

'ab c\n\nde fg\rkl\r\n'.splitlines()#以换行符为分割点留下单词

'ab c\n\nde fg\rkl\r\n'.splitlines(True)#保留行分隔符

s1 = '''I'm a super student.

You're a super teacher.'''

print(s1)#s1用三引号引起来故print打印时保留原格式有换行

print(s1.splitlines()) #以换行符分割

print(s1.splitlines(True))#以换行符分割并保留行分隔符

partition(sep) -> (head, sep, tail)

从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组；如果

没有找到分隔符，就返回头、2个空元素的三元组

sep 分割字符串，必须指定

s1 = "I'm a super student."

s1.partition('s') #("I'm a ", 's', 'uper student.')

s1.partition('stu')#("I'm a super ", 'stu', 'dent.')

s1.partition('')#空分割符报错

s1.partition('abc')#未找到分隔符，返回头、2个空元素的三元组即("I'm a super student.", '', '')

rpartition(sep) -> (head, sep, tail) 从右至左分割

replace(old, new[, count]) -> str

字符串中找到匹配替换为新子串，返回新字符串

count表示替换几次，不指定就是全部替换

'www.magedu.com'.replace('w','p') --->'ppp.magedu.com'

'www.magedu.com'.replace('w','p',2) --->'ppw.magedu.com'

'www.magedu.com'.replace('ww','p',2) --->'pw.magedu.com' #replace替换时不回头因此替换前两个ww后从第三个w开始无法替换则停止

'www.magedu.com'.replace('www','python',2)--->'python.magedu.com' 只替换了一遍无法替换则停止

strip([chars]) -> str

从字符串两端去除指定的字符集chars中的所有字符

如果chars没有指定，去除两端的空白字符

s = "\r \n \t Hello Python \n \t"

s.strip()---> 'Hello Python'

s = " I am very very very sorry "

s.strip()--->'I am very very very sorry'

s.strip('Iy')--->" I am very very very sorry "#chars中只有l和y 原字符串两端有空格无法去除原样返回

s.strip('Iy ')--->'am very very very sorr' #chars中只有l y 和空格 ,去除char内的所有字符遇到其他字符停下来

lstrip([chars]) -> str 从左开始

rstrip([chars]) -> str 从右开始

index(sub[, start[, end]]) -> int

在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError

rindex(sub[, start[, end]]) -> int

从左至右......

s = "I am very very very sorry"

s.index('very')---->5 #返回关键字首次出现的索引位置

s.index('very', 5)----->索引从5开始返回关键字首次出现的索引位置

s.index('very', 6, 13)#索引范围6~12 无法匹配

s.rindex('very', 10, 15)---->10 #索引范围10~14 关键字首次出现的索引位置为10

s.rindex('very',-10,-1)--->15 #索引范围-10~-2 关键字首次出现的索引位置为15

count(sub[, start[, end]]) -> int

在指定的区间[start, end)，从左至右，统计子串sub出现的次数

s = "I am very very very sorry"

s.count('very') --->3

s.count('very', 5)--->3

s.count('very', 10, 14)--->1

endswith(suffix[, start[, end]]) -> bool

在指定的区间[start, end)，字符串是否是suffix结尾

startswith(prefix[, start[, end]]) -> bool

在指定的区间[start, end)，字符串是否是prefix开头

s = "I am very very very sorry"

s.startswith('very') --->False

s.startswith('very', 5)--->True

s.startswith('very', 5, 9)--->True

s.endswith('very', 5, 9)--->True

s.endswith('sorry', 5)--->True

s.endswith('sorry', 5, -1)--->False #-1取不到

s.endswith('sorry', 5, 100)--->False

封装和解构

封装

将多个值使用逗号分割，组合在一起

本质上，返回一个元组，只是省掉了小括号

t1 = (1,2) # 定义为元组

t2 = 1,2 # 将1和2封装成元组

type(t1)

type(t2)

解构

把线性结构的元素解开，并顺序的赋给其它变量

左边接纳的变量数要和右边解开的元素个数一致

lst = [3, 5]

first, second = lst

print(first, second)

Python3的解构

使用 *变量名接收，但不能单独使用

被 *变量名收集后组成一个列表

lst = list(range(1, 101, 2))

head, *mid, tail = lst

*lst2 = lst

*body, tail = lst

head, *tail = lst

head, *m1, *m2, tail = lst

head, *mid, tail = "abcdefghijklmn"

type(mid)

x,y=y,x #先将等号右侧的所有数值封装为元组再结构实现xy数值交换

丢弃变量

这是一个惯例，是一个不成文的约定，不是标准

如果不关心一个变量，就可以定义改变量的名字为_

_是一个合法的标识符，也可以作为一个有效的变量使用，但是定义成下划线就是希望不要被使用，除非你明确的知道这个数据需要使用

_ 这个变量本身无任何语义，没有任何可读性，所以不是用来给人使用的

Python中很多库，都使用这个变量，使用十分广泛。请不要在不明确变量作用域的情况下，使用 _ 导致和库中_ 冲突

lst = [9,[8,7],20]

first, *second = lst

head, *_, tail = lst

print(head)

print(tail)

# _是合法的标识符，看到下划线就知道这个变量就是不想被使用

print(_)

_, (*_, tail), *_ = lst #解构是支持多层的

集合Set

可变无序不重复

定义集合 set() 或 set(iterable)

s1={}定义的是字典不是集合

集合内的元素要求可哈希hashable

可变类型如列表等都不可哈希

数值型int、float、complex

布尔型True、False

字符串string、bytes

tuple

None

可哈希

因为无序所以不可索引

可迭代

增加

set1.add(ele) 集合set1增加值为ele的元素若存在则无操作

set1.update(iterable)合并可迭代对象iterable到set1集合中就地修改

删除

set1.remove(ele) 集合set1中删除值为ele的元素若不存在则抛出KeyError异常

set1.discard(elem) 集合set1中删除值为ele的元素不存在不抛异常

pop() -> item 移除并返回任意的元素。空集则返回KeyError异常

clear() 移除所有元素

集合内元素无序使用元素的哈希值作为索引 (只是哈希值对人来说不够友好不便记忆)

查找集合内元素时先对所查元素做哈希这相当于计算出了元素的索引再去对应索引位置查找是否有该元素因此可以说哈希查找的时间复杂度是O(1) t=constant

而在列表元组等线性结构中查询时需要对该线性结构作多次遍历时间复杂度为O(n)或O(log(2)n)等

因此线性查找会随着数据规模的增大而增加耗时 t=f(n)

集合可以插入或删除元素但不可修改元素可迭代但不可索引

此处集合的概念与高中数学中集合的概念一致

A∪B表示为

A|B #集合AB都不会变化

A|=B #等同于A=A|B 集合A会被修改为AB并集的结果

A∩ B表示为

A&B#集合AB都不会变化

A&=B #等同于A=A&B 集合A会被修改为AB交集的结果

A-B表示差集由所有属于A且不属于B的元素组成的集合可表示为

A-B 或A-=B

A是B的子集表示为 A<=B

A是B的真子集表示为 A<B

对称差集

集合A和B，由所有不属于A和B的交集元素组成的集合，记作（A-B）∪（B-A）表示为

A^B 或 A^=B

A.isdisjoint(B)==True 表示A与B无交集

ipython使用

查看命令帮助 ? help(CMD) CMD? CMD??

特殊变量

_ 前一次输出

__倒数第二次输出 .....

_dh 目录历史

_oh 输出历史

SHELL命令

!CMD 调用ipython所在系统环境的系统命令

如windows下的

!dir !ipconfig

linux下

!ls !ifconfig

魔术方法以%开头是ipython内置的特殊方法

%CMD #line magic

%%CMD #cell magic

%alias ip ipconfig 定义系统命令别名

%timeit CMD 统计命令运行时间以评判算法优劣

%cd %pwd %ls 为魔术方法由ipython内部实现与操作系统无关

python代码实现杨辉三角

方法一:

n=6
for i in range(n):newline=[1]# newline0=newline.append(0)if i==0:print(newline)continuefor j in range(i-1):newline.append(pre[j]+pre[j+1])        newline.append(1)print(newline)pre=newline'''
可用循环方式生成每一行的数据列表
其中每行数据两端为1 中间按照杨辉三角的规律加和算出
其中i控制总行数 j控制加和数
i j n 的数量关系可由对应循环次数总结得出
同时i j亦可充当列表索引
'''

方法二补0:

n=6
oldline=[1]
print(oldline)
# oldline.insert(0,0)
oldline.append(0)
for i in range(1,n):newline=[]for j in range(i+1):# val=oldline[j]+oldline[j+1]val=oldline[j-1]+oldline[j]newline.append(val)print(newline)oldline=newline# oldline.insert(0,0)oldline.append(0)'''
可用循环方式生成每一行的数据列表
其中旧行末端补0 中间按照杨辉三角的规律加和算出
j从0开始取值 j-1的初始值为-1 刚好可对应旧行的末尾值0
其中i控制总行数 j控制加和数
i j n 的数量关系可由对应循环次数总结得出
同时i j亦可充当列表索引
'''

方法三预先生成列表并利用对称性求值:

trangle=[]
n=6
for i in range(n):line=[1]oldline=line*(i+1)trangle.append(oldline)for j in range(1,i//2+1):val=trangle[i-1][j-1]+trangle[i-1][j]oldline[j]=oldline[-j-1]=val
print(trangle)'''
可用循环方式生成每一行的数据列表
其中每行数据量已确定 可先用乘法生成全是1的列表
中间按照杨辉三角的规律加和算出
其中i控制总行数 j控制加和数
i j n 的数量关系可由对应循环次数总结得出
本题中利用每行数据的对称性 j只许取到i//2的位置即可
同时利用对称性可发现索引值为j与-j-1的数取值相等
同时i j亦可充当列表索引
'''

方法四利用杨辉三角与二项式系数的关系求值:

def combination(n,m):if m > n>>1:m=n-m #利用C(n,m)=C(n,n-m)的性质 简化运算base=1for i in range(n-m+1,n+1):base*=ifor j in range(1,m+1):base//=jreturn basen=int(input('请输入杨辉三角的行数>>>'))
m=int(input('请输入杨辉三角的列数>>>'))
print('杨辉三角第{}行的第{}个数是{}'.format(n,m,combination(n-1,m-1)))'''
杨辉三角第n行的m个数可表示为 C(n-1，m-1)，即为从n-1个不同元素中取m-1个元素的组合数
也可导入python的科学计算模块scipy(需事先使用pip install scipy 命令来安装)
from scipy.special import comb
直接调用comb方法来计算组合数
'''

冒泡排序:

n个数从左至右，编号从0开始到n-1，索引0和1的值比较，如果索引0大，则交换两者位置，如
果索引1大，则不交换。继续比较索引1和2的值，将大值放在右侧。直至n-2和n-1比较完，第
一轮比较完成。第二轮从索引0比较到n-2，因为最右侧n-1位置上已经是最大值了。依次类推，

每一轮都会减少最右侧的不参与比较，直至剩下最后2个数比较。

a=[5,9,100,6,3,-6,90,55,78,3,78,6.8,-59.5,67,-66]
lena=len(a)
for i in range(lena-1):flag=False #第二层循环加入flag 是为判断待排序序列是否为严格递增序列 若是则已得到所求结果 终止循环for j in range(lena-1-i):if a[j]>a[j+1]:a[j],a[j+1]=a[j+1],a[j]flag=Trueif not flag:break
print(a)

第四周python笔记 Python封装结构哈希查找杨辉三角冒泡排序相关推荐

python每行输出5个数_python打印杨辉三角及输出第m行第k个数
1.打印杨辉三角及输出第m行第k个数 1.计算到m行,打印出k项第m行有m项,m是正整数,因此k一定不会大于m,这个需求需要保存m行的数据,那么可以使用一个嵌套结构[[],[],[]] m=int( ...
Python 中使用 for、while 循环打印杨辉三角练习（列表索引练习）。
Python中使用for while循环打印杨辉三角练习(列表索引练习). 杨辉三角是一个由数字排列成的三角形数表,一般形式如下: 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 ...
python实现杨辉三角形博客园_Python实现杨辉三角
杨辉三角,是二项式系数在三角形中的一种几何排列.在欧洲,这个表叫做帕斯卡三角形.帕斯卡(1623----1662)是在1654年发现这一规律的,比杨辉要迟393年,比贾宪迟600年.杨辉三角是中国古代 ...
python创建和显示任意行数的杨辉三角/帕斯卡三角（函数）
def create_psc_triangle(line_num):"""创建杨辉三角(帕斯卡三角):param line_num: 行数:return: 存储杨辉三角的 ...
杨辉三角c语言程序for循环,C语言循环结构 -C语言打印杨辉三角
杨辉三角形是一个由数字排列组成的三角形数表.其一般形式如图 1 所示,每行开始和结尾处的数字都为 1,其他数字都是它所在行的上一行中靠近它的两个数之和. 图 1:杨辉三角形请编程输出其中的前 n(n ...
Python笔记 - Python切片
Python笔记 - Python切片 Python切片是对一个列表取其部分元素获得一个子序列的常见操作,切片操作的返回结果类型与被切片的对象一致.要创建一个已有列表的切片,通过指定切片的第一个列表元 ...
廖雪峰python教程杨辉三角_廖雪峰--python教程：笔记三
高级特性: 前面我们简单的聊了一下Python的数据类型.语句和函数,接下来来聊聊Python的高级特性切片: 取一个list.tuple.str一部分内容是很常见的操作,而切片操作,可以让这一个过 ...
用python编写杨辉三角金字塔_用python实现三道简单算法题：杨辉三角，蛇形矩阵，金字塔...
分享几道简单的python打印输出的问题,本质上都是可以将其分解成一个大循环之中有几个小循环. 1.杨辉三角主要特点: 每个数等于它上方两数之和. 每行数字左右对称,由1开始逐渐变大. 每行端点与结 ...
Python学习之---杨辉三角的五种解法
杨辉三角(也称帕斯卡三角)对与编程初学者来说,肯定不陌生,它是一个无限对称的数字金字塔,从顶部的单个1开始,下面一行中的每个数字都是上面两个数字的和. 杨辉三角,是二项式系数在三角形中的一种几何排列, ...

第四周python笔记 Python封装结构哈希查找杨辉三角冒泡排序

第四周python笔记 Python封装结构哈希查找杨辉三角冒泡排序相关推荐

最新文章

热门文章

第四周python笔记 Python封装结构 哈希查找 杨辉三角 冒泡排序

第四周python笔记 Python封装结构 哈希查找 杨辉三角 冒泡排序相关推荐

最新文章

热门文章

第四周python笔记 Python封装结构哈希查找杨辉三角冒泡排序

第四周python笔记 Python封装结构哈希查找杨辉三角冒泡排序相关推荐