✨博客主页： https://blog.csdn.net/m0_63815035?type=blog

💗《博客内容》：.NET、Java.测试开发、Python、Android、Go、Node、Android前端小程序等相关领域知识
📢博客专栏： https://blog.csdn.net/m0_63815035/category_11954877.html
📢欢迎点赞 👍 收藏 ⭐留言 📝
📢本文为学习笔记资料，如有侵权，请联系我删除，疏漏之处还请指正🙉
📢大厦之成，非一木之材也；大海之阔，非一流之归也✨

前言

本文是黑马Python4.0编程学习笔记，里面有相关的知识点还是重要的，期待大家的关注！！！

DAY--------------------------------------------01 （基础）

第一个python代码

• python源程序

  • python就是存放python代码的文本文件
  • 扩展名必须以.py结尾

• 演练步骤

  • 找到自己电脑中一个目录c:\file目录
  • 在file目录下新建了一个文本文件hello.py
  • 用记事本打开这个文件文件,如果以下内容

  print("hello world")
  print("hello python")
  

  • 保存退出
  • 打开cmd

  

  • 在命令行输入python hello.py

  

在pycharm中运行python程序

• 运行python有两种方式
  • 命令行通过 python python源程序方式运行
• 直接在pycharm中运行

第一个pycharm程序演练

• 启动pycharm
  • 在启动界面里选择create new project

在pycharm中运行多个py文件的注意项

注释

• 单行注释
  • # 注释内容
• 多行注释

'''
注释内容
注释内容
'''

在pycharm中可以用ctrl + / 快速注释一行代码

算数运算符

• *乘
• /除
• //取整除
• %取余数
• **幂(次方)

