signed

QiShunwang

“诚信为本、客户至上”

Python学习整理(之二)

2021/3/20 23:52:07   来源:

Python学习整理(之二)

循环,列表,字典,元组

  • Python学习整理(之二)
    • 一.循环结构
      • 1.while循环
      • 2.range()函数
      • 3.for in循环
      • 4.continue和break
    • 二.列表
      • 1.列表的创建
      • 2.列表的增删改
        • 列表的增加
        • 切片
        • 修改
        • 删除
      • 3.排序
      • 4.查询
      • 5.判断和遍历
      • 6.快速生成
    • 三.字典
      • 1.创建
      • 2.获取
      • 3.增删改
      • 3.获取字典的视图
      • 4.遍历
      • 5.快速生成
    • 四.元组
      • 1.创建
      • 2.遍历
      • 3.注意事项

一.循环结构

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

在多个程序进行对数据的访问时,如果数据发生改变,就会导致程序出现问题,所以这时候选择元组,进行操作,元组只能进行引用,但是不能修改