Python学习笔记

Python

Python语言

  • 是一种解释性、面向对象、动态数据类型的高级程序设计语言
  • 创始人:吉多,荷兰人
  • 时间:1989编写的,1991公开发行

Python语言特点

  • 开源、免费
  • 面向过程、面向对象、交互式编程
    • 面向过程:以事情或解决问题的过程为中心,主要考虑解决问题的思路和步骤
    • 面向对象:以事务为中心,主要考虑解决问题时涉及的事务的特征和行为

编写人生中第一个python程序

# 汇率转换器
# 在控制台中输入美元金额,打印出人民币金额
# 1美元为7.2914人民币
#获取数据--美元金额
usd = input("请输入美元金额:")
#数据出来
#TypeError: can't multiply sequence by non-int of type 'float'
#类型错误,因为input函数所获得都是字符串无法进行数学运算
rmb = float(usd) * 7.2914
#显示结果--人民币
print("人民币金额为"+str(rmb))
  • 书写代码,从右往左,从上往下顺序编写
  • 程序是改出来的,不是直接写出来的
  • 快捷键
  • 注释
  • 函数

快捷键

  • 移动到本行开头home健,笔记本fn+home
  • 移动到本行末尾end健
  • 注释代码:ctrl+/
  • 复制当前行:ctrl+d
  • 撤销:ctrl+z
  • 选择列:shift+alt+鼠标左键
  • 移动行:shift+alt+上下箭头
  • 智能提示:ctrl+space

注释

  • 是对程序或代码的解释性、说明性的文字
  • Python在执行程序时,会自动跳过注释,不把注释当成命令对的
  • 自己编写较大的程序或者公司中团队合作编程时,为了程序的易读性,通常要加注释
  • 一般注释量占总代码的20%/25%
  • 单行注释
    • 以#号字符开始
    • 一般单独写到一行,或者写道一行的末尾
  • 多行注释
    • 以三个单引号或者三个双引号开头和结尾
#print()函数是python中的输出语句,在终端输出666
print(666)

函数

  • 表示一个功能,函数的定义者是提供功能的人,函数的调用者是使用功能的人

input()与print()函数

#变量 = input("提示信息")
# 在终端中获取用户输入的信息,将输入的信息赋值给变量
# = 赋值符号,将右边数据给左边

# print(数据)
# 在终端中显示信息
#使用print()函数在终端中输出个人介绍(姓名、年龄、爱好)
print("刘思园")  #打印 字符串
print('21')    打印字符串
print(21)    #打印 整数
print("睡觉")  #字符串

#在一行上输出个人介绍
print("刘思园",21,"睡觉")
# 使用input()函数通过键盘输入个人介绍,并通过print()打印个人介绍
#获取姓名
name = input("请输入姓名:")
#获取年龄
age = input("请输入年龄:")
#获取爱好
hobby = input("请输入爱好:")
#输出
print(name,age,hobby)
Demo
"""
  请用户通过键盘输入用户的账号密码
  最后输出:
         输入的用户名是xxxx
         输入的密码是xxxx
"""

#请输入用户账号
use_id = input("请输入账号:")
#请输入密码
password = input("请输入密码:")
print("输入的用户名是:"+use_id,"\n"+"输入的密码是:"+password)
print(f'输入的用户名是:{use_id}\n输入的密码是{password}')

Python编写规范

  • 每个python文件以.py结尾,文件名为小写
  • Python严格区分大小写
  • 编码中使用英文标点符号
  • 添加注释对代码进行解释说明

标识符

  • 就是用来表示变量、函数、类、包、模块等名称

标识符命名规则

  • 第一个字符必须是字母或者下划线,其余的字符可以是字母、数字、下划线

  • 标识符不能包含空格或者其他特殊字符

  • 标识符中不能是python关键字

  • 标识符区分大小写

  • 通常以下划线开头和结束的名称,有特殊含义,一般不建议使用

  • 变量名命名时,尽量达到见名知意,使用驼峰模式命名,中文可以作为标识符使用(不建议)

  • 建议命名:字母小写,多个单词以下划线间隔

    class_name = input("请输入班级名称")
    

常量

  • 固定不变的量称为常量

  • 通常使用全部大写字母表示(多个词之间使用下划线增加可阅读性)

    #最大年龄
    MAXAGE=100
    MAX_AGE=100
    

