4

一、if

　　　　

1、格式

# 第一种：
if "判断条件":
    "条件成立, 执行的语句"

# 第二种：
if "判断条件":
    "条件成立, 执行的语句"
else:
    "条件不成立, 需要执行的语句"

# 第三种
if "判断条件":
    print("")
    if "判断条件":
        print("")
    else:
        print("")
elif "判断条件":
    print("")
elif "判断条件":
    print("")
else: “以上条件不成立执行”
    print("以上条件不成立执行这条")

示例1：

# 1. 定义年龄变量
age = int(input("请输入你的年龄: "))

# 2.判断是否满18岁
if age >= 18:
    # 条件成立, 条件为True时, 这个块下面的语句会被执行，块必须得是4个空格
    print("可以进入网吧嗨皮...")
else:
    # else 处理条件不满足的情况
    # 也是一个块语句，空4格
    print("你还没长大, 应该回去写作业!")
# 3. if 条不成立, 不会执行if下面的块语句, 但是程序会继续往下执行
print("这句代码会被执行吗? ")

示例2：

# 思考流程
# 1. 定义 `holiday_name` 字符串变量记录节日名称
# 2. 如果是 情人节 应该 **买玫瑰**／**看电影**
# 3. 如果是 **平安夜** 应该 **买苹果**／**吃大餐**
# 4. 如果是 **生日** 应该 **买蛋糕**
# 5. 其他的日子，只要有爱，每天都像过节……

# 定义一个变量
holiday_name = input("今天是什么节日? ")
love = "有爱"
if holiday_name == "情人节":
    print("买玫瑰花")
    if love == "有爱":
        print("去KTV唱歌")
    else:
        print("回家!")
elif holiday_name == "平安夜":
    print("买苹果")
    print("吃大餐")
elif holiday_name == "生日":
    print("买蛋糕")
else:
    print("只要有爱，每天都像过节")

print("还会继续往下执行吗?")

二、while循环

1、程序的执行顺序

一共有三种流程方式:

• 顺序 ---  从上向下，顺序执行代码
• 分支 ---- 根据条件判断，决定执行代码的分支
• 循环 ---- 让特定代码重复执行

　　　　

2、while循环

示例1：打印 5 遍 Hello Python

# 第一种方法
print("Hello Python" * 5)

# 第二种
# 第一步、定义重复次数计数器
i = 1

# 第二步、使用while判断条件
while i <= 5:
    # 如果条件为真(True), 那么会执行while下面的块语句
    print("Hello Python")
    # 第三步、 一定要修改循环条件，要不然会一直执行下去
    # i = i + 1
    i += 1

print("循环结束后的 i = {}".format(i))

示例2：计算0 ~ 100 之间所有数字的累计求和结果

# 第一步，定义计数器
i = 0
result = 0      # 最初的结果

# 第二步、使用while判断条件
while i <= 100:
    # result = i + result
    result += i
    # 第三步、 一定要修改循环条件，要不然会一直执行下去
    i += 1

示例3：计算0 ~ 100 之间所有奇数、偶数的累计求和结果

# 思路：# 对 2取余，为0则偶数；if i % 2 ！= 0  不为0则奇数；
# 根据上面三步

i = 0
result = 0
while i <= 100:
    # if i % 2 == 0:   # 偶数之和
    if i % 2 != 0:      # 奇数之和
        result += i
    i += 1
# 打印结果
print("0 ~ 100 之间偶数求和结构为: {}".format(result))

示例4：计算0 ~ 100 之间求和的时候, 遇到3, 则停止计算

• break　　（译：布瑞克）

　　一般程序遇到break，会跳出循环，while 循环结束；相当于踩刹车, 车刹踩死之后, 车就停下来了

i = 0           # 第一步，定义计数器
result = 0      # 定义最初的结果

while i <= 100:         # 第二步、使用while判断条件
    print("i = ", i)
    if i == 3:
        # 一般程序遇到break, 会跳出循环
        # 相当于踩刹车, 车刹踩死之后, 车就停下来了
        break
    result += i
    i += 1          # 第三步、 一定要修改循环条件，要不然会一直执行下去
# 打印每次的结果
print("result = ", result)

执行结果：
i =  0
i =  1
i =  2
i =  3
result =  3

示例5：计算1-100内，除5以外之和；

• continue　　# （译：抗体牛）

　　当程序遇到 continue 的时候，本次循环会停止，代码不会向下进行，while循环会继续进行

# 根据上面三步
i = 0
result = 0
while i <= 100:
    if i == 5:      # 奇数之和
        # 当程序中遇到 continue 的时候，本次循环会停止，while 循环会继续进行
        i += 1
        continue
    result += i
    i += 1
