liuliuya's blog
0%

for循环与序列结构

发表于 更新于 分类于

python的第四节课笔记（基础入门）

for循环：

for循环语法结构：

1
2
for 循环变量 in 序列:
    循环体里面要执行的代码块

注意：

  • 循环次数：由序列长度决定
  • 循环内容：由循环体里面的具体代码决定

查看序列长度的函数：

语法 解释
len(序列) 查看序列长度 
1
2
str2 = "xieqian cecb470"
print(len(str2))   #15

当循环序列为字符串时：

1
2
3
str1 = "hi class15"
for i in str1:
print("KaiChao")  # 打印了10遍KaiChao

注意：

  • KaiChao被打印了10遍—-str1的长度刚好为10
  • 循环次数与序列（可迭代对象)长度一致
  • i 是循环变量（既然是变量，只要符合命名规则可以随意更改）

当循环序列为可迭代对象时：

for 循环 遍历的必须是一个可迭代对象，在Python的六大基础数据类型当中，表现为序列结构 字符串 ，列表， 元组。

数值？—>不是序列结构,不是可迭代对象
解决：有没有数值的可迭代对象？—–> range()函数

注意：

  • range()函数 左闭右开区间，结束位要+1
  • range(n,m) 就可以生成 n ~ m 之间的正数可迭代对象
  • range(起始,结束,步长)
需求：打印1 ~10， 不用while循环
1
2
3
num = range(1, 11)
for i in num:
    print(i)  # 能够取到10
需求：生成 1~100的偶数---->2的倍数--->能够被2整除
1
2
3
4
5
#法一
for i in range(1, 101):
    # 判断是否为偶数，判断余数是否为0
    if i % 2 == 0:   # i % 2 取余，如果余数是0，就说明能够整除
        print(i)
1
2
3
4
#法二
for i in range(2,101, 2):
    #如果从1开始，则生成 1~100的奇数
    print(i)

for 嵌套：

首先执行外层循环第一遍，内层循环结束，开始外层循环第二遍。
需求：按每月4周，每周7天打印日历表

用while循环实现：

1
2
3
4
5
6
7
week = 1  # 初始化周数
while week <= 4:
    day = 1  # 初始化天数
    while day <= 7:
        print(f"第{week}周,第{day}天")
        day += 1  # 自增条件
    week += 1  # week = week + 1

用for循环实现：

1
2
3
for week in range(1, 5):  # 确定week的循环范围---外层
    for day in range(1, 8):  # 确定day的范围---内层
        print(f"第{week}周,第{day}天")

列表 ：

语法结构：

变量名 = [值一，值二，.....]

cls15 = [“Guf”, “dy”, “sj”, [“lh”, “Gaof”], 18]

1
2
3
4
5
6
a = ["lh", "Gaof"]  # 一个整体
cls14 = ["Guf", "dy", "sj", a, 18]
cls15 = ["Guf", "dy", "sj", ["lh", "Gaof"], 18]
print(type(cls15))  # list
print(len(cls14))  # 5
print(len(cls15))  # 5

注意：

  • 列表也叫 list
  • 使用中括号进行包裹，元素与元素之间使用逗号进行隔开
  • 列表里面的值（元素）,可以是任意的数据类型
  • 列表里面的列表或者元组、字典、集合，都要看成一个整体

强制转换：字符串—>列表

语法 解释
list(序列) 会将序列里面的每一个元素都进行拆分 
1
2
3
list2 = list("suntao")
print(type(list2))
print(list2)

运行结果为：

列表索引 ：

与字符串规则一致
1
2
3
4
5
6
7
cls15 = ["Guf", "dy", "sj", ["lh", "Gaof"], 18]
print(cls15[0])    #Guf
print(cls15[-1])    #18
print(cls15[2: 5])    #['sj', ['lh', 'Gaof'], 18]
li = cls15[3]
print(li[1])      #Gaof
print(cls15[3][0])  # 首先取出列表组合，然后再从列表组合里面用索引取值,lh

列表的增加：

