Python学习笔记02

判断语句

if 语句: 单分支

a = 10
b = 20
if a < b:
    print("a < b")

语法:

if 条件判断:

​ 输出的内容

if - else 语句: 双分支

a = 10
b = 20
if a < b:
    print("a < b")
else:
    print("a > b")

语法:

if 条件判断:

​ 输出的内容

else:

​ 输出的内容

if - elif - else 语句: 多分支

num = int(input("请输入成绩："))
if num == 100:
    print("恭喜满分！")
elif 80 <= num < 100:
    print("恭喜优秀！")
elif 60 <= num < 80:
    print("恭喜及格！")
else:
    print("不及格！")

语法:

if 条件判断:

​ 输出的内容

elif:

​ 输出的内容

else:

​ 输出的内容

if 嵌套: 满足前置条件的同时，还要再进行二次判断的，多层判断需求

num = input("请输入性别：")
if num == "男":
    age = int(input("请输入年龄："))
    if age >= 18:
        print(f"姓别:{num},年龄{age}岁,已成年")
    else:
        print(f"姓别:{num},年龄{age}岁,未成年")
elif num == "女":
    age = int(input("请输入年龄："))
    if age >= 18:
        print(f"姓别:{num},年龄{age}岁,已成年")
    else:
        print(f"姓别:{num},年龄{age}岁,未成年")

注意:

1. 条件判断是一个布尔值, 判断为真(True)输出内容, 判断为假(False), 则不输出或者输出else里面的内容
2. 多分支的判断是互斥且有序的, 如果满足其中一个判断要求, 就输出该判断要求里面的内容, 如果都不满足则输出else里面的内容
3. 多分支里面的else是可以省略不写的, 但是建议写上

循环语句

while 循环

语法:

​ while 条件判断:

​ 循环的内容

# 从1累加到100,最后输出结果
num = 0
a = 0
while num < 100:
    num += 1
    a += num
print(a)

注意:

1. while的条件需要得到布尔类型，True表示继续循环，False表示结束循环
2. 需要设置循环终止条件，否则将无限循环

for循环

语法:

​ for 临时变量 in 待处理数据集:

​ 循环满足条件时执行的代码

# 通过循环计算1-100之内所有的偶数有多少个
num = 0
for x in range(1, 100):
    if (x % 2) == 0:
        num += 1
print(f"1-100,不包含100本身有{num}个偶数")
print(x)

循环嵌套

# 双层while循环打印九九乘法表
a = 1
while a < 10:
    b = 1
    while b <= a:
        print(f"{a}*{b}={a*b}", end=' ')
        b = b + 1
    a += 1
    print()
    
# 双层for循环打印九九乘法表
for i in range(1, 10):
    for j in range(1, 10):
        if j <= i:
            print(f"{j}*{i}={i * j}\t", end='')
    print()

注意:

1. for循环是一种，轮询的机制，是对一批内容进行逐个处理
2. range() 函数：可以获得一个简单的数字序列
   1. range(num): 获取一个从0开始，到num结束的数字序列(不含num本身)
   2. range(num1, num2): 获取一个从num1开始，到num2结束的数字序列(不含num2本身)
   3. range(num1, num2, step)
      1. 获取一个从num1开始，到num2结束的数字序列(不含num2本身)
      2. 数字之间的步长，以step为准(step默认为：1)
   4. 循环语句也可以使用嵌套
   5. 在print语句中，加上 end= ’ ’ 即可输出不换行

循环中断关键字

break 关键字：完全终止循环

continue 关键字：跳过当前循环，直接开始下一次

for 循环演示

# 单循环
for i in range(1, 6):
    print("语句1")
    # continue
    break
    print("语句2")
# 嵌套循环
for i in range(1, 3):
    print("语句1")
    for j in range(1, 3):
        print("语句2")
        # continue
        # break
        print("语句3")
    print("语句4")

while 循环演示

a = 1
while a <= 10:
    print(a)
    # continue
    break
    a += 1

a = 1
while a <= 5:
    b = 1
    while b <= 5:
        print(a)
        # continue
        break
        b += 1
        print(b)
    a += 1

注意：在嵌套循环中，只能作用在，所在的循环，对上层循环无效

list 列表

语法：变量名称 = [元素1，元素2，元素3，…]

