【Python基础】Python全栈体系（二）

Python 基础

九、语句

1. 物理行：程序员编写代码的行。
2. 逻辑行：python解释器需要执行的指令。
3. 建议一个逻辑行在一个物理行上。
4. 如果一个物理行中使用多个逻辑行，需要使用分号；隔开。
5. 如果逻辑行过长，可以使用隐式换行或显式换行。
   隐式换行：所有括号的内容换行,称为隐式换行
   括号包括: () [] {} 三种
   显式换行：通过折行符 \ (反斜杠)换行，必须放在一行的末尾，目的是告诉解释器,下一行也是本行的语句。

"""
    行
"""
# 三个物理行  三个逻辑行
a = 1
b = a + 1
c = a + b

# 一个物理行  三个逻辑行
a = 1;b = a + 1;c = a + b

# 三个物理行  一个逻辑行
a = 1+2+\
    3+\
    4+5+6

a = (1+2+
     3+4+5+6)

1. pass 语句

• 通常用来填充语法空白。

2. 选择语句

• If elif else 语句

1. 作用:
   让程序根据条件选择性的执行语句。
2. 语法:
   if 条件1:
   语句块1
   elif 条件2:
   语句块2
   else:
   语句块3
3. 说明:
   elif 子句可以有0个或多个。
   else 子句可以有0个或1个，且只能放在if语句的最后。
   

"""
    选择语句
"""
sex = input("请输入性别：")
# sex  变量 等于 "男"
if sex == "男":
    print("您好，先生！")
# 否则如果
elif sex == "女":
    print("您好，女士！")
else:
    print("性别未知")

# 调试：让程序中断，逐语句执行。
# 目的：审查程序执行流程
#      查看执行过程中变量的取值
# 步骤：
# 1. 添加断点
# 2. 调试运行Debug
# 3. F7 逐语句执行
# 4. Ctrl + F2 停止调试

"""
    在控制台中获取一个季度，打印相应的月份。
    输入与输出：
      春    1月2月3月
      夏    4月5月6月
      秋    7月8月9月
      冬    10月11月12月
"""
season = input("请输入季度：")
if season == "春":
    print("1月2月3月")
elif season == "夏":
    print("4月5月6月")
elif season == "秋":
    print("7月8月9月")
elif season == "冬":
    print("10月11月12月")

"""
    先在终端中录入一个数字
    再录入一个运算符
    最后录入一个数字
    打印计算的结果
    要求：如果运算符不是+ - * /提示“运算符输入有误”
"""
number_one = float(input("请输入第一个数字："))
operator = input("请输入运算符：")
number_two = float(input("请输入第二个数字："))
if operator == "+":
    print(number_one + number_two)
elif operator == "-":
    print(number_one - number_two)
elif operator == "*":
    print(number_one * number_two)
elif operator == "/":
    print(number_one / number_two)
else:
    print("运算符输入有误")

"""
    在终端中依次录入4个同学体重，打印最重的值。
    思路：
        假设第一个就是最大的.
        使用假设的依次与后几个变量进行比较,如果发现更大的，则替换假设的。
    输入：52、40、37、60
    输出：60
"""
number_one = float(input("请输入第一个同学体重："))
number_two = float(input("请输入第二个同学体重："))
number_three = float(input("请输入第三个同学体重："))
number_four = float(input("请输入第四个同学体重："))
max_value = number_one
if max_value < number_two:
    max_value = number_two
if max_value < number_three:
    max_value = number_three
if max_value < number_four:
    max_value = number_four
print(max_value)

"""
    在终端中录入一个成绩，判断等级。
    输入：成绩
    输出：优秀、良好、及格、不及格、成绩有误
"""
score = float(input("请输入成绩："))
# if score >= 90 and score <=100:
#     print("优秀")
# elif score >= 80 and score <= 90:
#     print("良好")
# ....
# if 90 <= score <= 100:
#     print("优秀")
# elif 80 <= score < 90:
#     print("良好")
# elif 60 <= score < 80:
#     print("及格")
# elif 0 <= score < 60:
#     print("不及格")
# else:
#     print("成绩输入有误")