语法 解释
list.append(元素) 在列表末尾添加元素
list.insert(索引,元素) 指定位置添加
list.extent(序列) 添加多个 
1
2
3
4
cls15 = ["晓军董事", "落落经理", "大侠人事", "达龙搬砖人"]
cls15.append("韩摸鱼")
cls15.append("咯摸鱼")
print(cls15)     #['晓军董事', '落落经理', '大侠人事', '达龙搬砖人', '韩摸鱼', '咯摸鱼']
1
2
3
4
cls15 = ["晓军董事", "落落经理", "大侠人事", "达龙搬砖人"]
# 董事长后面加一个秘书
cls15.insert(1, "搞钱小秘书")
print(cls15)       #['晓军董事', '搞钱小秘书', '落落经理', '大侠人事', '达龙搬砖人']
1
2
3
4
5
6
7
cls15 = ["晓军董事", "落落经理", "大侠人事", "达龙搬砖人"]
# 招进来一批员工
li2 = ["周密", "永强", "熠钟", "文豪"]
cls15.extend(li2)  # 可以添加多个，熠个体形式加人
cls15.append(li2)  # 只能添加一个，所以是整个列表
print(cls15)
#['晓军董事', '落落经理', '大侠人事', '达龙搬砖人', '周密', '永强', '熠钟', '文豪', ['周密', '永强', '熠钟', '文豪']]

列表查找：

语法 解释
”元素1“ in 列表名 判断是否在序列里面
”元素1“ not in 列表名 判断是否不在序列里面 
1
2
3
4
big_cls15 =['晓军董事', '搞钱小秘书', '落落经理', '大侠人事', '达龙搬砖人', '韩摸鱼', '咯摸鱼', '周密', '永强', '熠钟', '文豪']
print("晓军" in big_cls15)  # False
print("晓军董事" in big_cls15)  # True
print("王老五" in big_cls15)  # False

列表的修改：

思路：修改需要先找到再修改，查找这个动作通过索引，修改这个动作通过变量名重复，新值覆盖旧值
语法： list[索引] = 新值 
1
2
3
4
5
big_cls15 =['晓军董事', '搞钱小秘书', '落落经理', '大侠人事', '达龙搬砖人', '韩摸鱼', '咯摸鱼', '周密', '永强', '熠钟', '文豪']
#将晓军董事更换为 晓军董事长
xj = big_cls15[0]
xj = "晓军董事长"
print(xj)

或者：

1
2
3
4
big_cls15 =['晓军董事', '搞钱小秘书', '落落经理', '大侠人事', '达龙搬砖人', '韩摸鱼', '咯摸鱼', '周密', '永强', '熠钟', '文豪']
# 结合使用：一步到位
big_cls15[0] = "晓军董事长"
print(big_cls15)

列表的删除：

语法 解释
list.pop() 默认删除最后一位
list.pop(索引) 指定索引删除
list.remove() 指定元素删除
list.clear() 清空列表里面的元素，列表存在
del list 删除列表对象,列表不存在 
1
2
3
4
big_cls15 =['晓军董事长', '搞钱小秘书', '落落经理', '大侠人事', '达龙搬砖人', '韩摸鱼', '咯摸鱼', '周密', '永强', '熠钟', '文豪']
big_cls15.pop()   
#['晓军董事长', '搞钱小秘书', '落落经理', '大侠人事', '达龙搬砖人', '韩摸鱼', '咯摸鱼', '周密', '永强', '熠钟'] 
print(big_cls15)
1
2
3
big_cls15 =['晓军董事长', '搞钱小秘书', '落落经理', '大侠人事', '达龙搬砖人', '韩摸鱼', '咯摸鱼', '周密', '永强', '熠钟', '文豪']
big_cls15.pop(-2)  # 指定删除倒数第二个
print(big_cls15)
1
2
3
big_cls15 =['晓军董事长', '搞钱小秘书', '落落经理', '大侠人事', '达龙搬砖人', '韩摸鱼', '咯摸鱼', '周密', '永强', '熠钟', '文豪']
big_cls15.remove("韩摸鱼")   #['晓军董事长', '搞钱小秘书', '落落经理', '大侠人事', '达龙搬砖人', '咯摸鱼', '周密', '永强', '熠钟', '文豪']
print(big_cls15)
1
2
3
big_cls15 =['晓军董事长', '搞钱小秘书', '落落经理', '大侠人事', '达龙搬砖人', '韩摸鱼', '咯摸鱼', '周密', '永强', '熠钟', '文豪']
big_cls15.clear()    #[]
print(big_cls15)
1
2
3
big_cls15 =['晓军董事长', '搞钱小秘书', '落落经理', '大侠人事', '达龙搬砖人', '韩摸鱼', '咯摸鱼', '周密', '永强', '熠钟', '文豪']
del big_cls15
print(big_cls15)   #报错，name 'big_cls15' is not defined

