Python基础入门知识笔记

Python基础入门知识笔记

基础知识

字面量

• 字面量：在代码中，被写下来的固定的值，称之为字面量

类型	描述	说明
数字(Number)	整数(int)	如：10、-10
数字(Number)	浮点数(float)	如：13.14、-13.14
数字(Number)	复数(complex)	如：4+3j，以j结尾表示复数
数字(Number)	布尔(bool)	布尔表达现实生活中的逻辑，即真和假，True表示真，False表示假。True本质上记作1，False记作0
字符串(String)	描述文本的一种数据类型	字符串由任意的字符组成
列表(List)	有序的可变序列	Python中使用最频繁的数据类型，可有序记录一推数据
元组(Tuple)	有序的不可变序列	可有序记录一堆不可变的Python数据集合
集合(Set)	无序不重复集合	可无序记录一堆不重复的Python集合
字典(Dictionary)	无序Key-Value集合	可无序记录一堆Key-Value型的Python数据集合

注释

注释的作用：

• 注释：在程序中对代码进行解释说明的文字
• 作用：注释不是程序，不能被执行，只是对程序代码进行解释说明，让别人可以看懂程序代码的作用，能够大大增强程序的可读性

注释的分类：

• 单行注释：以# 开头，#右边的所有文字当做说明，而不是真正要执行的程序，起辅助说明作用

  # 我是一行注释
  print("Hello World")
  

• 多行注释：以 一对三个双引号 引起来（“”“注释内容”“”)来解释说明一段代码

  """
  	我是注释
  """
  print("Hello World")
  

变量

• 在程序运行时，能储存计算结果或能表示值得抽象概念
• 简单的说，变量就是在程序运行时，记录数据用的

变量名称 = 变量的值

数据类型

• 入门阶段接触如下三类数据类型

类型	描述	说明
string	字符类型	用引号引起来的数据都是字符串
int	整型（有符号）	数字类型，存放整数
float	浮点型（有符号）	数字类型，存放小数

type()语句：

• 我们可以通过type()语句来得到数据的类型：
• 语法： type(被查看类型的数据)

# 方式一：使用print直接输出类型信息
print(type(3))
print(type(13.14))
print(type("类型"))
# 方式二：使用变量存储type语句的结果
int_type = type(3)
float_type = type(13.14)
string_type = type("类型")
print(int_type)
print(float_type)
print(string_type)
# 方式三：使用type()语句，查看变量中存储的数据类型
name = "张三"
name_type = type(name)
print(name_type)

数据类型转换

常见的转换语句：

语句（函数）	说明
int(x)	将x转换为一个整数
float(x)	将x转换为一个浮点数
str(x)	将对象x转换为字符串

# 数字转换成字符串
num_str = str(11)
print(type(num_str), num_str)
# 字符串转成数字
num = int("11")
print(type(num), num)
# 整数转浮点数
float_num = float(10)
print(type(float_num), float_num)  # 10.0
# 浮点数转整数
int_num = int(13.14)
print(type(int_num), int_num)  # 11

标识符

什么是标识符？

• 在Python中，我们可以给很多东西起名字，如：变量的名字、方法的名字、类的名字等等，统一称为标识符，用来做内容的标识

• Python中，标识符命名的规则主要有三类

  1. 内容限定

     标识符命名中只允许出现：

     • 英文
     • 中文
     • 数字
     • 下划线（_）

     不推荐使用中文

     数字不可以开头

  2. 大小写敏感

  3. 不可使用关键字

     

变量命名规范：

• 见名知意
  1. 明了：尽量做到，看到名字，就知道是什么意思
  2. 简洁：尽量在确保“明了”的前提下，减少名字的长度
• 下划线命名法：
  1. 多个单词组合变量名，要使用下划线做分割
• 英文字母全小写

运算符

算数（数学）运算符：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c5Hx3z1V-1676355386430)(C:\Users\Pomelo\AppData\Roaming\Typora\typora-user-images\1676043743545.png)]

赋值运算符：

运算符	描述	实例
=	赋值运算符	把等号右边的结果赋给左边
+=	加法赋值运算符	c += a == c = c + a
-=	减法赋值运算符	c -= a == c = c - a
*=	乘法赋值运算符	c *= a == c = c * a
/=	除法赋值运算符	c /= a == c = c / a
%=	取模赋值运算符	c %= a == c = c % a
**=	幂值赋值运算符	c ** = a == c = c ** a
//=	取整除赋值运算符	c // = a == c = c // a

字符串扩展

字符串的三种定义方法

• 字符串在Python中有多种定义形式：
  1. 单引号定义法：name = ‘字符串’
  2. 双引号定义法：name = “字符串”
  3. 三引号定义法：name = “”“字符串”“”
• 三引号定义法，和多行注释的写法一样，同样支持换行操作，使用变量接收它，它就是字符串，不使用变量接收它，就可以作为多行注释使用