if score < 0 or score > 100:
    print("成绩输入有误")
elif 90 <= score:
    print("优秀")
elif 80 <= score:
    print("良好")
elif 60 <= score:
    print("及格")
else:
    print("不及格")

"""
    在终端中录入月份，然后打印天数。
    输入：2 输出：28天
    输入：1 3 5 7 8 10 12 输出：31天
    输入：4 6 9 11 输出： 30天
"""
month = int(input("请输入月份："))
if month <1 or month >12:
    print("月份输入有误")
elif month == 2:
    print("28天")
elif month == 4 or month == 6 or month ==9 or month == 11:
    print("30天")
else:
    print("31天")

• if 语句的真值表达式

if 100:
	print("真值")
# 等同于
if bool(100):
    print("真值")

• 条件表达式
  • 语法：变量 = 结果1 if 条件 else 结果2
  • 作用：根据条件(True/False) 来决定返回结果1还是结果2。

"""
1.在终端中获取一个整数，如果是偶数为变量state赋值“偶数”,否则赋值“奇数”。
2.在终端中获取一个年份，如果是闰年为变量day赋值29,否则赋值28。
"""
# 1.
number = int(input("请输入整数："))
# if number % 2 != 0:
#     state = "奇数"
# else:
#     state = "偶数"

# if number % 2:# bool(number % 2)
#     state = "奇数"
# else:
#     state = "偶数"

state = "奇数" if number % 2 else "偶数"

# 2.
year = int(input("请输入年份："))
# if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
#     day = 29
# else:
#     day = 28

# if not year % 4 and year % 100 or not year % 400:
#     day = 29
# else:
#     day = 28

# 不建议
# day = 29 if not year % 4 and year % 100 or not year % 400 else 28

day =29 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 else 28

3. 循环语句

3.1 while语句

1. 作用:
   可以让一段代码满足条件，重复执行。
2. 语法:
   while 条件:
   满足条件执行的语句
   else:
   不满足条件执行的语句
3. 说明:
   else子句可以省略。
   在循环体内用break终止循环时,else子句不执行。

"""
    while 循环
"""
# 死循环
while True:
    number = int(input("请输入整数："))
    state = "奇数" if number % 2 else "偶数"
    print(state)
    if input("请输入exit退出：") == "exit":
        break  # 退出循环

"""
    在控制台中，获取一个开始值，一个结束值。
    将中间的数字打印出来。
    输入：3           9
    输出：  4 5 6 7 8
"""
start = int(input("请输入开始值："))  # 3
stop = int(input("请输入结束值："))  # 9

"""
# 3 --> 9
while start < stop - 1:
    start += 1
    print(start)
# 9 --> 3
while start > stop + 1:
    start -=1
    print(start)
"""
dir = 1 if start < stop else -1
while start != stop - dir:
    start += dir
    print(start)

"""
游戏运行产生一个１－－１００之间的随机数。
让玩家重复猜测，直到猜对为止。
输出:大了、小了、猜对了，总共猜了多少次。
提示：
	# 随机数工具(在开头写一次)
	import random

	# 产生一个随机数
	random_number = random.randint(1, 100)
"""
import random

random_number = random.randint(1, 100)

count = 0
while True:
    count += 1
    input_number = int(input("请输入数字："))
    if input_number > random_number:
        print("大了")
    elif input_number < random_number:
        print("小了")
    else:
        print("猜对了，总共猜了" + str(count) + "次")
        break

"""
    猜数字2.0版本
    如果猜错次数超过5次，则结束游戏，并提示“失败了”
"""
import random

random_number = random.randint(1, 100)
print(random_number)
count = 0
while count < 5:
    count += 1
    input_number = int(input("请输入数字："))
    if input_number > random_number:
        print("大了")
    elif input_number < random_number:
        print("小了")
    else:
        print("猜对了，总共猜了" + str(count) + "次")
        break
else:
    # 当循环不满足条件时退出，才执行以下代码
    print("失败了")

3.2 for 语句

