✨博客主页: 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代码
- 在pycharm中运行python程序
- 第一个pycharm程序演练
- 在pycharm中运行多个py文件的注意项
- 注释
- 算数运算符
- 运算符优先级
- 变量
- 超市买苹果变量演练
- 超市买苹果-够10斤,减5块
- 课堂练习-算数运算符
- 课堂练习-变量a和b的值交换
- 变量名命名规则
- 显示python关键字
- 变量命名习惯
- python的数据类型
- 数字型变量计算
- 字符串的计算
- 字符串和整数的区别
- 不同数据类型转化
- 课堂练习-类型转化
- 课堂练习-四舍五入
- input函数
- 转化input输入的结果
- 超市买苹果-增强版
- 格式化字符串
- 格式化字符串主要功能
- 格式化字符串-名片
- 课堂练习-格式化字符
- 多条print输出到一行
- 转义字符
- DAY--------------------------------------------02 (判断)
- 判断的定义
- 比较运算符
- if基本语法
- pass占位符
- if演练
- 课堂练习-判断除数是否为0
- 课堂练习-计算器
- if双分支
- 逻辑运算符
- if多分支
- 课堂练习-判断正负数-0排除
- if嵌套
- 课堂练习
- 课堂练习-计算器加强
- 运算符
- 生成随机数
- 随机数生成飞机坦克大炮
- if综合应用
- 猜拳游戏改进版
- DAY--------------------------------------------03(循环)
- 程序的三种结构
- while基本语法
- 死循环
- 循环的计数习惯
- 课堂练习
- 循环计数
- break终止循环
- 人造死循环
- continue
- 循环嵌套
- 循环嵌套输出三角形
- 输出数字三角形
- for循环
- while和for的不同
- range函数
- 用for实现指定次数的循环(用for替换while)
- 课堂练习
- DAY--------------------------------------------04(列表)
- 列表的定义和使用
- 空列表
- 查看列表所有方法
- 列表常用方法
- insert
- append
- extend
- 修改列表成员的值
- 删除成员值
- 统计相同成员数量
- 返回指定值在列表中的索引编号
- 排序
- 逆置
- for遍历列表
- 拆包
- 列表推导式
- for遍历列表,处理列表成员为不同数据类型的情况
- 课堂练习-写代码判断列表中名字为三个字的人有几个
- 公共方法
- len
- max
- min
- in
- not in
- 课堂练习-公共方法
- 元组的定义
- 元组的常用方法
- for遍历元组的方法
- 元组和列表的转化
- 课堂练习
- 课堂练习
- DAY--------------------------------------------05(集合)
- 集合的定义
- 集合常用操作
- 循环遍历集合
- 字典的定义
- 新增或者修改键值对
- 删除键值对
- 清空
- 得到键对应的值
- 遍历字典
- 通过items遍历字典
- 课堂练习-显示值9对应的键名
- 字符串中的引号
- 通过[索引]访问字符串中的指定位置字符
- 遍历字符串
- 字符串常用方法
- 得到字符串指定位置的字符
- 判断字符串是否由纯字母组成
- 判断字符串是否由纯数字组成
- 课堂练习
- islower
- isupper
- find
- replace
- count
- upper
- lower
- swapcase
- lstrip
- rstrip
- strip
- split
- 课堂练习-字符串中所有数字求和
- 去除字符串中间空格
- 格式化字符串
- 切片
- 列表切片
- 字符串切片案例
- 课堂练习-列表以及成员都逆置
- 索引为一个变量的用例
- 多维列表
- DAY--------------------------------------------06(函数)
- 函数简介
- 函数定义和调用的语法
- 函数的参数
- 形参与实参
- 函数的返回值
- 函数的嵌套
- 变量作用域
- 局部变量作用范围
- 全局变量的作用范围
- 局部变量与全局变量重名
- global关键字
- 形参和实参的值传递
- 形参的缺省值
- lambda匿名函数
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
今天这篇文章就到这里了,大厦之成,非一木之材也;大海之阔,非一流之归也。感谢大家观看本文