# 打印结果
print("0 ~ 100 之间偶数求和结构为: {}".format(result))
# 执行结果：5045

三、for循环

1、基础

定义：for 循环用来遍历对象，从对象的第一个元素到最后一个元素都一次访问一次

数据集合：可以是列表，元祖，字典，字符串，也可以是一个指定的数据范围

• 任意一个序列类型都支持for循环：列表，元祖，字典

one_list = ["江南", "阿登", "world"]
语法：
for 变量名 in 数据集合:
    print(变量名)

# 第一种，使用索引取值
print(one_list[0])
print(one_list[1])
print(one_list[2])

# 第二种，使用for取值
for item in one_list:
    print(item)

# 执行结果：
江南
阿登
world
江南
阿登
world

2、指定print 换行与不换行

sep 　　：指定换行符

• print 函数中 sep 默认为空格, 会打印所有数据以一个空格进行分割

end=" "　　 ：打印在一行，不换行

• end 参数为每个接下来的 print 函数打印内容的分割形式，默认为 （每一个print函数打印内容之后，会换行）

示例：

print(100, 200, 300, sep="&")
print("a", "b", end="	")
print("可优", "lemon")

执行结果：
100&200&300
a b    可优 lemon    # 打印在一行了

 

3、for 遍历字典

• 使用 for 循环来遍历(迭代)字典类型
• 遍历(迭代): 不断取值的过程

# 创建字典
one_dict = {"name": "咕咕夜", "age": 18, "sex": "不详"}

# for 循环默认迭代的是所有的key值
for i in one_dict:
    print("值为: {}	类型为: {}".format(i, type(i)))
print()

# keys:取出字典中的key
for keys in one_dict.keys():
    print("key值为: {}	类型为: {}".format(keys, type(keys)))
print()

# values:取出字典中的值
for value in one_dict.values():
    print("值为: {}	类型为: {}".format(value, type(value)))
print()

# items:同时取出key和value
for item in one_dict.items():  # 每次迭代，会返回一个元祖
    print("值为: {}	类型为: {}".format(item, type(item)))
print()

for key, value in one_dict.items():  # 每次迭代，会将元祖拆包，分别赋值给key、value
    print("key为: ", key, end='	')
    print("value为: ", value)

执行结果：

值为: name    类型为: <class 'str'>
值为: age    类型为: <class 'str'>
值为: sex    类型为: <class 'str'>

key值为: name    类型为: <class 'str'>
key值为: age    类型为: <class 'str'>
key值为: sex    类型为: <class 'str'>

值为: 咕咕夜    类型为: <class 'str'>
值为: 18    类型为: <class 'int'>
值为: 不详    类型为: <class 'str'>

值为: ('name', '咕咕夜')    类型为: <class 'tuple'>
值为: ('age', 18)    类型为: <class 'tuple'>
值为: ('sex', '不详')    类型为: <class 'tuple'>

key为:  name    value为:  咕咕夜
key为:  age    value为:  18
key为:  sex    value为:  不详

4、任何一个序列都支持拆包

• 等号左侧变量个数，要与右侧待拆包的元祖个数一致
• 相当于给变量通过一一对应进行赋值
• 如果左侧变量个数少于右侧待拆包的序列类型中元素个数时，会报错

# 元祖(tople)进行拆包
one_tuple = ("默", "七七", None)

one_var, two_var, three_var = one_tuple  # 拆包
print("值为: {}	类型为: {}".format(one_var, type(one_var)))
print("值为: {}	类型为: {}".format(two_var, type(two_var)))
print("值为: {}	类型为: {}".format(three_var, type(three_var)))

# 字符串也可以拆包
var1, var2 = "KY"

print(var1)
print(var2)

执行结果：
值为: 默    类型为: <class 'str'>
值为: 七七    类型为: <class 'str'>
值为: None    类型为: <class 'NoneType'>
K
Y

5、range  　也序列类型，支持序列类型的所有操作

作用：　

• 生成数字序列
• 跟切片的开始、结束索引类似
• 启始值能取到，但是取不到结束值（只能取到结束值前一位）
• 步长,，默认为1

# 示例：
one_var = range(10)  # 0~9
print(one_var)

# 将它转化为列表
print(list(one_var))

# 通过数字索引取值
print(one_var[-2])

# 可以使用for循环进行遍历
for i in one_var:
    print(i)

# 支持切片操作
# 步长, 默认为1,不能取到最后一位
print(list(range(50, 88, 3)))

执行结果：
range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
8
0
1
2
3
4
5
6
7
8
9
[50, 53, 56, 59, 62, 65, 68, 71, 74, 77, 80, 83, 86]

案例1：计算1-10之间的整数

result = 0
for i in range(1, 11):  # 往往可以控制循环执行的次数
    result += i

