语法笔记-

最新推荐文章于 2024-11-14 08:20:05 发布

从头开始的大学生

最新推荐文章于 2024-11-14 08:20:05 发布

阅读量1k

点赞数

文章标签：笔记 python

本文链接：https://blog.csdn.net/Hdjdjdj273848828/article/details/133344580

版权

课程安排

整体课程分为三个阶段，上课时间是15周

课程是Python数据分析

数据分析 = 数据分析思维【理论知识】+数据分析工具【实践工具】

数据分析思维常见的有对比法、拆分法、象限法等等

数据分析工具常见的有Excel/数据库[数仓]/BI工具/Python

三个阶段课程内容设定：

第一阶段：Python语法阶段 + 数据采集[爬虫] 4周

第二阶段: 商业数据分析数据分析思维【理论知识】+数据分析工具【实践工具】 6周

第三阶段: 机器学习【各种算法的理论知识 + Python相关的代码】 5周

Python的基本语法

1.计算机相关的名词知识

1.1计算机的组成

计算机之父 冯.诺依曼，根据冯.诺依曼结构体系，计算机是分为5部分的

输入设备

把信息传递到计算机中，比如键盘、鼠标
输出设备

信息从计算机中传递出来，比如音响、显示器、打印机等等
存储器

计算机被发明出来就是用于数据的存储与计算的

计算机上有两个存储数据的设备：内存、硬盘

硬盘：电脑上的磁盘分区，存储在硬盘中的数据都是持久化存储【只要不删除就一直存在】

内存：内存是用来存储计算机上应用app运行产生的数据, 当程序退出的时候，该程序存储于内存中的数据就会被释放

内存在之后的知识中会有提及【编写的Python程序产生的数据是存储于内存中】
运算器

调度存储器中的数据参与相应的运算【基本运算有加减乘除等等】
控制器

控制器和运算器结合在一起称为中央控制器[CPU]，相当于人的大脑，调度计算机各部分的运转

1.2命令行交互的指令

讲解的是人与应用程序交互的模式，这个模式常见的是有两种

图形化界面

接触起来是比较简单的，按照的操作描述很快上手进行操作

命令行指令

之后可能会接触一些文件操作相关的指令，来介绍一些常用的指令，这个指令在windows系统中称为DOS命令，在Mac或者Linux系统中称为Shell命令

这个指令是需要在终端上运行，这个工具在Mac上称为终端，在Windows称为命令提示符工具

启动工具的方式

windows下可以使用快捷方式 win键+r调出搜索器，输入cmd回车进行启动
Mac 在启动台上找到其他 – 终端

工具启动完成，默认打开的是当前用户的路径

Mac和windows的目录结构不一样

windows是分磁盘的，分为C盘、D盘，但是Mac下没有分盘，所有的路径延伸都是从根目录/来的, Mac的同学可以在终端上书写指令 open / 打开根目录

常用的一些指令：

主要是来接触目录的跳转的

1. 显式当前目录下的子文件
	windows:  dir
	mac: ls
	
   显式隐藏的文件的话
   	windows: dir /a
   	mac: ls -la
2. 路径的切换
	使用的指令是 cd  文件的路径
	文件路径分为两种的，分别是相对路径和绝对路径
		绝对路径：windows的话 从盘符开始到指定文件夹的路径
			比如C:\WorkContent\各班代课\JYPython2304\day02_计算机基础与Python相关软件安装配置
			Mac就是从/开始的，不知道路径是什么 找到文件夹 右键显式简介 -- 位置
		相对路径：参照物的，参照物就是当前的文件夹
			有两个符号需要大家记住，分别是 .和..
				. 当前文件夹
				.. 上一级文件夹
		相对路径需要根据需求 从当前文件夹使用.或者..定位相应位置 再去定位想要的路径
			定位到公用用户
				绝对路径： cd C:/Users/Public
				相对路径: cd ../Public
	
	windows下面可能涉及到盘符的切换， 路径盘符与当前位置不一样，需要先切换盘符,格式就是  盘符:  回车即可

1.3 计算机中数据存储

生活中的计算数据的时候是按照十进制规则来进行计算的

十进制的规则是逢十进一, 十进制的数字符号是由0/1/2/3/4/5/6/7/8/9组合成的

计算机中数据存储运算的时候，不是采用的十进制，而是二进制，这个二进制就是逢二进一，二进制的数字符号只有0和1

常见的进制形式：二进制/八进制/十进制/十六进制

二进制(0b – binary)：符号集只有0和1， 0b10代表的是数字2

八进制(0o — octal) ：符号集是有0/1/2/3/4/5/6/7， 0o10代表的是数字8

十进制: 符号集是0-9， 10 代表就是数字10

十六进制(0x – hexadecimal) : 逢十六进一,就意味着没有遇到16不会出现两位数， 0x10 代表的是数字16，符号集0/1/2/3/4/5/6/7/8/9/a/b/c/d/e/f 在十六进制中使用字母a-f表达10-15的数字【字母大小写都可以】

八进制和十六进制出现的原因是因为二进制表达数据可读性差，组合会过于长，因此就出现了八进制和十六进制，简化二进制的表达格式

进制转换

十进制转化为二进制的规则

整数部分的规则：
	将数据除以2取余数，再将商重复这个操作，直到商为0，将所有的余数逆向拼接，结果就是二进制数据
	比如： 24 == 0b11000
	24/2=12 --- 0
	12/2=6 ---- 0
	6/2 = 3 --- 0
	3/2=1 ----- 1
	1/2=0 ----- 1