字符串的拼接

print("Hello"+"World")

name = "Hello"
address = "World"
print(name+address)

字符串格式化

• 我们可以通过如下的语法，完成字符串和变量的快速拼接

  name = "中国"
  message = "我爱 %s" % name
  print(message)
  

  其中的 %s

  • % 表示：我要占位
  • s 表示：将变量变成字符串放入占位的地方

• 最常用的数据类型占位符

  格式符号	转化
  %s	将内容转换成字符串，放入占位位置
  %d	将内容转换成整数，放入占位位置
  %f	将内容转换成浮点型，放入占位位置

字符串格式化的精度控制

我们可以使用辅助符号“m.n”来控制数据的宽度和精度

• m，控制宽度，要求是数字（很少使用），设置的宽度小于数字自身，不生效
• .n，控制小数点精度，要求是数字，会进行小数的四舍五入

实例：

• %5d：表示将整数的宽度控制在5位，如数字11，被设置为5d，就会变成：[空格][空格][空格]11,用三个空格补足宽度

• %5.2f: 表示将宽度控制在5位，将小数点精度设置为2

  小数点和小数部分也算入宽度计算。如，对11.345设置了%7.2f后，结果是：[空格][空格]11.35 。2个空格补足宽度，小数部分限制2位精度后，四舍五入为.35

• %.2f：表示不限制宽度，小数部分限制2位精度后，四舍五入为.35，结果为11.35

字符串格式化的方式二

• 快速写法

  # 格式： f"内容{变量}"
  name = "张三"
  age = 18
  stock_price = 19.99
  print(f"我叫{name},今年{age}，微信还有{stock_price}元零钱")
  

对表达式进行格式化

• 表达式：一条具有明确执行结果的代码语句

  print("1*1的结果是：%d" % (1*1))
  print(f"1*1的结果是：{1*1}")
  print("字符串在Python中的类型是：%s" % type('字符串'))
  

字符串格式化练习

"""
定义如下变量：
name，公司名
stock_price，当前股价
stock_code，股票代码
stock_price_daily_growth_factor，股票每日增长系数，浮点数类型，比如1.2
growth_days,增长天数
计算,经过growth_days天的增长后,股价达到了多少钱
使用字符串格式化进行输出,如果是浮点数,要求小数点精度2位数。
"""
name = "强盛集团"
stock_price = 19.99
stock_code = "003032"
stock_price_daily_growth_factor = 1.2
growth_days = 7
share_price = stock_price * stock_price_daily_growth_factor ** growth_days
print(f"{name},股票代码：{stock_code}，当前股价：{stock_price}")
print("每日的增长系数是：%.1f，经过%d天增长后，股价达到了：%.2f" % (stock_price_daily_growth_factor, growth_days, share_price))

数据输入（input语句）

• 使用input()语句可以从键盘获取输入
• 使用一个变量接收（存储）input语句获取的键盘输入数据即可

user_name = input()
user_type = input()
print(f"您好：{user_name},您是尊贵的：{user_type}用户，欢迎您的光临。")

Python判断语句

布尔类型（bool）

• 进行判断只有两个结果

  • True 表示真
  • False 表示假

• 定义变量存储布尔类型数据：

  变量名称 = 布尔类型字面量
  

比较运算符

• == 判断内容是否相等
• != 判断内容是否不相等
• <= >= > <

if语句的基本格式

• 程序中的判断

  if 要判断的条件：
  	条件成立时，要做的事情
      
  if age >= 18:
      print("我已经成年了")
  

if else 语句

• 程序中的判断

  if 条件:
      语句1
      语句2
      语句3
      ...
  else:
      语句1
      语句2
      语句3
      ...
  

  print("欢迎来到游乐场，儿童免费，成人收费。")
  age = int(input("请输入您的年龄："))
  if age >= 18:
      print("您已成年，游玩需要补票10元。")
  else:
      print("您未成年，可以免费游玩。")
  print("祝您游玩愉快。")
  

if elif else语句

• 注意：

  1. elif可以写多个
  2. 判断是互斥有序的，上一个满足后面的就不会判断了
  3. 可以在条件判断中，直接写个input语句，节省代码量

• 程序中的判断

  if 条件1:
      条件1满足应做的事情
      ...
  elif 条件2:
      条件2满足应做的事情
      ...
  elif 条件N:
      条件N满足应做的事情
      ...
  else:
      所有条件都不满足应做的事情
      ...
  

  print("欢迎来到动物园")
  age = int(input("请输入您的身高（cm）："))
  vip_level = int(input("请输入你的VIP等级（1~5）："))
  if age >= 120:
      print("您的身高超出120cm，游玩需要补票10元。")
  elif vip_level >= 3:
      print("您的VIP级别大于3，可以免费游玩。")
  else:
      print("您的身高未超出120cm，可以免费游玩。")
  rint("祝您游玩愉快。")
  

  • 满足是互斥且有序的
    1. 满足1将不会理会2和3
    2. 满足2将不会理会3
    3. 1,2,3均不满足，进入else
    4. else也可以省略不写，效果等同3个独立的if判断