变量

  • 把程序中运行过程中需要处理的数据用变量存储起来,然后给这个变量一个可读性强的名字,将来一旦用到这些数据,可以通过变量名来获取数据

  • 变量是可以变化的量,实际上是编程人员申请的内存空间,给这段空间起的名字叫做变量名

  • 定义:关联一个对象的标识符

  • 作用:在内存中,操作数据

  • 语法格式

    变量名 = 变量值
    变量名1 = 变量名2 = 变量值
    变量名1,变量名2 = 变量值1,变量值2
    
    • = 表示赋值符号,将等于号右侧的值赋值给等号左侧变量
    age = 20
    print("age")
    x = 10
    y = 20
    result = x + y
    print(result)
    
    # 定义变量 申请内存,为内存空间命名
    person_name = '张三'
    class_name = 'test_2023'
    # 修改变量:python中允许对同一个变量,先后存入不同类型的数据,之前的数据会被覆盖
    person_name = '李四
    #使用/调用/引用 变量:可以向申请的内存中存入数据、修改数据、取出数据进行运算、查看数据、收回
    print(person_name)
    #删除变量:del 用于删除变量,同时解除与对象的关联
    #del 变量名1,变量名2
    del person_name,class_name
    

变量的特点

  • 变量在使用前必须先赋值,否则会报错
  • 可在一行同时对多个变量赋值。变量值可相同,也可不同
  • 变量赋值后,值随时可变,单值为最新一次所赋的值

数据类型

  • 数据类型就是数据所属的种类

python中的数据类型

  • 基本数据类型

    • 整数类型int

    • 浮点数类型float

    • 布尔类型bool

    • 只能存储一个数据,而且数据中能整体使用,不能只使用其中的一部分

      a = 234
      #234是一个整体,是一个数,不能拆分成2,3,4使用
      
  • 序列数据类型–称为容器

    • 字符串类型str
    • 列表类型list
    • 元组类型tuple
    • 集合类型set
    • 字典类型dict
    • 可以存储多个元素/数据,既可以整体使用,也可以使用其中一部分
    • 序列,数据成员(数据中的每一个)有序号/下标
  • 注意变量没有类型,关联的对象才有类型

    name = 'test'
    age = 18
    sal = 100.15
    
查看数据类型
  • type()函数

    name = 'test'
    age = 18
    sal = 100.15
    print(type(name)type(age),type(sal))
    

占位

  • 只希望有一个变量,但指向的对象还不能确定

    #占位
    skill = None
    #绑定数据
    skill = '乾坤大挪移'
    print(skill)
    #解除与对象的绑定关系
    name = None
    print(name)
    

整数类型–int

  • 正整数、负整数、0

    number01 = 1
    number02 = -1
    number03 = 0
    

浮点数类型–float

  • 浮点数类型表示的是带小数点的数据,也成为实数

  • 也称为小数,是由整数和小数组成,中间使用小数点

    number04 = 3.14
    

布尔类型

  • 表示逻辑值
  • 用来表示真或假,是或否、成立或不成立、满足或不满足的类型
  • 布尔类型的值
    • True表示真
    • False表示假
  • 布尔类型的值本质是整数类型
    • 0表示假,1表示真的情况

字符串

  • 是一个有序的字符集合,主要用于存储和表示文本

  • 字符串在Python中使用单引号,双引号,三个单引括起来的一串字符

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

    • ord(字符串)返回改字符串的unicode码
    • chr(整数)返回该整数对应的字符串
  • 字符串只能被重新赋值,不能修改某个字符的值,字符串是不可变的

  • 字符串中每个字符都有唯一一个编码(下标/序号)

    • 下标从0开始

      s = 'hello' #下标 0 1 2 3 4
      print(s[1])
      #定义字符串
      name = 'sean'
      address = "北京昌平区"
      sex = '''男'''
      email = """[email protected]"""
      
  • 统计总字数len()函数

    print(len("sean"))
    

数据类型转换

  • 是一种数据类型转换成另一种数据类型
  • 转换为整数类型:int(数据)
  • 转换为浮点型:float(数据)
  • 转换为字符串类型:str(数据)
  • 混合类型的自动升级
    • 1 + 2.14 返回的结果 3.14
    • 1 + 3.0 返回结果4.0
  • input()函数获取的任何内容都是字符串类型

数据的处理

  • 使用运算符将两个或多个具体数据或变量连接起来的式子

    a * 3
    a + 4
    a*2 / b/3
    

算是运算符

  • 只能用于整数或浮点数,不能用于字符串

  • 运算结果为数字

    符号 含义
    +
    -
    *
    /
    // 整除
    % 求余
    ** 乘方
    () 小括号

