Python语法

Python语法

1.print

print在Python中提供打印输出的功能，是将Python中的数据输出到控制台。

print()

2.注释

含义：对代码进行解释和说明，目的就是让别人和自己能够清晰的看懂代码的含义，提高代码的可读性。

注释是不会被计算机识别的 一般写注释的时候写在代码的上方或者右方。

注释另外的作用：修改代码的时候，可能代码需要调试，有部分代码用不到，没有必要删除，可以给注释掉。

单行注释 ： #空格 快捷键 ctrl+/ 去掉注释也一样ctrl+/

多行注释 ： 三对引号[英文格式下] 单引号也可以双引号也可以。

'''
多行注释
'''

3.行和缩进

编程语言：由多条语句按照相应的逻辑实现代码，编写相应的程序的。

​ 语句都有相应的结束标记，一般编程语言语句的结束标记是分号；。

在Python中，建议语句的结束不写分号，也可以写【但是会报警告】。

建议：一行一条语句【如果一行中有多条语句，语句结束必须加分号—这种方式不建议】

print('hello');print('world')

缩进：在代码前面不要随意加空格或者tab键。

4.标识符与关键字

标识某个实体的符号，使用这个符号可以代替实体进行相应的运算

在编程语言中，标识符一般就是给变量、项目名称、文件名称、函数名、类名等等自定义名称，建立起名称和使用的数据之间的关系。

自定义名称要遵循一定的规则：

1. 标识符是由数字、字母、下划线组成。

2. 标识符名称不能以数字开头。

3. 不能使用关键字与保留字。

   1. 关键字：编程语言中具有特殊含义的单词

      ​ Python环境中自带了很多工具包，每个工具包都有对应的作用。比如：time–包含时间相关的操作。

      ​ 要想使用工具包，需要导包。

      ​ 语法：import 工具包名

      ​ 使用工具包下面的内容：工具包名.内容名

      # 打印当前时间，需要获取time工具包
      import time
      # 当前时间的操作
      print(time.localtime())
      

   2. 保留字：编程语言中已经使用的名称，不建议再使用【因为再使用的话，会覆盖掉原本的含义】

# 1.标识符是由数字、字母、下划线组成。

# 打印一个数据10
print(10)   # 10
# 定义一个标识符，给它赋值为10
num = 10
print(num)  # 10

# 打印10+20的和
print(10+20)  # 30
print(num+20)  # 30

# 定义的时候不能包含其他符号，否则会报错
num@ = 10  # SyntaxError: invalid syntax

# 2.标识符名称不能以数字开头。
1_num = 10   # SyntaxError: invalid decimal literal

# 3.不能使用关键字与保留字。
# 3.1 不能使用关键字
"""
# python中的关键字，被放在 keyword的工具包
import keyword
# 获取所有的关键字的操作
print(keyword.kwlist)
'''
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 
 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal',
 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
'''
# 使用关键字定义名称，会报错
False = 10   # SyntaxError: cannot assign to False  不允许给False再次赋值
"""
# 3.2 不建议使用保留字
"""
# print 在Python中被使用了  具有输出的含义
print = 10  # print这个标识符 代表只是10  原本的输出的含义就被覆盖了
print(10)  # TypeError: 'int' object is not callable
# 怎么辨别是不是保留字： 写单词的时候被提示出来的都是Python中已经使用的了  就不再使用即可
"""

5.变量与数据类型

变量：变化的数据，这种变化的数据在程序中来使用的时候，一般会给数据做一个标记，方便获取相关的数据信息，这个标记就成为变量名。

​ 例如： 记录一天的气温

​ 在程序中使用这个气温的时候，具体使用哪个数据，就不确定了，一般会被这个数据值设置一个变量名，随着时间的推移 设置不同的数据值，当使用的时候直接使用这个标记名代替数据参与运算即可。

# 早晨温度
air_temp = 24
# 中午温度
air_temp = 30
print(air_temp)   # 30

数据类型：把相同特征的数据进行归类，形成一类数据，这个称为数据类型

Python中的数据类型

整数类型（整型int） 10 20 30 40

小数类型（浮点型float） 3.14 5.17

文本数据（字符串str）字符串数据是需要使用引号包含的[不区分单双引号] ‘hello’ “Nice” ‘’ [空字符串]

逻辑结果(布尔类型bool) 逻辑结果只有两种 成立与不成立，布尔值只有两个 True 和 False

空类型(NoneType) 空值(None) 代表什么都没有

空字符串和None不是一个东西 【空字符串理解成是空箱子 None连箱子都没有】

获取数据的类型 type变量名

​ 类和对象

类：对具有相同属性和特征的数据的一个抽象描述【泛泛的称呼】

比如：整数类型

对象;该类下实际存在的实体

比如：10

# 定义一个 变量，记录人的名称，[起名字尽量见名知意]
name = '喜唐'
print(name)  # 喜唐
print(type(name))  # <class 'str'>    class代表的就是类型
# 定义一个变量 记录一个人的年龄
age = 30
print(age)  # 30
print(type(age))    # <class 'int'>  # 30
# 定义一个变量 记录性别
gender = '女'
print(gender)   # 女
print(type(gender))    # <class 'str'>
# 记录一个状态值
flag = True
print(flag)   # True
print(type(flag))     # <class 'bool'>
# 空值
result = None
print(result)  # None
print(type(result))     # <class 'NoneType'>

6.Python的输出

按住ctrl键点击要查看信息的名称，就可以进入到Python定义的源码文件

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

value, ...代表print可以一次性输出多个数据，书写的时候数据之间使用逗号分隔

sep=' '一次性输出多个数据时,展示的结果中数据之间的分隔符 默认是空格

end='\n'输出内容结束符，print输出内容时,会在内容末尾追加一个结束符 默认是换行

字符串中特殊的符号 \ [转义符]：可以将某些符号的含义转变为其他的意思

n—\n 换行符