判断语句的嵌套

• 基础语法格式

  if 条件1:
      语句1
      语句2
      
      if 条件2:
          语句3
          语句4
  

• 关键点在于：空格缩进

• 通过空格缩进来决定语句之间的关系：层次关系

age = int(input("请输入您的年龄："))
time = int(input("请输入入职时间（年）："))
level = int(input("请输入您的级别："))
if age >= 18:
    print("成年人符合，继续判断")
    if age < 30:
        print("年龄达标继续判断")
        if time > 2:
            print("入职时间大于两年，满足条件，可以领取")
        elif level > 3:
            print("级别大于3级的成年人可直接领取礼物")
    else:
        print("您的年龄过大或者级别小于3级，不可领取")
else:
    print("未成年不可领取礼物")

实战案例

import random
num = random.randint(1, 10)

guess_num = int(input("请输入您要猜的数字："))
if guess_num == num:
    print("恭喜您，猜对了")
else:
    if guess_num > num:
        print("您猜大了")
    else:
        print("您猜小了")
    guess_num = int(input("请重新输入您要猜的数字："))
    if guess_num == num:
        print("恭喜您猜对了")
    else:
        if guess_num > num:
            print("您猜大了")
        else:
            print("您猜小了")
        guess_num = int(input("请您最后一次输入您要猜的数字"))
        if guess_num == num:
            print("恭喜您猜对了")
        else:
            if guess_num > num:
                print("您猜大了")
            else:
                print("您猜小了")
            print("很遗憾，您未能猜中，数字是：%d" % num)

Python循环语句

while循环的基础语法

• 程序中的循环

  while 条件:
      语句1
      语句2
      语句3
      ...
  

• 只要条件满足，会无限循环执行

• 注意点：

  1. while的条件需要得到布尔类型，True表示继续循环，False表示结束循环
  2. 需要设置循环终止的条件，i += 1 配合 i < 100，就能确保100次后停止，否则将无限循环
  3. 空格缩进和if判断一样，都需要设置

while循环的基础案例

"""
设置一个1~100的随机整数变量，通过while循环，配合input语句，判断输入的数字是否等于随机数
"""
import random
num = random.randint(1, 100)

count = 1
guess_number = int(input("请输入您猜的数字(1~100)："))
while guess_number != num:
    if guess_number > num:
        print("您猜的数字大了")
    else:
        print("您猜的数字小了")
    count += 1
    guess_number = int(input("请输入您猜的数字(1~100)："))
print(f"恭喜您猜对了，您一共猜了{count}次")

import random
count = 0

num = random.randint(1, 100)
flag = True
while flag:
    guess_num = int(input("请输入你猜测的数字："))
    count += 1
    if guess_num == num:
        print("恭喜您猜中了")
        flag = False
    else:
        if guess_num > num:
            print("你猜大了")
        else:
            print("你猜小了")

print(f"您一共猜了{count}次")

while循环的嵌套应用

• 程序中的循环

  while 条件1:
      语句1
      语句2
      语句3
      ...
      
      while 条件2:
          语句1
          语句2
          语句3
          ....
  

• 同判断语句的嵌套一样，循环语句的嵌套，要注意空格缩进

• 基于空格缩进来决定层次关系

• 注意条件的设置，避免出现无限循环(除非真的需要无限循环)

whlie循环的嵌套案例

• 输出不换行的功能

  print("Hello", end='')
  print("World", end='')
  # 在print语句中，加上end=''即可输出不换行了
  

• 制表符 \t:

  在字符串中，\t 相当于一个Tab键 他可以让我们的多行字符串进行对齐

  print("Hello\tWorld")
  print("itable\tbest")
  
  # Hello    World
  # itable   best
  

• 乘法表打印

  i = 1
  while i <=9:
      j = 1
      while j <= i:
          print(f"{j}*{i}={j*i}\t", end='')
          j += 1
      i += 1
      print()
  

for循环的基础语法

• while循环的循环条件是自定义的，自行控制循环条件
• for循环是一种“轮询”机制，是对一批内容进行“逐个处理”

基础语句

• 程序中的for循环

  for 临时变量 in 待处理的数据集：
  
  	循环满足条件执行的代码
  

• 遍历字符串

  # 定义字符串name
  name = "HelloWorld"
  # for循环处理字符串
  for x in name:
      print(x)
  

• for循环是将字符串的内容：依次取出

• for循环也被称为：遍历循环

range语句

• 语法中的：待处理数据集，严格来说，称之为：序列类型

• 序列类型是指，其内容可以一个个依次取出的一种类型，包括：

  字符串 列表 元组 等