1. 作用:
   用来遍历可迭代对象的数据元素。
   可迭代对象是指能依次获取数据元素的对象，例如：容器类型。
2. 语法:

for 变量列表 in 可迭代对象:
    语句块1
else:
    语句块2

3. 说明:
   else子句可以省略。
   在循环体内用break终止循环时,else子句不执行。

3.3 range 函数

1. 作用:
   用来创建一个生成一系列整数的可迭代对象(也叫整数序列生成器)。
2. 语法:
   range(开始点，结束点，间隔)
3. 说明:
   函数返回的可迭代对象可以用for取出其中的元素
   返回的数字不包含结束点
   开始点默认为0
   间隔默认值为1

"""
循环累加下列数字的和：0 1 2 3 4 5
循环累加下列数字的和： 2 3 4 5 6 7
循环累加下列数字的和： 0 2 4 6
循环累加下列数字的和： 4 3 2 1 0
循环累加下列数字的和： -1  -2  -3  -4
"""
# sum_value = 0
# for item in range(6):
#     sum_value += item
# print(sum_value)

# sum_value = 0
# for item in range(2,8):
#     sum_value += item
# print(sum_value)

# sum_value = 0
# for item in range(0,7,2):
#     sum_value += item
# print(sum_value)

# sum_value = 0
# for item in range(4,-1,-1):
#     sum_value += item
# print(sum_value)

sum_value = 0
for item in range(-1,-5,-1):
    sum_value += item
print(sum_value)

4. 跳转语句

4.1 break 语句

1. 跳出循环体，后面的代码不再执行。
2. 可以让while语句的else部分不执行。

4.2 continue 语句

• 跳过本次，继续下次循环。

"""
    随机产生两个数字(1--10),
    在控制台中获取两个数相加的结果
    如果用户输入正确得10分,否则扣5分。
    总共３道题，最后输出得分.
    例如:“请输入8+3=?” 11  得10分
       　　"请输入4+3=?"   8   扣5分
       　　"请输入4+4=?"   8   得10分
        　 "总分是15"
"""
import random

score = 0
for i in range(3):#0 1 2
    random_number01 = random.randint(1, 10)
    random_number02 = random.randint(1, 10)
    input_number = int(input("请输入" + str(random_number01) + "+" + str(random_number02) + "=?"))
    if input_number == random_number01 + random_number02:
        score += 10
    else:
        score -= 5
print("总分是"+str(score))

"""
在终端中录入一个整数，判断是否为素数。
素数:只能被１和自身整除的正数.
思路：排除法,使用２到当前数字之间的正数判断，如果存在被整除，则不是素数.
判断9：
     能否被2　--  8 之间的数字整除,其中3可以，所以不是素数.
判断８:
     能否被2　--  7 之间的数字整除,其中2可以，所以不是素数.
判断7:
     能否被2　--  6 之间的数字整除,其中没有，所以是素数.
2   3   5  7  11  13  15 ....
"""
number = int(input("请输入整数："))  # 5      9       7
# 2 3 4                  2 3                 2 3 4 5 6
for i in range(2, number):
    if number % i == 0:
        print("不是素数")
        break
else:
    print("是素数")

十、字符串

1. 定义

• 由一系列字符组成的不可变序列容器，存储的是字符的编码值。

2. 编码

1. 字节byte：计算机最小存储单位，等于8 位bit.
2. 字符：单个的数字，文字与符号。
3. 字符集(码表)：存储字符与二进制序列的对应关系。
4. 编码：将字符转换为对应的二进制序列的过程。
5. 解码：将二进制序列转换为对应的字符的过程。
6. 编码方式：
   –ASCII编码：包含英文、数字等字符，每个字符1个字节。
   –GBK编码：兼容ASCII编码，包含21003个中文；英文1个字节，汉字2个字节。
   –Unicode字符集：国际统一编码，旧字符集每个字符2字节，新字符集4字节。
   –UTF-8编码：Unicode的存储与传输方式，英文1字节，中文3字节。

3. 相关函数