小数部分的规则：
	将数据乘以2取整数部分，再讲积的小数部分乘以2取整数部分 重复此操作，直到小数部分为0，将整数部分正序拼接在一起
	比如：0.125 = 0b.001
	0.125 * 2 = 0.25 ---> 0
	0.25 * 2 = 0.5 -----> 0
	0.5 * 2 = 1.0 ------> 1
	
	如果数据是 24.125 ====》 0b11000.001

练习:

29=0b11101
58=0b111010
75.25=0b1001011.01

二进制转十进制

规则：按权展开求和
	以十进制为例，讲解这个按权展开
	比如 5436 = 5 * 1000 + 4 * 100 + 3 * 10 + 6 * 1
		1000/100/10/1都是基于本进制对应位置上的权值
		     = 5 * 10^3 + 4 * 10^2  + 3 * 10^1 + 6 * 10^0
		每位上的权值 = 进制^(位数-1)
	按照上面的规则，二进制上每位的权值 = 2^(位数-1)
	
	比如 0b1101 = 
		   1*2^0 + 0 * 2^1 + 1*2^2 + 1 * 2^3
           = 1 + 0 + 4 + 8
           = 13
    二进制比较特殊，特殊的就是符号集只有0和1,0乘以任何数为0 1乘以任何数位数据本身，可以假设所有位置上都是1，二进制数据每位的权值从右到左的结果为1 2 4 8 16 32 64 128 256 512 1024 ....
    讲解另外一个规则：
    	将数据减去离其最近且小于它的2幂数，将差值继续该操作 直到差值为0， 统计2的幂数有哪些，然后按照从右向左的位置 有该幂数的则该位置为1，否则对应位置为0
    	比如： 79 = 0b1001111
    	79 - 64 = 15
    	15 - 8  = 7
    	7 - 4 = 3
    	3 - 2 = 1
    	1 - 1 = 0

练习

0b10111=23
	1*2^0 + 1*2^1 + 1*2^2 + 0*2^3 +1*2^4 
	= 1 + 2 + 4 + 0 + 16
	= 23
	
	1+2+4+0+16 = 23
		
0b10010=18
	0 + 2 + 0 + 0 + 16 = 18
0b11100=28
	0+0+4+8+16 = 28
0b10110=22
	0+2+4+0+16 = 22

八进制和二进制之间的转换

二进制转八进制规则：
	八进制的最大数字是7，7转化为二进制需要3位，为0b111,最大的数字需要三位，其他的数字三位足以满足要求
	规则：将二进制数据从右向左3位3位一分，左边不足3位前面补0, 将分出的每一份按权展开求和，将和从左向右拼接在一起就是八进制
	比如 0b1100111011
	0b001  100  111  011
	   1    4    7    3 ====> 0o1473
八进制转二进制规则： 三位的幂值 4 2 1
	将每位数转化为三位二进制数，将结果拼接在一起即可
	比如0o2574
	 2 -- 0b010
	 5 -- 0b101
	 7 -- 0b111
	 4 -- 0b100
	 ===> 0b101101111100

十六进制和二进制之间的转换

二进制转十六进制规则：
	十六进制的最大数字是f(15)，15转化为二进制需要4位，为0b1111,最大的数字需要四位，其他的数字四位足以满足要求
	规则：将二进制数据从右向左4位4位一分，左边不足4位前面补0, 将分出的每一份按权展开求和，将和从左向右拼接在一起就是十六进制
	比如 0b1100111011
	0b0011  0011  1011
	   3     3      b  ====> 0x33b
十六进制进制转二进制规则： 四位二进制数幂值 8 4 2 1
	将每位数转化为四位二进制数，将结果拼接在一起即可
	比如0x9ae3
	 9 -- 0b1001
	 a -- 0b1010
	 e -- 0b1110
	 3 -- 0b0011
	 ===> 0b1001101011100011

练习

八进制转二进制
	0o756=0b111101110
	0o354=0b011101100
十六进制转二进制
	0xaf39=0b1010111100111001
	0xbcd7=0b1011110011010111

备注：八进制或者十六进制转化成十进制，规则也是按权展开求和；八进制和十六进制之间的转换需要以二进制为桥梁进行操作【先转二进制，再做转换】

八进制转十进制
	0o112 = 2*8^0 + 1*8^1 + 1*8^2
		  = 2 + 8 + 64 = 74
十进制转八进制
	数据除以8取余数，再用商除以8取余数直到商为0 将余数逆向拼接
	78 = 0o116
	78/8 = 9 --- 6
	9/8 = 1 ---- 1
	1/8 = 0 ---- 1
十六进制转十进制
	0xff = 15*16^0 + 15 * 16^1
	     = 15 + 240
	     = 255
十进制转十六进制
	数据除以16取余数，再用商除以16取余数直到商为0 将余数逆向拼接
	255 = 0xff
	255/16 = 15 -- 15
	15/16 = 0 ---- 15
八进制和十六进制之间的转换
	0xff === 0o377
		0xff = 0b011 111 111
				=0o377

1.4 编码和解码

计算机中数据的存储格式是二进制格式的，计算机被研发出来的作用就是来存储和计算的。

常见的一些数据存储与计算机中是如何存储的，这个规则称之为编码

常见的一些数据【数字、文字、图片、音视频等等】如何存储与计算机中的？？？

进制转换中数字可以通过规则转换成二进制进行存储，比如10可以转换成0b1010，但是文字[汉字、英文字母或者各国语言]这些如何进行存储？？？

因为数字可以直接存储，指定存储规则的逻辑将每个文字都映射一个数字，将数字转换为二进制数据进行存储，这种规则称为编码

常见的编码方式有

ASCII码【美国信息交换标准代码】只有128个文字符号