• 语法：

  1. range(num)

     获取一个从0开始，到num结束的数字序列(不含num本身)

     例如：range(5)取得的数据是：[0,1,2,3,4]

  2. range(num1, num2)

     获取一个从num1开始，到num2结束的数字序列(不包含num2本身)

     如：range(5,10)取得的数据是：[5,6,7,8,9]

  3. range(num1, num2, step)

     获得一个从num1开始，到num2结束的数字序列(不包含num2本身)

     数字之间的步长，以step为准(step默认为1)

     如，range(5, 10, 2)取得的数据是：[5,7,9]

变量作用域

• for循环中的临时变量，其作用域限定为：

  循环内

• 这种限定：

  1. 是编程规范的限定，而非强制限定
  2. 不遵守也能正常运行，但是不建议这样做
  3. 如需访问临时变量，可以预先在循环外定义它

for循环的嵌套应用

• 程序中的嵌套for循环

  for 临时变量 in 待处理数据集(序列):
      语句1
      语句2
      语句3
      ...
      for 临时变量 in 待处理数据集(序列):
          语句1
          语句2
          语句3
          ...
  

• for循环和while循环可以相互嵌套使用

break和continue

• continue
  1. continue关键字用于：中断本次循环，直接进入下一次循环
  2. continue可以用于：for循环和while循环，效果一致
• break
  1. break关键字在于：直接结束循环
  2. break可以用于： for循环的while循环，效果一致

综合案例

import random

money = 10000

for x in range(1, 21):
    score = random.randint(1, 10)

    if score < 5:
        print(f"员工{x},绩效分{score}，低于5，不发工资，下一位。")
        continue
    else:
        money -= 1000
        print(f"员工{x}发放工资1000元，账户余额还剩{money}元")

    if money == 0:
        print("工资发完了，下个月领取吧。")
        break    

Python函数

函数介绍

• 函数：是组织好的，可重复使用的，用来实现特定功能的代码块
• 函数的好处：
  1. 将功能封装在函数内，可供随时随地重复利用
  2. 提高代码的复用性，减少重复代码，提高开发效率

函数的定义

• 函数的定义

• def 函数名（传入参数）:
  	函数体
  	return 返回值
  

• 函数的调用： 函数名（参数）

函数的参数

• 传入参数的功能是：在函数进行计算的时候，接受外部(调用时)提供的数据
• 参数之间使用逗号进行分隔
• 传入的时候，按照顺序传入数据，使用盗号分隔

函数的返回值

返回值的定义

• 程序中函数完成事情后，最后给调用者的结果

• def 函数(参数...):
      函数体
      return 返回值
  
  
  变量 = 函数(参数)
  

None类型

• Python中有一个特殊的字面量：None，其类型是：<class ‘NoneType’>
• 无返回值的函数，实际上就是返回了：None这个字面量
• None表示：空的、无实际意义的意思

1. 用在函数无返回值上

2. 用在if判断上

   • 在if判断中，None等同于False
   • 一般用于在函数中主动返回None，配合if判断做相关处理

3. 用于声明无内容的变量上

   • 定义变量，但暂时不需要变量有具体值，可以用None来代替

     # 暂不赋予变量具体值
     name = None
     

函数说明文档

• 函数式纯代码语言，想要理解其含义，就需要一行行的去阅读理解代码，效率比较低

• 我们可以给函数添加说明文档，辅助理解函数的作用

• def func(x, y):
      """
      :param x: 形参x的说明
      :param y: 形参y的说明
      :return: 返回值的说明
      """
      函数体
      return 返回值
  

• 通过多行注释的形式，对函数进行说明解释，内容应写在函数体之前

函数的嵌套调用

• 所谓函数的嵌套调用指的是一个函数里面有调用了另一个函数

def func_b():
    print("------2------")


def func_a():
    print("------1------")
    func_b()
    print("-----3------")


func_a()

变量的作用域

• 变量作用域指的是变量的作用范围
• 主要分类：局部变量和全局变量

局部变量

• 所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效
• 作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量

全局变量

• 所谓全局变量，指的是在函数体内、外都能生效的变量

global关键字

• 使用global关键字可以在函数内部声明变量为全局变量

  num = 200
  
  
  def tsetA():
      print(num)
  
  
  def tsetB():
      global num
      num = 100
      print(num)
  
  
  tsetA()  # 200
  tsetB()  # 100
  print(num)  # 100
  
  

综合案例

import random

money = 500000


def look():
    print("--------查询余额--------")
    print(f"周杰伦您好，您的余额剩余：{money}元")


def delete():
    print("--------取款--------")
    print("请输入要取款多少：")
    money1 = int(input())
    global money
    money -= money1
    print(f"周杰伦您好，您的余额剩余：{money}元")