1. ord(字符串):返回该字符串的Unicode码。
2. chr(整数):返回该整数对应的字符串。

"""
    字符串编码
    练习:exercise07.py
"""
# 字 --> 数
number = ord("a")
print(number)

# 数 --> 字
str01 = chr(3498573945793475)
print(str01)

4. 字面值

4.1 单引和双引号的区别

1. 单引号内的双引号不算结束符
2. 双引号内的单引号不算结束符

4.2 三引号作用（可见即所得）

1. 换行会自动转换为换行符\n
2. 三引号内可以包含单引号和双引号
3. 作为文档字符串

4.3 转义字符

1. 改变字符的原始含义。
   \’ \” \””” \n \ \t \0 空字符
2. 原始字符串：取消转义。
   a = r”C:\newfile\test.py”

5. 字符串格式化

1. 定义：
   生成一定格式的字符串。
2. 语法：
   字符串%(变量)
   “我的名字是%s,年龄是%s” % (name, age)
3. 类型码：
   %s 字符串 %d整数 %f 浮点数

"""
    字符串字面值
"""

name01 = "悟空"
name02 = '悟空'

# 三引号：可见即所得
name03 = '''
   悟

空'''
print(name03)
name03 = """悟空"""

message = '我是"齐天大圣"孙悟空.'
message = "我是'齐天大圣'孙悟空."
message = '''我是'齐天大圣'"孙悟空".'''

# 转义符：改变原有含义的特殊字符
# \"   \'    水平制表格\t    换行\n    \\
message = "我是\"齐天\n大圣\"孙\t悟空."
print(message)

url = "c:\\a\\b\c\d\\a.txt"
print(url)
# 原是字符串(没有转义符)
url = r"c:\a\b\c\d\a.txt"

# 格式化字符串
# "..%d...%s...%f.."%(整数变量,字符串变量,小数变量)
# 1 + 2 = 3
number_one = 1
number_two = 2
str_resutl = "%d + %d = %d"%(number_one,number_two,number_one +number_two)
print(str_resutl)

name = "张无忌"
age = 25
score = 95.5
print("我叫%s今年%d岁了，考试%.1f。"%(name,age,score))

第四章 容器类型

一、通用操作

1. 数学运算符

1. +：用于拼接两个容器
2. +=：用原容器与右侧容器拼接,并重新绑定变量
3. *：重复生成容器元素
4. *=：用原容器生成重复元素, 并重新绑定变量
5. < <= > >= == !=：依次比较两个容器中元素,一但不同则返回比较结果。

2. 成员运算符

1. 语法：
   数据 in 序列
   数据 not in 序列
2. 作用：
   如果在指定的序列中找到值，返回bool类型。

3. 索引index

1. 作用：定位单个容器元素
2. 语法：容器[整数]
3. 说明：
   正向索引从0开始，第二个索引为1，最后一个为len(s)-1。
   反向索引从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)。

4. 切片slice

1. 作用：
   定位多个容器元素。
2. 语法：
   容器[(开始索引):(结束索引)(:(步长))]
3. 说明：
   小括号()括起的部分代表可省略
   结束索引不包含该位置元素
   步长是切片每次获取完当前元素后移动的偏移量

5. 内建函数

1. len(x) 返回序列的长度
2. max(x) 返回序列的最大值元素
3. min(x) 返回序列的最小值元素
4. sum(x) 返回序列中所有元素的和(元素必须是数值类型)

"""
    容器通用操作
        以字符串为例
"""
# + : 拼接
name = "悟空"
print(id(name))
# 不可变:字符串在拼接后，产生新对象，替换name存储的地址.
name += "八戒"
print(id(name))
print(name)

# *: 重复
name = "唐僧"
name *= 3
print(name)

# 成员运算
print("大圣" in "我叫齐天大圣")
print("大圣" not in "我叫齐天大圣")

# 索引
message = "我是花果山水帘洞的齐天大圣"
print(message[0])
# 倒数第二个字符
print(message[-2])
# 正数第三个字符
print(message[2])
# print(message[20])# 索引不能超过范围

