Python语言基础教程(上)4.0

在这里插## 标题入图片描述

> 						大家好,我是程序员小羊!

✨博客主页: 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
今天这篇文章就到这里了,大厦之成,非一木之材也;大海之阔,非一流之归也。感谢大家观看本文

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/881097.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

【LeetCode每日一题】——401.二进制手表

文章目录 一【题目类别】二【题目难度】三【题目编号】四【题目描述】五【题目示例】六【题目提示】七【解题思路】八【时间频度】九【代码实现】十【提交结果】 一【题目类别】 回溯 二【题目难度】 简单 三【题目编号】 401.二进制手表 四【题目描述】 二进制手表顶部…

4.提升客户服务体验:ChatGPT在客服中的应用(4/10)

本文大纲旨在指导撰写一篇全面探讨ChatGPT如何通过优化客户服务流程、提供实际应用案例和用户反馈&#xff0c;以提升客户服务体验的深入博客文章。 引言 在当今竞争激烈的商业环境中&#xff0c;客户服务已成为企业成功的关键因素。优质的客户服务不仅能够增强客户满意度和忠…

Docker 进入容器并运行命令的方法

目录 理解 Docker 容器的基本概念 使用 docker exec 进入运行中的容器 基本用法 常用选项解析 选项详解 实际案例演示 1. 进入容器的交互式 Shell 2. 在容器中运行单个命令 3. 以指定用户运行命令 4. 设置环境变量并运行命令 5. 指定工作目录 使用 docker attach 附…

数据结构-线性表顺序单项链表双向链表循环链表

1数据结构概述 数据结构是计算机组织、存储数据的方式。是思想层面的东西&#xff0c;和具体的计算机编程语言没有关系。可以用任何计算机编程语言去实现这些思想。 1.1 数据逻辑结构 反映数据逻辑之间的逻辑关系&#xff0c;这些逻辑关系和他们咱在计算机中的存储位置无关。…

原生+jquery写自动消失的提示框

<!DOCTYPE html> <html lang"en"> <head> <meta charset"UTF-8"> <meta name"viewport" content"widthdevice-width, initial-scale1.0"> <title>自动消失消息提示</title> <style>/…

使用scp命令从本地往服务器传输文件失败

解决办法&#xff1a; 找到这个文件&#xff0c;打开&#xff0c;将里面的服务器ip对应的一行数据删掉即可。

6.C_数据结构_查询_哈希表

概述 哈希表的查询是通过计算的方式获取数据的地址&#xff0c;而不是依次比较。在哈希表中&#xff0c;有一个键值key&#xff0c;通过一些函数转换为哈希表的索引值。 其中&#xff1a;这个函数被称为哈希函数、散列函数、杂凑函数&#xff0c;记为&#xff1a;H(key) 哈希…

Java知识点小结3:内存回收

文章目录 对象引用强引用软引用&#xff08;SoftReference&#xff09;弱引用&#xff08;WeakReference&#xff09;考一考 虚引用&#xff08;PhantomReference&#xff09;总结 垃圾回收新生代老年代永生代 内存管理小技巧尽量使用直接量使用StringBuilder和StringBuffer进行…

7--SpringBoot-后端开发、原理详解(面试高频提问点)

目录 SpringBoot原理 起步依赖 自动配置 配置优先级 Bean设置 获取Bean 第三方Bean SpringBoot原理 内容偏向于底层的原理分析 基于Spring框架进行项目的开发有两个不足的地方&#xff1a; 在pom.xml中依赖配置比较繁琐&#xff0c;在项目开发时&#xff0c;需要自己去找…

最新编程语言排行榜:Python创新高!

2024年编程语言排行榜又迎来了令人惊喜的变化&#xff01;Python&#xff0c;这门因简单易学而受到广大程序员青睐的语言&#xff0c;再次突破历史记录&#xff0c;稳居排行榜前列。无论是数据分析、机器学习&#xff0c;还是Web开发&#xff0c;Python都展现出了强大的生命力和…

828华为云征文 | 使用Flexus云服务器X实例部署GLPI资产管理系统