r—\r 回车 在windows系统下 存储数据的时候 \n 本质上存储的是\r\n(要写\r\n，\r\n会自动解读为\n，但\r不会）

t—\t 制表符 就是tab键

u— 这个识别成unicode编码符号

file=sys.stdout:print数据输出的目的地，默认就是控制台下

# 更新内容的输出目的地
把内容输出到文件中
1. 需要建立程序和文件之间的联系通道
    有一个操作 open(文件路径, 操作文件的模式, 文件的编码形式):以指定模式将文件与程序建立联系
        文件路径有两种格式:
    		a. 绝对路径
            	windows系统  从盘符开始 到 具体的文件的路径  就是绝对路径
                 	例如：D:\pythonproject1\静夜思.txt
            	Mac系统 从根路径 /开始到具体文件结束
                    	例如：/Users/各班代课/Python2304/day02_变量及其运算符/代码/静夜					思.txt
   			b. 相对路径[建议]
         		需要文件配置在项目路径下   
         		相对路径是有参照物的：当前正在编辑的文件  
         		相对路径中有两个特殊的符号：
            		.  ---  当前操作的文件所在的文件夹 pythonproject1
           			.. --- 当前操作的文件所在的文件夹上一级  D
        操作文件的模式
            r -- read  只读  在程序中要读取文件的数据
            w -- write  只写  要将信息从程序中写入到文件中
                    文件如果不存在 会自动创建文件
                    文件存在  会清空文件内容 再把数据写入
            a --append 只写  要将信息从程序中写入到文件中
                    文件不存在 会创建文件
                    文件存在 进行的是追加写的操作
        文件的编码形式 【不同的编码形式决定了文件中语言的类型】
            编码：人为规定一种编译规则  
                在计算机存储数据的时候，存储格式是 二进制形式的
                十进制数据  逢十进一  数字符号集 0 1 2 3 4 5 6 7 8 9 
                二进制数据  逢二进一  数字符号集 0 1
                
                但是数据存储的时候 并不是只有数字，还有汉字 英文字母等等
                十进制转化成二进制怎么转换的？？？
                    存储10  在计算机中的是什么样子？？？
                        除以2取余数  直到商为0  将所有的余数倒序拼接起来
                            10/2 = 5 ---- 0
                            5/2 = 2 ----- 1
                            2/2 = 1 ----- 0
                            1/2 = 0 ----- 1
                            
                            10 ====> 1010
                
                汉字、英文字母等等不能直接转化为二进制，因此就出现了编码
                计算机人为制造的，运算规则也是人为制造的
                
                汉字或者英文字母在存储的时候 指定了什么规则？？？  这个映射规则称为编码
                    将汉字或者英文字母 每一个字对应着一个数字 
                    例如
                       a ===> 97
                       一 ===> 27361
                    
                常见的编码规则有：
                    ASCII码  --- 只设置128个符号对应的数字  包括英文字母
                    GB2312 --- 国家编码标准 2312序列号
                    GBK --- 国标扩展   
                    Unicode --- 国际编码标准 【收录是世界语言在内的】
                        Python的编码就是unicode下UTF-8  
2. 通过通道把数据传递到文件中
"""
# 绝对路径示例：
handle=open('D:\喜唐的笔记\静夜思.txt','w',encoding='UTF-8')
print('床前明月光，疑是地上霜。',file=handle,flush=True)
# 相对路径示例：
handle1=open('.\静夜思.txt','w',encoding='UTF-8')
print('窗前明月光，疑是地上霜。',file=handle1)
handle2=open('..\李白.txt','w',encoding='UFT-8')
print('静夜思',file=handle2)

flush=False:是否快速的将通道中的数据输出到文件中

print(1,2,3,4)  # 1 2 3 4

# 自己设置多个数据之间的分隔符
# 如果直接使用逗号分隔 代表的输出的多个数据 为了区分是数据还是分隔符，给分隔符赋值的时候 sep=指定的分隔符
print(1,2,3,4,sep='+')  # 1+2+3+4

# 演示转义符
print('and')   # and
print('a\nd')
'''
a
d
'''
print('1\r\n2')
'''
1
2
'''
# 输出内容的时候 此时不需要换行 可以修改end的值
print('hello',end='\t')
print('world')  #  hello	world
# \u  每一个unicode编码值 都对应着一个文字
print('\u4e00')     # 一

# 有些情况下,不需要转义符进行转义，保持转义符的本意.比如：路径中 C:\users\...
# 方式1： 对转义符再次转义  \\  保持\本身的含义
print('\\u')   # \u
# 方式2: 使用r修饰字符串   字符串中每个符号都保持数据本身的含义
print(r'\u')   # \u

7.Python中的输入

input让用户在控制台输入数据，传递到程序中。

格式：input(提示语)----会让程序暂停

​ 如何让程序继续：在控制台上输入数据，结束输入的标记是回车，输入数据回车之后，就把控制台输入的数据传递到程序中，想要获取这个数据，需要接收。

注意：输入的数据是变化的【也就是变量】，想要获取变量的数据，需要给变量的值一个标记名【变量名】。

# 将用户在控制台输入的数据 赋值给name这个变量名
name = input('请输入你的姓名：')
print('打印name的值',name)

# 不管录入的数据格式是什么样的，在程序中变量的值永远都是字符串类型的。
value = input('请输入一个内容：')
print(type(value))    # <class 'str'>

8.类型转换

# 用户输入两个数，求和
num1 = input('请输入一个数字：')   # 11
num2 = input('请输入另一个数字；')  # 12
print('这两个数字的和',num1+num2)   # 这两个数字的和 1112

# 这个结果的原因是：input 不管用户输入的是什么格式的数据 在程序中拿到的都是字符串类型的
字符串数据之间进行相加 完成的是拼接的动作
print('a'+'b')   # ab

# 想要完成这个求和这个目的，num1和num2接收到数据类型得是整数类型的才可以，但是现在是字符串类型的，想让字符串格式的数值变成整数类型，就需要进行类型转换
  操作语法【这个格式是固定的】
     int(数据/变量名)
# 类型转换示例：
value = '1990'
print(type(value))   # <class 'str'>
num = int(value)
print(type(num))     # <class 'int'>
# 注意事项： 把字符串格式的数值转化为整型时  数值的格式必须满足整数形态
int('3.14') # ValueError: invalid literal for int() with base 10: '3.14' 不合法的数据
int('11a')  # ValueError: invalid literal for int() with base 10: '11a' 不合法的数据

# 改进：转换为整型，并赋值给num1和num2
num1 = int(input('请输入一个数字：'))    # 11
num2 = int(input('请输入另一个数字；'))   # 12
print('这两个数字的和',num1+num2)       # 这两个数字的和 23

# 把字符串数据转化成浮点型 
float(数据/变量名)
注意：转换的时候要满足数字的形态  【可以是整数 也可以小数】

data = '3.14'
res = float(data)
print(type(res))  # <class 'float'>

data = '11'
res = float(data)
print(type(res))  # <class 'float'>

9.运算符

算术运算符

一元运算符：正负号 +11 -11

二元运算符

加法+

减法-

乘法*

除法/ 和 //

取余%

幂数**

优先级别：幂数** > 负号 > 乘、除、取整、取余 > 加、减

提高运算符的优先级别 使用()包含 不管多少层都是()

复合赋值运算符

简单的赋值运算符 = :a=10[将等号右边的数据赋值给左边的变量名]

复合赋值运算符：在进行赋值的时候，先操作了算术运算

+=、-=、*=、/=、//=、%=、**=

比较运算符: 比较两个数据，判断大小

>判断前者是否大于后者

>=判断前者是否大于或者等于后者

<判断前者是否小于后者

<=判断前者是否小于或者等于后者

==判断前者是否等于后者

!=判断前者是否不等于后者

比较运算符运行结果是布尔类型的，结果只有两个值True和False

算数运算符优先级别高于比较运算符

逻辑运算符: 是来操作逻辑关系的

逻辑与 and

连接的条件必须同时成立【也就是条件之间是并且的关系】，结果才是成立的

逻辑或 or

连接的条件成立其中一个即可【也就是条件之间的关系是或者关系】

逻辑非 not

对条件结果进行取反操作【真变假，假变真】

比较运算符的优先级高于逻辑运算符

逻辑运算符中优先级别： not > and > or

成员运算符 in

成员： 众多中的一个,这个运算符是应用在容器型数据的元素判断的,判断数据是否在某个容器型数据中。

整数、小数、布尔值、空值 每个数据都是独立的个体，这些都不是容器型数据

字符串是一个容器型类型，元素是字符【长度为1的字符串称为字符， 比如’a’, ‘0’, ’ '】
字符串就是由0个或者多个字符拼接起来的
0个字符的情况下 称为空字符串 ‘’ [是个空箱子]

格式: 数据 in 容器型数据
逻辑：把数据当做一个整体，判断数据是否包含在容器中

格式： 数据 not in 容器型数据
判断数据是否不在容器中

# 算术运算符
a=9
b=2
print('加法',a+b)
print('减法',a-b)
print('乘法',a*b)
print('除法',a/b)  # 结果是浮点型的
print('向下整除',a//b)    # 有一个向下取整的操作： 结果是<=商 且最接近于商的整数
print('取余',a%b)     # 两数相除 获取余数
print('幂数',a**b)
'''
加法 11
减法 7
乘法 18
除法 4.5
向下整除 4
取余 1
幂数 81
'''
# 开方
# 对8开3次方，就是8的三分之一次方
print(8**(1/3))   # 2.0

# 复合赋值运算符
num = 125
num += 5  # num = num + 5 = 130
print(num)   # 130

num //= 6  # num = num // 6 = 21
print(num)   # 21

num %= 10  # num = num % 10 = 1
print(num)    # 1

# 比较运算符
a = 17
b = 9

res = a + b > b * 2
print(res)  # True

res = a - b <= a % b
print(res)  # True

# 判断一个数的个位数是否为7
# 获取数据的个位数？？？？  除以10 取余数     比如 17除以10 商1 余7    16除以10商1余6
res = num % 10 == 7
print(res)  # True

# 如何获取十位上的数据？？？？
"""
1.可以将十位上的数 处理成个位上的数  ===== 整除10    245//10 = 24
2.将处理后的结果对10取余   24 % 10=4
"""

# 判断一个数据是否是奇数  除以2余1
res = num % 2 == 1
print(res)

res = num % 2 != 0
print(res)

# 逻辑运算符

# 逻辑与 and
'''
大学中评奖学金   平均成绩和绩点
平均成绩在90以上 并且 绩点在4.5以上
定义两个变量 表示成绩和绩点
score = float(input('请输入平均成绩：'))
gpa = float(input('请输入绩点：'))
res = score > 90 and gpa > 4.5
print(res)
'''
"""
练习:
    1. 输入一个数 判断这个数是否是3的倍数 并且也是7的倍数
    2. 输入一个数 判断这个数的十位是否为2的倍数 并且 个位是否是3的倍数
"""
# 1. 输入一个数 判断这个数是否是3的倍数 并且也是7的倍数   倍数：整除【余数为0】
num = int(input('请输入一个整数：'))
res = num % 3 == 0 and num % 7 == 0
print(res)
# 因为找的是既是3的倍数 也是7的倍数 可以找两个最小公倍数 21
res = num % 21 == 0
print(res)
#  2. 输入一个数 判断这个数的十位是否为2的倍数 并且 个位是否是3的倍数
num = int(input('请输入一个整数：'))
decade = num // 10 % 10
unit = num % 10  # 个位上的数据是不足10   除以10会被余下的
# 加这个不等于0  考虑的是0不是任何数的倍数
res = (decade % 2 == 0 and decade != 0) and (unit % 3 == 0 and unit != 0)
print(res)


# 逻辑或 or
'''
条件1 or 条件2
    其中一个条件成立即可
'''
# 判断一个年是否为闰年
'''
闰年：分为普通闰年和世纪闰年
    普通闰年： 能被4整除但是不能被100整除   2020年
    世纪闰年： 能被400整除  2000年
    
    普通闰年和世纪闰年满足其中一个要求 就是闰年 
'''
'''
year = int(input('请输入年份：'))
common = year % 4 == 0 and year % 100 != 0
century = year % 400 == 0
res = common or century
print(res)

# 判断输入的月份是否是第三季度的  7月8月9月
'''
month = int(input('月份：'))
res = month == 7 or month == 8 or month == 9
print('输入的月份是否是第三季度的结果：', res)
'''
"""
练习：
1. 判断输入的数据是否是3或者5的倍数
2. 判断输入的月份的天数是否是30天
"""
# 1. 判断输入的数据是否是3或者5的倍数
num = int(input('请输入整数：'))
res = num % 3 == 0 or num % 5 == 0
print(res)
# 2.判断输入的月份的天数是否是30天
# 4 6 9 11
month = int(input('输入月份：'))
res = month == 4 or month == 6 or month == 9 or month == 11
print(res)


# 逻辑非 not
"""
对逻辑结果取反，not条件
如果条件成立，not之后为False
如果条件不成立，not之后为True
"""
# 判断一个数是否为奇数
'''
num = int(input('输入一个数：'))
# num % 2 !=0   不等于0就是对等于0进行取反
# num % 2 ==1
res = not(num % 2 == 0)
print(res)
'''

# 判断一个数是否能被3或者7整除 但是不能同时被3和7整除
'''
num = int(input('请输入一个数字：'))
res = (num % 3 == 0 or num % 7 == 0) and not(num % 3 == 0 and num % 7 == 0)
print(res)
'''
"""
练习：
    1. 判断一个数是否不为正数
    2. 输入一个月份 判断其是否在 1-12之间
"""
# 1. 判断一个数是否不为正数
num = int(input('请输入整数:'))
res = not(num > 0)
print(res)
# 2.输入一个月份 判断其是否在 1-12之间
month = int(input('月份：'))
month >= 1 and month <= 12
res = not(month < 1 or month > 12)
print(res)
# 区间形式的范围判断  month >= 1 and month <= 12
# python可以对其进行简写
res = 1 <= month <= 12
print(res)

# 成员运算符

s = 'hello'
res = 'h' in s
print(res)

res = 'hl' in s
print(res)


res = 'hl' not in s
print(res)

10.分支结构语句

分支结构语句有三种形态：

1.单分支结构

​ 在顺序流程过程中，检测数据是否达到某个状态点，如果达到这个状态点按照状态点的流程进行操作。如果没有达到的话，按照原流程进行操作。

例如：
学校 — 回家
如果时间比较早 在6点之前到家 先去洗车 —再回家

语法：
if 条件:
满足条件执行的操作
解读： 如果条件满足 就执行相应的操作
注意： 相应的操作的执行 要看条件是否满足 体现这种关系使用的是代码块包含的结构
Python中如何体现代码块包含： 使用冒号+四个空格的缩进 【一般编辑器会默认一个tab键 就是四个空格】

print('从学校出发')
# 需要记录当前的时间点
hour = 17
# 要求时间在18点之前，进行洗车的操作
if hour < 18:
    print('洗车店')
print('回家')

2.双分支结构

相当于十字路口，是向左还是向右
语法：
if 条件:
满足条件执行的操作
else:
不满足条件执行的操作
解读：
如果条件满足，做事情A ，否则做事情B

# 做一个成绩判定器： 判断输入的成绩是及格还是不及格
score = float(input('成绩：'))
if score >= 60:
    print('合格')
else:
    print('不合格')

3.多分支结构

出现了3种及其以上的选择
语法：
if 条件1:
操作1
elif 条件2:
操作2
…
elif 条件n:
操作n
else:
以上条件都不满足，执行的操作

这个else语句可以省略
elif ==== else if
如果与否则是对立面， 执行了如果，就不会执行否则

# 给成绩分等级
'''
    >= 90  A
    >= 80  B
    >= 70  C
    >= 60  D
    <60    E
'''
score = float(input('请输入成绩:'))
if score >= 90:
    print('A')
elif score >= 80:
    print('B')
elif score >= 70:
    print('C')
elif score >= 60:
    print('D')
else:
    print('E')
"""
练习：
    1. 超市活动，购买金额不足180，支付原金额，在180以上 打8折， 金额在300以上打6折 
        录入购买金额，计算出支付金额
    2. 做一个数据比较器：根据输入的两个数 获取其中的最大值
    3. 录入身高(单位是m)、体重(单位是kg),计算一个人的BMI值，判定身材状况 
            BMI小于 18.5 偏瘦
            BMI在18.5到24.9之间正常
            BMI大于24.9 偏胖
    4. 模拟用户登录：录入用户名与密码，如果用户名为admin 密码为123456abc 则提示登录成功 否则提示登录失败
"""
# 1. 超市活动，购买金额不足180，支付原金额，在180以上 打8折， 金额在300以上打6折
#         录入购买金额，计算出支付金额
money = float(input('请输入购买金额：'))
if money > 300:
    payment = money * 0.6
elif money > 180:
    payment = money * 0.8
else:
    payment = money
print('支付金额为', payment)
# 2. 做一个数据比较器：根据输入的两个数 获取其中的最大值
num1 = float(input("a:"))
num2 = float(input('b:'))
if num1 > num2:
    print('a比较大，a的值为', num1)
else:
    print('b比较大，b的值为', num2)
# 3. 录入身高(单位是m)、体重(单位是kg),计算一个人的BMI值，判定身材状况
#             BMI小于 18.5 偏瘦
#             BMI在18.5到24.9之间正常
#             BMI大于24.9 偏胖
height = float(input('身高(m):'))
weight = float(input('体重(kg):'))
bmi = weight / height ** 2
if bmi < 18.5:
    print('偏瘦')
elif bmi <= 24.9:
    print('正常')
else:
    print('偏胖')
#  4. 模拟用户登录：录入用户名与密码，如果用户名为admin 密码为123456abc 则提示登录成功 否则提示登录失败
username = input('用户名：')
password = input('密码：')
if username == 'admin' and password == '123456abc':
    print('登录成功')
else:
    print('登录失败')

分支语句嵌套

在满足某个条件的基础上还需要再次进行逻辑判断

"""
需求：
    计算加油的金额
    因为油号不同 价格不同 优惠也是不一样
    92  单价8元/L   添加30L及其以上  打8折 否则按照原价处理
    95  单价8.8元/L  添加25L及其以上  打8折  否则按照原价处理
    98  单价9.5元/L   添加20L及其以上  打9折  25L及其以上8.5折  30L及其以上8折 否则按照原价处理
"""
oil_num = int(input('请输入油号：'))
litre = float(input('加油的升数：'))
# 判断油号
if oil_num == 92:
    # pass
    if litre >= 30:
        payment = 8 * litre * 0.8
    else:
        payment = 8 * litre
elif oil_num == 95:
    # pass
    if litre >= 25:
        payment = 8.8 * litre * 0.8
    else:
        payment = 8.8 * litre
else:
    # if litre >= 30:
    #     payment = 9.5 * litre * 0.8
    # elif litre >= 25:
    #     payment = 9.5 * litre * 0.85
    # elif litre >= 20:
    #     payment = 9.5 * litre * 0.9
    # else:
    #     payment = 9.5 * litre
    if litre < 20:
        payment = 9.5 * litre
    elif litre < 25:
        payment = 9.5 * litre * 0.9
    elif litre < 30:
        payment = 9.5 * litre * 0.85
    else:
        payment = 9.5 * litre * 0.8
print('加油的金额为：',payment)

11.循环结构语句

循环：周而复始 重复做同一件事
一直重复操作，没有终止，在编程里称为死循环 【在程序中是要避免的 — 程序卡死】
常见的循环结束状态：

1. 循环满N次 比如：体育测试：围着操场跑满5圈
2. 循环达到某个条件 比如： 体育测试：跑满1000米

Python提供的循环操作，有两个结构：

1. for-in循环，适合于循环满N次的情景

   本质上是在遍历[逐个获取]容器型数据，在遍历获取元素的过程中进行相应的逻辑判断，容器中有几个元素，这个循环就执行几次。
   语法：
   for 变量名 in 容器型数据:
   循环体
   解读：
   in 可以理解成进入容器中拿元素数据
   变量名 in进入拿到数据之后 赋值给变量名
   循环结束点： in到容器中 没有数据可拿的时候 循环结束

   # for-in循环
   
   s = "hello"
   # 逐个将字符串s中的元素取出来
   for c in s:
       print(c)
       # print('跑了一圈')
   # 获取字符串中小于l的字符
   # 逻辑 获取到元素之后 要对其进行判断  判断是否是小于l的
   for d in s:
       if d < 'l':
           print(d)
   
   
   # 假如跑100圈  使用循环的时候 可以使用range快速生成一个等差数列
   """
   range(stop)
       设定一个结束值， 等差数列是从0开始 步长为1 到stop[不包含]结束
           range(10) ====> 0 1 2 3 4 5 6 7 8 9 
   range(start, stop)
       设定了起始值和结束值 等差数列是从start[包含]开始 步长为1 到stop[不包含]结束
           range(1, 11) ====> 1 2 3 4 5 6 7 8 9 10 
   range(start, stop, step)
       step步长  
           正数 --- 生成的是递增的等差数列  要求 起始值<结束值    
           负数 --- 生成的是递减的等差数列  要求 起始值>结束值
       stop结束位置[不包含]
       start开始位置[包含]
           range(1, 10, 2) ====> 1 3 5 7 9 
           range(10, 0, -2) ====> 10 8 6 4 2 
   range(100) ===> 0-99
   """
   # 跑第几圈
   for x in range(1,101):
       print('跑第',x,'圈')
   
   for y in range(0,100,4):
       print(y)
   

   for循环和range结合例题

   # 1. 求1+2+3+...+99+100
   """
   产生一个容器 容器放着1-100的数据
   遍历容器取值 ，取出来一个累加起来
   注意： 和随着取值 会发生变化的  【定义一个变量 用来接受累加和的值】
   """
   total = 0   # 放在循环的外面  避免每次循环重置
   for i in range(1,101):
       total += i  # total = total + i
   """
           第一次 in 的时候 i = 1
               total += i  ===> total  = total + i = 1
           第二次 in 的时候 i = 2
               total += i  ===> total  = total + i = 1 + 2 = 3
           第三次 in 的时候 i = 3
               total += i  ===> total  = total + i = 3 + 3 = 6
   """
   print(total)
   
   # 求 1-2+3-4+5-6+...-98+99-100
   """
   观察：
       发现奇数是相加的 偶数是相减的
       获取数据的是加还是减  需要判断拿到的数据是奇数还是偶数
   """
   total = 0  # 定义一个变量 记录累加和
   for i in range(1,101):
       if i % 2 == 1:
           total += i
       else:
           total -= i
   # 当循环结束的时候 把所有的数据都参与运算了
   # 写的代码与for对齐 代表已经出了循环  如果还是缩进的操作 代表还在循环之中
   print(total)
   # 另一种求幂数的方法
   total2 = 0  # 定义一个变量 记录累加和
   for k in range(1, 101):
       # 不想使用分支判断 可以利用对-1求幂数  (-1)的奇数次幂结果是-1  (-1)的偶数次幂结果是1
       value = (-1) ** (k - 1) * k
       total2 += value
   print(total2)
   
   # 求1**2 + 2**2 + 3**2 +......+ 10**2 的结果
   total = 0
   for a in range(1,11):
       value = a ** 2
       total += value
   print(total)
   
   # 求1-100中能被3整除且个位数为5的数据的个数
   # 需要一个变量作为计数器
   count = 0
   for b in range(1,101):
       if b % 3 == 0 and b % 10 == 5:
           count += 1
   print(count)
   

   关键字break和continue

   # 任何查询关键字
   import keyword
   print(keyword.kwlist)
   """
   ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 
   'await', 'break', 'class', 'continue', 'def', 'del', 
   'elif', 'else', 'except', 'finally', 'for', 'from', 'global',
    'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 
    'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
   """
   

   都是应用在循环结构语句中，只能对循环起作用。

   break的作用是中断它所在的循环【退出循环】

   continue的作用【循环一次一次执行的】是，结束当前次【循环体中后面的代码不再执行】，跳到循环判断的位置，再决定是否开启下一次【判断成立的时候开启下一次】

   # 演示continue的作用
   # 打印1-10中的偶数
   '''
   for i in range(1,11):
       # 判断这个数据是否是偶数
       if i % 2 == 0:
           print(i)
   '''
   # 换一种思路，判断这个数据是否是奇数，是奇数，跳过这次循环，继续下一次
   '''
   for i in range(1,11):
       if i % 2 == 1:
           continue
       print(i)
   '''
   # 练习：利用continue写 数7游戏，1-100中 遇到7 或者 7的倍数 跳过  否则是输出
   """
   1. 使用range 生成1-100的数列 
   2. 遍历逐个获取数据
   3. 判断 获取的数据 是否是7的倍数 或者 带7
           带有7 有两种情况
               个位   %10 == 7
               十位  //10%10 == 7
           7的倍数
               %7 == 0
   """
   for m in range(1, 101):
       if m % 10 == 7 or m // 10 % 10 == 7 or m % 7 == 0:
           continue
       print(m)
   

   # 演示break的作用
   """
   break 是结束所在的循环 
       一般循环结束是  循环条件不成立或者容器中没有数据可拿时  结束循环
   """
   for n in range(1, 11):
       print(n)
       if n == 5:
           break
   
   # 练习：获取 1-100中 3的倍数且个位数为5  当获取到第二个的时候 结束获取
   """
   思路：
       获取的时候还需要计数  当计数器为2的时候 结束循环
   """
   count = 0  # 计数器
   for k in range(1, 101):
       if k % 3 == 0 and k % 10 == 5:
           count += 1  # 计算器+1
           print(k)
   
       # 判断计算器是否为2 结束
       if count == 2:
           break
   

2. while循环

   语法：
   while 条件判断:
   循环体代码块
   解读：
   只要条件成立，程序就一直在此循环，直到循环条件不成立

   # 输出1-10之间的数据
   # for循环的思想： 需要一个容器，容器中存放在1-10
   for i in range(1, 11):  #  容器的起始值是1  步长是1  结束位置是11[不包含]
       print(i)
   print('================')
   # while循环 思想:
   """
   1. 重复做的操作是什么   ==== 打印数据  每次打印的都是1个
   2. 做这件事情的条件  ===== 只要打印的数据没有到10  就得一直打印
   """
   # 根据这两件事情，需要哪些数据支持
   """
   打印数据 每打印1次 数据要在原来的基础上+1
   也就是说要打印的数据是变化的  就得设置标记名给其进行标记 【定义一个变量 记录打印的数据值】
   """
   num = 1
   # 循环的操作
   while num <= 10:
       print(num)
       # 数据还在原来的基础上+1
       num += 1
   print('循环结束时 num的值', num)
   
   # 1-10中的偶数  使用while打印1-10中的偶数
   # 定义一个数据的起始值
   m = 1
   # 循环 数据进行递增
   while m <= 10:
       if m % 2 == 0:
           print(m)
       m += 1
   
   # 使用while循环 完成 1+2+3+...+100
   # 1.使用for来完成的时候
   total = 0  # 记录和的
   for i in range(1, 101):
       total += i
   print(total)
   # 2.使用while来完成的时候
   m = 1
   total1 = 0
   while m < 101:
       total1 += m
       m += 1
   print(total1)
   
   '''
   练习
   1.求 1-2+3-4+5-6+...-98+99-100
   2.求1-100中能被3整除且个位数为5的数据的个数
   '''
   # 练习1:求 1-2+3-4+5-6+...-98+99-100
   k = 1
   total2 = 0  # 接受和
   while k < 101:
       if k % 2 == 0:
           total2 -= k
       else:
           total2 += k
       k += 1
   print(total2)
   
   # 2.求1-100中能被3整除且个位数为5的数据的个数
   p = 1
   count = 0  # 计数器
   while p < 101:
       # 判断这个数据是否满足要求
       if p % 3 == 0 and p % 10 == 5:
           count += 1
       p += 1
   print(count)
   

循环结束的场景

明确循环次数 — for-in循环 遍历容器，容器中有几个数据 循环就执行几次

明确结束状态的 — while循环

​ while 循环条件:

		        满足条件就执行

经过上面代码的演示 while也可以适用于明确循环次数的，只不过使用while书写起来麻烦了一些， 所以建议使用for-in循环

# 案例:  有1023个桃子， 猴子每天吃桃子剩余个数的一半多1个，问多少天能吃完
# 来操作的时候 循环次数不明确  就使用while循环
"""
1. 重复做的事情是什么      桃子个数/2 + 1
2. 结束做这件事情的状态[只要没有达到这个状态就不会结束]  桃子个数为0 就不用吃 【只要桃子个数不为0 就得一直吃】
"""
"""
需要准备的数据：
1. 需要一个变量名 接受桃子的个数  起始值是1023
2. 计数器 记录吃的天数
"""
peach_count = 1023  # 桃子的个数
day = 0  # 计数器【天数】
# 开启循环
while peach_count > 0:
    # 吃完 记录的剩余的桃子的个数
    peach_count = peach_count - (peach_count//2 + 1)
    # 计数器+1
    day += 1
# 循环结束的时候 桃子被吃完
print('1023个桃子猴子需要', day, '天吃完')

"""
练习:
    1. 录入一个大于1的整数  
        如果这个数值是偶数  将数据整除2后-1
        如果这个数是奇数  将这个数据-1 再整除2
        重复操作  问多少次之后才能将数据设置为0
    2. 一张纸的厚度是0.8mm，假设纸足够长，问对折多少次可以将纸的高度达到1000米
"""
# 练习1
num = int(input('请输入一个大于1整数：'))
num1 = num  #  记录原始的数据
count1 = 0
while num > 0:
    # 判断奇偶性
    if num % 2 == 0:
        num = num // 2 - 1
    else:
        num = (num - 1) // 2
    # 计数器+1
    count1 += 1
print(num1, '经过运算', count1, '次之后置为0')
# 练习2
'''
1m = 1000mm
重复的事情   对折  厚度*2
做这件事情的目的  达到1000000mm 
'''
'''
准备数据
1. 记录纸的高度  起始高度是0.8mm
2. 计数器 记录次数
"""
paper_height = 0.8
count2 = 0
while paper_height < 1000 * 1000:
    # 重复的操作
    paper_height *= 2
    # 计数器+1
    count2 += 1
print('0.8mm的纸经过', count2, '次对折后达到千米')

while True思想【死循环】

分析出来结束点 判断是否达到结束点 到了的话 结束循环break

# 一张纸的厚度是0.8mm，假设纸足够长，问对折多少次可以将纸的高度达到1000米
paper_height1 = 0.8
count3 = 0
while True:
    # 对折
    paper_height1 *= 2
    # 计数
    count3 += 1
    # 判断 纸的高度达到千米
    if paper_height1 >= 1000 * 1000:
        break

        
# 数字炸弹练习        
"""
数字炸弹：
        规则： 有一个出题人 随便在1-100之间设定一个数据，然后其他人猜
            猜小了、猜大了  出题人提示新的范围 
            猜中了 就一顿暴揍
           
        69
        
        你： 85    出题人 1-85
        他： 70    出题人 1-70
        她： 55     出题人 55-70
        我:  69    挨揍了  
"""
# 程序中生成随机数
# Python提供了一个工具包  random  就是来提供随机操作
import random
print(random.randint(1, 101))  # 在给定的a,b之间随机选择一个整数
"""
完成这个游戏 是需要循环的
循环次数是不明确的，使用while循环
循环结束状态： 猜中了
"""
"""
数据准备
1. 准备一个1-100中的随机数
2. 猜数的范围的起始值和结束值
"""
random_num = random.randint(1, 100)  # 唯一一个包含结束位置的
# 猜数的范围
start = 1
stop = 100
# 开始猜
while True:
    # 猜的动作是重复的  所以放在循环中
    # 字符串数据可以使用+将数据拼接在一起 【只能是字符串与字符串拼接】
    # 把数据转化成字符串的操作 str(数据)  int() float()
    guess = int(input('请输入' + str(start) + '-' + str(stop) + '之间的数据，进行竞猜：'))
    # 将输入的数据与随机的数据进行对比
    if guess > random_num:
        # pass
        print('猜大了')
        stop = guess
    elif guess < random_num:
        print('猜小了')
        start = guess
    else:
        print('猜中了  暴揍中.....')
        break
print('游戏结束')

12.列表

可变的有序型容器。

可变：数据的值可以发生变化，可以修改/增加/删除

有序: 容器存储放数据的时候，容器中有多少个数据，会给数据设置编号，编号是从0开始[左边视为开始]，可以通过编号定位获取这个位置的数据,也可以修改。这个编号被称为下标/索引

数据在进行定义的时候，数据标识是[], 在[]中定义多个数据，数据之间使用逗号分隔

例如：比如[19, 24, 26, 22]，数据中的编号0 1 2 3

1.获取列表中元素的个数
len(数据/变量名)

print(len(airtemp_list))  # 7

2.下标(索引)

数据的一个编号，可以通过这个编号获取数据，也可以修改这个位置的数据，一般的编程语言中 编号就是从左向右 ，从0开始 加1递增。

Python对于下标有两种表达形式：

​ 获取数据的时候可以使用正向索引 也可以使用负向索引

正向索引 — 从左向右
0,1,2,3,4,5,6，…, len(数据)-1

负向索引 — 从右向左
-1，-2，-3，-4，-5， … -len(数据)

​ 格式：

列表数据[下标] ====> 代表的是获取这个位置的数据

列表数据[下标] = 数据值 ====> 修改这个位置的数据

​ 注意：下标不能超过编号的界限，否则报错

'''
7点  9点  11点  1点  2点  4点 6点
0    1     2    3    4    5    6 正向索引
-7   -6    -5   -4   -3   -2   -1  负向索引
'''
airtemp_list = [17, 19, 22, 26, 30, 28, 26]
# 获取9点  【第二个位置的数据】
print(airtemp_list[1])  # 正向索引获取的
# 使用负向索引
print(airtemp_list[-len(airtemp_list) + 1])
# 获取左边的使用正向  获取右边的使用负向

# airtemp_list.pop() # 把最后一个删除了   [17, 19, 22, 26, 30, 28]
# airtemp_list[6]  #  IndexError: list index out of range
# 获取倒数第一个位置
print(airtemp_list[len(airtemp_list) - 1])  # 正向索引
print(airtemp_list[-1])  # 负向索引

# 修改这个位置的数据
airtemp_list[-3] = 33
print(airtemp_list)  # [17, 19, 22, 26, 33, 28, 26]
# 列表是可变的，所有的操作都影响的数据列表本身
# 操作完查看数据变化 直接打印列表本身即可

3.切片（slice):提取子序列