需要记住的就是字符0-9 小写英文字母a-z 大写英文字母A-Z

字符0对应的十进制数据是 48

字符a对应的十进制数据是 97

字符A对应的十进制数据是 65
GB2312/GBK

国家编码标准，简称国标,兼容ASCII码
Unicode

国际编码标准，收录的世界语言在内，兼容ASCII码

Unicode下又分为很多种，常见的是其中的UTF-8

Python采用的数据编码方式就是UTF-8

不同编码的存储区别：

ASCII属于单字节编码方式，里面规定的字符，在内存中存储的时候开辟的一个字节进行存储的
GBK/GB2312 存储汉字的时候规定汉字字符在内存占2个字节
utf-8存储汉字的时候规定汉字字符在内存中占3个字节

计算机中数据的存储格式是二进制，数据在存储的时候单位有哪些？

位(bit) 二进制数据中一个0或者一个1称为1位，0b10 这是2位
字节(Byte) 1个字节等于8位 1B=8b
千字节(KB) 1KB = 1024B
兆字节(MB) 1MB = 1024KB
吉字节(GB) 1GB = 1024MB
太字节(TB) 1TB=1024GB

存储的时候开辟的最小的单位就是字节

编码：把文字数据编译成计算机中存储的二进制数据的过程称为编码

解码：把计算中存储的二进制数据解析成文字数据的过程称为解码

1.5 编程语言

语言：沟通交流传递信息的方式，有效信息的传递包含三部分：传递者/接收者/共识信息[两方都能听懂表达的含义]

编程语言：人们想要和计算机打交道，并且让计算机帮我们做一些事情，主动传递者需要向计算机传递一些计算机能听懂的语言，这个语言就叫做编程语言

编程语言分为低级编程语言和高级编程语言

低级语言包含机器语言、汇编语言

机器语言直接通过0和1指令与计算机进行交互

汇编语言使用一些容易理解的单词来代替指令与计算机进行交互
高级编程语言

编译型编程语言：写的代码计算机没有办法直接识别的，需要将程序文件编译成计算机能识别的文件，再对文件中的内容逐行解释给计算机，让计算机完成相应的操作，比如Java

解释型编程语言：直接对程序文件逐行向计算机进行解释，完成指令操作，比如Python

1.6 Python解释器程序的安装

Python官网www.python.org推出自己的解释器软件，这个工具安装完成之后包含着解释器以及Python程序编写相应的一些工具库文件

Anaconda集成环境工具，除了有Python解释器及其自带的一些Python程序编写相应的一些工具库文件之外，额外安装好了180多个数据科学计算包【这个工具包对于官方提供的属于第三方，要使用的时候是需要自己来进行安装的】

版本号的解读：Python 3.11.5

一般格式为A.B.C

C — 程序中出现小问题，修复之后发行的版本

B — 程序中增加了新的功能发行的版本

A — 程序重构重新发行一版新的

注意：编程语言环境一般不建议使用最新的，避免有些工具库没有适配到新环境，这个工具库就不能使用了，建议使用稳定的环境 Python3.8/3.9/3.10

安装成功之后，软件解读

C:\Software\Anaconda3\python.exe 解释器，由它向计算机解释写的每行Python代码的含义
C:\Software\Anaconda3\Lib Python环境下工具库的目录【这些工具库都是原生的，可以直接使用的】
C:\Software\Anaconda3\Lib\site-packages 三方工具库的目录【这些工具是需要额外安装的】
C:\Software\Anaconda3\Scripts\pip.exe 管理工具库的软件【负责下载、安装、卸载等等工具库的软件】

全局变量Path的解读

问题：为什么安装anaconda的时候要把Python解释器路径放在全局变量PATH下？？？【方便在任意位置获取解释器解释Python程序】

写代码的时候代码文件可以在任意的目录下，但是python.exe这个解释器文件想要发挥作用只能在安装路径下能找到

在终端上书写python 的时候没有限制路径，查找顺序是

在全局路径path下进行查找有没有文件夹中包含这个执行文件的，有的话直接调度运行，如果没有就进行第2步
查看cmd当前路径下有没有该执行文件，有的话直接调度执行，如果没有提示既不是内部命令也不是外部命令

全局路径设置的流程：

windows的设置流程：

此电脑 - 右键 - 属性 - 高级系统设置 - 环境变量 - 用户变量[仅针对于当前用户]/系统变量[针对于所有用户] - PATH

检查有没有配置好这个全局路径，启动终端，书写Python回车检查是否能够进入到Python环境下 ,退出环境就是 exit()

C:\Users\liuyanan>python
Python 3.8.8 (default, Apr 13 2021, 15:08:03) [MSC v.1916 64 bit (AMD64)] :: Anaconda, Inc. on win32

Warning:
This Python interpreter is in a conda environment, but the environment has
not been activated.  Libraries may fail to load.  To activate this environment
please see https://conda.io/activation

Type "help", "copyright", "credits" or "license" for more information.
>>>exit()

1.7 开发工具的安装

利用可视化工具编写代码，软件使用的是pycharm[集成开发工具]

集成开发工具就是集编写代码、运行代码、调试代码于与一身的开发工具

关于pycharm的设置

设置主题 File | Settings | Appearance & Behavior | Appearance - Theme
设置编辑区的背景图 File | Settings | Appearance & Behavior | Appearance|background image
设置字号字体 File | Settings | Editor | Font
设置解释器 File | Settings | Project | Python Interpreter