print(3 + 2)
print(3 - 2)
print(3 * 2)
print(3 / 2)
print(3 // 2)
print(3 % 2)
print(3 ** 2)

python中字符串需要用引号引起来

数字不需要引号

• 字符串可以和一个整数相乘
  • 字符串重复整数次数

print("hello" * 3)

运算符优先级

• **最高
• * / // %
• + -最低
• 可以通过括号改变优先级

print((3 + 2) * 5)

变量

• 在计算机语言中可变的量
• 变量在使用前必须先定义赋值

变量名 = 值

# 定义了一个变量名叫name,值为字符串张三
name = "张三"
# 定义了一个变量名叫age 值为数字26
age = 26

print(name)  # 如果print里面写的是变量名,那么输出的是变量的值
print(age)

超市买苹果变量演练

price = 8.5
weight = 7.5
money = price * weight
print(money)

超市买苹果-够10斤,减5块

price = 8.5
weight = 10
money = price * weight
# 变量定义之后,再=号赋值,只是改变变量的值而已
money = money - 5  # 改变了money变量 的值
print(money)

课堂练习-算数运算符

a = 12
b = 3
print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a // b)
print(a % b)
print(a ** b)

课堂练习-变量a和b的值交换

# 交换a和b的值
a = 10
b = 20
c = a
a = b
b = c
print(a, b)  # 如果一个print输出两个变量的值,两个变量需要用逗号分隔

变量名命名规则

• 可以使用字母数字和下划线
• 不能用纯数字
• 不能以数字开头
• 不能用特殊符号
• 不能用python的关键字

name = '妲己'
age = 25
name_age = "妲己25"
# 3name = "妲己"  错误的变量名
_name = "妲己"

name = 25
age = "妲己"

显示python关键字

• 先用import导入keyword

# 显示python关键字
import keyword
print(keyword.kwlist)

变量命名习惯

• 习惯不是python语言强制的,只是习惯而已
• 多个单词
• 习惯一:
  • 都用小写字母,单词和单词之间用下划线连接
• 习惯二小驼峰:
  • 第二个单词首字母大写
• 习惯三大驼峰
  • 所有单词首字母大写

first_name = "张三" # 所有字母都小写
firstName = "张三" # 小驼峰,只有第二个单词首字母大写
FirstName = "张三" # 大驼峰, 每个单词首字母都大写
# 变量名不会所有字母都大写, FIRSTNAME

python的数据类型

• 数字型
  • 整数int
  • 浮点数float
  • 布尔bool
    • True(真)
    • False(假)
• 非数字型
  • 字符串str(string)
  • 列表list
  • 元组tuple
  • 集合set
  • 字典dict(dictionary)
• None
  • 首字母是大写的N
  • 空

a = 10 # int
b = 3.5 # float
c = False # bool
d = True # bool
e = "aaaaaa"   # str

name = "小明"
age = 18
sex = "男"
height = 1.75
isStudent = True
print(name, age, sex, height, isStudent)

变量赋值的时候,等号右边是什么数据类型, 变量就是什么数据类型

数字型变量计算

• 数字型变量可以直接使用算数运算符计算
• 布尔类型
  • True代表1
  • False代表0

i = 10
f = 10.5
b = True

print(i + f)
print(i + b)
print(i - b)

字符串的计算

• 字符串 + 字符串
  • 两个字符串拼接成一个字符串
• 字符串 * 数字
  • 字符串重复整数的次数
• 字符串不能用-,/和其他计算操作

str1 = "你好"
str2 = "python"
str3 = str1 + str2
print(str3)
str3 = str1 * 5
print(str3)
# str3 = str1 - str2 字符串和字符串不能减

字符串和整数的区别

• 一个数字如果用引号引起来,这就不是数字了,而是一个字符串

a = 10   # 数字10
b = "10"   # 这个地方不是整数10, 是一个字符串 有一个字符是1 还有一个字符是0
c = 1
d = "1"
print(a + c)
print(b + d)

不同数据类型转化

• 转化为字符串
  • str(要转化的变量或者值)
• 转化为整数
  • int(要转化的变量或者值)
• 转化为浮点数
  • float(要转化的变量或者值)

a = 10
b = "1"
# 要把b转化成int,与a相加
print(a + int(b))
# 要把a转化为str,与b相加
print(str(a) + b)
c = "你好"
# print(a + int(c)) # 如果c不能转化,那么代码会报错
d = "3.5"
print(a + float(d))

课堂练习-类型转化

a = "123"
b = 456
print(a + str(b))
print(int(a) + b)

课堂练习-四舍五入

# 如何把一个float类型的小数点去掉只保留整数
# f = 3.5
# a = int(f)  # 只要把一个浮点数用int()转化为一个整数,那么小数点就没了
# print(a)
a = 5
b = 2
# 2.5 + 0.5 = 3
print(int(a / b + 0.5))

a = 10
b = 3
# 3.333333 + 0.5 = 3.83333333333
print(int(a / b + 0.5))

a = 11
b = 2
# 5.5 + 0.5 = 6
print(int(a / b + 0.5))

# 任意两个数字除,结果加0.5,最后只保留整数位,就是对一个小数四舍五入取整的结果

input函数

• input可以用户通过键盘给一个变量输入值
• 语法

变量名 = input("提示文字")

name = input("请输入")  # 当代码执行到input就停止了,等待用户通过键盘输入
print(name)
# 如果用户通过键盘输入了tom,那么name变量的值就是tom
name = input("请再次输入")
print(name)

• 用input输入的任何数字也都是字符串,而不是数字

age = input("请输入")
print(age + "1")
# 如果用户输入的是25,其实是字符串"25"

转化input输入的结果

• 只要把input输入的结果用数据类型转化的方式int(), float()即可

# a = input("请输入第一个数字")
# b = input("请输入第二个数字")
# print(int(a) + int(b))
# 上面代码和下面代码执行结果是一样的
a = int(input("请输入第一个数字"))
b = int(input("请输入第二个数字"))
print(a + b)

超市买苹果-增强版

price = float(input("请输入苹果的单价"))
weight = float(input("请输入购买重量"))
money = price * weight
print(money)

格式化字符串

• 在python字符串中如果有%,这个字符串就叫格式化字符串
• %d 要格式化的是一个整数
  • %05d 整数位数固定5位,如果不足5位,左补0
• %f 要格式化的是一个浮点数
  • %.2f 保留小数点后2位
• %s 要格式化的是一个字符串
• %% 要输出一个%

格式化字符串主要功能

• 把多个字符串以及数字拼接到一起

• 语法

  print("格式化字符串" % (变量1, 变量2, .....))
  

  name = "张三"
  age = 20
  print("姓名" + name + ", 年龄" + str(age) + "岁")
  # 这两个print输入的结果是一样的
  print("姓名%s, 年龄%d岁" % (name, age))
  print("姓名%s, 年龄%d岁, %%, %%s" % (name, age))
  

  f = 3.14
  str1 = "圆周率是"
  print(str1 + str(f))
  print("%s%.2f" % (str1, f))
  a = 10
  print("变量a的值是%05d" % a)
  

• 格式化字符串的功能

  • 只是把字符串和字符串以及数字和其他类型通过print拼接成一个字符串显示出来而已

格式化字符串-名片

company = input("请输入公司名称")
name = input("请输入姓名")
tel = input("请输入电话号码")
mailbox = input("请输入邮箱地址")
print("*" * 20)
print("公司名称:%s" % company)
print("姓名:%s" % name)
print("电话:%s" % tel)
print("邮箱:%s" % mailbox)
print("*" * 20)

课堂练习-格式化字符

# 定义字符串变量 name = “小明”，输出: 我的名字叫小明，请多多关照！
name = "小明"
print("我的名字叫%s，请多多关照！" % name)
# 2. 定义整数变量 num = 1，输出: 我的学号是 000001
num = 1
print("我的学号是 %06d" % num)
# 3. 定义⼩数 price = 8.5、 weight = 5 ，输出：苹果单价 8.5 元／⽄，购买了 5.00 ⽄，需要支付 42.50 元
price = 8.5
weight = 5
print("苹果单价 %.1f元／⽄，购买了 %.2f ⽄，需要支付 %.2f 元" % (price, weight, price * weight))
# 4. 定义⼀个⼩数 scale = 10.01 ，输出: 数据是 10.01%
scale = 10.01
print("数据是 %.2f%%" % scale)

多条print输出到一行

• print函数默认会自动输出一个回车换行,所以如果有多条print函数,会在多行输出
• 去掉print后面默认的回车换行

print("要输出的字符串", end="")

print("hello")  # print在输出之后,会自动添加一个回车换行
print("world")
print("hello", end="") # print输出之后,不会自动添加回车换行
print("world")

转义字符

• 有些字符,不方便通过键盘输入
• 常见的转义字符
  • \\
  • \n
  • \t
  • \"
  • \'
• 如果在字符串前面加r,代表字符串不转义

print("我\t你")
print("我\n你")
print("我\\你")
print("我\"你")
print("我\'你")
print(r"我\n你")

DAY--------------------------------------------02 （判断）

判断的定义

• 如果条件满足,就做一件事情,如果条件不满足,就做另一件事情或者什么也不做
  • 条件只有满足和不满足两个结果

比较运算符

• >大于
• >=大于等于
• <小于
• <=小于等于
• ==等于
  • =在python中是变量赋值使用的,判断是否相等用==
• !=不等于

if基本语法

if 条件:
    条件成立要执行的代码

a = 10
if a < 3:
    print("你好")  # 这个print和if是一个代码块
print("hello") # 这里的print和上面的if没有关系

pass占位符

• 在写python程序的时候,有时候必须写代码,不写语法报错,但又不知道该写什么,就可以用pass占位符

a = 10
if a > 5:
    pass
print("hello")

if演练

age = int(input("请输入年龄"))
if age >= 18:
    print("可以嗨皮")
print("程序结束")

课堂练习-判断除数是否为0

# num1通过input输入的数字
# num2通过input输入的数字
num1 = int(input("请输入num1的值"))
num2 = int(input("请输入num2的值"))
# 如果num2不等于0,计算num1 除以num2的结果
if num2 != 0:
    print(num1 / num2)

课堂练习-计算器

num1 = int(input("请输入num1的值"))
num2 = int(input("请输入num2的值"))
a = input("请输入a的值")
if a == "+":
    print(num1 + num2)
if a == "-":
    print(num1 - num2)
if a == "*":
    print(num1 * num2)
if a == "/":
    print(num1 / num2)

if双分支

• 条件成立执行一件是事情,条件不成立执行另外一件事情
• 语法

if 条件:
    条件成立执行的代码
else:
    条件不成立执行的代码
# if和else要对齐, else必须放到if后面,不能单独使用

age = int(input("请输入年龄"))
if age >= 18:
    print("可以进网吧嗨皮")
else:
    print("回家写作业")

num1 = int(input("请输入num1的值"))
# 如何判断一个整数是否为偶数,可以和2取余数,如果余数为0就是偶数,否则为奇数
if num1 % 2 == 0:
    print("偶数")
else:
    print("奇数")

num1 = int(input("请输入num1的值"))
# 判断num1是否为正数 只要num1大于等于0就是正数
if num1 >= 0:
    print("正数")
else:
    print("负数")

逻辑运算符

• and
  • 条件1 and 条件2
  • 两个条件必须同时满足
• or
  • 条件1 or 条件2
  • 两个条件只要有一个满足即可
• not
  • not 条件
  • 条件求反

name = "小明"
age = 6
if name == "小明" and age > 20:
    print("通过")
else:
    print("不通过")

name = "小"
age = 30
if name == "小明" or age > 20:
    print("通过")
else:
    print("不通过")

name = "小"
if not name == "小明":
    print("通过")
else:
    print("不通过")

a = int(input("请输入一个数字"))
# 判断一个数字是否在0到120之间 ,这个数字要大于等于0 并且小于等于120
if a >= 0 and a <= 120:
    print("在0到120之间")
else:
    print("不在0到120之间")

name = input("请输入账号")
passwd = input("请输入密码")
if name == "itcast" and passwd == "123456":
    print("通过登录")
else:
    print("登录失败")

if多分支

• 有多个条件,不同的条件要执行不同的代码
• 语法

if 条件1:
    条件1满足执行的代码
elif 条件2:
    条件2满足执行的代码
elif 条件3:
    条件3满足执行的代码
else:
    以上条件都不满足,执行的代码
# elif和else要和if对齐,elif和else都需要写在if后面

hday = input("请输入今天是什么日子")

if hday == "情人节":
    print("买玫瑰")
elif hday == "平安夜":
    print("吃大餐")
elif hday == "生日":
    print("吃蛋糕")
else:
    print("去上班")

age = int(input("请输入年龄"))
if age < 10 and age > 0:
    print("小孩")
elif age >= 10 and age < 20:
    print("小朋友")
elif age >= 20 and age < 30:
    print("年轻人")
elif age >= 30 and age < 50:
    print("中年人")
elif age >= 50:
    print("老年人")
else:
    print("年龄不对")

课堂练习-判断正负数-0排除

a = int(input("请输入一个整数"))
if a > 0:
    print("正数")
elif a == 0:
    print("不是正数也不是负数")
else:
    print("负数")

if嵌套

• 一个if语句里面还可以有其他的if语句
• 语法

if 条件:
    if 条件:
        要执行代码
    else:
        要执行代码
else:
    要执行代码
# 只有最外面的if条件满足,才会执行嵌套在里面的if语句

a = int(input("请输入一个数字"))
# 判断0到100之内,任意一个数字是否能被3整数
# 首先需要判断这个数字是否在0到100之内
# 如果一个数字大于0,并且小于100,就是在0到100之内
if a > 0 and a < 100:
# 如果条件满足,再判断是否能被3整除
# 一个数字和3取余数,如果余数为0,代表可以被3整除
    if a % 3 == 0:
        print("能被3整除")
    else:
        print("不能被3整数")
else:
    print("不在0到100之间")

课堂练习

name = input("请输入姓名")
if name == "tom":
    age = int(input("请输入年龄"))
    if age >= 30:
        print("大叔")
    else:
        print("小弟")
else:
    print("姓名错误")

课堂练习-计算器加强

num1 = int(input("请输入num1的值"))
num2 = int(input("请输入num2的值"))
a = input("请输入a的值")
if a == "+":
    print(num1 + num2)
elif a == "-":
    print(num1 - num2)
elif a == "*":
    print(num1 * num2)
elif a == "/":
    if num2 != 0:
        print(num1 / num2)
    else:
        print("除数不能为0")
else:
    print("a的值必须为+-*/")

运算符

• 算数运算符

• 比较运算符

• 逻辑运算符

• 赋值运算符

  =
  a += 1   a = a + 1  +=中间没有空格
  a -= 1   a = a - 1
  a *= 1   a = a * 1
  a /= 1   a = a / 1
  a //= 3  a = a // 3
  a %= 3   a = a % 3
  a **= 3  a = a ** 3
  

  a = 10  # =赋值运算符
  a += 1 #a = a + 1
  print(a)
  b = 5
  b -= 2 #b = b - 2
  print(b)
  c = 5
  c *= 2 #c = c * 2
  print(c)
  
  

• 运算符优先级

• 

算数运算符优先级最高

比较运算符

赋值运算符

逻辑运算符最低

小括号优先级最高

a = 4 + 5 * 2 > 3
print(a)
a = 4 + 5 * (2 > 3)
print(a)

生成随机数

• 第一步导入一个叫random模块
• 第二步调用randint函数

import random
# 要定义一个变量,来存放随机数
a = random.randint(1, 5) # 会生成从1到5之间的一个随机的整数(包含1和5)
print(a)
a = random.randint(10, 20) # 生成从10到20之间的随机数,包含10和20
print(a)

• randint函数说明
  • random.randint(a, b)
  • a和b是两个整数,代表要生成的随机数的范围,a为开始范围,b为终止范围

随机数生成飞机坦克大炮

# 1代表坦克
# 2代表飞机
# 3代表大炮
import random
a = random.randint(1, 3)
if a == 1:
    print("坦克")
elif a == 2:
    print("飞机")
else:
    print("大炮")

if综合应用

# 1:石头
# 2:剪刀
# 3:布
# 石头赢剪刀  1赢2
# 剪刀赢布    2赢3
# 布赢石头    3赢1
# 人通过键盘输入数字1或者2或者3
# 电脑随机产生数字1或者2或者3
# 比较胜负
import random
# pc代表电脑要出的拳,可能是1,可能2或者3
pc = random.randint(1, 3)
# player代表人要出的拳,可能是1或者2或者3
player = int(input("请输入1或者2或者3"))
if (pc == 1 and player == 2) or (pc == 2 and player == 3) or (pc == 3 and player == 1):
    print("电脑出了%d, 我出了%d电脑赢了" % (pc, player))
elif (pc == player):
    print("电脑出了%d, 我出了%d, 平局" % (pc, player))
else:
    print("电脑出了%d, 我出了%d,我赢了" % (pc, player))

猜拳游戏改进版

# 1:石头
# 2:剪刀
# 3:布
# 石头赢剪刀
# 剪刀赢布
# 布赢石头
# 人通过键盘输入石头,剪刀,和布
# 电脑随机产生数字1或者2或者3
# 如果电脑产生数字1,那么就要转化为石头
# 如果电脑产生数字2,那么就要转化为剪刀
# 如果电脑产生数字3,那么就要转化为布

# 比较胜负
import random
# pc代表电脑要出的拳,可能是1,可能2或者3
pc = random.randint(1, 3)
# 需要把数字1,2,3转化为对应的字符串
# 变量a存放数字转化为字符串的结果
a = None
if pc == 1:
    a = "石头"
elif pc == 2:
    a = "剪刀"
else:
    a = "布"

# player代表人要出的拳,可能是石头或者剪刀或者布
player = input("请输入石头或者剪刀或者布")

if (a == "石头" and player == "剪刀") or (a == "剪刀" and player == "布") or (a == "布" and player == "石头"):
    print("电脑出了%s, 我出了%s, 电脑赢了" % (a, player))
elif (a == player):
    print("电脑出了%s, 我出了%s, 平局" % (a, player))
else:
    print("电脑出了%s, 我出了%s, 我赢了" % (a, player))

DAY--------------------------------------------03（循环）

程序的三种结构

• 顺序,代码自上而下执行
• 分支,根据条件有选择的执行特定代码
• 循环,根据条件循环执行特定代码

# print("hello world")
# print("hello world")
# print("hello world")
a = 0
while a < 3:
    print("hello world")
    a += 1

如果要输出的是100个hello world,该怎么做?

a = 0
while a < 100:
    print("hello world")
    a += 1

while基本语法

• 语法

while 条件:
    要循环执行的代码
# 如果条件成立,那么循环执行,如果条件不成立,那么循环终止

死循环

• 程序应该避免出现死循环

a = 0
while a < 3:
    print("hello world")
# a的值永远不会变,所以循环条件永远成立

循环的计数习惯

• 人类计数习惯从1开始
• 程序计数习惯从0开始,除非有明确的要求,可以不从0开始,否则一定要从0开始计数

a = 0
while a < 6:
    print(a)
    a += 1

课堂练习

a = 5
while a >= 0:
    print(a)
    a -= 1

循环计数

• 循环在程序中经常用到的功能是循环计数
• 先在循环开始之前定义一个变量,用来存放计算结果
• 在循环内部对这个变量进行计算
• 循环完成后,输出这个变量的值

# 定义一个变量,来存放累加的和
sum = 0

# 开始循环,从0到100
a = 0
while a <= 100:
    sum = sum + a   # sum += a
    a += 1
# 在循环内部没有任何的print语句,因为不需要在循环内部输出任何数字
# 在循环完成之后,输出sum的值,因为sum就是从0到100所有整数累加的和
print(sum)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

sum = 0

a = 300
while a <= 415:
    sum += a
    a += 1

print(sum)

break终止循环

• break必须放到循环内部
• 如果循环遇到break,立刻终止
• 一般在循环内部通过if的条件,来执行break,某一个条件成立的时候来break

a = 0
while a < 10:
    print(a)
    if a == 3:
        break  # break执行,循环不在执行了  # break由于是在if语句里面,所以要缩进两次
    a += 1
# break之后,代码到这里了

a = 0
while a < 100000000:
    str1 = input("请输入一个字符串")
    if str1 == "exit":
        break
    print(str1)
    a += 1

人造死循环

• 代码中循环开始的时候不知道循环次数,可以使用人造死循环
• 在人造死循环内部,一定要有if结合break来退出循环的机制

# 如果while后面的条件为True,这个while就是一个人为的循环
# 循环内部一定要有if结合break来让循环退出的机制
while True:
    str1 = input("请输入一个字符串")
    if str1 == "exit":
        break
    print(str1)

continue

• 循环一旦遇到continue就不在执行continue下面的循环代码了,而是直接返回到循环开始判断条件
• continue一定是放到if后面,

a = 0
while a < 5:
    a += 1
    if a == 3:
        continue
    print(a)

• 使用continue一定要注意,因为使用不当很容易成死循环

a = 0
while a < 5:
    if a == 3:
        continue  # a等于3的时候,就再也没机会执行a += 1这个代码了
    print(a)
    a += 1

# a还是一个循环计数器
# b决定了循环的最大次数
a = 0
b = int(input("请输入b的值"))

while a < b:
    print("*")
    a += 1
    if a >= 20: # 不管b的值多大,一旦a到了20,循环就退出
        break

• 再讲一次

# 如果输出3行星号
# a = 0
# b = 3
# while a < b:
#     print("*")
#     a += 1
# 如果b的值不是代码写死的,是通过input输入的
a = 0
b = int(input("请输入b的值"))  # 假设用户输入了数字10
while a < b:
    print("*")
    a += 1   # 在循环内部,a的值一直在变化,但b的值从来不变
    if a >= 20:
        break

循环嵌套

• 一个循环语句里面还有其他的循环语句
• 语法

while 条件:
    while 条件
    	代码
        

# ***
# ***

# 一个print只输出一个星号, 如何输出连续的三个星号
num1 = 0
while num1 < 2:  # 外循环一共循环2次,每次外循环的时候,内循环循环3次
    a = 0
    while a < 3:
        print("*", end="")
        a += 1
    print()  # 输出一个空的回车换行
    num1 += 1
print("end")

循环嵌套输出三角形

# 一个print只能输出一个星号
# *
# **
# ***
num1 = 0
while num1 < 3:
    a = 0
    while a <= num1:
        print("*", end="")
        a += 1
    print()
    num1 += 1

num1 = 0
while num1 < 5:
    a = 0
    while a <= num1:
        print("*", end="")
        a += 1
    print()
    num1 += 1

输出数字三角形

num1 = 0
while num1 < 5:
    a = 0
    while a <= num1:
        print(a + 1, end="")
        a += 1
    print()
    num1 += 1

for循环

• for主要是用于遍历字符串
• 字符串中有几个字符,for就会循环几次
• 语法

for 变量名 in 字符串:
    循环代码

# for主要用于遍历,字符串中有几个字符,for就会循环几次
# 这个for循环了5次,因为str1这个字符串中有5个字符
str1 = "hello"
for n in str1:   # n是自己定义的一个变量
    print("*")
    print(n)
# 第一次循环的时候n的值是h
# 第二次循环的时候n的值是e
# 第三次循环的时候n的值是l
# 第四次循环的时候n的值是l
# 第五次循环的时候n的值是o

str1 = "hello itcast"
sum = 0 # 存放计算结果
for n in str1:
    sum += 1  # 每循环一次sum的值就加1,结果是for循环几次,sum的值就是几

print(sum)

while和for的不同

• while用在指定次数的循环
• for主要用在遍历
• while和for可以互换

range函数

• 生成指定范围的一个数字序列
• 语法

range(start, stop, step)
start代表范围的开始值
stop代表范围的结束值,但不包含stop
step步长,可以为负数,正数代表升序范围,负数代表降序范围

range(1, 5, 1)   # 生成1, 2, 3, 4
range(1, 5)   # 生成1, 2, 3, 4
range(1, 6, 2)   # 生成1, 3, 5
range(6, 2, -1)  # 6, 5, 4, 3
range(6, 2, -2)   # 6, 4

用for实现指定次数的循环(用for替换while)

for 变量名 in range(开始值,结束值, 步长):
    执行代码

# a = 0
# while a < 10:
#     print(a)
#     a += 1
for a in range(0, 10):  # for用于遍历,所以这里遍历的是一个范围,a就是范围中每个数字
    print(a)

# 外循环循环了5次
# 内循环循环了5次
# 内循环的print("*", end="")
# 每次内循环完成外循环都有个print()
for a in range(0, 5):
    for b in range(0, 5):
        print("*", end="")
    print()

课堂练习

用for循环
计算从50到124之间所有偶数的累加和
包含50也包含124

# 在循环外,先定义一个变量存放累加和
# 在循环内,计算
# 循环完成后,输出这个变量的计算结果
sum = 0
for n in range(50, 125, 2):
    sum += n
print(sum)

DAY--------------------------------------------04（列表）

列表的定义和使用

• 列表用[]定义
• 列表中多个成员用逗号分隔
• 列表可以使用[索引]方式访问指定的成员
  • 第一个成员的索引编号是0
  • 不能访问不存在的索引编号

# list1是列表变量名, 列表中有三个成员
list1 = ['关羽', '曹操', '刘备']
print(list1[0])
print(list1[1])
print(list1[2])
print(list1[3])  # 显示第四个成员, 如果显示一个列表没有的成员,会出错

空列表

• 通过[]定义一个空的列表

list2 = []   # 定义了一个空列表变量叫list2
print(list2[0])  # 对于空列表,不能访问成员

查看列表所有方法

• dir(列表变量名)

print(dir(list1))

列表常用方法

insert

• insert作用是在列表指定位置插入指定的值
• 语法

insert(位置索引, 要插入的值)

list1 = ['刘备', '关羽', '张飞']
list1.insert(1, '吕布')
print(list1)

append

• append作用是列表最后位置添加成员
• 语法

append(要添加成员的值)

extend

• 把一个列表的成员追加到指定列表的后面
• 语法

extend(列表变量名)

list1 = ['刘备', '关羽', '张飞']
list1.insert(1, '吕布')
list1.append("曹操")
print(list1)
list2 = ['周瑜', '孙权']
list1.extend(list2)  # 把list2的所有成员,追加到list1的后面
print(list1)

修改列表成员的值

• 语法

列表变量名[索引] = 值

list1[1] = '许褚'  # 修改第二个成员的值

删除成员值

• 语法

del(列表变量[索引])

del(list1[4])

• 语法

remove(要删除的值)

list1.remove('张飞')

• 语法

pop()   # 删除列表中最后一个成员

list1.pop()

• 语法

pop(索引)  # 删除指定索引的值,功能与del类似

list1.pop(0)  # 删除索引为0的成员

• 语法

clear() # 	清空列表

list1.clear()

统计相同成员数量

• 语法

count(值)  # 如果有多个值,返回值的数量,如果没有值,返回0

list1.count('刘备')

返回指定值在列表中的索引编号

• 语法

index(指定的值, 起始位置)   # 如果不写起始位置,默认为0, 指定的值一定要存在,不然报错

list1.index('刘备')

排序

• 语法

sort()   # 对列表成员从小到大排序

list1.sort()

• 语法

sort(reverse=True) # 对列表成员从大到小排序

list1.sort(reverse=True)

逆置

• 语法

reverse()  # 把列表所有成员顺序颠倒

list1.reverse()

list1 = ['刘备', '关羽', '张飞']
list1.insert(1, '吕布')
list1.append("曹操")
print(list1)
list2 = ['周瑜', '孙权']
list1.extend(list2)  # 把list2的所有成员,追加到list1的后面
print(list1)
list1[1] = '许褚'  # 修改第二个成员的值
print(list1)
del(list1[4])
print(list1)
list1.remove('张飞')
print(list1)
list1.pop()
print(list1)
list1.pop(0)  # 删除索引为0的成员
print(list1)
list1.clear()
print(list1)

list1 = ['刘备', '关羽', '张飞', '刘备', '关羽']
print(list1.count('刘备'))
print(list1.count('张飞'))
print(list1.count('吕布'))
print(list1.index('刘备'))
list1 = [4, 3, 1, 56, 12, 67]
# list1.sort()
# list1.sort(reverse=True)
list1.reverse()
print(list1)

# 练习一
list1 = []
list1.append(5)
list1.append(9)
list1.append(13)
print(list1)
list2 = ['张飞', '刘备', '关羽', '刘邦', '刘老二', '曹操']
list2[4] = '周瑜'
print(list2)

for遍历列表

• 语法

for 变量名 in 列表:
    代码
列表中有多少成员,for就会循环多少次
变量名代表for每次循环的时候,得到的列表成员的值

list1 = ['张飞', '刘备', '关羽']
for n in list1:   # 这个for循环会循环三次,因为list1中有三个成员
    print(n)

# for第一次循环的时候n的值为'张飞'
# for第二次循环的时候n的值为'刘备'
# for第三次循环的时候n的值为'关羽'

list1 = [0, 3, 3, 9, 10, 3, 5]
sum = 0
for n in list1:
    sum += 1
print(sum)

list1 = [0, 3, 3, 9, 10, 3, 5]
sum = 0
for n in list1:
    sum += n
print(sum)

拆包

• 语法

变量1, 变量2, 变量n = 列表变量
# 等号左边和变量数量要和等号右边的列表中成员数量一致

list1 = ['关羽', '张飞', '刘备']
# a = list1[0]
# b = list1[1]
# c = list1[2]
a, b, c = list1   # 等号左边的变量数量要和等号右边的列表成员数量匹配
print(a, b, c)

列表推导式

• 作用就是来快速的生成成员数量庞大的列表
• 语法

列表变量名 = [x for x in range(开始值,结束值,步长)]
列表变量名 = [x for x in range(开始值,结束值,步长) if 条件]

list1 = [x for x in range(0, 10)]
print(list1)
list1 = [x for x in range(0, 100)]
print(list1)
list1 = [x for x in range(5, 20, 3)]
print(list1)
list1 = [x for x in range(30, 5, -1)]
print(list1)
list1 = [x for x in range(6, -10, -2)]
print(list1)
list1 = [x for x in range(0, 10) if x % 2 == 0]
print(list1)

list1 = [x for x in range(0, 101, 10)]
print(list1)
list1 = [x for x in range(0, 101) if x % 10 == 0]
print(list1)

for遍历列表,处理列表成员为不同数据类型的情况

• 当列表中成员数据类型不统一,但又要在for中通过一条代码来处理不同类型的数据,需要把数据做一个强转

list1 = ['张飞', 3, 4.5, '曹操']
a = 1
for n in list1:
    print("列表第%d个成员的值是%s" % (a, str(n)))
    a += 1

sum = 0
list1 = [56, '32', 45, '6']
for n in list1:
    sum += int(n)
print(sum)

课堂练习-写代码判断列表中名字为三个字的人有几个

list1 = ['张三', '李四', '刘老二', '王麻子', '王达成', '隔壁老王']
# 写代码判断列表中名字为三个字的人有几个

# 思路,首先得把每个名字遍历一遍
num1 = 0   # 存放名字为3个字的出现次数
for n in list1:  # n是列表中的每个成员,list1中有几个成员循环几次
    sum = 0
    for a in n:  # a是字符串n中的每个字符,n中有几个字符for循环几次
        sum += 1
    if sum == 3:
        num1 += 1
print(num1)
# 只要知道sum出现3有几次,就是这个答案

# 第一次循环n是张三
# 第二次循环n是李四
# 第三次循环n是刘老二
# 第四次循环n是王麻子
# 第五次循环n是隔壁老王
# n = "刘二"
# sum = 0
# for a in n:
#     sum += 1
# print(sum)

公共方法

len

• 返回非数字类型成员个数
  • len(字符串) – 返回字符串中字符的数量
  • len(列表) – 返回的是列表中成员的数量

list1 = [4, 2, 5, 3]
print(len(list1))
str1 = "hello"
print(len(str1))
list1 = ['刘备','关羽','张飞']
print(len(list1))
# 如果len里面放的是列表,返回列表成员的个数
# 如果len里面放的是字符串,返回字符串中字符的个数

max

• 返回列表中的最大值

max(列表)   -- 列表中最大的值
max(字符串)  -- 返回字符串中ASCII最大的那个字符

list1 = [54, 12, 78, 123, 77]
print(max(list1))
str2 = "hellaz"
print(max(str2))

min

• 返回列表中的最小值

min(列表)   -- 列表中最小的值
min(字符串)  -- 返回字符串中ASCII最小的那个字符

list1 = [54, 12, 78, 123, 77]
print(min(list1))
str2 = "hellaz"
print(min(str2))

in

• 判断指定的值是否在列表中存在

指定的值 in 列表
# 这个操作对字符串同样有效

not in

• 判断指定的值是否不在列表中

指定的值 not in 列表
# 这个操作对字符串同样有效

list3 = [4, 6, 1, 23]
if 4 in list3:
    print("有4")

if 5 not in list3:
    print("没有5")

str3 = "hello"
if "a" in str3:
    print("有a")

if "b" not in str3:
    print("没有b")

课堂练习-公共方法

list1 = ['张飞', '刘备', '关羽', '刘邦', '刘老二', '曹操']
if "刘备" in list1:
    list1.remove("刘备")
print(list1)

list2 = [3, 5, 67, 2, 34, 12, 5, 11]
# 求列表的平均值
# 求平均值就是先求和,然后除以成员数量
sum = 0
for n in list2:
    sum += n
print(sum / len(list2))

元组的定义

• 元组可以理解为一个只读的列表
• 成员不能修改,不能添加,不能删除的列表
• 语法

tuple1 = ('刘备', '关羽', '张飞') # 定义了一个元组,有三个成员
tuple2 = ()  # 定义了一个空元组
tuple3 = ('刘备', )  # 如果元组中只有一个值,那么后面必须写逗号
tuple4 = '刘备', '关羽', '张飞'  # 定义了一个元组,有三个成员
tuple5 = '刘备',  # 如果元组中只有一个值,那么后面必须写逗号
tuple6 = "刘备"  # 定义的不是元组,是字符串
tuple7 = ("刘备")  # 定义的不是元组,是字符串
print(tuple1)
print(tuple2)
print(tuple3)
print(tuple4)
print(tuple5)
print(tuple6)
print(tuple7)

• 用小括号来定义元组
• 小括号也可以省略
• 如果元组中只有一个成员,那么成员后必须写一个逗号

元组的常用方法

• 元组[索引]
  • 得到元组指定索引的值
  • 但不能修改指定索引的值
• count
• index
• 公共方法
  • len
  • min
  • max
  • in
  • not in
• 只要不涉及到修改成员的值,所有列表适用的方法,元组都通用

tuple1 = ('刘备', '关羽', '张飞')
a = tuple1[1]
print(a)
# tuple1[1] = '曹操'  # 元组的值不能修改
print(tuple1.count('刘备'))
print(tuple1.index('刘备'))
tuple2 = (4, 6, 1, 67, 100)
print(len(tuple2))
print(max(tuple2))
print(min(tuple2))
if 3 in tuple2:
    print("3在元组tuple2中")

for遍历元组的方法

• for遍历元组的语法与遍历列表是一样

for 变量名 in 元组名:
    代码

tuple1 = ('张三', '李四', 4, 12)
for n in tuple1:
    print(n)

元组和列表的转化

• 元组转列表
  • list(元组)
• 列表转元组
  • tuple(列表)

list1 = [1,2, 4, 2]
tuple1 = tuple(list1)   # 把list1转化为元组类型
print(tuple1)
tuple2 = (3, 6, 12, 100)
list2 = list(tuple2)   # 把元组tuple2转化为列表
print(list2)

课堂练习

在这里插入图片描述](https://i-blog.csdnimg.cn/direct/c195fa7133874964918186c257cc83c8.png)

list1 = ['刘备', '关羽', '张飞']
tuple1 = ('曹操',  '周瑜')
list1.extend(tuple1)   # 改变的是list1,tuple1没有改变
print(list1)
print(tuple1)
list1[3] = '张三'
print(list1)
print(tuple1)

课堂练习

• 把元组放到列表前面

list1 = ['刘备', '关羽', '张飞']
tuple1 = ('曹操',  '周瑜')
# list1.insert(0, tuple1)
# print(list1)
# for n in tuple1:
#     list1.insert(0, n)
# print(list1)
# for第一次循环的时候,n的值是曹操
# insert的时候,曹操是第一个成员
# for第二次循环的时候,n的值是周瑜
# insert的时候,周瑜是第一个成员

# 第一次循环的时候,把n放到0这个位置
# 第二次循环的时候,把n放到1这个位置
a = 0
for n in tuple1:
    list1.insert(a, n)
    a += 1
# 第一次循环a的值为0insert(0, 曹操)
# 第二次循环a的值为1insert(1, 周瑜)
print(list1)

DAY--------------------------------------------05（集合）

集合的定义

• 定义集合用{}
• 定义空集合用set()
• 集合与列表的区别
  • 集合中所有成员是无序的,列表中所有成员是有序的
  • 集合中成员的值不能重复,列表中成员的值可以重复

set1 = {'刘备', '关羽', '张飞'} # 定义了一个集合变量set1
set2 = set()   # 定义一个空集合set2
set3 = {'刘备', '关羽', '刘备'}
print(set1)
print(set2)
print(set3)

集合常用操作

• add添加值
  • 集合变量.add(值)
• pop删除一个值
  • 集合变量.pop()
• remove删除指定的值
  • 集合变量.remove(值)
• clear删除所有值
  • 集合变量.clear()

set1 = {'刘备', '关羽', '张飞'} # 定义了一个集合变量set1
set2 = set()   # 定义一个空集合set2
set3 = {'刘备', '关羽', '刘备'}
print(set1)
print(set2)
print(set3)

set1.add('曹操')
print(set1)
# set1.pop()
print(set1)
set1.remove('刘备')
print(set1)
set1.clear()
print(set1)

set1 = set()
a = 0
while a < 5:
    set1.add(int(input("请输入一个整数")))
    a += 1
print(min(set1))

循环遍历集合

• 语法

for n in 集合变量:
    循环中的代码

set1 = {'刘备', '关羽', '张飞'}
for n in set1:
    print(n)
# 这个for循环3次
# 第一次循环的时候n是刘备或者...
# 第二次循环的时候n是...
# 第三次循环的时候n是...
# 不管顺序是否对,但遍历的结果,总是能把集合中每个成员都显示出来

set1 = set()
a = 0
while a < 3:
    set1.add(input("请输入字符串"))
    a += 1

for n in set1:
    print(n)

字典的定义

• 用{}定义
• 用{}定义一个空字典
• 一个字典中可以存放多个键值对
  • 键key,一个字典中键不能重复
  • 值value
  • 键和值用冒号分隔
• 字典和集合的区别
  • 集合里面只有值
  • 字典里面是键值对

dict1 = {"name":"刘备", "age":20, "sex":"男"}
dict2 = {}  # 定义了一个空字典

新增或者修改键值对

• 字典[键] = 值
  • 如果键存在,就是修改值
  • 如果键不存在,就是新增键值对

dict1 = {"name":"刘备", "age":20, "sex":"男"}
dict1["name"] = "关羽"  # 修改键name对应的值
print(dict1)
dict1["class"] = '1班'   # 新增一个键值对,键为class,值为1班
print(dict1)

删除键值对

• pop(键)

dict1.pop('name')   # 删除name键,一旦键被删除,对应的值也同时被删除

清空

• clear()

dict1.clear()

得到键对应的值

• 变量名 = 字典[键]
  • 把键对应的值赋值给指定的变量

a = dict1["age"]  # 得到键对应的值

dict1 = {"name":"刘备", "age":20, "sex":"男"}
dict1["name"] = "关羽"  # 修改键name对应的值
print(dict1)
dict1["class"] = '1班'   # 新增一个键值对,键为class,值为1班
print(dict1)
dict1.pop('name')   # 删除name键,一旦键被删除,对应的值也同时被删除
print(dict1)
# dict1.clear()
print(dict1)
a = dict1["age"]  # 得到键对应的值
print(a)
b = dict1["sex"]  # 得到键sex对应的值
print(b)

dict1 = {"name":"周瑜", "age":32, "id":"001"}
dict1["sex"] = "男"
dict1.pop("id")
dict1["age"] = 26
print(dict1)

遍历字典

• 语法

for n in 字典:
    代码
# n是键

dict1 = {"name":"刘备", "age":20, "sex":"男"}
for n in dict1:
    print(n, dict1[n])   # dict1[n]意思就是得到键n对应的值
    #直接写n代表输出键,dict1[n]代表输出键对应的值

# for循环3次
# n代表键,第一次循环n的值是name,第二次循环n是age,第三次循环n是sex
# 如何在for循环中输出值?

通过items遍历字典

• 字典.items()返回一个包含键和值的元组

dict1 = {"name":"刘备", "age":20, "sex":"男"}
# for n in dict1.items():
#     print(n)
# 一旦使用了字典的items方法,n就是一个包含了键和值的元组
# n就是一个包含了两个成员的元组,第一个成员是键,第二个成员是值
# for循环了3次
# 第一次n = ('name', '刘备')
# 第二次n = ('age', 20)
# 第三次n = ('sex', '男')

# for n in dict1.items():
#     a, b = n  # 对一个元组进行拆包
#     print(a, b)

for a, b in dict1.items():  # a就是键,b就是键对应的值
    print(a, b)

dict1 = {"a":23, "b":4, "c":9, "d":3, "e":12}
for n in dict1:
    print(n, dict1[n])
print("------------------")
for a, b in dict1.items():
    print(a, b)

课堂练习-显示值9对应的键名

dict1 = {"a":23, "b":4, "c":9, "d":3, "e":12}
# 思路
# 遍历字典,在遍历的时候,检查值是否为9,如果是9,显示9对应的键
for n in dict1:
    if dict1[n] == 9:
        print(n)  # 如果条件成立,那么就显示n,就是是值9对应的键

字符串中的引号

• 在字符串中如果包含单引号,那么字符串用双引号引起来
• 在字符串中如果包含双引号,那么字符串用单引号引起来
• 如果字符串不包含引号,那么双引号单引号引字符串无所谓
• 如果字符串同时包含单引号和双引号,必须用转义字符的方式实现

str1 = "我\"你"
print(str1)
str1 = '我"你'
print(str1)
str2 = '我\'你'
print(str2)
str2 = "我'你"
print(str2)
str3  = "我你"
str4  = '我你'
str5 = "我\'你\"他"
print(str5)

通过[索引]访问字符串中的指定位置字符

• 字符串[索引]
  • 第一个字符的索引编号为0
• 只能得到指定位置的字符,不能修改指定位置的字符

str1 = "hello python"
a = str1[0]  # a就是字符串str1的第一个字符
print(a)
a = str1[3]  # a是字符串str1的第四个字符
print(a)
# str1[0] = "b" 不能通过[索引]的方式修改字符串中具体字符的值
# 字符串更像一个由字符构成的元组

遍历字符串

• 语法

for n in 字符串:
    代码

str1 = "我爱python"
for n in str1:
    print(n)

字符串常用方法

得到字符串指定位置的字符

• 字符串[索引]
  • 第一个字符的索引为0
  • 最后一个字符的索引为-1

str1 = "abcdefg"
print(str1[3])
print(str1[-1])
print(str1[-3])

判断字符串是否由纯字母组成

• isalpha()
  • 如果条件成立,返回True,否则返回False

str1 = "abcde123fg"
print(str1[3])
print(str1[-1])
print(str1[-3])
if str1.isalpha():
    print("字符串都是由字母构成的")

判断字符串是否由纯数字组成

• isdigit()
  • 如果字符串是纯数字组成,返回True,否则返回False

str2 = "1234ab5"
if str2.isdigit():
    print("str2是由纯数字组成的")

课堂练习

# a = int(input("请输入一个整数"))
# b = int(input("请输入一个整数"))
str1 = input("请输入一个整数") # 不要着急转int,转int前先判断能不能转
str2 = input("请输入一个整数") # 不要着急转int,转int前先判断能不能转
if str1.isdigit() and str2.isdigit():
    a = int(str1)
    b = int(str2)
    print(a + b)
else:
    print("老实点,小心挨打")

# 如果用户老老实实,输入的是整数,就计算两个整数的相加结果
# 如果用户不老实,输入的是不是整数,就显示"老实点,小心挨打"

islower

• 判断字符串是否全部由小写字母构成

isupper

• 判断字符串是否全部由大写字母构成

str1 = "aaaaAbbbcc"
if str1.islower():
    print("str1全部使用小写字母构成")

str2 = "ABaCDE"
if str2.isupper():
    print("str2全部都是大写字母构成")

find

• 查找子串在字符串中的位置
• 找不到返回-1,找到返回子串的位置

str1 = "hello python"
a = str1.find("python")
print(a)
a = str1.find("asffsf")
print(a)

replace

• 替换子串

str1 = "hello python"
a = str1.find("python")
print(a)
a = str1.find("asffsf")
print(a)
str2 = str1.replace("python", "world")
# 并不是str1改变了,是把str1中的python变为world给str2了
# str1的值并没有改变
print(str2)

count

• 查找子串出现次数
• 找到返回次数
• 找不到返回0

str3 = "hello world hello python"
a = str3.count("hello")
print(a)
a = str3.count("a")
print(a)

upper

• 把字符串中的小写字母改成大写字母

lower

• 把字符串中的大写字母改成小写字母

swapcase

• 把字符串中大小写字母反转

str1 = "AbCdEf"
str2 = str1.upper()  # str1的值并没有改变,str2是改变后的结果
print(str2)
str2 = str1.lower()
print(str2)
str2 = str1.swapcase()
print(str2)

lstrip

• 去除左侧空格

rstrip

• 去除右侧空格

strip

• 去除左右两侧空格

str1 = "  aaaaaaaaa    "
str2 = str1.lstrip()
print(str2)
str2 = str1.rstrip()
print("'%s'" % str1)
print("'%s'" % str2)
str2 = str1.strip()
print("'%s'" % str2)

split

• 根据子串拆分字符串
• 拆分后的结果,放到一个列表中

str1 = "aaaa_bbbb_eeee_hello"
list1 = str1.split("_") # 拆分之后,list1有四个成员,每个成员类型是字符串
print(list1)
str2 = "123@4567@000"
list2 = str2.split("@")
print(list2)

课堂练习-字符串中所有数字求和

str1 = "123 98 234 23 345"
# 思路,先把str1中每个数字分隔出来
list1 = str1.split(" ")
# 遍历列表,计算和
sum = 0
for n in list1:
    sum += int(n)    # n的类型为字符串,所以需要转化为int
print(sum)

去除字符串中间空格

str1 = "aaa   bbbbb     eeee     aaaaaa   bbbb"
str2 = str1.replace(" ", "")
print(str2)

格式化字符串

• %x意思是把一个十进制数按照十六进制方式显示,abcdef用小写表示
• %X意思是把一个十进制数按照十六进制方式显示,ABCDEF用大写表示

print("%x" % 9)
print("%x" % 10)  # 十进制的10就是十六进制的a
print("%x" % 16)  # 十进制的16就是十六进制的???
print("%x" % 15)  # 十进制的15就是十六进制的???
# 0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13 ...
print("%X" % 10)

str1 = "我是%s, 年龄是%d" % ("小明", 20)  # 把格式化字符串的结果,放到str1这个变量里面去
print(str1)

id = 1
name = '刘备'
weight = 80.2
tel = '13912345678'
print("*" * 20)
print("编号%06d" % id)
print("姓名:%s" % name)
print("体重:%.3f" % weight)
print("电话:%s" % tel)
print("*" * 20)

切片

• 只要可以使用[索引]访问成员的数据类型,都可以使用切片
• [开始索引:结束索引:步长]
  • 包含开始索引
  • 不包含结束索引
  • 省略开始索引,默认从0开始
  • 省略结束索引,默认到最后
  • 省略步长,默认步长为1

str1 = "abcdefg"
str2 = str1[2:4:1]
print(str2)
str2 = str1[:4:1]
print(str2)
str2 = str1[2::1]
print(str2)
str2 = str1[2:4:]
print(str2)

列表切片

list1 = ["刘备", "关羽", "张飞", "赵云", "马超"]
list2 = list1[2:4:]
print(list2)
list2 = list1[::2]
print(list2)

字符串切片案例

str1 = "我爱python"
str2 = str1[2:6]
print(str2)

str2 = str1[2:]
print(str2)

str2 = str1[:6]
print(str2)

str2 = str1[:]
print(str2)

str2 = str1[::2]
print(str2)

str2 = str1[1::2]
print(str2)

str2 = str1[2:-1]
print(str2)

str2 = str1[-2:]
print(str2)

str2 = str1[::-1]
print(str2)

课堂练习-列表以及成员都逆置

# ['刘备', '诸葛亮', '曹操', '周瑜', '关羽']
# 作业,把列表中个成员名字逆序
# 把列表中也逆序
list1 = ['刘备', '诸葛亮', '曹操', '周瑜', '关羽']
list1 = list1[::-1]   # 把列表中的成员逆置
# print(list1)
# 列表中每个字符串也要逆置
# 思路,遍历列表,在遍历出来每个字符串后,把每个字符串逆置
index = 0   # 定义了一个变量叫index,值为0
for n in list1:
    str1 = n[::-1]  # str1就是n颠倒后的结果
    list1[index] = str1  
    # 第一次循环的时候index的值为0,所以相当于list1[0] = str1
    # 第二次循环的时候index的值为1,所以相当于list1[1] = str1
    index += 1
print(list1)

索引为一个变量的用例

• 列表,或者元组,或者字符串都经常用[索引]的方式访问成员
• [索引]可以是一个具体的数字,也可以是一个变量

a = 1
列表[a] = '张三'   # 相当于列表[1] = '张三'

list1 = ['刘备', '关羽', '张飞']
list1[0] = '曹操'
print(list1)

list1[1] = '周瑜'
print(list1)
index = 2
list1[index] = '马超'
print(list1)
# 列表[索引] = 值 修改列表指定成员的值
# 索引可以是一个具体的数字,也可以是一个变量
index = 0
list1[index] = '张三'
print(list1)

多维列表

• 一个列表的成员,又是一个列表,这种列表就是多维列表

list1 = ['张飞', '刘备', '关羽']
# list1是一个一维的列表,有三个成员,分别为'张飞', '刘备', '关羽'三个字符串
list2 = [['张飞', '刘备', '关羽'], ['曹操', '周瑜', '孙权']]
# list2是一个二维列表,有两个成员
# 第一个成员也是一个列表['张飞', '刘备', '关羽']
# 第二个成员也是一个列表['曹操', '周瑜', '孙权']
a = list2[1]  # a是什么, a是一个列表['曹操', '周瑜', '孙权']
print(a)
print(a[1])  # 显示列表a的第二个成员

DAY--------------------------------------------06(函数)

函数简介

• 封装代码,提高代码的重用性

• 函数先定义,然后再调用

• 函数的定义

  • 把代码封装到函数内部

• 函数的调用

  • 执行函数内部封装的代码

函数定义和调用的语法

• 定义

def 函数名():
    函数内部封装的代码
# 函数名的命名规则与变量名命名规则一致

• 调用

函数名()

# 这里只是定义了一个函数,名叫hello
# 定义函数的时候,函数内部的代码并不会执行
def hello():
    print("hello world")
    print("hello world")
    print("hello world")

# 调用函数
# 只有调用函数的时候,函数内部的代码才回真正执行
hello()

• 定义函数和调用函数的说明

def my_func1():
    print("*" * 20)

my_func1()

函数的参数

• 函数的主要功能是封装代码
• 一个已经定义完成函数,不应该在去修改函数内部的定义代码
• 可以通过函数的参数,实现函数代码的灵活功能
• 语法

def 函数名(参数1, 参数2, .....):
    函数内部封装代码

函数名(参数1对应的值, 参数2对应的值, .......)
# 调用的时候和定义函数的时候,参数的数量要一一对应

# def my_sum():
#     a = 5
#     b = 6
#     print(a + b)
# 函数一旦定义完成,就不会再次修改函数内部代码
# my_sum()
def my_sum(a, b):
    print(a + b)
# 函数在定义的时候,有几个参数,调用的时候就要对应几个值
my_sum(5, 6)   # 把5赋值给my_sum函数的a参数,把6赋值给my_sum函数的b参数

形参与实参

• 形参
  • 定义函数的时候,括号里面的参数
  • 形参必须是变量
• 实参
  • 调用函数的时候,括号里面的参数
  • 实参可以是常量
  • 实参可以是变量
  • 实参可以是表达式
• 定义函数的时候,形参有值吗?
  • 定义函数的时候,形参没有值,只是一个变量名
  • 只要调用函数的时候,通过实参把值实时赋值给形参

def my_func2(num1):  # 定义函数的时候,形参没有值
    print("*" * num1)

my_func2(10)
my_func2(5)

函数的返回值

• 有时候,函数并不是要显示什么内容,而是要把一个值返回给调用者, 比如python自带的len函数就是这样的

• 函数内容通过return返回给调用者一个值

• return后面可以是常量,也可以是变量,还可以是表达式

# # 我们没有使用过函数 带返回值
# print("hello python")
# # 对于没有返回值的函数,调用方法,直接函数名(参数)
# # len是有返回值的函数
# a = len("hello python")  # 会把一个值返回给调用者
# print(a)
# print(len("hello python"))

def my_sum(a, b):
    return a + b   # 把a + b 的结果,返回给调用者

num1 = my_sum(2, 3)  # 这里就是调用my_sum函数,所以num1得到了函数的返回值
print(num1)
print(my_sum(5, 6))

def my_max(num1, num2):
    if num1 > num2:
        return num1
    else:
        return num2

a = my_max(50, 6)
print(a)

def my_func1(start, stop):
    sum = 0
    a = start
    while a <= stop:
        sum += a
        a += 1
    return sum

num1 = my_func1(4, 10)
print(num1)

def cir(r):
    pai = 3.14
    return pai * r ** 2

print(cir(10))
print(cir(15))
a = cir(20) + cir(30)
print(a)

• return的意义
  • 需求不停的变化,但函数一旦定义函数内部的代码不应该因为需求改变而改变
  • 所以要把因为需求而改变的代码放到函数之外,函数之内代码函数定义完不改变

def my_squar(height, width):
    return height * width

a = my_squar(3, 4) # 定义一个变量a,得到调用my_squar函数的返回值
print(a)

def my_func(num1, num2):
    if num1 % num2 == 0:
        return True
    else:
        return False

print(my_func(8, 4))
print(my_func(9, 4))

函数的嵌套

• 一个函数内部又调用了另一个函数

# 一个函数里面又调用另一个函数
def test1():
    print("我是test1")

def my_func():
    print("我是my_func")

def test2():  # 如果不调用test2函数,那么test1和my_func都不执行
    test1()  # test2内部调用了test1
    my_func()

test2()  # 程序第一条执行的语句

变量作用域

• 局部变量
  • 函数内部定义的变量就是局部变量
  • 局部变量只能在函数内部使用
  • 不同的函数局部变量名字可以相同
• 全局变量
  • 函数外部定义的变量就是全局变量
  • 全局变量在所有函数内部也可以使用
  • 局部变量能解决的问题,不要通过全局变量解决, 尽量少定义全局变量

局部变量作用范围

• 局部变量从调用函数的时候开始在内存出现,函数调用完毕,局部变量从内存消失
• 如果一个函数内部定义了局部变量,但这个函数没有被调用,那么局部变量也不在内存中存在

def my_func1():
    a = 1  # a是一个局部变量,只属于my_func1函数
    print(a)

def my_func2():
    a = 2 # a是一个局部变量,只属于my_func2函数
    print(a)

my_func1()  # 调用函数的时候,局部变量a出现了
# my_func1函数调用完毕,a消失了
# 定义函数的时候局部变量并不存在,只有调用函数的时候局部变量出现了
print("end")

全局变量的作用范围

• 全局变量一般定义在函数定义的上方
• 全局变量从定义变量开始在内存中出现,一直到程序运行完成,和程序一起从内存中消失

num1 = 2

def my_func1():
    print(num1)

def my_func2():
    print(num1)

my_func1()
num1 = 10
my_func2()
print("end")

局部变量与全局变量重名

• 如果在函数内部定义一个变量,名字和全局变量重名,那么在这个函数内部只能使用局部变量

num1 = 1
def my_func1():
    num1 = 10   # 这里不是为全局变量赋值, 这里是定义了一个局部变量, 名字和全局变量重名
    print(num1) # 打印的是局部变量num1的值
    num1 += 1   # 这里改的是局部变量num1的值

def my_func2():
    print(num1) # 全局变量num1

my_func1()
my_func2()
print(num1) # 打印的是全局变量num1的值

global关键字

• 当需要在函数内部修改全局变量的值,修改前需要用global修饰全局变量的名字

def 函数():
    global 全局变量名
    全局变量名 = 值

num1 = 10
def my_func1():
    global num1  # 函数内部就不存在和全局变量同名的局部变量了
    num1 = 1     # 这里是给全局变量num1修改值

def my_func2():
    print(num1)   # 如果在函数内部不修改全局变量的值,就不用global

print(num1)
my_func1()
print(num1)

name = "张三"

def my_test1():
    global name
    name = "李四"

my_test1()
print(name)

• 变量作用域的一个案例

a = 1

def my_test1():
    global a
    a = 2

def my_test2():
    a = 3   # 这里的a是一个只在my_test2里面的局部变量
    my_test1()

print(a)  # 程序入口在这里
my_test2()
print(a)

• 小结代码

a = 1
def my_test1():
    a = 2
    return a  # 函数的返回值都是依赖于return, 一个没有return的函数是没有返回值

def my_test2():
    a = 10

num1 = my_test2()  # 把my_test2的返回值赋值给变量num1

print(my_test1())  # 用print显示my_test1函数的返回值
print(a)

形参和实参的值传递

• 如果形参的类型为数字或者字符串,在函数内部修改了形参的值,实参的值不会改变

def my_func1(a):   # 这里的a是形参, 这里的a只是一个属于函数my_func1的形参,而不是全局变量a
    a += 1  # 在函数内部,修改了形参a的值,不是修改了全局变量a的值
    print(a) # 输出了形参a的值

a = 10  # 程序的入口 定义一个全局变量a,值是10
my_func1(a)  # 把全局变量a做为实参,去调用函数my_func1
print(a) # 全局变量a的值没有改变

# 当参数类型为数字或者字符串, 形参的值改变了,实参的值不会改变

• 函数的形参,本质就是一个属于函数内部的局部变量

a = 10

def my_test1(a):
    a += 1   # 重名后,这里操作的是局部变量a
    print(a)


my_test1(a)  # 把全局变量做为形参来调用my_test1函数了
print(a)
# 代码中一共出现两个变量
# 全局变量a和一个形参a(形参其实就是一个属于函数内部的局部变量)
# 以上代码的结果是全局变量与局部变量重名

• 形参类型如果是列表,集合字典,形参的值改变,会影响实参的值

a = [1, 2, 3]

def my_test1(a):  # 这里的a是一个形参,也是一个属于my_test1的局部变量
    a[0] = 10  # 修改的是形参a的值
    # 如果形参的类型为列表,集合和字典,修改形参的值会直接影响实参的值

print(a)  # 显示的是全局变量a的值
my_test1(a) # 把全局变量做为实参,来调用my_test1
print(a)

• 课堂练习-形参类型为list

a = [1, 2, 3]
def my_test1(a):
    a.clear()

my_test1(a)
print(a)

形参的缺省值

• 形参可以有缺省值,当调用函数的时候,没有提供相应的实参,那么形参会采用缺省值

def 函数名(形参 = 缺省值)

def my_test1(a, b = 10):  # 形参b有缺省值
    print(a, b)

def my_test2(a = 1, b = 2):
    print(a, b)

my_test1(1, 2)
my_test1(100)
my_test2()
my_test2(100, 12)

不能把有缺省值的形参写在没有缺省值形参的前面

# def my_test3(a = 10, b):  不能把有缺省值的形参写到没缺省值形参的前面
#     print(a, b)

lambda匿名函数

• lambda是给特别小型的函数准备一个简化语法
• 不用写def,也不用写return
• 一行代码就能定义一个函数
• 语法

lambda 参数1, 参数2, ..... : 函数执行代码

# def my_sum(a, b):
#     return a + b

my_sum = lambda a, b : a + b
num1 = my_sum(3, 4)
print(num1)
num1 = my_sum(23, 4)
print(num1)

# def my_max(a, b):
#     if a > b:
#         return a
#     else:
#         return b

# num1 = my_max(4, 5)
num1 = (lambda a, b : a if a > b else b)(4, 5)
print(num1)

• lambda注意事项
  • 匿名函数内部只能有一条语句,而且这条语句要有个具体的值返回
  • 匿名函数不能使用print

今天这篇文章就到这里了，大厦之成，非一木之材也；大海之阔，非一流之归也。感谢大家观看本文