​ 本质上根据下标定位到容器相应的位置， 从指定的起始位置按照步长取数据元素去

格式：列表数据[起始下标:结束下标:步长]

步长为正数：代表的是正向切片 【根据位置从左向右按照步长取值】
注意：起始下标定位的位置 要在 结束下标定位的位置 的左边

步长为负数，代表的是负向切片 【根据位置从右向左按照步长取值】
注意：起始下标定位的位置 要在 结束下标定位的位置 的右边

解读：

1. :步长可以省略, 步长默认为1
   列表数据[起始下标:结束下标]
   代表从起始下标对应的元素开始 逐个取值 到结束下标对应的位置[结束下标不包含]

2. 起始下标可以省略
   看步长为正还是为负
   步长为正 代表从最左边开始
   步长为负 代表从最右边开始

3. 结束下标也可以省略
   看步长为正还是为负
   步长为正 代表到最右边结束
   步长为负 代表到最左边结束

scores = [76, 28, 39, 45, 57, 82, 91, 68]  # 8个数据
# 0 1 2 3 4 5 6 7
sub_scores = scores[1:7:1]
print(sub_scores)
# 等价于
sub_scores = scores[1:7]
print(sub_scores)
# 等价于  只是按照下标定位到列表相应的位置范围
sub_scores = scores[1:-1]
print(sub_scores)