设置文件表头 File | Settings | Editor | File and Code Templates | Python Script

  可用的预定义文件模板变量为：
  ${PROJECT_NAME} - 当前项目的名称。
  ${NAME} - 在文件创建过程中在“新建文件”对话框中指定的新文件的名称。
  ${USER} - 当前用户的登录名。
  ${DATE} - 当前的系统日期。
  ${TIME} - 当前系统时间。
  ${YEAR} - 今年。
  ${MONTH} - 当月。
  ${DAY} - 当月的当天。
  ${HOUR} - 目前的小时。
  ${MINUTE} - 当前分钟。
  ${PRODUCT_NAME} - 将在其中创建文件的IDE的名称。
  ${MONTH_NAME_SHORT} - 月份名称的前3个字母。 示例：1月，2月等
  ${MONTH_NAME_FULL} - 一个月的全名。 示例：1月，2月等

"""
项目名称: ${PROJECT_NAME}
用户名: ${USER}
创建日期: ${DATE}
flag标语：键盘敲烂 月薪过万!!!!
"""

2.Python的基本语法知识

2.1 代码初尝试

Python中输出功能为print(输出的数据)

数据如果是数字，直接写print(10)
数据如果是文本, 书写的时候需要加引号[单双引号都可以]输出，print('hello world')

2.2编码规范

2.2.1 语句和缩进

语句: 完成逻辑的表达式称为语句

在编程语言中习惯语句结束的时候使用分号标记[;] 在Python中不建议写分号，建议一条语句独占一行

如果写代码的时候，一行中有多条语句，语句之间必须使用分号隔开

空格缩进：在Python中是体现代码块包含的意思【有些代码需要满足一定的条件才能执行，是需要被包含在一个条件内】，不能随便乱增加空格缩进

2.2.2注释

程序员为了更好的解读代码，给代表添加的标注，这个标注是不被计算机当做程序识别的，或者是有些代码功能暂时不被启动，需要将代码进行注释

注释分为两种

单行注释，格式是#空格
多行注释，格式三对引号包含，可以是三对双引号，也可以是三对单引号【编码规范中推荐使用的是三对双引号】

2.3`print`的使用

"""
项目名称: 02_print与注释.py
用户名: liuyanan
创建日期: 2023-9-20
flag标语：键盘敲烂 月薪过万!!!!
"""

# print的使用  按住ctrl键 点击功能名称
# print()
# print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
"""
1.value, ..., 代表的是print可以一次性输出多个数据，书写的时候，数据之间使用逗号隔开 
2.sep=' '  代表的是print一次性输出多个数据展示结果时，数据之间的分隔符默认为空格
        也可以进行修改， 为了避免print将设定的分割符识别成输出的数据，设置分割符的时候格式为
            print(数据1, 数据2, 数据3, sep=分隔符)
3.end='\n' 代表的是print输出内容的结束符，这个结束符默认是换行
        一个知识点: 转义符\,可以将某些特定的符号转变其他的含义
            比如符号n  加上\就变成换行符  \n
            符号t  \t代表的是tab键 称为制表符 【四个空格】
            符号u  转义符会把u后面的内容当做unicode编码 想去获取其对应的文字
                4e00 ===> 一
        因为end默认是换行 所以每个print打印的结果都是独占一行的
            也可以对end进行修改 修改格式类似于sep 
            print(数据1, 数据2, 数据3, sep=分隔符, end=结束符)
4.file=sys.stdout  代表的内容输出的目的地 默认是控制台上输出
5.flush 冲洗刷新的意思
"""
print(10)
print('hello world')
print(10, 20, 30, 40)

# 打印的时候 分隔符没有使用sep指定  会被识别成多个数据中的一个进行打印输出
print(10, 20, 30, 40, '+')  # 10 20 30 40 +
# 想要展示内容使用+分割 必须使用sep指定
print(10, 20, 30, 40, sep='+')  # 10+20+30+40

# 转义符
print('and')  # and
print('a\nd')
"""
a
d
"""
print('heath')  # heath
print('hea\th')  # hea	h

print('\u4e00')  # 一

# 报错 报错的原因是 把sers当做了unicode编码  但是sers没有对应的文字
# print('\Users')

# 修改结束符
print(10, end='\t')
print(20)  # 10	20


# 演示把内容输出到文件中
"""
目的：要在一个文件中写内容
如果使用文件系统图形化界面的形式 向文件中写入内容
1. 按照路径找到文件
2. 打开文件
3. 进行书写
4. 保存关闭
"""
# 如何使用Python代码按照路径打开文件
# open这个操作
# 格式： open(文件路径, 操作模式, encoding=文件存储编码形式)
"""
文件路径：
    可以是绝对路径，也可以是相对路径
        绝对路径 从盘开始一直到具体的文件
            C:\WorkContent\各班代课\JYPython2304\day03_Python入门须知与运算符\笔记\语法笔记.md
        相对路径：参照物
            当前所在的路径使用.来表示
            ..表示的是上一级路径
            举例:
                现在路径是C:\WorkContent\各班代课\JYPython2304\day03_Python入门须知与运算符\代码\Day03
                
                有一个路径 为 ./demo.py  这个文件就在现在的路径下
                有一个路劲为 ../demo.py  这个文件在代码文件夹下
                有一个路径为 ../../demo.py 这个文件在 day03_Python入门须知与运算符 这个文件夹下
                有一个路径为 ../../笔记/demo.py
                    先回到 day03_Python入门须知与运算符这个文件夹 再进入到文件夹下的笔记文件夹中 有一个demo.py
操作模式
    w -- write 代表的是写
        如果路径对应的文件不存在 会先创建文件 再写入
        如果文件存在，会清空文件 再写入
    a -- append 代表的是写
        如果路径对应的文件不存在 会先创建文件 再写入
        如果文件存在，不会清空文件 在原本的基础上追加写
encoding 文件的编码形式
"""
# open的操作就相当于是将Python程序与文件建立联系
print('hello file', file=open('./hello.txt', 'w', encoding='utf-8'))