def add():
    print("--------存款--------")
    print("请输入要存款多少：")
    global money
    money1 = int(input())
    money += money1
    print(f"周杰伦您好，您存款{money1}元成功")
    print(f"周杰伦您好，您的余额剩余：{money}元")


def main():
    while True:
        print("--------主菜单--------")
        print("周杰伦，您好，欢迎来到黑马ATM，请选择操作：")
        print("查询余额\t[输入1]")
        print("存款\t\t[输入2]")
        print("取款\t\t[输入3]")
        print("退出\t\t[输入4]")

        count = int(input())
        if count == 1:
            look()
        elif count == 2:
            add()
        elif count == 3:
            delete()
        elif count == 4:
            return


main()

Python数据容器

数据容器入门

Python中的数据容器：

• 一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素

• 每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

• 数据容器根据特点的不同，如：

• • 是否支持元素重复

  • 是否可以修改

  • 是否有序，等

  • 分为5类，分别是：

    列表（list） 、元组（tuple） 、字符串（str） 、集合（set） 、字典（dict）

数据容器：list(列表)

列表可以被修改

列表的定义

• 基本语法

  # 字面量
  [元素1，元素2，元素3，...]
  
  # 定义变量
  变量名称 = [元素1，元素2，元素3，...]
  
  # 定义空列表
  变量名称 = []
  变量名称 = list()
  

  列表的每一个数据，称之为元素

  • 以[]作为标识
  • 列表每一个元素之间用逗号隔开

列表的下标索引

• 列表中的每一个元素，都有其位置下标索引，从前向后的方向，从0开始，依次增加

  name_list = ['Tom', 'Lily', 'Rose']
  print(name_list[0])  # 结果：Tom
  print(name_list[1])  # 结果：Lily
  print(name_list[2])  # 结果：Rose
  

• 或者，可以反向索引，也就是从后向前：从-1开始，一次递减（-1，-2，-3…）

  name_list = ['Tom', 'Lily', 'Rose']
  print(name_list[-1])  # 结果：Rose
  print(name_list[-2])  # 结果：Lily
  print(name_list[-3])  # 结果：Tom
  

  嵌套列表的下标（索引）

  

  • my_list = [[1, 2, 3], [4, 5, 6]]
    print(my_list[0])   # 第一个元素   [1, 2, 3]
    print(my_list[0][0])   # 第一个元素中的第一个元素  
    

列表的常用操作（方法）

列表的查询功能

查找某元素的下标

功能：查找指定元素在列表的下标，如果找不到，报错ValueError

语法：列表.index(元素)

index就是列表对象（变量）内置的方法（函数）

my_list = [1, 2, 3, 4, 5, 6]
print(my_list.index(3))  # 2
print(my_list.index(7))  # ValueError: 7 is not in list

列表的修改功能（方法）

• 修改特定位置（索引）的元素值：

  语法：列表[下标] = 值

  可以使用如上语法，直接对指定下标（正向，反向下标均可）的值进行：重新赋值（修改）

# 正向下标
my_list = [1, 2, 3]
my_list[0] = 5
print(my_list)  # 结果：[5, 2, 3]

# 反向下标
my_list = [1, 2, 3]
my_list[-3] = 5
print(my_list)  # 结果：[5, 2, 3]

• 插入元素

  语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素

  my_list = [1, 2, 3]
  my_list.insert(0, "Hello")
  print(my_list)  # 结果：['Hello', 1, 2, 3]
  

• 追加元素：

  语法：列表.append(元素)，将指定元素，追加到列表的尾部

  my_list = [1, 2, 3]
  my_list.append(4)
  print(my_list)  # 结果：[1, 2, 3, 4]
  

• 追加元素方式2：

  语法：列表.extend(其他数据容器),将其它数据容器的内容取出，依次追加到列表尾部

  my_list = [1, 2, 3]
  my_list.extend([4, 5, 6])
  print(my_list)  # 结果：[1, 2, 3, 4, 5, 6]
  

• 删除元素

  语法1： del 列表[下标]

  语法2： 列表.app（下标） 返回删除元素的值

  my_list = [1, 2, 3]
  
  # 方式1
  del my_list[0]  # 结果：[2, 3]
  print(my_list)
  # 方式2
  my_list.pop(0)
  print(my_list)  # 结果：[3]
  

• 删除某元素在列表中的第一个匹配项

  语法：列表.remove(元素)

  my_list = [1, 2, 3, 2, 4]
  my_list.remove(2)
  print(my_list)  # 结果：[1, 3, 2, 4]
  

• 清空元素

  语法：列表.clear()

  my_list = [1, 2, 3, 4]
  my_list.clear()
  print(my_list)  # 结果：[]
  

• 统计某元素在列表中的数量

  语法：列表.count(元素)

  my_list = [1, 2, 1, 3, 1, 4]
  print(my_list.count(1))  # 结果：3
  