# 前3个
sub_scores = scores[:3]
print(sub_scores)
# 后三个
sub_scores = scores[-3:]
print(sub_scores)
# 反转
sub_scores = scores[::-1]
print(sub_scores)
# 步长为2
sub_scores = scores[::2]
print(sub_scores)

4.增加数据的操作

列表数据.append(数据) 把数据追加在列表的末尾

列表数据.insert(指定位置, 数据) 在指定位置添加数据， 原位置及其之后的数据都向后移一个

course_list = ['语文', '数学', '英语', '体育']
# 增加一门Python课程
course_list.append('Python')
print(course_list)
# 在1的位置添加政治
course_list.insert(1, '政治')
print(course_list)

5.删除数据的操作

列表数据.remove(数据) 将数据在列表中移除 如果数据有多个的话 只会移除出现的第一个

列表数据.pop() 将列表中最后一个元素移除

列表数据.pop(位置) 将列表中指定位置的元素移除

列表数据.clear() 清空列表

course_list.remove('英语')
print(course_list)

course_list.pop()
print(course_list)

course_list.pop(0)
print(course_list)

course_list.clear()
print(course_list)

6.关于列表遍历的操作

• 获取下标序列 ，根据下标提取数据值
• 遍历列表，获取列表中的元素

nums = [18, 29, 33, 56, 71, 28, 42, 56, 37]
for pos in range(len(nums)):  # 0 1 2 3 4 5 6 ... 长度-1
    print(nums[pos])
