Python学习整理（之二）

最新推荐文章于 2024-11-16 19:19:32 发布

耐心K

最新推荐文章于 2024-11-16 19:19:32 发布

阅读量178

点赞数 1

分类专栏：笔记文章标签： python

本文链接：https://blog.csdn.net/H24568/article/details/115035699

版权

笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

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