特殊运算符–复合赋值运算符

符号 含义
+=
-=
*=
/=
//= 整除赋值运算符
%=
**= 幂赋值运算符
Demo
"""
超市收银系统V1.0
大家都有到过超市购物收银台账的经历。现要求编写一个收银柜台收款程序
现要求:商品单价、商品数量、给收银员的钱都是通过键盘输入获得的
其中:商品数量是int类型,商品单价是float类型,给收银员的钱是float类型
提示:键盘输入的数据类型为str
"""

#获取商品单价
price = float(input("请输入商品单价:"))
#获取商品数量
num = int(input("请输入商品数量:"))
print(f'应收金额{price*num}元')
#获取收钱总额
money = float(input("收钱总额:"))
#计算找零
result = money - (price*num)
#输出结果
print("找零"+str(result)+"元")
"""
任意三位数的取数字操作
准备一个任意三位数,要求:使用学过的算数运算符等操作,通过程序输出这个三位数上的每一位
例如:这个三位数为495,则百位数字为4,十位数字为9,个位数字为5
三个数字和为18
"""
#随便输入一个三位数
num = int(input("请随便输入三位数:"))
# # 495 // 100 4
# # 495 // 10  49
# # 495 // 10 % 10 9
# # 495 % 10  5
print(num //100 + num // 10 % 10 + num % 10)

"""
在终端中分别录入3个数据(分钟数、小时数、天数)
输出总秒数
"""
#获取分钟数
minute = float(input("请输入分钟数:"))
#获取小时数
hour = float(input("请输入小时数:"))
#获取天数
day = float(input("请输入天数:"))
count = (minute*60)+(hour*3600)+(day*86400)
print("总秒数:",count)
"""
古代的秤一斤有16两,请在终端中获取两,计算是几斤零几两
输入:100
输出:6斤零4两
"""
#test09  古代单位换算
#获取两
weight = int(input("请输入几两:"))
# 获取的两整除16 得斤数
result1 = weight // 16
# 获取的两取余16 得两
result2 = weight % 16
#打印结果
print(f'换算结果是:{result1}斤零{result2}两')
"""
在终端中录入距离,时间,初速度,计算加速度.
匀变速直线运动的位移与时间公式:
	距离=初速度 * 时间 + 加速度 * 时间平方的一半
输入:
	距离:100
	初速度:2
	时间:5
输出:加速度7.2
公式:
	距离=初速度 * 时间 + 加速度 * 时间平方的一半
"""
#test10 计算匀变速直线运动
#获取距离
d= float(input("请输入距离:"))
#获取初速度
v = float(input("请输入初速度:"))
#获取时间
t= float(input("请输入时间:"))
#计算加速度
a = (d - v * t)*2 / t**2
print(f'加速度{a}')
"""
在终端中获取一个四位整数,计算每位相加和.
输入:1234
输出:10
"""
#test12
#获取四位整数
num = int(input("请随机输入四位整数:"))
#num//1000  得千位数
#num % 1000 // 100 得百位数
#num % 1000 % 100 //10 得十位数
#num % 1000 % 100 %10 得个位数
result = (num//1000)+(num % 1000 // 100)+(num % 1000 % 100 //10)+(num % 1000 % 100 %10)
print(f'每位相加和为:{result}')

关系运算符

  • 也称为比较运算符

    <,>,<=,>=,==, !=
    
  • 关系运算符运算的结果是布尔类型的值 True,False

Demo
"""
准备一个数,判断这个数是否是偶数
"""
num = int(input("请随意输入一个数"))
result = num %2 == 0
print(f'您输入的数:{num},它是否是偶数:{result}')

逻辑运算符

  • 逻辑运算符通常和关系运算符一起使用

  • 通过逻辑运算符连接多个关系运算符

  • 参与的数据主要是布尔类型的数据

  • 比较厚的结果是布尔类型

    符号 含义
    and
    or
    not 非(取反)
Demo
"""
在终端中录入年份,判断年份是否为闰年
条件1:年份能被4整除,但是不能被100整除
条件2:年份能被400整除
输入2019
输出False
输入2000
输出True
"""

year = int(input("请输入年份:"))
result = (year % 4 ==0 and year % 100 != 0) or (year % 400 ==0)
print(f'判断的年份是:{year}')
print(f'判断闰年的结果是:{result}')

短路运算

  • 一旦结果确定,后面的表达式将不再执行

    #False and  ?
    result1 = 1>1 and input("请输入一个数")==0
    print(result1)
    # True or ?
    result2 = 2>1 or input("请输入一个数")
    print(result2)
    
    
  • 逻辑运算时尽量将复杂的判断放在后面

    • and 当第一个式子为false时,将不会判断后面的式子,结果一定为false

    • or 当第一个操作数为True是,将不会再判断第二个操作数,因此不论第二个操作数为何,结果一定为True

三目运算符

  • 也成为 三元运算符 或 条件运算符
第一处内容 if 条件 else 第二处内容
  • 条件: 布尔值、布尔类型的变量、布尔表达式
  • 条件满足时,运行第一处内容,否则执行第二处内容
# 如果10大于等于10,则打印1,否则打印-1
print(1) if 10>=10  else print(-1)
# 如果今天天气好,输入天气真好,否则输出天气很不好
#定义变量获取天气情况,晴朗、阴天、雨天、刮风
str = input("请输入今天的天气,晴朗、阴天、雨天、刮风:")
print("天气真好!") if str == '晴朗' else print("天气真不好")
#准备一个数字
#判断是否为奇数或者偶数
#如果是奇数输出奇数,否则输出偶数
num = int(input("请输入一个整数:"))
print("您输入的数为偶数") if num % 2 ==0 else print("您输入的数为奇数")

运算符优先级

  • 小括号()
  • 幂运算(指数)**
  • 正负号 ±
  • 算数运算符
    • *,/,//,%
    • +,-
  • 比较运算符
    • < <=,>,>=,==,!=
  • 逻辑运算符
    • 先not,后and,最后or

字符串

字符串运算

  • 加法运算
    • +:用于拼接两个容器
    • +=:用于原容器与右侧拼接,并重新绑定变量
  • 乘法运算
    • *:重复生成容器元素
    • *=:用原容器生成重复元素,并重新绑定变量
  • 比较运算
    • 依次比较两个容器中元素,一旦不同则返回比较结果
  • 成员运算
    • in
    • not in
s1 ="你好"
s2 ="同学"
s3 = s1+s2
print(s3,type(s3))
s3 += "a"  # s3 = s3+'a'
print(s3,type(s3))
#乘法
print("--------乘法--------")
s4 ='python'
s5 =s4*3
print(s5)
#比较
print("--------比较--------")
print(s4 != s5)
print(s4 > s5)
#成员运算
print("--------成员运算--------")
print('大圣'in'我是齐天大圣')
print('大圣' not in'我是齐天大圣')
  • 索引(正向索引,反向索引)

    • 索引也成为下标,就是元素编号

    • 作用:定位单个元素

    • 语法:容器[整数]

    • 正向索引从0开始,第二个索引为1,最后一个索引为容器名[len(容器名)-1]

      • 语法格式

        容器名[下标]
        容器名[len(容器名)-1]
        
    • 反向索引从-1开始,-1代表最后一个,-2代表倒数第二个,第一个-len(容器)

  • 切片

    • 作用:定位多个元素

    • 语法:容器[开始索引:结束索引:间隔]

    • 结束索引不包含该位置元素

    • 开始索引默认为0,间隔默认为1

      • 倒叙打印

        容器名[::-1]

    • 间隔 是整数时表示自左向右

    • 间隔 是负数时表示自右向左

      s2 = '我是齐天大圣孙悟空'
      print(s2[:])
      print(s2[:3]) #不包含结束索引对应的内容
      print(s2[3:]) #包含开始值
      print(s2[::-1]) #倒叙打印
      print(s2[::2]) #步长为2
      
#我是花果山水帘洞的齐天大圣
#打印第一个
#打印倒数第二个
#打印第三个
#打印花果山
#打印我是花果山
#打印我花山
#打印我是花果山水帘洞的齐天大圣
#倒叙打印这句话
s1 = "我是花果山水帘洞的齐天大圣"
print(f"打印第一个字符为:{s1[0]}")
print(f"打印倒数第二个字符为:{s1[-2]}")
print(f"打印第三个字符为:{s1[2]}")
print(f"打印‘花果山’:{s1[2:5]}")
print(f"打印‘我是花果山’:{s1[:5]}")
print(f"打印‘我花山’:{s1[:5:2]}")
print(f"打印‘我是花果山水帘洞的齐天大圣’:{s1[:]}")
print(f"倒叙打印:{s1[::-1]}")
"""
创建字符串:人生苦短,我用Python
打印第一个字符,最后一个字符
打印前两个字符,后6个字符
打印中间一个字符
倒叙打印所有字符
"""

s2 = "人生苦短,我用Python"
print(f"打印第一个字符,最后一个字符:{s2[0],s2[-1]}")
print(f"打印前两个字符,后6个字符:{s2[:2],s2[-6:]}")
print(f"打印中间一个字符:{s2[len(s2)//2]}")
print(f"倒叙打印所有字符:{s2[::-1]}")

字符串常见的函数

  • 获取字符串长度

    • len() 统计字符串长度

      s1 ="123456"
      print(len(s1))
      
  • 查找一个字符串在另一字符串中首次出现的位置

    • find(str,start,end)
    • str表示要查找的字符串
    • start 表示查找的开始位置
    • end表示查找的终止位置
    • 返回范围是第一个字符首次出现的对应下标
  • 统计一个字符串在另一个字符串中出现的次数,如果不存在返回0

    • count(str)
  • 指定某个字符为分隔符,从字符串的左边开始将其分割成多个字符串,并将结果以列表形式返回

    • split(分隔符,分割数量)
  • 大小写转换

    • upper()英文字母全变为大写
    • lower()英文字母全变成小写
  • 字符串替换

    • replace(旧字符串,新字符串,个数)
  • 删除字符串两端,右端、左端空白字符

    • strip()

    • rstrip()

    • lstrip()

  • 判断是否全为字母

    • isalpha()
  • 判断是否全为数字

    • isdigit()
  • 判断字符串以什么开头

    • startswith()
  • 判断字符串以什么结尾

    • endswith()

列表

  • 属于序列数据类型
  • 以[]定界,多个数据之间用英文逗号间隔
  • 列表是有序、
  • 可变的序列之一
  • 列表中各个元素的数据类型可以不同
#创建列表
列表名 = []
列表名 = list(可迭代对象)
# 添加元素
列表名.append(元素) #追加
列表名.insert(索引,元素) #根据索引插入元素
# 定位元素
索引、切片
创建列表
# list1 = []  #定义空列表
# print(list1,type(list1))
# list2 = list(range(10)) #list括号中放入可迭代对象
# print(list2,type(list2))
# list3 = ['a','b','c']
# print(list2,type(list3))
# list4 = ['a','b','c',1,2,3,5.6,6]
# print(list4,type(list4))
# list5 = [['a','b','c',1,2,3,5.6,6],['a','b','c']]
# print(list5,type(list5))
# 遍历列表
    -正向方法
    for 变量 in 列表名:
        print(变量)
    -反向方法
    for 索引名 in range(len(列表名)-1-1-1)print(列表名[索引])
# 拆包/解包
*[1,2,3]
list5 = [['a','b','c',1,2,3,5.6,6],['a','b','c']]
print(list5,type(list5))
print(*list5)
print(*[1,2,3])
a,b,c =[1,2,3]
print(a,b,c)
#定义列表,列表中存入测试用例
#用例编号、测试标题、用户名、密码、预测结果
cases = [
    [101,'测试用户登录01','admin','123456','登录成功'],
    [102, '测试用户登录02', 'admin', '123', '密码错误'],
    [103, '测试用户登录03', 'adm', '123456', '用户名错误'],
    [104, '测试用户登录04', 'admin', '', '密码为空'],
]
#获取第二条测试用例
#将第二条用例的用户名、密码、预期结果获取出来并存入变量中
print(cases[1])
username = cases[1][2]
password = cases[1][3]
expect = cases[1][4]

列表运算

  • 加法运算 – 拼接

  • 乘法运算 – 复制

    list01 = [1,2,3,4]
    list02 = list01 * 3
    print(list02)
    

修改列表中的某个元素

list01 = [1,2,3,4]
#更新或修改元素
list01[1] = 1
print(list01)
# 列表名[下标] = 新数据

#删除某个元素   
del list01[2]
print(list01)

#del 列表名[下标]
#列表名.pop(下标/索引号)


list01 = ["高程","周景阳","赵平岩","张文博"]
# print(list01.count("高程"))
# print(list01.clear()) #清空列表中的内容
print(list01.remove("高程")) #返回None
print(list01)
"""
创建列表,存储水金地木土天王星
向列表中追加海王星
在地球后插入火星
打印地球里太阳最近的行星(最后一个行星)
打印地球之前的所有行星(前两个行星)
删除金星
删除地球后面的所有行星
倒叙打印所有行星
"""

ball = ["水星","金星","地球","木球","土星","天王星"]
ball.append('海王星')
print(f"追加海王星{ball}")
ball.insert(3,'火星')
print(f"插入火星{ball}")
print(f'打印地球里太阳最近的行星:{ball[-1]}')
print(f'打印地球之前的所有行星:{ball[:2]}')
#删除金星
# print(f"删除金星{ball.pop(1)}")
# print(f'删除金星后的数据:{ball}')
# del ball[2:]
# print(f"删除地球后面的所有行星:{ball}")
print(f'倒叙打印所有行星:{ball[::-1]}')

元组

  • 是有序,不可变的序列类型,一旦创建,不可改变

  • 元组也称为常量列表

  • 使用元组,访问速度快,代码安全性更高

    元组名 = (数据1,数据2,....数据n)
    元组名 = tuple(可迭代对象)
    
    #整体访问
    print(元组名)
    #索引/切片访问单个或多个元素
    #也可以通过拆包解包访问
    #元组可以进行加法运算、乘法运算
    #元组不能单独删除某个元素
    
    """
    在控制台录入日期(月日),计算是这一年的第几天
    例如:
       3月15日 -->31+28+15
       5月20日 -->31+28+31+30+20
    """
    
    #获取月份
    date1 = int(input("请输入月份:"))
    #获取日期
    date2 = int(input("请输入日期:"))
    # 定义 每月天数的元组
    day = (31,28,31,30,31,30,31,31,30,31,30,31)
    #      1  2  3   4 5  6  7  8  9  10 11 12  对应的月份
    #      0  1  2   3 4  5  6  7  8  9  10 11  对应的天数的下标
    result = sum(day[:date1-1]) + date2
    print(f"你输入的日期是{date1}{date2}日,这是这一年的第{result}天")
    

字典

  • 字典属于无序、可变的数据类型

  • 以键:值 的方式存储,通过键来访问字典的值 键不可重复,只可以重复

    #创建字典
    字典名 = {键1:值1,键2:值2} #常用
    字典名 = dict(键1:值1,键2:值2)
    
    student = {"username":"张三","age":18,"sal":23.23}
    #使用整个字典
    print(student)
    #获取字典中的姓名,年龄
    print(student["username"])
    print(student["age"])
    #删除字典元素
    del student["age"]
    #删除字典
    del 字典
    

    不可拼接不可复制

  • 常用字典函数

    • 复制字典copy() 和赋值一样

      student01 = {"username":"张三","age":18,"sal":23.23}
      student02 = student01.copy()
      
    • clear() 清空字典

    • **pop()**删除字典中指定元素

    • **get()**获取键所对应的值

    • update() 更新将一个字典元素更新到另一个字典中(存在则覆盖)

    • 获取字典中所有的键 keys()

    • 获取字典中所有的值 values()

    • 以键与值形式返回字典元素 items()

集合

  • 集合是无序的、可变的序列

  • 同一个集合内的每个元素都是唯一的,不允许存在重复元素

  • 不支持修改、复制

    • 创建集合
    • 解包
    • 删除集合 del 集合名
    #创建集合
    集合名 = {数据1,数据2,...}
    集合名 = set(可迭代对象)
    
    #创建集合
    set01 = {1,2,3,4,5,6}
    set02 = {'a','b',2,'c',3,4}
    set03 = set(range(10))
    #使用集合
    print(set01)
    #解包
    a,b,c,d,e,f = set01
    #删除集合
    del 集合名
    
  • 常见运算

    • 并集 | 去重且合并

      set06 = {1,2,3,4,5}
      set07 = {1,6,3,4,7}
      result = set06 | set07
      
    • 交集 & 打印共同含有的元素

    • 差集 - 一集合比另一个集合多的元素

  • 集合常用的函数

    • add() 添加元素如果元素已存在则忽略该操作

    • update() 将一个集合中的元素更行到另外一个集合中

    • pop() 删除集合中的一个元素,并返回该值

      number = set.pop()
      print(number)
      
    • remove() 移除集合中的某个元素

    • clear() 清空集合

流程控制语句

  • 顺序结构:按照顺序一行一行的写代码,程序执行时按照书写代码的顺序执行
  • 选择结构:编写过程中会写不同的程序,只执行其中的一个程序
  • 循环结构:写一份程序,会反复执行多次

选择结构

  • 根据条件是否成立,决定执行那段代码

  • 选择结构分为单分支、双分支、多分支、嵌套分支

  • 单分支

    if 条件:
         语句段(代码)
    

    Python学习笔记_第1张图片

  • 双分支

    if  条件:
         语句段1
    else:
         语句段2
      
    

Python学习笔记_第2张图片

  • 多分支

    if 条件:
         语句段1
    elif 条件:
         语句段2
    elif 条件:
         语句段3
    else:
         语句段4
    

    Demo

    # 题目1:输入两个整数,使用if语句,判断大小,把比较大的值输出
    print("判断输入整数的大小")
    num1 = int(input("请输入第一个整数:"))
    num2 = int(input("请输入第二个整数:"))
    max_number =num1
    if max_number <num2:
        max_number =num2
    print(f"最大的数是:{max_number}")
    
    # 题目2:从键盘输入性别,当输入正确时,输出“你的性别是...”,输出错误时,什么也不做
    sex = input("请输入性别:")
    if sex == '男' or sex == '女':
        print(f'你的性别是{sex}')
    else:
    print("性别未知")
    
    #题目3:当两个整数都是正数时,计算和,否则什么也不错
    num1 = int(input("请输入第一个正数:"))
    num2 = int(input("请输入第二个正数:"))
    if num1 >0 and num2 >0 :
        print(f"两数之和为{num1}+{num2}={num1+num2}")
    
    
    #题目4:获取键盘输入的一个整数值,求该数的绝对值
    num1 = int(input("请输入第一个整数:"))
    if num1 < 0 :
        num1 = -num1
    print(f'该数的绝对值为{num1}')
    
    #题目5:键盘输入2个整数,比较大小(双分支)
    num1 = int(input("请输入第一个整数:"))
    num2 = int(input("请输入第二个整数:"))
    if num1 > num2:
        print(f"您输入的{num1}{num2}大")
    else:
        print(f"您输入的{num2}{num1}大")
    
    #题目6:获取键盘输入的整数,判断时整数还是负数
    num = int(input("请输入第一个整数:"))
    if num > 0:
        print(f"您输入的整数{num}是正数")
    else:
        print(f"您输入的整数{num}是负数")
    
    #题目7:获取键盘输入的分数,判断分数所属的等级(优秀、良好、中等、及格、不及格)
    score = float(input("请输入您的分数:"))
    if score >= 90:
        print(f"您的成绩为优秀")
    elif 80 <= score < 90:
        print(f"您的成绩为良好")
    elif 70 <= score < 80:
        print(f"您的成绩为中等")
    elif 60 <= score <70:
        print(f"您的成绩为及格")
    elif score>=0 and score <60:
        print(f"您的成绩为不及格")
    else:
        print(f"分数只能输入0~100之间的数”)
    
    #题目8:在控制台获取一个季度,打印相应的月份
    #      输入与输出
    #      春 1~3月
    #      夏 4~5月
    #      秋 7~8月
    #      冬 10~12月
    
    season = input("请输入季度:")
    if season == '春':
        print(f"您输入的季度{season}有1月2月3月")
    elif season == '夏':
        print(f"您输入的季度{season}有4月5月6月")
    elif season == '秋':
        print(f"您输入的季度{season}有7月8月9月")
    elif season == '冬':
        print(f"您输入的季度{season}有10月11月12月")
    else:
        print(f"请重新输入”)
    
    # 题目9
    """
    	先在终端中录入一个数字
    	再录入一个运算符
    	最后录入一个数字
    	打印计算的结果
    	要求:如果运算符不是+ - * / 提示"运算符输入有误"
    """
    num1 =float( input("请输入第一个数字:"))
    char = input("请输入运算符:")
    num2 =float( input("请输入第二个数字"))
    if char == '+':
        print(f"{num1}+{num2}={num1+num2}")
    elif char == '-':
        print(f"{num1}-{num2}={num1-num2}")
    elif char == '*':
        print(f"{num1}*{num2}={num1 * num2}")
    elif char == '/':
        print(f"{num1}/{num2}={num1 / num2}")
    else:
        print(f"运算符输入错误")
    
    # 题目 10
    """
    在终端中依次录入4个同学体重,打印最重的值.
    	思路:假设第一个就是最大的
    	使用假设的依次与后几个变量进行比较,如果发现更大的,则替换假设的
    输入:52 ,40,37,60
    输出:60
    """
    
    print("请依次输入四位同学的体重(kg)")
    weight1 = float(input("请输入第一个同学的重量:"))
    weight2 = float(input("请输入第二个同学的重量:"))
    weight3 = float(input("请输入第三个同学的重量:"))
    weight4 = float(input("请输入第四个同学的重量:"))
    if weight1 > weight2 >weight3 >weight4 :
        print(f"体重最重的是第一位同学:{weight1}")
    elif weight2 > weight3 >weight4 >weight1:
        print(f"体重最重的是第二位同学{weight2}")
    elif weight3 > weight4 >weight1 >weight2:
        print(f"体重最重的是第三位同学{weight3}")
    else:
        print(f"体重最重的是第四位同学{weight4}")
    
    # 题目 11
    """
    	在终端中录入一个成绩,判断等级
    	输入:成绩
    	输出:优秀,良好,及格,不及格,成绩有误
    """
    print("请输入你的成绩")
    score = float(input("请输入您的分数:"))
    if score >= 90:
        print(f"您的成绩为优秀")
    elif 80 <= score < 90:
        print(f"您的成绩为良好")
    elif 70 <= score < 80:
        print(f"您的成绩为中等")
    elif 60 <= score <70:
        print(f"您的成绩为及格")
    elif score <60:
        print(f"您的成绩为不及格")
    else:
        print(f"成绩有误”)
    # 题目12
    """
    在终端中录入月份,然后打印天数.
    输入:2 输出:28天
    输入:1 3 5 7 8 10 12 输出:31天
    输入:4 6 9 11 输出:30天
    """
              
    month = int(input("请输入月份:"))
    if month == 2:
        print(f"{month}月有28天")
    elif {month} & {1, 3, 5, 7, 8, 10, 12}:
        print(f"{month}月有31天")
    elif {month} & {4,6,,9,11}:
        print(f"{month}月有30天")
    else:
        print(f"请重新输入”)
    # 题目13
    '''
    获取键盘输入的节日名称,输入相应的礼物
    春节---饺子 情人节---玫瑰花 
    端午节---粽子 中秋节---月饼
    '''
              
    #获取节日名称
    print("输入节日名称(春节、情人节、端午节、中秋节),将会打印出对应的节日礼物")
    festival = input("请输入节日名称:")
    if festival == '春节':
        print(f"{festival}的礼物是饺子")
    elif festival == '情人节':
        print(f"{festival}的礼物是玫瑰花")
    elif festival == '端午节':
        print(f"{festival}的礼物是粽子")
    elif festival == '中秋节':
        print(f"{festival}的礼物是月饼")
    else:
        print(f"请重新输入”)
    
              
    # 题目14
    """
    在终端中获取一个整数,如果是偶数为变量state赋值"偶数",否则赋值"奇数"
    在终端中获取一个年份,如果是闰年为变量day赋值29,否则赋值28
    """
    num = int(input("请输入一个整数:"))
    state = "奇数" if num % 2 else "偶数"
              
    year= int(input("请输入一个年份:"))
    day = 29 if (year % 4 ==0 and year % 100 != 0) or (year % 400 ==0) else 28          
    
    # 题目15
    '''
    获取键盘输入的三角形3条边,判断是否可以组成三角
    形,如果能组成三角形,进一步判断是什么三角形(等边、等
    腰、直角、普通)
    '''
              
    a = float(input("请输入三角形第一条边:"))
    b = float(input("请输入三角形第二条边:"))
    c = float(input("请输入三角形第三条边:"))
    if a>b>c and b+c > a :
        print("可以组成三角形")
    elif b>c>a and c+a >b:
        print("可以组成三角形")
    elif c>a>b and a+b >c:
        print("可以组成三角形")
    else:
        print("不可以组成三角形")
    if a==b==c:
        print("改三角形为等边三角形")
    elif a**2 == b**2+c**2 or b**2 == a**2+c**2 or c**2 == b**2+a**2:
        print("该三角形为直角三角形")
    elif a==b or a==c or b==c:
        print("该三角形为等腰三角形")
    else:
        print("该三角形为普通三角形")
    # 题目16
    '''
    键盘输入1000---5000年之间的年份,如果在范围里
    判断是平年还是闰年,如果不在范围里给出错误信息提示
    '''
              
    year= int(input("请输入1000~5000年份:"))
    if year<=1000 or year>=5000:
        print("请输入范围内的年份")
    elif(year % 4 ==0 and year % 100 != 0) or (year % 400 ==0):
        print(f"{year}为闰年")
    else:
        print(f"{year}是平年")
    

注:文章中的练习题是从网上复制其他博主的,但是是自己做的,笔记是老师上课讲的,可能或许打给会与其他博主有相似之处,是我自己整理的哦

你可能感兴趣的:(Python,python,学习,笔记)