# 等同输出
for ele in nums:
    print(ele)
# 获取列表中所有的偶数
for even in nums:
    if even % 2 == 0:
        print(even)
# 定义一个新的列表 用来存储所有的偶数
even_list = []
for n in nums:
    if n % 2 == 0:
        even_list.append(n)
print(even_list)
# 获取所有偶数所在的位置
pos_list = []
for i in range(len(nums)):
    if nums[i] % 2 == 0:
        pos_list.append(i)
print(pos_list)
# 获取所有的偶数及其对应的位置
# 遍历位置
for j in range(len(nums)):
    if nums[j] % 2 == 0:
        print(j, nums[j])
        
# enumerate(有序容器数据) ====》产生一个新的容器  [[位置, 元素], [位置, 元素]]
# 二维结构
for item in enumerate(nums):
    print(item)
# 拆包： 把容器中的数据赋值给N个变量， 把容器拆解 这个过程叫做拆包
a, b = [11, 23]
print(a, b)
# 利用拆包的原理
for p, e in enumerate(nums):
    # p接受的位置  e接受的元素
    if e % 2 == 0:
        print(p, e)

7.列表推导式

产生新列表 – 遍历简化的格式

​ [变量 for 变量 in 容器型数据 if判断条件]

"""
even_list = []
for n in nums:
    if n % 2 == 0:
        even_list.append(n)
print(even_list)
"""
#列表推导式
result = [n for n in nums if n % 2 == 0]
print(result)