print('hello file', file=open('./hello1.txt', 'a', encoding='utf-8'))

2.4变量与数据类型

2.4.1变量

变量名词的定义来源于数学的，和数学中方程式的变量是一样的，只不过在计算机中定义格式不一样，变量也不仅仅数字，还可以是其他格式的数据

从数学角度回忆方程式

今有雉兔同笼，上有三十五头，下有九十四足，问雉兔各几何？

解：设鸡有x只， 兔子有y只
x + y = 35   #  x = 35 - y   # x = 35 - 12
2x + 4y = 94  # 2(35 - y) + 4y = 94 # y = 12

使用某个标记名标记数据，这个标记名称为变量名

变量，从名字来进行判定，它标记的数据是可变化的，比如上面方程式中只要题目的需求发生一些变化，x和y持有的数据就会发生变化

在Python中定义变量的格式 变量名 = 数据值，这里的变量名起名的时候是要遵守一定的规则的，这个规则来源于标识符

变量定义的其他格式：

同时定义多个变量名赋予相同的值

[变量名1=变量名2=变量名3 = 数据值]

比如格式为 a = b = c = 10
同时定义多个变量，但是值不相同

[变量1, 变量名2, 变量名3 = 值1, 值2, 值3]

比如 a, b = 10, 20

注意: 变量在使用之前一定要定义并被初始化 【赋予初始值】

2.4.2标识符

计算机中自定义的名字称为标识符，比如自定义项目名称/python文件名称/变量名/函数名/类名等等

规则：

包含数字、字母、下划线其中的符号

字母：注意Python的编码是UTF-8，这个是国际编码标准，收录的世界语言在内的，这里的字母包含各国语言文字，换句话说各国语言文字统称为字母【英文、汉字、韩文、日文…】

虽然是各国语言都能进行定义，但是按照编写代码的规范建议还是使用英文字母
不能以数字开头
不能使用关键字与保留字

关键字：在Python中已经具有特殊含义的单词

保留字：在Python已经被使用定义的名字【根据你的定义覆盖其原本的含义所以不建议使用初次定义提示出来的不要使用了】

不同内容的命名规范：

项目名称在满足标识符规则的基础上，定义的时候建议采用大驼峰命名格式【每个单词首字母大写，比如PythonProject】
python文件名称/变量名/函数名在满足标识符规则的基础上，定义的时候英文字母都是小写的，单词和单词之间使用下划线隔开【比如 max_value】
尽量做到见名知意

2.4.3数据类型

计算机中能处理的数据不仅仅只有数字，还可以处理文本/图形/音频/视频/网页等等各种各样的数据，再做处理的时候按照数据的特征进行了归类

在Python中基本的数据类型有：

整型(int)

整数类型，该类型的数据值全部都是整数。Python可以处理任意大小的整数[包括负整数]，写法和数学的格式是一样的，比如10，-20， 100等等
浮点型(float)

小数类型，之所以叫浮点类型，是因为数字可以使用科学计数法表示，小数点是可以移动的，比如1.23*10^9 ==== 1.23e9 ==== 12.3e8
布尔类型(bool)

布尔值与布尔代数的表达形式是一样的，布尔值只有两个 True和False，这个值一般是来表达式逻辑表达式运行结果的

字符串类型(str)

表达的是文本数据，是有单引号或者双引号包含起来的任意文本

比如'hello world' , 我的年龄是18

注意'0' 和 0 不是同一个内容，前者是一个字符串，是一个文本；后者是一个数字，可以算术运算

提这个原因是在ASCII码中看到字符0对应的十进制数据是48，这个字符0是'0', 不是数字0

在内存中存储的时候

'0' ===> 48 ===> 11 0000
0 ====> 0000000000

字符串是一个有序的不可变的容器型数据
    字符串是有0个或者多个字符组合而成的，容器里面的数据元素就是字符
    字符：长度为1的字符串就叫做字符
        'a'   'b'  ' '  '\n'  '0'
    当字符串是一对空引号称之为空字符串 【容器中什么符号都没有】  
    ''
    
空字符串不等价于空值None
    把容器理解成箱子   
        'abc'  箱子中有数据 a  数据b 数据c
        '' 一个空箱子
        None 就是连箱子都没有

空类型(NoneType)

有一个值就是None，这个表示的是空值【可以理解成空什么都没有】

不能理解成0 【0还是有意义的数字】

获取数据的类型方式 type(数据)

Python属于动态类型的语言，变量的类型是由值来决定的，变量可以赋予任意类型的值

还有一种语言是静态类型的，特点是定义变量的时候必须指明变量的类型，而且给变量赋值的时候只能赋予指明类型的值，比如Java

int age = 10;
age = 18;

2.4.4类型转换

在有些场景下需要把数据设置为相同类型的才能进行计算，这个就需要类型转换

把数据转化为整型，格式int(数据)

场景：
1. 对浮点数取整
  1. 把字符串转化为整型【要求：字符串中的字符内容必须满足整数格式】
把数据转化为浮点型，格式float(数据)

场景就是字符串格式的小数转换成浮点类型【要求: 字符串中的字符内容必须满足数字格式】
把数据转化为布尔类型，格式bool(数据)

可以把任意类型的数据转化为布尔类型，转换规则是
1. 数字格式的数据，非0即为True
2. 容器型数据，非空容器即为True
3. None空值为False
这个规则要记住！！！！因为后面的知识点中有逻辑判断，会使用到这个规则【把数据应用到逻辑中结果为真还是假应用的就是这个规则】