print(result)

执行结果：
55

四、while、for有什么区别

• 相同：都能进行循环
• 不同：
  • while循环：往往会在循环次数不确定的情况下使用　　
  • for 循环：如果一个循环的次数是确定的，那么就用for　　
  • 优先使用 for，性能更优，效率更高　　 

练习题：

1.求三个整数中的最大值

提示：三个整数使用input提示用户输入

first_num = int(input("请输入第一个整数："))
second_num = int(input("清输入第二个整数："))
three_num = int(input("清输入第三个整数："))
# 方法一：
if first_num >= second_num:
    max_num = first_num
else:
    max_num = second_num
if three_num >= max_num:
    max_num = three_num
print("最大的数字是：{}".format(max_num))

# 方法二：
max_num = first_num
if second_num > max_num:
    max_num = second_num
if three_num > max_num:
    max_num = three_num
print("最大的数字是：{}".format(max_num))

#方法三：
max_num = max(first_num,second_num,three_num)
print("最大的数字是：{}".format(max_num))

#方法四：
if first_num >= second_num and first_num >= three_num:
    print("最大的数字是：{}".format(first_num))
elif second_num >= three_num:
    print("最大的数字是：{}".format(second_num))
else:
    print("最大的数字是：{}".format(three_num))

2.break 和 continue的区别

• break和continue都是在循环中使用
• break：当程序碰到 break 后直接跳出最近一层循环，结束最近一层的整个循环
• continue：当程序碰到 continue 时跳过该次循环，继续下一次循环

3.判断是否为闰年

提示:

• 输入一个有效的年份（如：2019），判断是否为闰年
• 润年的判断规则，请自行“撩度娘”
• 如果是闰年，则打印“2019年是闰年”；否则打印“2019年不是闰年”

# 方法一：
year = int(input("请输入一个年份（如2020）："))
if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
    print("{}年是闰年".format(year))
else:
    print("{}年不是闰年".format(year))

# 方法二：
year = int(input("请输入一个年份（如2020）："))
if year % 4 == 0 and year % 100 != 0:
    print("{}年是闰年".format(year))
elif year % 400 == 0:
    print("{}年是闰年".format(year))
else:
    print("{}年不是闰年".format(year))

# 方法三：
year = int(input("请输入一个年份（如2020）："))
if (year % 4) == 0:
    if year % 100 != 0:
        print("{}年是闰年".format(year))
    elif year % 400 == 0:
        print("{}年是闰年".format(year))
    else:
        print("{0}年不是闰年".format(year))
else:
   print("{0}年不是闰年".format(year))

方法四：

import calendar


def leap_year():
    year_num = int(input("请输入一个年份的数字（如：2019）："))
    if calendar.isleap(year_num):
        print("您输入的年份为闰年！")
    else:
        print("您输入的年份为平年！")


leap_year()

4.编写如下程序

• a.用户输入1-7的数字，分别代表周一到周日
• b.如果输入1-5，打印对应的“周一”~“周五”，如果输入的数字是6或7，打印输出“周末”
• c.如果输入0，退出循环
• d.输入其他内容，提示“输入有误，请重新输入！”
• 提示：本题可以使用if和while循环

number_dict = {"1": "周一", "2": "周二", "3": "周三", "4": "周四", "5": "周五"}
while True:
    number = input('请输入一个1-7中的数字（输入0退出）：')
    if number.isdigit() and int(number) >= 0 and int(number) <= 7:
        if int(number) == 6 or int(number) == 7:
            weekend = '周末'
            print(weekend)
        elif int(number) >= 1 and int(number) <= 5:
            number_dict.get(number)
            print("今天是：{}".format(number_dict.get(number)))
        elif int(number) == 0:
            print("退出循环")
            break
    else:
        print('输入数字错误请重新输入')

方法二：

weekends_tuple = ("周一", "周二", "周三", "周四", "周五", "周末")


def weekend():
        while True:
            try:
                input_day = int(input("请输入一个1-7的数字："))
                if input_day in range(1, 8):
                    if input_day in range(6, 8):
                        print(weekends_tuple[-1])
                    else:
                        print(weekends_tuple[input_day-1])
                elif input_day == 0:
                    break
                else:
                    print("输入的数字已超出范围！")
                    break
            except ValueError:
                print("输入有误，请重新输入！")
weekend()

5.使用while、for打印九九乘法表

# 方法一：使用while循环
def product():
    i = 1               # 定义计数器
    while i <= 9:       # 外层循环，行号
        j = 1           # 定义计数器
        while j <= i:   # 内层循环，列号
            print("{} * {} = {}	".format(j, i, i * j), end='')
            j += 1      # 如果i > j 内层循环结束
        print()         # 打印空行
        i += 1          # 下一行打印