# 有些需求不一定是有判断的  if判断条件的存在是按照需求来决定有或者没有的
values = [1, 2, 3, 4, 5]
# ====> [1, 4, 9, 16, 25]
pow_list = []
for d in values:
    pow_list.append(d ** 2)
print(pow_list)
# 列表推导式
print([d ** 2 for d in values])

"""
练习:
    1. scores = [82, 79, 65, 47, 58, 91, 66]
    利用列表推导式获取 60及其以上的成绩
    
    2. 利用列表推导式 获取 1-100中个位数是1 且是3的倍数的数据
    
"""
# 练习1
scores = [82, 79, 65, 47, 58, 91, 66]
pass_score = [s for s in scores if s >= 60]
print(pass_score)
# 练习2
res = [g for g in range(1, 101) if g % 10 == 1 and g % 3 == 0]
print(res)

8.其他容器型数据

max(容器型数据) 获取数据中的最大值

min(容器型数据) 获取数据中的最小值

sum(容器型数据) 对容器中数据求和

13.元组（tuple)

和列表是类似的。列表是可变的有序序列；元组是不可变的有序序列

什么时候使用元组？ 数据元素确定 且不会再发生变化 就可以使用元组

​ 例如：31天的月份 1 3 5 7 8 10 12

元组的数据标记是(), 列表的是[]
提高运算符优先级的时候 也是使用()