# 切片
print(message[2:5:1])
print(message[:5])
print(message[:5:2])
print(message[:])
print(message[::-1])# 圣大天齐的洞帘水山果花是我
print(message[2:-8])
print(message[2:-8:-1])# 空
print(message[2:2])# 空
print(message[2:100])# 越界不报错

"""
    1. 创建字符串：人生苦短,我用Python
    2. 打印第一个字符，最后一个字符。
    3. 打印前两个字符，后六个字符。
    4. 打印中间一个字符。
    5. 倒序打印所有字符。
"""
message = "人生苦短,我用Python"
print(message[0])
print(message[-1])
print(message[:2])
print(message[-6:])
print(message[len(message) //2])
print(message[::-1])

"""
在控制台中获取一个整数作为边长，打印矩形。
输入：4
输出：
    ****
    *  *
    *  *
    ****
"""
number = int(input("请输入边长:"))
print("*" * number)
for i in range(number -2):
    print("*" + " " * (number -2) + "*")
print("*" * number)

二、列表

1. 定义

• 由一系列变量组成的可变序列容器。

2. 基础操作

2.1 创建列表

• 列表名 = []
• 列表名 = list(可迭代对象)

2.2 添加元素

• 列表名.append(元素)
• 列表.insert(索引，元素)

2.3 定位元素

• 列表名[索引] = 元素
• 变量 = 列表名[索引]
• 变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表
• 列表名[切片] = 容器 # 右侧必须是可迭代对象，左侧切片没有创建新列表。
• 遍历列表：
  • 正向：
    • for 变量名 in 列表名:
      • 变量名就是元素
  • 反向：
    • for 索引名 in range(len(列表名)-1,-1,-1):
      • 列表名[索引名]就是元素

2.4 删除元素

• 列表名.remove(元素)
  • del 列表名[索引或切片]

3. 深拷贝和浅拷贝

• 浅拷贝：复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
• 深拷贝：复制整个依懒的变量。

"""
    列表 list
    练习:exercise11
"""
# 1. 创建列表
list01 = []
list02 = list()

list01 = [90,"唐僧",True]
# 根据其他可迭代对象
list02 = list("我是齐天大圣")

# 2. 添加
# -- 追加
list01.append("悟空")
# -- 插入
list01.insert(2,"八戒")

# 3. 获取
# 索引：单个
print(list01[-1])
# 切片：多个
# 创建新列表
print(list01[:3])
# 循环：所有
for item in list01:
    print(item)
# 倒序
# 因为切片会产生新列表，浪费内存，所以不建议下面的方式
# for item in list01[::-1]:
#     print(item)
for i in range(len(list01)-1,-1,-1):
    print(list01[i])

# 4. 修改
# 索引
# 将右侧的数据地址赋值给左侧定位的元素
list01[-1] = "end"

# 切片
# 遍历右侧的可迭代对象，将每个元素赋值给左侧定位的元素
# list01[:2] = [1,2]
print(list01)
# list01[:2] = [1,2,3,4,5,6,7,8,9,10]
# list01[:3] = []
list01[1:1] = [1,2,3,4]
# 循环
for i in range(len(list01)):
    list01[i] = None
print(list01)

# 5. 删除
# 根据元素移除
list02.remove("我")

# 根据索引、切片移除
del list02[-1]
del list02[:2]
print(list02)

"""
    创建列表，存储水星，金星，地球，木星，土星，天王星。
    向列表中追加海王星。
    在地球后插入火星。
    打印距离太阳最远的行星(最后一个行星)
    打印地球之前的所有行星(前两个行星)。
    删除金星。
    删除地球后面的所有行星。
    倒序打印所有行星。
"""
list_planet = ["水星","金星","地球","木星","土星","天王星"]
list_planet.append("海王星")
list_planet.insert(3,"火星")
print(list_planet[-1])
print(list_planet[:2])
list_planet.remove("金星")
del list_planet[3:]
for i in range(len(list_planet)-1,-1,-1):
    print(list_planet[i])

"""
    在控制台中循环录入同学们的身高，如果输入空，则停止。
    打印所有人的身高(一行一个)。
    打印总数。
    打印最高、最低、和平均的身高。
    使用 max   min    sum
"""
list_height = []
while True:
    str_height = input("请输入身高：")
    if str_height == "":
        break
    list_height.append(float(str_height))

for item in list_height:
    print(item)

print(len(list_height))
print(max(list_height))
print(min(list_height))
print(sum(list_height)/len(list_height))

"""
    列表内存分配
"""
list01 = [10, 20]
list02 = list01
list01[0] = 100
print(list02[0])  # ?100

list01 = [10, 20]
list02 = list01
list01 = 100
print(list02[0])  # ?10

# 练习：
list01 = [10, 20]
list02 = list01[:]
list01[0] = 100
print(list02[0])  # ?

import copy

list01 = [10, [20, 30]]
list02 = list01[:]  # 浅拷贝
list03 = list01  # 赋值
list04 = copy.deepcopy(list01)  # 深拷贝

# 深拷贝
# 优点:互不影响
# 缺点：往往占用内存过多

4. 列表VS字符串

1. 列表和字符串都是序列,元素之间有先后顺序关系。
2. 字符串是不可变的序列,列表是可变的序列。
3. 字符串中每个元素只能存储字符,而列表可以存储任意类型。
4. 列表和字符串都是可迭代对象。
5. 函数：
   将多个字符串拼接为一个。
   result = “连接符”.join(列表)
   将一个字符串拆分为多个。
   列表 = “a-b-c-d”.split(“分隔符”)

"""
    list --> str
"""
# 根据xx逻辑，拼接一个字符串。
# range(10) --> "0123456789"

# str_result = ""# 不可变
# for item in range(10):
#     # str_result += str(item)
#     # 每次循环 每次拼接 都会创建新对象 产生一个垃圾
#     str_result = str_result + str(item)
# print(str_result)

list_temp = []#可变
for item in range(10):
    # 每次追加新对象 不会产生垃圾
    list_temp.append(str(item))

str_result = "-".join(list_temp)
print(str_result)

"""
    在终端中循环录入字符串，如果输入空则停止。
    最后打印所有的内容(拼接后的字符串)
"""
list_temp = []
while True:
    str_input = input("请输入：")
    if str_input == "":
        break
    list_temp.append(str_input)
str_result = "".join(list_temp)
print(str_result)

"""
    str --> list
"""

message = "悟空-猪八戒-沙和尚"
list_result = message.split("-")
print(list_result)

5. 列表推导式

1. 定义：
   使用简易方法，将可迭代对象转换为列表。
2. 语法：
   变量 = [表达式 for 变量 in 可迭代对象]
   变量 = [表达式 for 变量 in 可迭代对象 if 条件]
3. 说明:
   如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。

6. 列表推导式嵌套

1. 语法：
   变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2]
2. 传统写法：
   result = []
   for r in [“a”, “b”, “c”]:
   for c in [“A”, “B”, “C”]:
   result.append(r + c)
3. 推导式写法：
   result = [r + c for r in list01 for c in list02]

"""
    将英文单词翻转。
    输入：How are you
    输出：you are How
"""
message = "How are you"
list_temp = message.split(" ")
result = " ".join(list_temp[::-1])
print(result)

"""
    list 推导式
"""
list01 = [5, 56, 67, 7, 89]

# list02 = []
# for item in list01:
#     list02.append( item + 1 )

list02 = [item + 1 for item in list01]
print(list02)

# list03 = []
# for item in list01:
#     if item % 2 ==0:
#         list03.append(item)
list03 = [item for item in list01 if item % 2 == 0]
print(list03)

"""
    生成1—10之间的数字，将其平方存入list01中。
    将list01中所有奇数存入list02中。
    将list01中所有大于5的偶数增加1后存入list03中。
"""
list01 = [item ** 2 for item in range(1, 11)]
list02 = [item for item in list01 if item % 2]
list03 = [item + 1 for item in list01 if item % 2 == 0 and item > 5]

print(list01)
print(list02)
print(list03)