2.5运算符

分为一元运算符、二元运算符、三元运算符【Python中没有其他语言条件语句?表达式1:表达式2】

一元运算符是由一个数据参与运算，比如正负号 +78 -10 ~19[按位取反]

2.5.1算术运算符

加法 +
减法 -
乘法 *
除法	
	/  结果是浮点类型的  除不尽 商会有小数
	// 结果是整型的  对商进行向下取整 
		<=商且最接近于商的整数 称为向下取整
取余数 
	%  A除以B除不尽 会余下数据 这个余下的数据就是余数
	11除以3得3余2  这个2就是余数
	11 % 3 = 2
求幂数 
	**  比如x**y,求x的y次方 
	y如果是正整数N  对x求幂数次方
	y是1/N 小数格式  对x进行开方
	
	x = 2
	y = 3
	x ** y = 2的3次方 = 8
	
	x = 27
	y = 1/3
	x ** y = 27的三分之一次方 
	开方的时候结果是浮点型的  8**(1/2)

算术运算符的优先级别：

** > 符号 > *、/、//、% > 加减

提高表达式的优先级使用小括号()包含

2.5.2赋值运算符

简单赋值运算符

变量名 = 数据值
	将等号右边的表达式计算结果 赋值给左边的变量名
	
	比如 a = 17
	a = 19 % 4
	b = 18
	a = b // 4

复合赋值运算符

结合其他运算符在内的赋值格式，比如
变量名 += 表达式
-=
*=
/=
//=
%=
**=

先计算表达式的结果  在对变量名根据结果进行相应的算术运算，最后把计算结果赋值给变量名

比如 a = 17
a -= 18 % 4

1. 18 % 4 = 2
2. a - 2 = 17 - 2 = 15
3. a = 15

赋值表达式(海象运算符)

把某个赋值表达式的结果再赋值给另外一个变量，这种格式称为赋值表达式

比如在其他语言中支持 y = (x = 17 % 3)

解读：先计算x的结果，再把x的值赋值给y

但是这个写法在Python中不支持，Python变更成 y = (x := 17 % 3)

这里其实也是同时定义了两个变量，只不过不同于a, b=11, 22的是这个赋值表达式在定义变量的时候，某个变量的值参与另外一个变量定义的运算

2.5.3 比较运算符

又称为关系运算符，对比两个表达式结果的关系的，运算符有：

>  判断前者是否大于后者
>= 判断前者是否大于或者等于后者
<  判断前者是否小于后者
<= 判断前者是否小于或者等于后者
== 判断两者是否相等
!= 判断两者是否不相等

算术运算符的优先级别高于比较运算符

介绍字符串数据的比较，本质比较的是字符对应的十进制数据，比较规则是相同位置的字符进行比较，直到比较出结果

比如
s1 = 'hello'
s2 = 'head'
res = s1 > s2  这个结果是真还是假？？？

第一次比较是 h 对 h
第二次比较是 e 对 e
第三次比较是 l 对 a   成立
因此结果为真

2.5.4 逻辑运算符

逻辑运算符的优先级别是低于比较运算符的

逻辑运算符是来关联表达式的逻辑关系的，逻辑关系是有三种的

逻辑与(and)

连接的逻辑关系是一个并且的关系，这两个表达式同时成立，结果才是成立的
```
True and True = True
True and False = False
False and False = False
False and True = False
```
总结and的运行机制：

and是具备有短路原则，左边表达式不成立，右边表达式不被执行

执行机制是左边表达式成立，结果取决于右边表达式；左边表达式不成立，结果就是左边表达式的值
逻辑或(or)

连接的逻辑关系是或者的关系，两个表达式中有一个成立，结果就是成立的
```
True or True = True
True or False = True
False or True = True
False or False = False
```
or也是具备短路原则的，左边表达式成立，右边不执行

执行机制：左边表达式成立，结果就是左边表达式的；左边表达式不成立，解决取决于右边表达式的值
逻辑非(not)

对逻辑关系取反，逻辑关系结果为真，not之后设定为假；逻辑结果为假，not之后设定为真
```
not True = False
not False = True
```

优先级别的问题:

not > and > or

2.5.5成员运算符

成员运算符是用来判定数据是否是某个容器型数据中的元素

数据 in 容器型数据
	把数据作为一个整体 判断是否在容器中
数据 not in 容器型数据
	把数据作为一个整体 判断是否不在容器中

目前接触到的是字符串，之后还会接触到列表、元组、字典、集合、range等等

2.5.6 身份运算符

判定两个数据的地址在内存是否是一致的

数据1 is 数据2
	判断两个数据在内存中的地址是否是一致的
数据1 is not 数据2
	判断两个数据在内存中的地址是否是不一致的

启动程序，维护程序运行的数据存储于内存中，当程序结束，数据在内存中被释放了

内存也是分为不同的区域的，不同的区域存储的数据是不一样的，数据的生命周期也是不一样的，区域有：

栈区
堆区
常量池

常量池中存储的是数值类型以及字符串类型的数据

特点：获取数据时检查数据是否在常量池中存在，如果存在的话直接根据地址获取数据，如果不存在，先分配空间添加数据，再把数据的地址赋值给变量

生命周期：当程序结束的时候才会释放
静态池

存储全局变量【直接在py文件中定义的变量称为全局变量】

生命周期：当程序结束的时候才会释放
方法区

2.5.7 位运算符

这个运算符的运算机制是对二进制数据进行计算的，因为直接是针对于二进制数据计算，计算效率是非常高的