**注意: **一元组[元组中有1个数据]定义的时候 元素后面必须加上逗号， 否则会识别成提高表达式优先级 就不是元组类型的

nums = (11)
nums1 = (11,)
print(type(nums), type(nums1))  # <class 'int'> <class 'tuple'>

# 判断输入的某年某月有多少天？
month = int(input('请输入月份：'))
year = int(input('请输入年份：'))
if month == 4 or month == 6 or month == 9 or month == 11:
    print(month, '有30天')
# 元组
if month in (4, 6, 9, 11):
    print(year, '年', month, '月有30天')
elif month in (1, 3, 5, 7, 8, 10, 12):
    print(year, '年', month, '月有31天')
else:
    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
        print(year, '年', month, '月有29天')
    else:
        print(year, '年', month, '月有28天')


nums = (11, 23, 45, 67, 87, 29, 45)
# 获取前三个
print(nums[:3])
# 获取最后一个
print(nums[-1]).
# 不支持元素被修改的
nums[0] = 19  # TypeError: 'tuple' object does not support item assignment


# 当给一个变量 赋值的时候使用逗号分隔开多个数据  这个多个数据进行打包的操作  打包成元组赋值给变量
values = 11, 23, 45, 61, 72, 38, 49
print(type(values))  # <class 'tuple'>
# 解包  把一个容器中多个数据赋值给多个变量
a, b = 11, 23
print(a, b)
# 将位置和该位置的元素组合成元组 放在一个新的容器A中    这个A就是一个二维容器
for item in enumerate([12, 34, 56, 71]):
    print(item)  # (0, 12)  

14.字符串

字符串是容器型数据，里面的元素都是字符[长度为1的字符串]，是不可变的有序序列。例如：‘a’ ‘b’ ’ ’ ‘0’

s = 'hello everyone'
# 获取元素个数
print(len(s))
# 可以通过下标 获取字符
print(s[0]) # 第一个
print(s[-1]) # 最后一个
print(s[:3]) # 前三个
print(s[-3:]) # 后三个
# 不可修改字符
s[0] = 'H'   # TypeError: 'str' object does not support item assignment

获取得操作

1. 字符串数据.find(子串)：查找子串第一次出现的位置
2. 字符串数据.rfind(子串)：查找子串最后一次出现的位置
3. 字符串数据.count(子串)：统计子串出现的次数

s = 'hello everyone'
# 'e'第一次出现的位置
pos = s.find('e')
print(pos)  # 1
# 'e'最后一次出现的位置
pos = s.rfind('e')
print(pos)  # 13
# 'e'出现的次数
count = s.count('e')
print(count)

转换的操作

将字符串中的相关符号进行转换 【因为字符串不可变 产生的数据是影响不了原本的数据 都是产生的是一个新的数据】

1. 字符串数据.upper() 将字母变大写
2. 字符串数据.lower() 将字母变小写
3. 字符串数据.swapcase() 将大写变小写 将小写变大写
4. 字符串数据.title() 每个单词首字母大写 【单词：没连接在一起的就视作一个新的单词】
5. 字符串数据.capitalize() 首字母大写 其他小写

s = 'hello everyone'
# 将字母变大写
new_s = s.upper()
print(new_s)
# 将字母变小写
new_s1 = new_s.lower()
print(new_s1)
# 将每个单词首字母大写
new_s2 = new_s.title()
print(new_s2)  # Hello Everyone
# 将大写变小写，小写变大写
new_s3 = new_s2.swapcase()
print(new_s3)
# 将首字母大写，其他小写
new_s4 = new_s3.capitalize()
print(new_s4)

判断的操作

1. 是否以指定内容开头
   字符串数据.startswith(指定内容)
2. 是否以指定内容结尾
   字符串数据.endswith(指定内容)
3. 判断是否是纯数字
   字符串数据.isdigit()
4. 判断字符串的内容是否为纯字母
   字符串数据.isalpha()
5. 判断字符串的内容是否为数字或字母
   字符串数据.isalnum()
6. 判断字符串中的字母是否为大写
   字符串数据.isupper()
7. 判断字符串中的字母是否为小写
   字符串数据.islower()

s = 'Hello Everyone'
# 是否以'H'开头
print(s.startswith('H'))  # True
# 是否以'one'结尾
print(s.endswith('one'))   # True
# 字符串内容是否都为数字或字母 ，有空格
print(s.isalnum())  # False
# 字符串内容是否为纯字母 ，有空格
print(s.isalpha())  # False
# 字符串中首位字符是否大写
print(s[0].isupper())  # True
# 字符串中后三位字符是否小写
print(s[-3:].islower())  # True

# 字符串’123‘中是否都为数字
print('123'.isdigit())

练习

'''
data = "hello my age is 18, my birthday is September 5th."
   1.遍历字符串 提起其中的数字符号 
   2.将字符串中首字母大写 其他小写
   3.统计字符串中a出现的次数
   4.查找is第一次出现的位置 并从这个位置一直提取到最后   
'''
data = "hello my age is 18, my birthday is September 5th."
# 1.遍历字符串 提起其中的数字符号 
digit_s = ''  # 空字符串
for ch in data:
    # 判断是否为数字
    if ch.isdigit():
        # 字符串的+号运算
        digit_s = digit_s + ch
print(digit_s)
# 2.将字符串中每个单词首字母大写 其他小写
print(data.title())
# 3.统计字符串中a出现的次数
print(data.count('a'))
# 4.查找is第一次出现的位置 并从这个位置一直提取到最后
print(data[data.find('is'):])

字符串的切割与拼接

切割：字符串数据.split(切割符)

​ 将指定切割符为切割点 把字符串分成N份， 结果是一个列表 存储多个子串

拼接：‘拼接符’.join(容器型数据)

​ 使用拼接符将容器中的元素拼接在一起

​ 注意：容器中的元素必须是字符串类型的 ，底层实现的时候使用的是 +号运算，+在字符串中完成的字符串拼接 ，只能拼接字符串类型的。

# 切割
data = "hello my age is 18, my birthday is September 5th."
# 以空格为切割符
print(data.split(' '))
# ['hello', 'my', 'age', 'is', '18,', 'my', 'birthday', 'is', 'September', '5th.']

# 拼接
nums = [18, 34, 56, 71, 29]
# 使用+号将其拼接在一起
print('+'.join(nums))
# TypeError: sequence item 0: expected str instance, int found
# 期待的是字符串 但是获取的却是整型
# 拼接之前转化成字符串
str(nums)  # 将传进的数据转化为字符串 ====> '[18, 34, 56, 71, 29]'
str_nums = [str(ele) for ele in nums]  # ['18', '34', '56', '71', '29']
print('+'.join(str_nums))  # 18+34+56+71+29

字符串格式化

1. 在指定宽度中居中显式 字符串.center(宽度, 占位符)
2. 在指定宽度中居左显式 字符串.ljust(宽度, 占位符)
3. 在指定宽度中居右显式 字符串.rjust(宽度, 占位符)

s = 'hello'
print(s.center(10, '*'))
print(s.ljust(10, '*'))
print(s.rjust(10, '*'))

将未知的数据格式化拼接在字符串文本中
目的：将非字符串类型的数据与字符串类型的数据进行拼接

# 方式1. + 可以让字符串进行拼接  但是只能字符串类型的数据
# print('年龄'+ 17)  # TypeError: can only concatenate str (not "int") to str  # 只能字符串与字符串进行拼接
# 将数据转化为字符串类型
print('年龄' + str(17))