列表推导式：

[要添加到列表里面的元素 for 循环变量 in 可迭代对象 if 条件]
1
2
3
4
li = []
for i in range(1, 10):
    li.append(i)
print(li)    #[1, 2, 3, 4, 5, 6, 7, 8, 9]
1
2
3
#[要添加到列表里面的元素  for  循环变量  in  可迭代对象  if  条件]
li2 = [i for i in range(1, 10) if i % 2 == 1]
print(li2)    #[1, 3, 5, 7, 9]

其他方法：

语法 解释
count(元素) 计算元素个数
reverse() 将列表反向并没有反序的功能
sort() 对列表中元素进行排序，默认就是顺序 
1
2
3
4
li4 = [60, 70, 80, 90, 100, 60, 60, 80, 80]
print(li4.count(60))  #3
print(li4.count(70))   #1
print(li4.count(80))    #3
1
2
3
4
#li4 = [60, 70, 80, 90, 100, 60, 60, 80, 80]
li4 = ['晓军董事', '搞钱小秘书', '落落经理', '大侠人事', '达龙搬砖人']
print(li4.reverse())  # None  他是在原来的基础上进行反向输出
print(li4)  #需要打印的是原来的列表

运行结果为：

1
2
3
4
li4 = [60, 70, 80, 90, 100, 60, 60, 80, 80]
#li4 = ['晓军董事', '搞钱小秘书', '落落经理', '大侠人事', '达龙搬砖人']  #好像只能排数字
print(li4.sort())  # None 他是在原来的基础上进行排序（顺序）
print(li4)    #需要打印的是原来的列表

运行结果为：

1
2
3
4
li4 = [60, 70, 80, 90, 100, 60, 60, 80, 80]
#li4.sort(reverse=True)  # 逆序，[100, 90, 80, 80, 80, 70, 60, 60, 60]
li4.sort(reverse=False)  # 顺序,默认就是False顺序，[60, 60, 60, 70, 80, 80, 80, 90, 100]
print(li4)

元组 :

语法结构：

变量名 = (值一，值二，.....)

tu = (1, 2, 3, 4)

1
2
3
4
5
6
7
tu = (1, 2, 3, 4)
print(type(tu))    #<class 'tuple'>

li = [1, 2, 3, 4]
li1 = tuple(li)
print(li1)    #(1, 2, 3, 4)
print(type(li1))    #<class 'tuple'>

注意：

  • 元组也叫 tuple
  • 元组：类似列表，不同之处在于元组的元素不可修改，元组使用小括号包含元素
  • 元组叫不可变的序列结构，或者说叫不可变的列表
  • 强制转换：字符串—>列表与字符串—>元组，唯一的区别就是[]变成了()
  • 单个元素一定要加上逗号
1
2
3
4
tu1 = ("Y")
print(type(tu1))   #<class 'str'>
tu2 = ()
print(type(tu2))    #<class 'tuple'>
1
2
3
4
tu1 = ("Y",)  # 单个元素使用逗号声明类型
print(type(tu1))   #<class 'tuple'>
tu2 = tuple()
print(type(tu2))    #<class 'tuple'>

元组拆包:

拆包：元组可以同时赋值给多个变量，只要变量个数不超过元组长度，变量前面加上* 号则可以将多于元素都接受，并返回一个列表 
1
2
3
tu = (1, 2, 3, 4, 5, 6)
a, b, c = tu
print(a, b, c)  #元组的变量与元素的数目不一致会报错，需要*号解决
1
2
3
4
5
6
7
8
9
10
11
tu = (1, 2, 3, 4, 5, 6)
#  3个变量, 会多出3个元素
# 按顺序拿去，发现会多三个，那么有*的拿4个
a, b, *c = tu  #
print(a, b, c)    #1 2 [3, 4, 5, 6]

a, *b, c = tu
print(a, b, c)    #1 [2, 3, 4, 5] 6

*a, b, c = tu
print(a, b, c)     #[1, 2, 3, 4] 5 6