&  按位与
	  相同位置的数据，只要有一个是0，该位置的结果为0
|  按位或
	  相同位置的数据，只有有一个是1，该位置的结果为1
^  按位异或
	  相同位置的数据一样，该位置位0，否则为1  【相同为0 不同为1】
	  一个数与相同的数异或两次结果是其本身  【交换两个变量的值】
	  
	  交换两个变量的值  a = 10  b = 20 ====> a = 20 b = 10
	  [使用至少3种方法交换两个变量的值]  ***** 
	  -- 方式1：大众的方式 借助第三方变量
          c = a
          a = b
          b = c
      -- 方式2：采用异或 【不用第三方变量】
      	  a = a ^ b  # 10 ^ 20
      	  b = a ^ b  # 10^20 ^ 20  ====> 10
      	  a = a ^ b  # 10^20^10   ====> 20
      -- 方式3：采用距离问题  【不采用第三方变量】
      	  a = a + b  # 10 + 20
      	  b = a - b  # 10 + 20 - 20 ====> 10
      	  a = a - b  # 10 + 20 - 10 ====> 20
      -- 方式4：Python独有的方法
      	 a, b = b, a  ====> a, b = 20, 10
	  
~  按位取反
	   该位置上的数据0变1, 1变0
>> 按位右移
	   将二进制数据向右移动N位，左边空出
	   如果是正数 左边补0
	   如果是负数 左边补1
	   规律：
	   	  数值//(2**N)
<< 按位左移
		将二进制数据向左移动N位，右边空出补0
		规律：
			数值*2**N

运算符都是针对于位【二进制数据中一个0或者一个1称为一位】的

在计算机发展过程中，根据数据计算的发展的一个历程，二进制形态出现过三种：原码/反码/补码。现在的计算机中存储处理二进制数据的形态是补码

对于正数来说，三码合一，格式是一样的，原码样子就是将十进制数据按照规则转化为二进制的格式

负数的原码：在正数的基础上将最高位置为1，则表示这个数据为负数。【二进制的最高位为符号位：0表示正数 1表示负数】，之前接触过进制转换，数据大小不一样，获取的二进制数据中位的个数不一样，怎么确定哪个是最高位？？？【计算机中数据存储时开辟的最小单元是字节，1个字节是8位，位数一确定最高位就确定了】，比如常规的数据开启的字节数是4个字节 0000 0000 0000 0000 0000 0000 0000 0001

0000 0000 0000 0000 0000 0000 0000 1010 [10]

1000 0000 0000 0000 0000 0000 0000 1010 [-10]

负数的反码：在负数原码的基础上，除了符号位，0变1，1变0

-10的反码1111 1111 1111 1111 1111 1111 1111 0101

负数的补码：在负数反码的基础上加1

-10的补码 1111 1111 1111 1111 1111 1111 1111 0110

补充：布尔类型参数算术或者位运算时 True被当做1，False被当做0

2.6流程控制语句

2.6.1顺序结构语句

代码是从上向下逐行运行的

2.6.2 分支结构语句

分为三种格式的，这三种格式分别是

单分支

语法：
```
if 条件表达式:
	满足条件执行的代码块
```
语境：如果达到了某个条件，就去做某件事

:缩进 代表Python中代码块的包含体，满足要求执行的代码要统一缩进 体现出来包含的关系

双分支

语法：

if 条件表达式:
	满足条件执行的代码块
else:
	不满足条件执行的代码块

语境: 如果满足某个条件做事情A，否则做事情B

多分支

语法:

if 条件表达式1:
	满足条件1执行的代码块
elif 条件表达式2:
	不满足条件1 但是满足条件2执行的代码块
elif 条件表达式3:
	满足条件3 但是不满足条件1和2执行的代码块
...
else:
	以上条件都不满足执行的代码块

语境: 如果满足条件1，就做事情A，否则如果满足条件2，就做事情B…

语句嵌套

在满足某种要求的基础上，还需要再进行逻辑判断才可以确定结果

Python中的三元运算符

格式：表达式1 if 条件表达式 else 表达式2

解读：判断if后面的表达式是否成立，如果成立的话执行表达式1，否则执行表达式2

隐式布尔转换

隐隐式布尔转换：把非布尔类型的数据当做布尔类型判定逻辑【数据本身没有变化】，这种行为称为隐式布尔类型转换

"""
文件名称: 03_隐式布尔转换.py
用户名: liuyanan
创建日期: 2023-9-22
flag标语：键盘敲烂 月薪过万!!!!
"""
# ch = input('请输入一个字符：')
# # ch 是什么类型的数据？？？ 字符串【容器型的  转换规则：非空容器即为True】
# if ch:  # 隐式布尔转换
#     print(ch)
# else:
#     print('没有输入内容')

# 判断一个数是否为偶数
# num = int(input('请输入一个整数：'))
# if num % 2:  # %2的结果为0或者1， 数值转换为布尔类型 非0即为True
#     print('奇数')
# else:
#     print('偶数')


# 把非布尔类型的数据参与逻辑运算符的运算
print(not 1)  # False

"""
and 执行过程
    True and True = True
    True and False = False
    False and False = False
    False and True = False
    执行机制是左边表达式成立，结果取决于右边表达式；左边表达式不成立，结果就是左边表达式的值
"""
# max_value = num1 if num1 > num2 and num1 > num3 else (num2 if num2 > num3 else num3)
# num1 > num2 and num3  能否写成这样？？？？？  不能！！！！！！
# 这样写 and 右边的表达式不是布尔值 而是一个非布尔类型的数据
num1 = 17
num2 = 15
num3 = 27

