放弃考研，准备春招！
过去几天学习了python基础中的容器、函数调用与递归、排序算法、字符串和模块部分，下面是近期小结
一、容器
1、概念：
容器：编程语言提供给开发者使用的对象
2、用途
批量管理和操作数据
3、分类
在python中，容器分为四类，分别是：列表（list）、元组（tuple）、集合（set）、字典（dic）
【1】列表（list）：
概念:
即一组有序的数列
定义方法：
由python的弱数据类型，可通过 ls = [1,2,……] 直接定义
ls = [] #空列表
由全局函数list定义：
ls = list ([1,2,3……])
访问方法：
通过下表访问，如打印列表第一个元素操作为——print(ls[0])
遍历方法：
通过循环体遍历列表（for、while）
for index in ls2:
print(index)
index = 0
while index < len(ls2):
print(ls2[index])
index += 1
常见方法：
append(元素) #在列表尾部追加元素
insert(index, x) #在指定位置index插入元素x
remove(元素) #移除列表中该元素，不存在则报错
pop(index = -1) #移除列表最后一个元素，不存在择报错
clear() #清空列表
reverse() #反转列表
sort() #排序
index() #查找
count() #统计元素个数
extend #合并
copy() #复制、浅拷贝
练习：
No1. 求百位数为3，十位数为6，且能被2、3同时整除的四位数中最大的和最小的
#求百位数为3，十位数为6，且能被2、3同时整除的四位数中最大的和最小的
ls = []
ls1=[]
for i in range(1000,10000):
j = i // 1000
k = (i - j *1000)// 100
a = (i - j*1000-k*100)//10
if k == 3 and a == 6:
ls.append(i)
print("符合的数据列表为：%s"%(ls))
for i in ls:
if i % 2 == 0 and i%3==0:
ls1.append(i)
print("最小值为:%s"%ls1[0])
ls1.reverse()
print("最大值为:%s"%ls1[0])
结果：
2、求四位数ABCD*A=DCBA
ls = []
for i in range(1000,10000):
a = i // 1000
b = (i - a *1000)// 100
c = (i - a*1000-b*100)//10
d = i - 1000*a - 100*b - 10*c
if i * a == d*1000 + c*100 + b*10 + a:
ls.append(i)
print("符合的数据列表为：%s"%(ls))
结果：
3、求100以内孪生数
ls = []
ls1= []
for i in range(1,101):
for j in range(2,i):
if i%j==0:
break
else:
ls.append(i)
print("符合要求的质数为：%s"%(ls))
i = 1
while i<len(ls):
if (ls[i]-ls[i-1])==2:
print("%s,%s"%(ls[i-1],ls[i]))
i += 1
结果：
4、求一个前面加7是后面加7的五倍的五位数
ls=[]
for i in range(10000,100000):
a = 7*100000 + i
b = 10*i + 7
if a == 5*b:
ls.append(i)
print(ls)
结果：
【2】集合（set）：
概念：
集合与列表不同的是，他是无需的，且不能重复。
定义方法：
与列表相同的两种定义方法，注意的是集合用 {} 定义
遍历方法：
只能通过for循环遍历、while不行，因为是无序的
常用方法：
add() #添加元素
clear() #清空集合
copy() #浅拷贝
difference() #求差集
intersection() #求交集
union() #求并集
remove() #移除元素
pop() #随机删除一个元素，不存在则报错
discard() #随机删除一个元素，不存在无反应
【3】元组（tuple）：
概念：
元组是不可变的数据类型！！里面的元素不允许修改
定义方法：
定义与列表相同，也是两种方式，用（）定义
常用方法：
count() #统计元组元素个数
index() #查找位置
【4】字典（dict）：
定义方法：
d = {}
d = {k1: v1, k2: v2}
d = dict({…})
可以使用key访问到key对应的值
d[“k1”]
d.get(“k2”)
p[“name”] = “lisi” # 增加键值对
常见方法：
clear #清除元素
copy #浅拷贝
get #添加
keys() # 将所有的key返回
values() # 将所有的值返回
items() # 一对一对的返回
pop(key) # 通过key删除对应键值对
popitem() # 安装 LIFO (last-in, first-out) order 删除键值对
遍历方法：
1、
for key in p:
print(key, p[key])
2、
for key in p.keys():
print(key , p.get(key))
3、
for (key, value) in p.items():
print(key, value)
for t in p.items():
print(t[0], t[1])
容器部分学习结束……
———————————————分割线———————————————
二、排序查找算法
在线性表里存储了许多数据，需要对其实现查找和排序功能
主要学习掌握了三大主流排序查找算法：冒泡排序、选择排序、插入排序
1、冒泡排序：
思想：
冒泡排序是按顺序一个一个往前冒的过程，所以形象的称为冒泡，
给定一组数据，有升序和降序两种排序方法，这里假定升序排列。
在这组数据中，从第一个元素开始，每个元素和他后面紧挨的元素两两比较，在每一次两两比较的过程中：
（1）如果前面的数小于后面的数，说明这两个数的相对顺序正确，故不需进行操作
（2）如果前面的数大于后面的数，则交换这两个数的位置
然后开始下一次两两比较，即第二个元素和第三个元素的比较。
以此类推直至倒数第二个数与最后一个数比较完成，称为一轮比较结束。
然后开启下一轮的比较，直至所有数据按正确顺序排列，结束比较。
降序排列思想一样，就是大于和小于的判决条件调换一下即可
代码实现：
#冒泡排序
ls = [1,3,2,4,5,9,8,6]
for i in range(len(ls)):
for j in range(len(ls)-1-i):
if ls[j] > ls[j+1]:
ls[j], ls[j+1]= ls[j+1],ls[j]
print(ls)
结果：
2、选择排序
思想：
选择排序就是挑选后再比较的过程
还是给定一组数据，有升序和降序两种排序方法，这里假定升序排列。
在这组数列中，我们假定第一个元素就是最小的那一个，然后在第二个元素到最后一个元素中间选择出他们里面最小的数，然后与第一个数进行比较。称为一轮比较，在这轮比较中：
（1）如果第一个数小于后面所有数中最小的那个，则第一个数就是所有数中最小的数，我们便设第二个数为最小的。此轮比较结束。
（2）如果第一个数大于后面所有数中最小的那个，则第一个数不是所有数中最小的数，后面挑选出来的才是。所以我们调换两个数的位置。此时最小的数就是调换后的第一个元素。我们再设第二个元素为最小的数。此轮比较结束。
每轮结束后，我们都假设第二个元素为除第一个真正最小的元素之外剩下元素最小的那个，然后在剩下的元素中开始第二轮比较。直至所有元素正确排列。
代码实现：
#选择排序
ls = [1,3,2,4,5,11,9,8,6,7]
for i in range(len(ls)-1):
min = i
for j in range(i+1 , len(ls)):
if ls[j] < ls[min]:
min = j
if i != min :
ls[i], ls[min] = ls[min], ls[i]
print(ls)
结果：
3、插入排序
思想：
插入排序，即将元素插进有序列表的相应位置上，很像插队。
还是给定一组数据，有升序和降序两种排序方法，这里假定升序排列。
在这组数据中，假定第一个数是有序的，有点抽象，其实就是假定前面一直有一个有序的数列，然后从第二个元素开始，将每个元素插进这个有序数列对应的位置上。举个例子：
假定前面的第一个数是有序的，我们让第二个数与第一个数比较，如果第二个大于第一个，则将第二个元素“插”到第一个元素后面，如果小于则“插”到第一个元素前面。目的是让第一个元素和第二个元素一起构成一个“新的有序数列”，此为第一轮比较。
往后的比较中，都是一个不断往前面的有序数列里插队的过程。比如第三个插进队伍之后，就与前两个元素又组成一个新的有序数列，然后进行下一轮循环。由此我们发现，每轮循环结束后前面都会有“新的”有序数列产生，而后面需要插队的元素也越来越少，直至所有元素插队完毕排序就结束了。
代码实现
#插入排序
ls = [1,3,2,4,5,11,9,8,6,7]
for i in range(len(ls)):
value = ls[i]
j = i-1
while j >= 0:
if ls[j] > value:
#ls[j],ls[i] = ls[i],ls[j]
ls[j+1] = ls[j]
else:
break
j -= 1
ls[j+1] = value
print(ls)
结果：
———————————————分割线———————————————
三、函数
1、 概念
函数就是一种行为，一种过程，是一种功能，一个动作。
2、命名规范：
与变量命名规范相同，不对赘述
3、定义方法：
def 函数名称([参数列表]):
# 函数体
# [return 返回值]
eg：
def id_info(name,age,address):
print("我叫{}".format(name))
print(f'我今年{age}岁了')
print("我家在%s"%address)
id_info("zzy",21,"xian")
结果：
4、分类
函数按如下标准进行分类：
（1）有无返回值：分为有返回值和无返回值函数
（2）有无参数：分为有参数和无参数的函数
（3）函数定义者：分为系统函数、第三方定义函数和自定义函数
5、全局变量和局部变量：
全局变量：
即在整个代码都可以调用的变量，直接定义在py模块。
局部变量：
即定义在函数体内部的变量，只能在函数内部调用。
注：全局变量可以在函数体内访问，但如需修改则应在函数体内部用global关键字声明该变量后再修改。
目前已经学习的全局函数有：
int(), str(), float(), print(), input(), type(), range(), list(), tuple(), set(), dict(), len(), help(), dir()
6、函数调用本质
函数调用本质上是一个压栈和弹栈的过程。
函数是写在堆空间的，如需调用则会进行压栈过程。然后函数执行结束系统会释放这部分内存空间，即弹栈过程。
7、引用传递和值传递
引用传递：传递的本质是地址、是对象、是引用
值传递：本质就是传递值
8、函数的参数
分为默认值参数、可变参数和命名参数。
默认值参数，即代码运行中大多数情况下固定不变的参数。运行过程中如果不传这个参数，就按设置的默认值运行，如果传了就按传入的参数运行。
可变参数就是可能有很多也可能没有的参数，将其设置为可变参数，如果没有则不影响代码正常运行，如果有这些参数则传进函数体。习惯性用*args命名。默认以元组进行封装。
这里进行一些函数调用的练习：
（1）求10000内能被5和6整除但不能被这两个同时整除的数
ls = []
def find_zhengchu(n):
global ls
for i in range(n):
if i % 5 == 0 or i % 6 == 0 :
ls.append(i)
for i in ls:
if i % 30 == 0:
ls.remove(i)
#如果写双函数调用，则第二个函数写法为
def fn(n):
n(10000)
for i in ls:
if i % 30 == 0:
ls.remove(i)
#调用语句为：
# fn(find_zhengchu)
find_zhengchu(10000)
print(ls)
结果：
（2）计算列表偶数下标元素的和
ls = [1,3,5,7,9,-11,22,16]
l=[]
def sum_oushu(n):
for i in range(len(n)):
if i % 2 == 0:
l.append(ls[i])
return sum(l)
sum_oushu(ls)
print (l)
print(sum_oushu(ls))
（3）#判断素数：
def pandaun_sushu(n):
if n == 1 or n == 2 or n == 3:
print("是素数")
else:
for i in range (2,n):
if n % i == 0 :
print("不是素数")
break
else:
print("是素数")
pandaun_sushu(int(input("请输入一个数")))
9、函数递归
递归过程及函数自己调用自己的过程。但调用过程不会自动停止，需要设置终止条件，否则会死循环栈溢出。
举个栗子：
如果计算一个数的阶乘，一般来说可以通过简单的for循环来实现，即：
def add(n):
k = 1
for i in range(1,n):
k *= i
return k
print(add(10))
结果为：
现在我们使用递归方法去写：
def add(n):
if n == 0:
return 1
return n * add(n-1)
print(add(10))
结果：
我们再用递归去求解一些问题：
比如斐波那契数列的求解：
斐波那契数列即从第三个数开始每个数是前两个数的和
我们先使用循环写法实现此功能：
代码如下：
#斐波那契的循环写法
ls = []
for i in range(10):
if i == 0 or i == 1:
ls.append(1)
else:
a = ls[i-1] + ls[i-2]
ls.append(a)
print(ls)
结果：
然后我们使用递归方法去求解斐波那契模型的题：
比如：上n阶楼梯，一次只能上一阶或者俩阶，求有几种方法
#:斐波那契数列之上楼梯
def fbnq(n):
if n ==1 :
return 1
elif n == 2:
return 2
else:
return fbnq(n-1) + fbnq(n-2)
print(fbnq(4))
四、字符串部分
……明早继续，阿姨催着熄灯先写到这hhhh
358
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