• 统计列表内，有多少个元素

  语法：len(列表)

  可以的到一个int数字，表示列表的元素数量

  my_list = [1, 2, 1, 3, 1, 4]
  print(len(my_list))  # 结果：6
  

列表的特点：

1. 可以容纳多个元素（上限为2**63-1、9223372036854775807个）
2. 可以容纳不同类型的数据（混装）
3. 数据是有序存储的（有下标序号）
4. 允许重复数据存在
5. 可以修改（增加或删除元素等）

list(列表)的遍历

• 将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代

列表的遍历-while循环

index = 0
while index < len(列表):
    元素 = 列表[index]
    对元素进行处理
    index += 1

列表的遍历-for循环

• 对比while，for循环更加适合对列表等数据容器进行遍历

• 语法：

  for 临时变量 in 数据容器：

  ​ 对临时变量进行处理

• 表示，从容器内，依次取出元素并复制到临时变量上，在每一次的循环中，我们可以对临时变量(元素)进行处理

  mylist = [1, 2, 3, 4]
  
  for i in mylist:
      print(i)
  

while循环和for循环的对比

while循环和for循环，都是循环语句，但细节不同：

• 在循环控制上：

  • while循环可以自定循环条件，并自行控制
  • for循环不可以自定循环条件，只可以一个个从容器内取出数据

• 在无限循环上：

  • while循环可以通过条件控制做到无限循环

  • for循环理论上不可以,因为被遍历的容器容量不是无限的

• 在使用场景上：

  • while循环适用于任何想要循环的场景
  • for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

数据容器：tuple(元组)

元组同列表一样，都是可以封装多个、不同类型的元素在内。

但最大的不同点在于： 元组一旦定义完成，就不可以修改

定义元组

元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同类型的数据

# 定义元组字面量
(元素， 元素， ... , 元素)
# 定义元组变量
变量名称 = (元素， 元素， ... , 元素)
# 定义空元组
变量名称 = ()    # 方式1
变量名称 = tuple()    # 方式2

t = (1, )  # 必须带有逗号，否则不是元组

注意： 元组只有一个数据，这个数据后面也要添加逗号

元组也支持嵌套：

# 定义一个嵌套元组
t1 = ((1, 2, 3), (4, 5, 6))
print(t1[0][0])  # 结果： 1

元组的相关操作

方法	作用
index()	查找某数据，如果数据存在返回对应的下标，否则报错
count()	统计某个数据在当前元组出现的次数
len(元组)	统计元组内的元素个数

元组的特点：

1. 可以容纳多个数据
2. 可以容纳布偶听类型的数据（混装）
3. 数据是有序存储的（下标索引）
4. 允许重复数据存在
5. 不可以修改
6. 支持for循环

数据容器：str(字符串)

字符串的下标

和其他容器：列表、元组一样，字符串也可以通过下标进行访问

同元组一样，字符串是一个：无法修改的数据容器

字符串的常用操作

• 查找特定字符串的下标索引值：

  语法：字符串.index(字符串)

  my_str = "it cast and atheism"
  print(my_str.index("and"))  # 结果：8
  

• 字符串的替换：

  语法：字符串.replace(字符串1， 字符串2)

  功能：将字符串内的全部：字符串1，替换为字符串2

  注意：不是修改字符串本身，而是得到了一个新字符串

• 字符串的分割：

  语法：字符串.split(分割符字符串)

  功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

  注意：字符串本身不变，而是得到了一个列表对象

  my_str = "hello python mysql java"
  my_str_list = my_str.split(" ")
  print(my_str_list)  # 结果：['hello', 'python', 'mysql', 'java']
  

• 字符串的规整操作（去前后空格）

  语法：字符串.strip()

  my_str = " Hello world Python "
  print(my_str.strip())  # 结果："Hello world Python"
  

• 字符串的规整操作（去前后指定字符串）

  语法：字符串.strip(字符串)

  my_str = "12Hello world Python12"
  print(my_str.strip())  # 结果："Hello world Python"
  

  注意，传入的是"12"其实就是"1"和"2"都会移除，是按照单个字符

字符串的特点：

1. 只可以存储字符串
2. 长度任意
3. 支持下标索引
4. 允许重复字符串存在
5. 不可以修改
6. 支持for循环

数据容器的切片

序列：

序列是指：内容连续、有序，可使用下标索引的一类数据容器

列表、元组、字符串，均可以视为序列

序列的常用操作-切片

序列支持切片，即：列表、元组、字符串，均支持进行切片操作

切片：从一个序列中，取出一个子序列