空列表：变量名称 = []

# 定义列表
list1 = [1, "list", 3]
# 定义空列表
list2 = []

mylist = ['神魔', '邪星', 555, '天煞', '孤星']

# 通过下标获取元素，也可以通过下标修改元素
print(mylist[2])

# 列表名.index(元素)：查询某元素的下标
print(mylist.index("天煞"))

# 列表名.insert(下标，元素)：指定下标插入元素
mylist.insert(2, "假面骑士")
print(mylist)

# 列表名.append(元素)：在列表最后追加一个元素
# 列表名.append(数据容器)：在列表最后追加一批元素
mylist.append('堕天')
print(mylist)

# del 列表[下标]：彻底删除指定下标的元素
del mylist[6]
print(mylist)

# 列表名.pop(下标)：通过把指定下标的元素从列表中取出来，进而达到删除的目的
a = mylist.pop(3)
print(a)
print(mylist)

# 列表名.remove(元素)：删除某一个元素在列表中的第一个匹配项
mylist.remove('邪星')
print(mylist)

# 列表.count(元素)：统计某个元素在元组中的数量
print(mylist.count('神魔'))

# len(列表)：统计列表内有多少个元素
print(len(mylist))

# 列表.clear()：清空列表
mylist.clear()
print(mylist)

注意：

1. Python中的数据容器是：列表，元组，字符串，集合，字典
2. 列表可以嵌套

tuple 元组

语法：变量名称 = (元素1，元素2，元素3，…)

空元组：变量名称 = ()

# 定义元组
list1 = (1, "tuple", 3)
# 定义空元组
list2 = ()

my_tuple = (1, 2, 3, 4, 5)

# 通过下标索引取出元组的元素
print(my_tuple[2])

# 元组名.index(元素) ：查询某元素的下标
print(my_tuple.index(4))

# 元组名.count(元素) ：统计某个元素在元组中的数量
print(my_tuple.count(3))

# len(元组): 统计元组内有多少个元素
print(len(my_tuple))

注意：

1. 元组里面的元素无法修改
2. 元组可以嵌套

str 字符串

# 创建一个字符串
my_str = 'Hello Word'

# 通过下标获取元素
print(my_str[0])

# 字符串名.index(元素) 方法：查询某元素的下标
print(my_str.index('W'))

# 字符串名.replace(原字符串，替换的字符串)方法：字符串的替换
# 不是修改字符串本身，而是得到一个新的字符串
new_my_str = my_str.replace('Hello', 'hello')
print(new_my_str)

# 字符串名.split()方法
# 按照指定的分割字符串，将字符串划分为多个字符串，并存入列表对象中
# 字符串本身不变，而是得到一个列表对象
list_my_srt = my_str.split(' ')
print(list_my_srt)

# 字符串的规整操作：strip方法
# 字符串.strip()：去除前后空格
# 字符串.strip(字符串)：去除前后指定的字符串
print(my_str.strip('Hd'))

# 字符串.count(元素)方法：统计字符串中某个字符出现的次数
print(my_str.count('o'))

# len(字符串): 统计字符串内有多少个元素
print(len(my_str))

注意：字符串和元组一样都是一个无法修改的数据容器

数据容器（序列）的切片

语法：序列[起始下标: 结束下标: 步长]

# 对list进行切片，从1开始，4结束，步长1
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
m_l = my_list[1:4:1]
print(m_l)

# 对tuple进行切片，从头开始，到结尾结束，步长1
my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)
m_t = my_tuple[::1]
print(m_t)

# 对str进行切片，从头开始，到最后结束，步长-1
my_str = 'hello word'
m_st = my_str[::-1]
print(m_st)

注意：

1. 序列指的是：有序的，可以使用下标索引的数据容器（列表，元组，字符串）
2. 切片指的是：从一个序列中，取出一个子序列
3. 起始下标表示：开始截取的下标位置，可以留空，留空视作从头开始截取
4. 结束下标表示：终止的下标位置，可以留空，留空视作截取到结尾
5. 步长表示：依次截取元素的间隔（每次跳过N-1个元素），步长为负数，表示反向取截取
6. 切片操作不会影响序列本身，而是会得到一个新的序列

set 集合