res = num1 > num2 and num1 > num3
print(res)  # False
"""
and 左边的表达式的结果为真
所以最终的结果 等于 右边表达式的值
"""
res1 = num1 > num2 and num3
"""
and 左边的表达式的结果为真
所以最终的结果 等于 右边表达式的值
"""
print(res1)  # 27

# 写成这种 会执行else后面小螺号的内容
max_value = num1 if num1 > num2 and num1 > num3 else (num2 if num2 > num3 else num3)
# 但是 条件写成这种 不会执行
# max_value = num1 if num1 > num2 and num3 else (num2 if num2 > num3 else num3)


"""
执行机制：左边表达式成立，结果就是左边表达式的值；左边表达式不成立，解决取决于右边表达式的值
"""
# 非布尔类型的数据参与逻辑运算的时候 和 布尔类型的数据参与逻辑运算不一样的
# 因为布尔类型的值只有两个 True或者False  参与逻辑运算结果 也就只有两个 要么为True 要么为False
# 但是非布尔类型的数据 ，因为有一个隐式转换规则  结果又取的是表达式的  这个结果不一定是True或者False
res = 1 or 0
print(res)

2.6.3 循环结构语句

循环：周而复始重复的做某件事

编程语言中对一直重复做某件事没有终止的情况下称为死循环，但是编程语言中是禁止死循环

在编程语言中见到的循环通常是两种情况

明确循环次数【重复做几次之后就不做了】
明确循环结束的条件

Python为这两个场景的循环提供了对应的循环机制，分别是

for-in循环，应用与明确循环次数的

本质是在遍历容器型的数据，【遍历：将容器中的数据从左向右逐个取出】，容器中有几个数据，for-in包含的操作就被被执行几次

语法：
```
for 变量名 in 容器型数据:
	重复操作的代码块
```
解读：重点在与in[进入]，进入容器中获取数据
1. 有数据，获取出来赋值给变量名然后进行重复的操作，再次执行in
  1. 没有数据循环结束了
while循环，应用于明确循环结束条件的

语法：
```
while 条件判断:
	重复操作的代码块
```
解读：判断条件是否成立
1. 条件成立，执行重复的操作，再次判断条件是否成立
2. 条件不成立，循环结束

range功能

用来产生等差数列的，这个结果也是容器型的一个数据，是range类型的

什么叫等差数列？数据是递增或者递减【递增或者递减的数据的差值-步长，在整个数据序列中是一致的】

注意：range只能产生整数的等差数列

格式1： range(stop结束值)
		序列中的数值是从0开始步长为1的递增到stop[不包含]的数列
		比如 range(10) ===> 0 1 2 3 4 5 6 7 8 9 
格式2: range(start起始值, stop结束值)
		序列中的数值是从start[包含]开始步长为1的递增到stop[不包含]的数列
		比如: range(1, 11) ===> 1 2 3 4 5 6 7 8 9 10
格式3：range(start起始值, stop结束值, step步长)
		step为正数 表示递增的数列  start < stop
		step为负数 表示递减的数列  start > stop
		从start[包含]开始 以步长 step 递增或者递减到 stop[不包含]的数列
		比如: range(1, 11, 2) ===> 1 3 5 7 9 
		range(1, 100, 10) ====> 1 11 21 31 41 51 61 71 81 91  [可以理解为100以内 个位数为1的数据]
		range(10, 0, -2) ====> 10 8 6 4 2

beak、continue、pass

pass 是代码块占位符，代码块中不能空白的【那块的逻辑暂时未写可以使用pass占位】

break和continue都是应用于循环语句中的

break 的作用是退出结束其所在的循环语句
continue的作用是结束当前执行，回归到条件判断或者in 遍历操作的位置，检测条件是否成立或者容器是否还有数据，条件成立或者是容器中有数据，继续执行下一次，否则结束循环

循环语句嵌套

场景：重复的操作被重复的执行

注意：尽量避免过多的循环嵌套，建议最多就3层

2.7函数

2.7.1函数定义

对一段功能独立并且重复使用的代码进行封装，当我们需要使用的时候，在进行调用，目的是为了减少代码的重复性，提高代码的复用率

语法格式

def 函数名(形式参数名, 形式参数名1,...,形式参数名n):
    函数功能体
    return 返回值

解读：

def 关键字，用来定义函数的
函数名，根据功能自定义的名字，需要遵守标识符规则
() 存放函数的形式参数的，如果没有形式参数，()内为空

形式参数: 函数运算的时候有些数据的未知[动态]的, 将这些未知的数据使用变量名来进行表示，这个变量名就是形式参数，简称形参。未知的数据有几个，就定义几个形式参数
return,也是一个关键字，结束函数，并把结果返回到函数调用的位置

如果功能需求中不需要返回值，可以写成return None或者省略

注意：return和print不一样
1. print把数据输出到程序外的控制台
2. return把数据传递到函数调用的位置，数据还是在程序中运转的

定义函数的规则：

明确是否有未知项参与功能的运算【用来定义形式参数有什么】
明确是否需要将结果返回到调用的位置【决定return的情况】

函数的调用

# 有返回值的函数调用
变量名 = 函数名(实际参数, 实际参数1, 实际参数2,..,实际参数n)
# 没有返回值的函数调用
函数名(实际参数, 实际参数1, 实际参数2,..,实际参数n)

"""
实际参数：实际参与函数功能运算的数据 称为实际参数，简称实参
实际参数的个数要和形式参数的个数一致，并且位置是一一对应的

定义函数的时候 函数内部的功能并未被执行，当调用的时候才会执行内部的功能
"""