语法：序列[起始下标:结束下标:步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔
  • 步长1表示,一个个取元素
  • 步长2表示，每次跳过1个元素取
  • 步长N表示，每次跳过N-1个元素取
  • 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

数据容器：set(集合)

不支持元素的重复（自带去重功能）、并且内容无序

集合的定义

基本语法：

# 定义集合字面量
{元素， 元素， ... , 元素}
# 定义集合变量
变量名称 = {元素， 元素， ... , 元素}
# 定义空集合
变量名称 = set()

• 和列表、元组、字符串等定义基本相同

集合的常用操作-修改

首先，因为集合是无序的，所以集合不支持：下标索引访问，不支持while循环遍历

操作	说明
集合.add(元素)	集合添加一个元素
集合.remove(元素)	移除集合内指定的元素
集合.pop()	从集合中随机取出一个元素
集合.clear()	将集合清空
集合1.difference(集合2)	得到一个新集合，内含2个集合的差集原有的2个集合内容不变
集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素 集合1被修改，集合2不变
集合1.union(集合2)	得到一个新集合，内含2个集合的全部元素，原有的2个集合内容不变
len(集合)	得到了一个整数，记录了集合的元素数量

集合的特点

• 可以容纳多个数据
• 可以容纳不同类型的数据(混装)
• 数据是无序存储的（不支持下标索引）
• 不允许重复数据存在
• 可以修改（增加或删除元素等）
• 支持for循环

数据容器：dict(字典、映射)

使用字典，实现用key取出value的操作

字典的定义

# 定义字典字面量
{key: value, key: value, ... ,key: value}
# 定义字典变量
my_dict = {key: value, key: value, ... ,key: value}
# 定义空字典
my_dict = {}
my_dict = dict()

字典的常用操作

• 字典数据的获取

  字典可以通过Key值来取得对应的Value

  语法：字典[Key]可以取到对应的Value

  stu_score = {"王力宏": 99, "周杰伦": 88, "林俊杰": 77}
  print(stu_score["王力宏"])  # 结果：99
  print(stu_score["周杰伦"])  # 结果：88
  print(stu_score["林俊杰"])  # 结果：77
  

• 字典的嵌套

  字典的Key和Value可以是任意数据类型（Key不能是字典）

  字典的获取

  语法： 字典[元素][元素]

  stu_score = {
      "王力宏": {
          "语文": 99,
          "数学": 88,
          "英语": 77
      }, "周杰伦": {
          "语文": 98,
          "数学": 87,
          "英语": 76
      }, "林俊杰": {
          "语文": 95,
          "数学": 84,
          "英语": 73
      }}
  print(stu_score)  # {'王力宏': {'语文': 99, '数学': 88, '英语': 77}, '周杰伦': {'语文': 98, '数学': 87, '英语': 76}, '林俊杰': {'语文': 95,
  # '数学': 84, '英语': 73}}
  print(stu_score["周杰伦"])  # 结果：{'语文': 98, '数学': 87, '英语': 76}
  print(stu_score["林俊杰"]["语文"])  # 结果：95
  

  • 新增元素：

    语法：字典[Key] = Value, 结果： 字典被修改，新增了元素

    stu_score[“张信哲”] = 66

• 更新元素

  语法：字典[Key] = Value, 结果： 字典被修改，元素被更新

  注意：字典的Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

  stu_score[“周杰伦”] = 33

• 删除元素：

  语法：字典.pop(Key),结果：获得指定Key和Value，同时字典被修改，指定Key的数据被删除

  stu_score = {"王力宏": 99, "周杰伦": 98, "林俊杰": 95}
  value = stu_score.pop("王力宏")
  print(value)  # 结果：99
  print(stu_score)  # 结果：{'周杰伦': 98, '林俊杰': 95}
  

• 清空字典：

  语法：字典.clear(), 结果：字典被修改，元素被清空

  stu_score = {"王力宏": 99, "周杰伦": 98, "林俊杰": 95}
  value = stu_score.clear()
  print(stu_score)  # 结果：{}
  

• 获取全部的Key

  语法：字典.keys

  stu_score = {"王力宏": 99, "周杰伦": 98, "林俊杰": 95}
  keys = stu_score.keys()
  print(keys)  # 结果：dict_keys(['王力宏', '周杰伦', '林俊杰'])
  

• 遍历字典

  stu_score = {"王力宏": 99, "周杰伦": 98, "林俊杰": 95}
  keys = stu_score.keys()
  print(keys)  # 结果：dict_keys(['王力宏', '周杰伦', '林俊杰'])
  
  for key in keys:
      print(f"字典的key是：{key}")
      print(f"字典的value是:{stu_score[key]}")
      
  for key in stu_score:
      print(f"字典的key是：{key}")
      print(f"字典的value是:{stu_score[key]}")
  

• 统计字典内元素数量：

  语法:len(字典)

字典的特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是KeyValue键值对
• 可以通过Key获取到Value，Key不可重复(重复会覆盖)
• 不支持下标索引
• 可以修改
• 支持for循环，不支持while循环五类数据容器对比总结

数据容器的分类：

1. 是否支持下标索引：
   • 支持：列表、元组、字符串-序列类型
   • 不支持：集合、字典-非序列类型
2. 是否支持重复元素：
   • 支持：列表、元组、字符串-序列类型
   • 不支持：集合、字典-非序列类型
3. 是否可以修改：
   • 支持：列表、集合、字典
   • 不支持：元组、字符串

使用场景：

1. 列表：一批数据，可修改、可重复的存储场景
2. 元组：一批数据，不可修改、可重复的存储场景
3. 字符串：一串字符的存储场景
4. 集合：一批数据，去重存储场景
5. 字典：一批数据，可用Key检索Value的存储场景

数据容器的通用操作

遍历：

• 5类数据容器都支持for循环遍历
• 列表、元组、字符串支持while循环

数据容器的通用统计功能：

• len(容器)
• max(容器)
• min(容器)

数据容器的通用转换功能：

• 容器转列表：list(容器)
• 容器转字符串： str(容器)
• 容器转元组：tuple(容器)
• 容器转集合：set(容器)

容器的通用排序功能：

sorted(容器, [reverse=True]) [reverse=True]表示降序

将给定容器进行排序

排序结果会变成列表对象

字符串比较：

字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大

单个字符通过ASCII码表数值来确定大小

综合案例

# 升职加薪：
# 对所有级别为1的员工上升一级，薪水增加1000

info_dict = {
    "王力宏": {
        "部门": "科技部",
        "工资": 3000,
        "级别": 1
    },
    "周杰伦": {
        "部门": "市场部",
        "工资": 5000,
        "级别": 2
    },
    "林俊杰": {
        "部门": "市场部",
        "工资": 7000,
        "级别": 3
    },
    "张学友": {
        "部门": "科技部",
        "工资": 4000,
        "级别": 1
    },
    "刘德华": {
        "部门": "市场部",
        "工资": 6000,
        "级别": 2
    },
}
print(f"升职加薪前的员工信息：{info_dict}")

# 通过for循环遍历字典
for name in info_dict:
    # 定义一个新变量存储员工信息
    employee_info_dict = info_dict[name]
    # 判断级别是否为1
    if employee_info_dict["级别"] == 1:
        # 修改新变量中的工资和级别
        employee_info_dict["级别"] = 2
        employee_info_dict["工资"] += 1000
        # 将员工信息更新回info_dict
        info_dict[name] = employee_info_dict

print(f"升职加薪后的员工信息：{info_dict}")

集合、字典-非序列类型
2. 是否支持重复元素：

• 支持：列表、元组、字符串-序列类型
• 不支持：集合、字典-非序列类型

3. 是否可以修改：
   • 支持：列表、集合、字典
   • 不支持：元组、字符串

[外链图片转存中…(img-o8pEtMDA-1676355386432)]

使用场景：

1. 列表：一批数据，可修改、可重复的存储场景
2. 元组：一批数据，不可修改、可重复的存储场景
3. 字符串：一串字符的存储场景
4. 集合：一批数据，去重存储场景
5. 字典：一批数据，可用Key检索Value的存储场景

数据容器的通用操作

遍历：

• 5类数据容器都支持for循环遍历
• 列表、元组、字符串支持while循环

数据容器的通用统计功能：

• len(容器)
• max(容器)
• min(容器)

数据容器的通用转换功能：

• 容器转列表：list(容器)
• 容器转字符串： str(容器)
• 容器转元组：tuple(容器)
• 容器转集合：set(容器)

容器的通用排序功能：

sorted(容器, [reverse=True]) [reverse=True]表示降序

将给定容器进行排序

排序结果会变成列表对象

字符串比较：

字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大

单个字符通过ASCII码表数值来确定大小

综合案例

# 升职加薪：
# 对所有级别为1的员工上升一级，薪水增加1000

info_dict = {
    "王力宏": {
        "部门": "科技部",
        "工资": 3000,
        "级别": 1
    },
    "周杰伦": {
        "部门": "市场部",
        "工资": 5000,
        "级别": 2
    },
    "林俊杰": {
        "部门": "市场部",
        "工资": 7000,
        "级别": 3
    },
    "张学友": {
        "部门": "科技部",
        "工资": 4000,
        "级别": 1
    },
    "刘德华": {
        "部门": "市场部",
        "工资": 6000,
        "级别": 2
    },
}
print(f"升职加薪前的员工信息：{info_dict}")

# 通过for循环遍历字典
for name in info_dict:
    # 定义一个新变量存储员工信息
    employee_info_dict = info_dict[name]
    # 判断级别是否为1
    if employee_info_dict["级别"] == 1:
        # 修改新变量中的工资和级别
        employee_info_dict["级别"] = 2
        employee_info_dict["工资"] += 1000
        # 将员工信息更新回info_dict
        info_dict[name] = employee_info_dict

print(f"升职加薪后的员工信息：{info_dict}")