语法：变量名称 = {元素1，元素2，元素3，…}

空集合：变量名称 = {}

# 创建集合
my_set = {"hello", "word", "list", "tuple", "set"}

# 集合.add(元素)：将指定元素，添加到集合中
my_set.add("str")
print(my_set)

# 集合.remove(元素)：将指定元素，从集合内移除
my_set.remove("str")
print(my_set)

# 集合.pop(元素)：从集合中随机取出来一个元素，和列表pop一样，但是没有下标
print(f"取出来的元素是：{my_set.pop()}，取出来之后的集合：{my_set}")

# 集合1.difference(集合2)：取两个集合的差集
# 取出集合1与集合2的差集（集合1有的集合2没有的），得到一个新集合，原来集合不变
set1 = {1, 2, 3}
set2 = {1, 3, 6}
set3 = set1.difference(set2)
print(f"得到的新集合:{set3},原来的集合一{set1},集合二{set2}")

# 集合1.difference_update(集合2)：消除两个集合的差集
# 在集合1内，删除和集合2相同的元素，集合1被修改，集合2不变
set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 6}
set1.difference_update(set2)
print(set1)
print(set2)

# 集合1.union(集合2)：合并集合
# 将集合1和集合2组成新的集合，原集合不变
set1 = {1, 2, 3}
set2 = {1, 3, 6}
set3 = set1.union(set2)
print(set3)
print(set1)
print(set2)

# len(集合)：统计集合元素数量
print(len(my_set))

注意：集合不允许重复的，同时是一个无序的数据容器(所以不支持下标索引访问)

dict 字典

语法：变量名称 = {“key”: “value”, “key”: “value”, …}

空字典：变量名称 = dict()

# 定义字典
my_dict = {"邪星": 21, "孤星": 18, "魔星": 23}

# 字典[key] = value：新增和更新元素
my_dict["琉星"] = 20
my_dict["孤星"] = 21
print(my_dict)

# 字典名.keys()：获取全部的key值
a = my_dict.keys()
print(a)

# 字典名.pop(key)：删除元素，和列表pop一样
age = my_dict.pop("邪星")
print(my_dict)
print(age)

# 字典名.clear()：清空字典
my_dict.clear()
print(my_dict)

# len(字典)：统计字典元素数量
print(len(my_dict))

注意：

1. 字典不可以使用下标索引来获取值，通过key来检索value(键值对操作)
2. 字典的key不可以重复

数据容器的遍历

# 定义数据容器，列表，元组，字符串，集合，字典
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)

my_srt = 'hello world'

my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9}

my_dict = {'a': 1, 'b': 2, 'c': 3}

# 遍历数据容器
for i in my_list:
    print(i, end=' ')
print()

for i in my_tuple:
    print(i, end=' ')
print()

for i in my_srt:
    print(i, end=' ')
print()

for i in my_set:
    print(i, end=' ')
print()

for i in my_dict:
    print(f"字典的key是：{i}")
    print(f"字典的value是：{my_dict[i]}")

注意：

1. 列表，元组和字符串可以使用while循环和for循环遍历
2. 集合与字典只能使用for循环遍历
3. 遍历数据容器推荐for循环
4. 字典的遍历，和其他数据容器稍微有点不同

数据容器的对比

1. 是否支持下标索引
   支持：列表，元组，字符串
   不支持：集合，字典

2. 是否支持重复元素
   支持：列表，元组，字符串
   不支持：集合，字典

3. 是否可以修改
   支持：列表，集合，字典
   不支持：元组，字符串

4. 使用场景
   列表：一批数据，可修改，可重复的存储场景
   元组：一批数据，不可修改，可重复的存储场景
   字符串：一串字符的存储场景
   集合：一批数据，不可重复的存储场景
   字典：一批数据，可用key检索value的存储场景

5. 通用操作
   都支持for循环遍历
   统计容器的元素个数：len(容器)
   统计容器的最大元素：max(容器)
   统计容器的最小元素：min(容器)
   都支持类型转换（除了不能转换成字典）
   字典在列表，元组和集合的转换过程中，只保存key抛弃value

6. 通用排序功能
   sorted(容器, [reverse = True])
   通过True和False，控制容器从小到大或者从大到小的排序，默认为False
   排序的结果都变成了，列表对象