# 方式2： 使用字符串中 % 运算符  【% 在数字运算是取余】
"""
先生成文本 在未知的位置使用占位符进行占位，再对字符串进行%, 给占位的符号赋值
    占位符:
        %s --- 可以填充任意类型的数据
        %d --- 填充的是整型数据
            可以单独再进行格式化操作
                %0nd  === n代表的是数字显式的宽度 不足n位 左边补充0
                    %05d ====> 10 ====> 显式的时候 为 00010
        %f --- 填充的浮点型数据
            可以再单独格式化 
                %.nf === n代表的是保留小数的位数
                    %.3f ====> 3.1415926 ===>显式为 3.142
"""
# 例1
year = 2020
month = 4
if month in (4, 6, 9, 11):
    day = 30
elif month in (1, 3, 5, 7, 8, 10, 12):
    day = 31
else:
    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
        day = 29
    else:
        day = 28
# 有几个占位符 就赋予几个值  值和占位符之间是一一对应的
content = '%s年的%s月有%s天'%(year,month,day)
print(content)
# 例2
# 学号  显式的时候按照6位来显式
sid = 1
# 姓名
name = '张三'
# 年龄
age = 17
# 成绩  显式的时候保留一位小数
score = 89.65
info = '学号为%06d的%s的年龄为%s,成绩为%.1f'%(sid,name,age,score)
print(info)

# 方式3： 字符串数据.format()
"""
先生成字符串文本数据，未知数据的地方使用 {}进行占位 调用字符串的format操作 给占位符进行赋值
有几个占位符 传递就有几个值
    如果对数据有特殊的格式 在{}操作
        {:0nd}  按照n位填充
        {:.nf}  保留n位小数
"""
info1 = '学号为{:06d}的{}的年龄为{},成绩为{:.1f}'.format(sid,name,age,score)
print(info1)

# 方式4： 是方式3的简化  使用f修饰字符串
"""
f修饰完字符串  可以直接在{}的位置填充对应的数据值
要修饰数据 {数据:0nd}   {数据:.nf}
"""
info2 = f'学号为{sid:06d}的{name}的年龄为{age},成绩为{score:.1f}'
print(info2)

15.字典

存储一天温度变化记录 ，可以使用的一个列表进行存储，
为了更方便表达数据的含义，可以使用字典来进行存储 {key:value, key:value},会给每一个数据设置标记， 通过标记名获取对应的数据值.

字典是使用键值对进行数据的存储，是通过键定位值的，要求键是不允许重复的, 键的内容一旦确定不允许发生变换

字典是无序的可变序列
无序：代表元素没有位置编号，也就是不同过下标获取数据 只能通过键获取数据值
可变：数据值可以修改 可以增加新的键值对 删除键值对

air_temp = {'7点': 17, '9点': 20, '11点': 26, '14点': 30, '16点': 25, '18点': 22}
print(air_temp)
# 获取数据的话通过标记名取值,获取11点的温度
print(air_temp['11点'])
# 如果键不存在就报错
print(air_temp['10点'])  # KeyError: '10点'
# 获取数据值推荐方式
print(air_temp.get('11点'), air_temp.get('10点'))   # 26 None
# 获取键值对的个数
print(len(air_temp))  # 6
# 添加新的键值对
air_temp.setdefault('19点', 20)  # 影响的是原数据
print(air_temp)
# 移除键值对
air_temp.pop('11点')
print(air_temp)
# 修改键值对
air_temp['19点'] = 18
print(air_temp)
# 清楚键值对
# air_temp.clear()

### 遍历
# 直接遍历字典 遍历的是字典中的键  [直接对字典进行成员操作 获取的是键]
for ele in air_temp:
    print(ele, air_temp.get(ele))
# 等价于
print(air_temp.keys())   # dict_keys(['7点', '9点', '14点', '16点', '18点', '19点'])  # 字典中所有的键
for k in air_temp.keys():
    print(k)
# 单独拿值
print(air_temp.values())  # dict_values([17, 20, 30, 25, 22, 18])
for j in air_temp.values():
    print(j)
# 获取字典中键值组合
print(air_temp.items())   # dict_items([('7点', 17), ('9点', 20), ('14点', 30), ('16点', 25), ('18点', 22), ('19点', 18)])
for item in air_temp.items():
    print(item)
for a,b in air_temp.items():
    print(a,b)

字典的案例

'''
词频统计
    	词/字符/数字出现的个数 或者对数据进行归类
'''

#### 出现的个数
'''
统计每个字符出现的个数   字符-个数 ====》 使用字典类型展示数据
思路：
1. 遍历字符串  获取每个字符
2. 把字符出现的个数存储字典中  字符与个数的信息   【字符为键  个数为值】
   把遍历到的字符作为键  个数作为值存放于字典中
'''
s = 'good good study day day up'
count_dict = {}   # 空字典 因为不知道最终有多少个键值对
for ch in s:   # 遍历获取每个字符
    if ch not in count_dict:   # 直接对字典使用成员运算 获取的是键
        # 代表第一次出现
        count_dict.setdefault(ch,1)
    else:
        count_dict[ch] = count_dict.get(ch) + 1  # 次数+1
print(count_dict)

#### 归类
nums = [19, 27, 38, 41, 25, 66, 24, 32, 51]
# 偶数为一类  奇数为一类
# 字典中会有两组键值对  值为什么是[]  因为偶数是什么  有多少个不知道   奇数是什么  有多少个 也不知道
# 但是肯定是多个的  所以放一个可变的容器
classify_dic = {'even':[],'odd':[]}
for ch1 in nums:
    if ch1 % 2 == 0:
        classify_dic['even'].append(ch1)
    else:
        classify_dic['odd'].append(ch1)
print(classify_dic)
# 每一类的数据的个数
classify_dict1 = {'even': 0, 'odd': 0}
# 遍历
for ch2 in nums:
    if ch2 % 2 == 0:
        classify_dict1['even'] += 1
    else:
        classify_dict1['odd'] += 1
print(classify_dict1)

"""
练习：
    1. data = "hello nice to meet you nice to meet you too good fine nice"
        统计每个单词出现的个数
    2. nums = [82, 71, 65, 43, 29, 72, 64, 58, 87, 39]
        将十位大于个位的归为一类   另外一种自成一类
"""
# 练习1
data = "hello nice to meet you nice to meet you too good fine nice"
# 获取单词
words = data.split(' ')
print(words)
count_dict1 = {}
for w in words:
    if w not in count_dict1:
        count_dict1.setdefault(w, 1)
    else:
        count_dict1[w] += 1
print(count_dict1)
# 练习2
nums = [82, 71, 65, 43, 29, 72, 64, 58, 87, 39]
classify_dict2 = {'gt': [], 'other': []}
for ele2 in nums:
    if ele2 // 10 % 10 > ele2 % 10:
        classify_dict2['gt'].append(ele2)
    else:
        classify_dict2['other'].append(ele2)
print(classify_dict2)

# 字典数据的过滤
dict0 = {'hello': 1, 'nice': 3, 'to': 2, 'meet': 2, 'you': 2, 'too': 1, 'good': 1, 'fine': 1}
print(dict0)
# 找到次数为1的单词信息  以键值对形式展示
new_dict = {}
for k, v in dict0.items():
    if v == 1:
        new_dict.setdefault(k, v)
print(new_dict)
# 字典推导式   注意：字典中存放的是键值对  key:value
print({k: v for k, v in dict0.items() if v == 1})

# 单词中包含e的词频信息
new_dict1 = {}
for k, v in dict0.items():
    if 'e' in k:
        new_dict1.setdefault(k, v)
print(new_dict1)
# 等价于
print({k: v for k, v in dict0.items() if 'e' in k})