Python学习整理（之二）
循环，列表，字典，元组
一.循环结构
1.while循环
在符合条件的情况下进行循环，否则就退出循环
pk=0
# 初始化参数
a=1
while a<=100:
# 判断a是否在100以内
if a%2==0:
# 判断a是否为偶数
pk+=a
# 对a进行累加
a+=1
# 改变参数值使其可以遍历1-100中间的整数
print(pk)
# 输出结果
'''
这就是1-100的偶数之和
'''
在使用while循环的时候要注意一定要循环体的末尾进行条件参数的改变，否则会陷入死循环
2.range（）函数
在我学习for in循环前先进行了range函数的学习，range函数能使我这样的初学者更好的理解for in循环。
rang函数的作用为从0开始生成一个序列（类似于c中的一维数组）
生成一个range函数有三种方式，第一种：
range（stop）只有一个参数，生成一个从0开始步长为1的序列
g=range(5)
# 默认从0开始，步长为1
print(g)
# 生成结果为range（0，5）这里的返回值为迭代器对象
print(list(g))
# 生成结果为[0,1,2,3,4] 这是一个列表
我们无法直接将range函数的结果直接输出，但是可以通过使用list函数将range函数的运算结果输出
第二种方式：
range（start，stop）默认step为1
print(list(range(1,10)))
# 从1开始步长为1，到9结束
# 输出结果为[1,2,3,4,5,6,7,8,9]
第三种方式range(start,stop,step)
print(list(range(1,10,2)))
# 输出结果为[1,3,5,7,9]
print(10 in range(1,10,2))
# 运行结果为False说明10并不在这个序列中
其实三种方式归根结底是一种方法，只是前两种方式可以省略一些步骤，使用默认值输出
3.for in循环
Python里的for in循环有点类似c里面的for循环，使用格式为
for 自变量 in 可迭代对象
直接看代码会比较直观
sum=0
for i in range(101):
if i%2==0:
sum+=i
i+=1
print(sum)
上面计算了1-100的偶数之和，in后面一定要是可迭代对象，像列表，元组，字符串之类的，详细的可以去看看这个博主博客[可迭代对象是啥]，个人感觉讲的还是蛮清楚地
4.continue和break
说道循环结构，就绕不开continue和break这两个控制循环的关键字，这两一般配合if的分支结构来使用，continue是当程序执行到continue时是跳到循环开始的时候继续执行程序
# 输出1-50之间所有5的倍数
for item in range(1,51):
if item %5!=0:
continue
else:
print(item)
break作用和continue的作用相反，brake是执行到break时跳出循环
"""
输入三次密码，正确的话结束，不正确继续输入直到输完3次结束
"""
for item in range(3):
# 最多输入三次
pwd=input('请输入密码：')
if pwd=="45681":
print('密码正确')
break
else:
print('密码错误')
else:
print('对不起，由于密码输入错误过多，该账户已被锁定')
"""
下面是使用while语句进行实现
"""
a=0
while a<3:
pwd=input('请输入密码：')
if pwd == "45681":
print('密码正确')
break
else:
print('密码错误')
a+=1# 这个不加的话a就一直是0然后整体死循环
else:
print('对不起，由于密码输入错误过多，该账户已被锁定')
简而言之，break和continue的作用对象是在其所对应那一层的循环，break跳出，continue从头再来
在学完循环后常规练习99乘法表
for i in range(1,10):
# 外层循环控制行数
for j in range(1,i+1):
# 内层循环控制列数
print(j,"*",i,"=",j*i,end="\t")
print("")
还有空心矩形
# 接下来试一试空心矩形7*10
for i in range(7):
for j in range(10):
if 0<i<6:
if j==0 or j==9:
print("*",end=" ")
else:
print(" ",end=" ")
else:
print("*",end=" ")
print("\n")
在这里学到的东西是end=，这个关键字的意思是，在执行完print函数后，不进行换行操作，打印它“=”后面的参数
二.列表
个人将列表理解成了类似C语言里面一维数组，与C语言不同的是，这里的列表存储的数据集类型不仅仅是同一种类型的参数，它的原理是存储各个参数的id，因此可以存储不同类型的参数
1.列表的创建
列表的创建方式有两种：
第一种使用[ ]直接赋值
lst=['hello',132,'world']
创建列表的第二种方式，使用内置函数list( )
lst2=list(['hello','world',998])
在这里学到的是赋值运算的本质是将id值赋予对象，在调用参数的时候大体上是通过形参里存储的id找到实参，再参与运算
2.列表的增删改
列表的增加
lst=['add',33.6,'item',454,77,False]
print('修改前的列表id：',id(lst))
"""
列表元素的增加操作
"""
# append()在列表末尾增加一个元素
lst.append('sg553')
print(lst)
print('第一次修改后的列表id：',id(lst))# 运行结果和初始的id一样并没有发生改变
# extend（）在末尾增加至少一个元素（可以增加多个元素）
lit2=['ssd','ssd',556]
lst.extend(lit2)# 将lit2的元素添加到lit2的末尾
print(lst)
# inset（）在列表的任意位置增加一个元素
lst.insert(1,5)# 在索引为1的位置插入一个整数5
print(lst)
# 切片，在列表的任意位置增加至少一个元素
lst2=[55,66,44]
lst[2:]=lst2# 这里的意思是将索引2后面的元素全切掉然后将lst2的元素替换进去
上面讲到了列表里的一个关键的点—切片，切片顾名思义就是将列表里面的一段参数切出来进行操作
切片
切片格式：
列表名[start:stop:step]
start默认值为0，step默认值为1，stop不赋值的话就默认直接切到末尾，这里是step为 正的情况
如果step为负，就从列表的最后一个元素开始开始，到列表的第一个元素结束
切片范围为[),取左不取右
lst2=[22,33,55,'python','cpp','java']
print(id(lst))# 输出切片前的列表对象的ID
print(lst2[1:5:1])# 输出结果为[33，55，‘python’，‘java’]
print(id(lst2[1:5:1]))# 输出切片后的id
经过对比后发现切片操作完成之后，列表的id发生改变，这就说明了切片操作的实质是生成一个新的列表对象，将指定的元素id给到新生成的对象中去
print(lst2[::-2])# 这里的输出结果为['java','python',33]
里可以用这种方法进行逆序输出
修改
代码看的更直观
lst=[77,55,88,66,44,11,2,'sst',True]
# 一次修改一个值
lst[1]='555'
print(lst)
# 一次修改多个值需要用到切片操作
lst[2:5:]=[44,66]
print(lst)
删除
lst=[10,20,11,22,11,'assd','kt']
lst.remove(11)
# 移除列表中的一个元素，如果有重复的元素，默认删除第一个
print(lst)
lst.pop(2)
# 移除索引为2的元素，如果pop（）值为空的话默认删除最后一个元素
print(lst)
上面是进行单参数的修改，如果进行多元素的修改需要进行切片操作
'''删除指定位置的元素'''
lst[1:4:1]=[]# 将切片部分的值替换成空元素
print(lst)
清空元素clear
lst.clear()
print(lst)
删除列表
del lst
print(lst)
# 这里由于lst列表被删除所以报错
3.排序
既然有了列表那么肯定会有排序的需求，在C语言里面我个人喜欢用冒泡法对一个数组里的元素进行排序，在Python里面排序好像还挺方便的，使用 列表名.sort() 就可以对列表进行升序排列
lst=[100,55,46,87,44,66,55,22]
lst.sort()
print(lst)# 默认升序排列
lst.sort(reverse=True)# 降序排列
print(lst)
还有一种使用内置函数sorted（）进行排序
print('---------------使用内置函数进行升序序排列----------------')
lst2=[10,55,2,4,66,89]
print('排序前的id：',id(lst2))
lst3=sorted(lst2)
print(lst3)
print('排序后的id：',id(lst3))
在这里我产生了一个大胆的想法，这里是因为将排序后的结果赋值给了另一个变量，如果赋值给自己是不是不会变呢？
于是
lst2=sorted(lst2)
print(lst2,id(lst2))
print()
结果是
排序前的id： 2268982508544
排序后的id： 2268982508672
直接打脸，这里的id变了，应该是sorted函数生成了一个新的对象，所以变量名不变并不是代表它的id不变，此时的变量不是原来的变量
后面我就想着如果列表里面不止一种类型的参数怎么排序
lst4=[True,False,2]
lst4.sort()
print(lst4)#[False, True, 2]
在将bool值和int型参数比较时，将Ture对应int值转化为1，False值转化为0后进行比较
lst5=['2','py','4','1','gt']
lst5.sort()
print(lst5)
如果全为str类型的变量，优先进行数字的字符串比较，其他的按序输出
含有str和int类型的参数不能进行比较哦，会报错
4.查询
# 使用index方法来获取元素的索引（下标？）
lst=['hello',667,'hello']
print(lst.index('hello'))# 输出结果为0，若列表中有多个相同的元素只返回第一个的索引
# print(lst.index('kkk'))# 查找的元素不存在的话，会报错
# print(lst.index('hello',1,2))# 会报错，包括索引为1但不包括2
print(lst.index('hello',1,3))
5.判断和遍历
查找元素是否在列表对象里面使用in，not in
对列表的遍历使用for in
lst=[10,20,30,40,50,60,70,80,90,'hello','ytg']
print(10 in lst)# True
print(100 in lst)# False
print('ytg' not in lst)# False
print('--------------------遍历列表元素------------------')
for i in lst:
print(i)# 输出结果10,20,30,40,50,60,70,80,90,'hello','ytg'
6.快速生成
lst=[i*i for i in range(10)]
print(lst)# 将0-9的平方数以列表的形式输出
lst2=[j for j in range(2,11,2)]
print(lst2)
这也没啥东西，看看就行
三.字典
字典是一个可变的无序序列，与列表不一样的是，它的存储方式是以键值对的存储的，经过hash函数对键值的计算来确定键值对的位置（通过key值来确定value的位置）
1.创建
字典的创建方式有两种
第一种是使用花括号来创建
pwd={'1号':55,'2号':66,'3号':44}
print(pwd)
# {'1号': 55, '2号': 66, '3号': 44}
第二种是用内置函数dict（）创建
xiaoming=dict(name='ming',age=16,occupation='student')
print(xiaoming)
# {'name': 'ming', 'age': 16, 'occupation': 'student'}
print(type(xiaoming))
# <class 'dict'>
空字典
d={}
print(d)
2.获取
字典元素的获取使用[key]和get()函数
# []通过键来获取值
print(pwd['1号'])
# 55,若果给定的key不存在，会抛出error
print(pwd.get('1号'))
# 55，如果给定的key不存在不会报错会返回none
# 可以设置初始的value值来修改返回值
print(pwd.get('4号',777)
)# 当查找的key不存在时输出指定value
3.增删改
字典的删除操作使用 del 字典名[‘key’]
pwd={'ex':100,'es':520,'ct':10}
print('删除前：',pwd)
# 删除前： {'ex': 100, 'es': 520, 'ct': 10}
del pwd['es']# 方括号
print('删除后：',pwd)
# 删除后： {'ex': 100, 'ct': 10}
字典清空
pwd.clear()
字典的新增
pwd['cs']=55
# 同时可以用于key的value值的修改
print('增加后',pwd)
3.获取字典的视图
lay={'1':12,'2':13,'3':14,'4':15,'5':16}
print(lay.keys())# 获取字典里所有的键
print(lay.values())# 获取字典里全部的值
print(lay.items())# 获取字典里所有的键值对,输出形式为元组
4.遍历
字典的遍历使用for in循环
lay={'1':12,'2':13,'3':14,'4':15,'5':16}
for item in lay:
print(item,end='\t')# 默认输出key
print(lay[item],end='\t')# 输出value
print(lay.get(item))# 或者可以使用get方法获取value
总结：
- 字典中的元素是无序的，key为不可变对象，int和str类型参数都是不可变对象
- key不能重复，如果重复会出现值覆盖的情况，value会产生覆盖
- 字典的内存空间是动态的，会根据需求去分配内存空间，它的效率提升是通过增加内存来实现的
5.快速生成
先定义两个列表一个作为key，一个作为value，这两个列表的元素个数一定要一样
item=['ft','fk','fi','fj']
cpt=[15,16,18,147]
然后使用zip一一对应打包成元组
zip(item,cpt)
接着使用for in循环
cpk={item.upper():cpt for item,cpt in zip(item,cpt)}
print(cpk)
结果：{‘FT’: 15, ‘FK’: 16, ‘FI’: 18, ‘FJ’: 147}
upper（）将字母转化为大写
lower（）将字母转化为小写
四.元组
元组和字符串一样属于不可变的序列（在不改变id的情况下不能进行增删改的操作），列表，字典，是可变序列可以进行增删改的操作
1.创建
元组的创建方式有两种，第一种，直接进行小括号的操作
t=('temp',55,'hello')# 这里的小括号可以省略
第二种使用内置函数tuple（）赋值,这个函数可以进行数据类型的强制转换
f=tuple(('temp',56,22))
在定义只有一个元素的远足的时候需要加逗号和小括号
e=(12,)
2.遍历
元组是可迭代对象可以使用for in进行输出
h1=[11,22,33]
s1=(55,h1,'dlc')
for item in s1:
print(item)
或者通过索引一个一个输出
h1=[11,22,33]
s1=(55,h1,'dlc')
print(s1[0])
print(s1[1])
print(s1[2])
3.注意事项
元组存储的是对象的的引用，元组中对象的引用是无法改变的，但是如果引用所指向的的对象是可变的那么该对象是可变的
h1=[11,22,33]
s1=(55,h1,'dlc')
print('修改前',s1,id(s1))
# 运行结果 修改前 (55, [11, 22, 33], 'dlc') 2291777599232
# 这里是s1中的55，h1，dlc不变，但是可变列表h1可以进行增删改的操作
h1.extend('hello')
print('修改后:',id(s1))
# 运行结果 修改后: (55, [11, 22, 33, 'h', 'e', 'l', 'l', 'o'], 'dlc') 2291777599232
在多个程序进行对数据的访问时，如果数据发生改变，就会导致程序出现问题，所以这时候选择元组，进行操作，元组只能进行引用，但是不能修改
最后博主是纯小白，如果有啥写的不对的地方欢迎指正