product()


# 方法二：使用for循环，乘法表有九行，第一行一列，二行二列。。
def product():
    for i in range(1, 10):  # 乘法表有9行
        for j in range(1, i + 1):  # 取列号
            result = i * j          # 第几列 * 第几行
            print("{} * {} = {}	".format(j, i, result), end='')
        print()  # 打印空行
product()

6、写出将列表翻转的所有方法

• 将列表[13, 20, 42, 85, 9, 45]翻转之后为[45, 9, 85, 42, 20, 13]

# 源列表：[13, 20, 42, 85, 9, 45]
# 翻转之后为：[45, 9, 85, 42, 20, 13]
src_lis = [13, 20, 42, 85, 9, 45]  # 源列表
print("源列表src_lis为：{}".format(src_lis))
len_src_lis = len(src_lis)  # 求长度6

# 方法一
new_lis = []
for i in range(len_src_lis - 1, -1, -1):
    new_lis.append(src_lis[i])
print("翻转之后的列表new_lis为：{}".format(new_lis))

# 或者
new_lis = []
for i in range(1, len_src_lis):
    new_lis.append(src_lis[-i])     # -1取最后一个
print("翻转之后的列表new_lis为：{}".format(new_lis))

# 方法二
new_lis = src_lis[::-1]
print("翻转之后的列表new_lis为：{}".format(new_lis))

# 方法三
src_lis.reverse()
print("翻转之后的列表new_lis1为：{}".format(src_lis))

# 方法四
loop_count = len_src_lis // 2
for i in range(0, loop_count):
    src_lis[i], src_lis[-i - 1] = src_lis[-i - 1], src_lis[i]
print("翻转之后的列表为：{}".format(src_lis))

5.取出列表中最大的值

• 将列表[13, 20, 42, 85, 9, 45]中最大的值为85

src_lis = [13, 20, 42, 85, 9, 45]
print("源列表src_lis为：{}".format(src_lis))
# 方法一：依次取值作比较取最大值
max_num = 0
for i in src_lis:
    if max_num < i:
        max_num = i
print("最大值为：{}".format(max_num))

# 方法二
print("最大值为：{}".format(max(src_lis)))

6.编写打印出1-100之间除了含7和7的倍数之外的所有数字

• 提示：不符合要求的部分数字为：7、14、17、21、27等等

def is_int_or_float(str_num):
    """
    判断用户输入的是否为浮点型字符串
    """
    if str_num.replace(".", "", 1).isdigit():
        return True
    else:
        return False


def display_bmi_info(bmi):
    """
    显示用户bmi信息
    """
    if bmi > 32:
        print("你的bmi为{}，严重肥胖！".format(bmi))
    elif bmi > 28:
        print("你的bmi为{}，肥胖！".format(bmi))
    elif bmi > 25:
        print("你的bmi为{}，过重！".format(bmi))
    elif bmi > 18.5:
        print("你的bmi为{}，正常！".format(bmi))
    else:
        print("你的bmi为{}，过轻！".format(bmi))


your_height = input("请输入你的身高（单位m）：")
your_weight = input("请输入你的体重（单位kg）：")
while True:
    if is_int_or_float(your_height):
        if is_int_or_float(your_weight):
            your_height = float(your_height)
            your_weight = float(your_weight)
            your_bmi = round(your_weight / your_height ** 2, 2)
            display_bmi_info(your_bmi)
            break
        else:
            print("输入的体中有误，请重新输入！：")
            your_weight = input("请输入你的体重（单位kg）：")
    else:
        print("输入的体中有误，请重新输入！：")
        your_height = input("请输入你的身高（单位m）：")

7.列表去重

将列表[10, 1, 2, 20, 10, 3, 2, 1, 15, 20, 44, 56, 3, 2, 1]去除重复元素

src_lis = [10, 1, 2, 20, 10, 3, 2, 1, 15, 20, 44, 56, 3, 2, 1]
print("源列表src_ .lis为: {}".format(src_lis))

# 方法一：
new_lis = list(set(src_lis))
print("去除重复元素后列表new_lis为: {}".format(new_lis))

# 方法二：
new_lis = []
for item in src_lis:
    if item not in new_lis:
        new_lis.append(item)
print("去除重复元素后列表new_lis为: {}".format(new_lis))

8.所有的序列类型都支持成员操作：str、list、tuple

序列类型支持哪些操作？

• 通过数字索引取值
• 支持切片操作
• len()
• 支持重复操作:序列类型 * 数字 "Keyou" * 100
• 成员运算操作 (in、not in)
• for循环遍历

总结：

 

*******请大家尊重原创，如要转载，请注明出处：转载自：https://www.cnblogs.com/shouhu/，谢谢！！*******