828华为云征文 | 使用Flexus云服务器X实例部署GLPI资产管理系统 1. 部署环境说明2. 部署基础环境2.1. 操作系统基本配置2.2. 部署Nginx2.3. 部署MySQL2.4. 部署PHP 3. 部署GLPI资产管理系统 1. 部署环境说明 本次环境选择使用华为云Flexus云服务器X实例&#xff0c;因为其具有高…

无人机之AI跟踪篇

无人机的AI识别技术依托于计算机视觉和深度学习技术&#xff0c;实现了对目标的快速精准识别&#xff0c;在多个领域展现出了巨大的应用潜力和价值。以下是对无人机AI识别技术的详细解析&#xff1a; 一、无人机AI识别算法的基础原理 无人机AI识别算法主要基于先进的计算机视觉…

【刷题日记】15. 三数之和

15. 三数之和 两数之和可以用巧思也可以用map 三数之和会更加复杂一点&#xff0c;且这道题还需要考虑避免重复答案&#xff01; 思路&#xff1a; 特判&#xff1a;检如果nums 为 null 或长度小于 3直接返回空数组。排序&#xff1a;使用 sort对数组进行升序排序。就变成了…

JS实现树形结构数据中特定节点及其子节点显示属性设置的技巧(可用于树形节点过滤筛选)

大家好&#xff0c;今天我要分享的是如何在树形结构的数据中&#xff0c;根据特定条件设置节点及其所有子节点的显示属性。在实际项目中&#xff0c;这种需求非常常见&#xff0c;特别是在需要动态展示和隐藏节点的情况下。下面我将通过一个具体的示例来讲解实现过程。 需求分析…

Web开发:ABP框架3——入门级别的接口增删改查实现原理

一、上节回顾 运用了ABP框架&#xff0c;使用了EFcore进行增删改查 二、程序的入口 代码解说&#xff1a; public class Program // 定义程序主类 {public async static Task<int> Main(string[] args) // 主方法&#xff0c;返回状态码{// 配置Serilog日志Log.Logger…

【QT】定时器使用

文章目录 关于 Qt 定时器使用的注意细节总结实例-检查工具使用周期时间是否合理UI设计头文件 remind.h源文件 remind.cpp实现效果 关于 Qt 定时器使用的注意细节总结 一、创建与初始化 使用 QTimer 类来创建定时器。可以在构造函数中指定父对象&#xff0c;确保定时器在正确的…

【C++】STL----list常见用法

&#x1f525;个人主页&#x1f525;&#xff1a;孤寂大仙V &#x1f308;收录专栏&#x1f308;&#xff1a;C从小白到高手 &#x1f339;往期回顾&#x1f339;&#xff1a;[C]vector常见用法 &#x1f516; 流水不争&#xff0c;争的是滔滔不息。 文章目录 一、list的介绍li…

【网络通信基础与实践第二讲】包括互联网概述、互联网发展的三个阶段、互联网的组成、计算机网络的体系结构

一、互联网概述 计算机网络是由若干节点&#xff08;node&#xff09;和连接这些节点的链路&#xff08;link&#xff09;组成。 网络之间还可以通过路由器互联起来&#xff0c;这就构成了一个覆盖范围更大的计算机网络。这样的网络称为互联网。 网络把许多计算机连接在一起…

SpringCloud-04 OpenFeign服务调用与负载均衡

OpenFeign是一个声明式、模板化的HTTP客户端&#xff0c;它简化了在Java应用程序中调用RESTful API的过程。OpenFeign是Netflix开发的一个开源项目&#xff0c;它构建在Feign的基础上&#xff0c;为开发者提供了更加简单、灵活的方式来实现HTTP请求。OpenFeign的特点包括&#…

计算机网络:概述 - 性能指标

目录 一. 速率 二. 带宽 三. 吞吐量 四. 时延 五. 时延带宽积 六. 往返时间RTT 七. 利用率 八. 丢包率 此博客介绍计算机网络中的性能指标&#xff0c;性能指标从不同的角度来度量计算机网络的性能。下面介绍几个常用的性能指标&#xff1a; 一. 速率…