[Python知识库]【Python基础知识整理】

????????【Python基础知识整理之常识】

一、基础名词解释

目录

【Python基础知识整理之常识】一、基础名词解释

Python的基本信息

1、Python的起源

2、Python的基本工作机制

3、Python的特点

数据类型

变量

函数

参数

常见的内置函数

函数的返回值

运算符

算术运算符

逻辑运算符

赋值运算符

?

关系运算符

位运算符（——针对二进制的运算）

比较运算符

运算符的优先级

控制结构

顺序结构

循环结构

选择结构

列表

字典

递归

递归的组成部分

递归调用过程

递归的优缺点

文件处理

机器语言：0、1组合的电脑能够直接处理的指令。（计算机不能直接理解任何除机器语言以外的语言）

编程语言：用来定义计算机程序的形式语言，人和计算机交流的语言

解释型语言：逐行编译，逐行执行

编译型语言：?统一编译，一次执行

Ps:编译型语言执行速度快；但是不具备跨平台执行能力

高层语言

源代码

伪代码

解释器：用来处理代码编译的软件，编译器以解释方式运行

编译器：将其他语言翻译成机器语言的工具。编译器翻译的方式有两种——编译和解释，两种方式的区别在于翻译时间点的不同

解释：

编译：将Python、Java等编程语言的代码翻译成机器语言的过程

流程图

字符编码表

镜像源：提供软件下载的地方。Python 的默认镜像源是国外的，在国内的网络环境下访问不太稳，于是下载速度也就比较慢。????????

集成开发环境

程序：指令的集合，写程序就是用指令控制计算机做我们想让他做的事情。程序是用来处理数据的

可执行程序

源程序

交互式编程：直接在终端上运行解释器，而不使用文件名的方式来执行程序。也可以称之为REPL——读取(read)输入的内容、执行(eval)用户输入的指令、打印(print)执行结果、最后进行循环(loop)。Python支持交互式编程

源文件

标识符：程序员定义的变量名、函数名

保留字

关键字：Python在自身开发过程中已经使用的标识符

??

科学计数法??

格式化

转义字符：

转义字符“\”+想要实现功能的首字母

“\r”回车（覆盖上一项）； “\t”水平制表符（4位的空格）； “\n”换行；“\\”一个反斜杠字符；“\'”单引号；?? "\''"双引号；“\b”退格（返回上一步骤）

?查明“\\”的作用

注释：用来向用户提示或解释某些代码的作用和功能，它可以出现在代码中的任何位置。Python?解释器在执行代码时会忽略注释，不做任何处理；在调试（Debug）程序的过程中，注释还可以用来临时移除无用的代码。注释的最大作用是提高程序的可读性。

????????Python 支持两种类型的注释，分别是单行注释和多行注释。Python 使用井号#作为单行注释的符号，语法格式为：# 注释内容 ；从#开始，直到这行结束为止的所有内容都是注释。Python 解释器遇到#时，会忽略它后面的整行内容。多行注释指的是一次性注释程序中多行的内容（包含一行）。多行注释通常用来为 Python 文件、模块、类或者函数等添加版权或者功能描述信。?Python 多行注释不支持嵌套。Python 使用三个连续的单引号'''或者三个连续的双引号"""注释多行内容

????????注释除了给代码添加说明以外还有另外一个实用的功能，就是用来调试程序。如果猜测某段代码可能有问题，可以先把这段代码注释起来，让 Python 解释器忽略这段代码，然后再运行。如果程序可以正常执行，则可以说明错误就是由这段代码引起的；反之，如果依然出现相同的错误，则可以说明错误不是由这段代码引起的。在调试程序的过程中使用注释可以缩小错误所在的范围，提高调试程序的效率。

? ? ? ? Ps :?①?说明多行代码的功能时一般将注释放在代码的上一行；说明单行代码的功能时一般将注释放在代码的右侧 ②不管是多行注释还是单行注释，当注释符作为字符串的一部分出现时，就不能再将它们视为注释标记，而应该看做正常代码的一部分。③注释的快捷操作，选择需要注释的代码范围，按住Ctrl+/ 进行注释，并在所选代码行的开头自动添加“#”。取消注释也是相同的操作。

引号的作用总结：三引号是保留格式的输出？单引号和双引号的逻辑关系：引用别人的话？交叉使用

程序阻塞

二、Python的基本信息

1、Python的起源

Python的创始人是吉多·范罗苏姆

Python的创作过程

?吉多对于Python的定位

2、Python的基本工作机制

一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。

运行程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。而Python语言写的程序不需要编译成二进制代码。你可以直接从源代码运行程序。

在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。

3、Python的特点

优点：

①、简单易学

阅读一个良好的Python程序就感觉像是在读英语，使你能够专注于解决问题而非搞明白语言本身。

相对于其他语言，Python的代码量较少。

Python有极其简单的说明文档 。

用Python语言编写程序的时无需考虑诸如如何管理你的程序使用的内存一类的底层细节。

②、免费、开源，拥有良好的社区生态

Python是FLOSS（自由/开放源码软件）之一。使用者可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。FLOSS是基于团体分享知识的概念。

③、解释性

可以以注释的形式说明程序的作用

④、可移植性

由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。这些平台包括Linux、Windows、Mac以及Google基于linux开发的android平台等。Python 作为一门解释型的语言，它天生具有跨平台的特征，只要为平台提供了相应的 Python 解释器，Python 就可以在该平台上运行

⑤、面向对象

Python既支持面向过程的编程也支持面向对象的编程。在“面向过程”的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在“面向对象”的语言中，程序是由数据和功能组合而成的对象构建起来的。函数、模块、字符串都是对象，在Python中一切皆对象

⑥、可扩展性

Python 的可扩展性体现为它的模块，Python 具有脚本语言中最丰富和强大的类库，这些类库覆盖了文件 I/O、GUI、网络编程、数据库访问、文本操作等绝大部分应用场景。Python 可扩展性一个最好的体现是，当我们需要一段关键代码运行的更快时，可以将其用 C 或 C++ 语言编写，然后在 Python 程序中使用它们即可。

⑦、可嵌入性

可以把Python嵌入C/C++程序，从而向程序用户提供脚本功能。

⑧、丰富的库

Python标准库确实很庞大。它可以帮助处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。这被称作Python的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如wxPython、Twisted和Python图像库等等。

⑨、规范的代码

Python采用强制缩进的方式使得代码具有较好可读性。而Python语言写的程序不需要编译成二进制代码。?

缺点：

①运行速度慢（解释型语言的速度慢于编译型语言，但是Python的可扩展性会在一定程度上改善这种情况）

②中文资料匮乏，国内市场狭小

4、Python的应用领域

web服务器应用开发、云基础设施开发、网络数据采集（爬虫）、数据分析、量化交易、机器学习、深度学习、自动化测试、自动化运筹等等

5、如何理解Python是“胶水语言”？

胶水语言（glue language）是用来连接软件组件的程序设计语言（通常是脚本语言）

胶水语言：使用输入输出命令，接口，动态链接库，静态链接库，服务，对象等。

在终端上：

可以随意地组合Python和其它程序，作为一个中间处理模块。而且，一些简单的脚本只需要cat一下马上就能明白是什么意思。一个表达式一行代码，代码块有一致的标准的缩进，标准的命名方式，简练的语言，支持注释……别的程序要访问或调用，一个命令把指定数据输入到这里就好，然后要怎么拼接怎么拼接；周期性地处理也没问题，输出到文件，等待别的程序调用。?

系统脚本上：

Python比SHELL多了很多数学及字符串处理能力，还多了很多很好用的迭代方法，还多了很多的原生的数据结构；?比PERL多了很要命的代码可读性。比起ruby和nodejs，他基本所有机器都预装，而且已经经历了时间的考验；比起C/C++，他多了一个终端、甚至像ipython这样的加强版神器终端，可以边调试代码边把没问题的代码写进文件。而且，源码即可执行。

数据类型

一、分类：

1、整数类型（int / integer）可以表示正数负数和零

? ? ? ?①?整数的不同进制表示方式

? ? ? ? ? ? ? ? 十进制—>默认的进制? ? 逢10进1? ? ? ? 基本数为0.1.2.3.4.5.6.7.8.9

????????????????二进制—>以0b开头? ? ? ?逢2进1? ? ? ? ? 基本数为0.1

? ? ? ? ? ? ? ? 八进制—>以0o开头???????逢8进1? ? ? ? ? 基本数为0.1.2.3.4.5.6.7

? ? ? ? ? ? ? ? 十六进制—>以0x开头? ?逢16进1????????基本数为0.1.2.3.4.5.6.7.8.9.A.B.C.D.E.F

????????Ps:0b1110110(2)—>0o166(8)—>118(10)—>0x76? ??

? ? ? ?????????使用辗转相除法和更相减损法计算不同进制下对应的数字? ? ? ? ? ? ? ? ?

? ? ? ? ②转化代码：

????????????????将其他进制的字符转换为二进制，使用函数bin()；

????????????????将其他进制的字符转换为八进制，使用函数oct()

????????????????将其他进制的字符转换为十六进制，使用函数hex()

????????????????将其他进制的字符转换为十进制，使用函数?int()? ? ?

print(bin(10))  # 0b1010
# 1 * 2 ** 3 + 0 * 2 ** 2 + 1 * 2 ** 1 + 0 * 2 ** 0 = 10
print(1 * 2 ** 3 + 0 * 2 ** 2 + 1 * 2 ** 1 + 0 * 2 ** 0)  # 10
print(bin(149))  # 0b10010101
# 转化技巧：可以被2整除，对应位数的数值就是0.
# 不可以被2整除，对应位数的数值为余数，剩余部分做整除运算
# 也可以使用计算器的程序员模式

? ? ? ? ? ? ? ??

? ? ? ? ?③转换技巧：????????

????????利用进制之间的关系巧妙地转化结果-----八进制、十六进制与二进制之间的倍数关系—>用等可能来代替等可能数字——八进制中的每一位需要二进制中的三位来表示，十六进制中的每一位数需要二进制中的四位来表示，不足相应位数补0

????????④Python 整数的取值范围是无限的，不管多大或者多小的数字，Python 都能轻松处理。当所用数值超过计算机自身的计算能力时，Python 会自动转用高精度计算（大数计算）。

? ? ? ? ⑤为了提高数字的的可读性，Python 3.x 允许使用下划线_作为数字（包括整数和小数）的分隔符。通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。下划线不会影响数字本身的值。
????????【实例】click = 1_301_547????????distance = 384_000_000

2、浮点数类型(float) 由整数部分和小数部分组成

Ps：①浮点数储存不精确，使用浮点数进行计算时可能会出现小数位数不确定的情况②使用除法结果会变成浮点数（有小数点）

print(1.1+2.2) #3.3000000000000003
print(1.1+2.1) #3.2

from decimal import Decimal  #解决浮点数储存不精确的问题
print(Decimal('1.1')+Decimal('2.2')) #3.3

print(8/2)   #4.0

3、字符串类型

①字符串又被称为不可变的字符序列

②字符串可以使用单引号、双引号、三引号来定义；单引号和双引号定义的字符串必须在一行；三引号定义的字符串可以分布在连续的多行；在字符串中“+”起连接作用

str1='龙潜于渊，龙跃于天 '
str2="龙潜于渊，龙跃于天"
str3="""龙潜于渊，龙跃于天"""
str4='''龙潜于渊，龙跃于天'''
print(str1+str2) #龙潜于渊，龙跃于天 龙潜于渊，龙跃于天

③字符串的格式化? 快捷键Alt+Ctrl+L——代码的规范

4、布尔值类型

①Python一切皆有对象，所有对象都有一个布尔值，可以使用内置函数bool()获取对象的布尔值

②布尔值可以用于计算

????????【实例】print(False + 1) # 1? ? ? ? ?print(True + 1) # 2

③布尔值开发中一般用于判断

5、其它数据类型

complex? 复数????????list 列表????????tuple 元组????????dictionary? 字典?

二、不同类型之间的转化

1、转化为整数

? ? ? ?print(int(100.99))??#?100?将浮点数转换成为整数，舍去小数部分

? ? ???print(int("100"))??#?100? 将字符串转换成为整数

? ?????print(int(True))??#?1?布尔值True转换成为整数是?1

? ? ? ?print(int(False))?#?0?布尔值False转换成为整数是?0

Ps :?①包含非法字符将会转换失败??????

??【实例】?print(int("99.88"))????????print(int("56ab"))????????不能被转换成为整数

????????②?超出基本数范围会报错

??【实例】八进制里允许的最大值是7,所以 29 不是一个合法的八进制数? ? print(int("29",8))会报错

????????③使用int()函数进行类型转换时，还可以传入两个参数，第二个参数用来表示进制。

??【实例】print(int("21",8))??#?输出的结果是17.八进制的21,对应的十进制数字是17

? ? ? ? ? ? ? ? print(int("F0",16))?#?输出的结果是240.十六进制的F0,对应的十进制数字是240

2、转换成为浮点数

print(float("12.34"))? # 12.34? 将字符串的 "12.34" 转换成为浮点数?

print(float(23)) ????????# 23.0? 将整数转换成为了浮点数

print(float(True))????????#1.0? ?将布尔值转化为浮点数

print(float(False))??????#0.0??将布尔值转化为浮点数

3、转换成为字符串

print(str(45))????????# '45'

print(str(34.56))? ?# '34.56'

print(str(True))? ? # 'True'

4、转换成为布尔值

在Python中，只有空字符串''、“”、''''''、数字0，空字典{}，空列表[]，空元组()，和空数据None会被转换成为False，其他的都会被转换成为True

5、其他类型转换

?三、使用函数 type()可以检索数据的类型

str1=0
str2=0.0
str3='0.0'
str4=False
print(type(str1),type(str2),type(str3),type(str4),sep='  ')
# <class 'int'>  <class 'float'>  <class 'str'>  <class 'bool'>

变量

１、变量的定义

对于重复使用，并且经常需要修改的数据，可以定义为变量，来提高编程效率。

????????定义变量的语法为:　name = value，其中?“=” 的作用是赋值，? “将变量值赋值给name”

Ｐｓ：①变量名：我们可以理解为箱子，箱子里面放的就是右侧的值。当需要使用变量值，就把对应的箱子拿来。②变量即是可以变化的量，可以随时进行修改。③程序就是用来处理数据的，而变量就是用来存储数据的。③变量没有类型，数据才有类型；变量自身可以运算

２、变量命名的规则

? ? ? ? ? ? ? ? 硬性规则：①变量名由字母、数字和下划线构成，数字不能开头

??????????????????????????????????②区别大小写

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?③尽量不使用关键字或者保留字

? ? ? ? ? ? ? ? ? ? ? ? Ｐｓ：（如果标识符与保留字重复，系统会以自定义的标识符为主）

? ? ? ? ? ? ? ? 非硬性规则：　

????????????????????????①变量名通常使用小写英文字母，多个单词用下划线进行连接。

????????????????????????②受保护的变量用单个下划线开头。

????????????????????????③私有的变量用两个下划线开头

? ? ? ? ? ? ? ? ? ? ? ? ④出于便于理解的诉求，最好用便于理解的变量名来写代码，见名知义

? ? ? ? Ｐｓ：变量命名驼峰式命名、大驼峰、小驼峰；

３、变量的使用

声明变量——等号后面就是变量中存的值。如果我们想使用这个值就可以通过变量找到他们。变量名第一次出现需要定义变量，再次出现时使用变量，可以修改变量中存储的值

????????a = 45 　　#　 变量a保存了45　

全局变量

局部变量

????????局部变量与全局变量之间的转化

系统变量

环境变量

字符串格式?

message = '"龙潜于渊，龙跃于天"'
age = 18
money = 108.108108
print('经历了' + str(age) + '岁月的考验, 我坚信' + message)  # 字符串的连接

print('经历了%d岁月的考验, 我坚信 % s ' % (age, message))  # 字符串的格式化
# %d 整数（十进制）；   %f浮点数；   %s字符串：    %x/x十六进制整数；    %o八进制整数    
print('经历了%d,我坚信%s,赚取了%.2f' % (age, message, money))
# %.2f的意思是浮点数保留两位小数    %.3f的意思是浮点数保留三位小数

print('经历了%s,我坚信%s,赚取了%s' % (age, message, money))
# 在这种情况下，字符串格式化会自动将其它数据类型转化为str

函数

参数

形式参数

实际参数

常见的内置函数

type(name)可以用来查看变量的数据类型；

id()可以用来查找数据在内存空间中的位置信息；?

input('提示语句')输到控制台上的信息都是字符串类型，如果需要其他类型的数据，需要将数据类型转换

print 函数可以输入文本、数字、字符串、表达式、指定位置的文件内

input() 函数? 接收来自用户的输入数据，输入数据的类型为str，需要一个变量来存储这个数据

chr()

ord()

id()? ? ? ? ? ? ?数据储存位置查询

type()????????类型查询函数

dir(math)

函数的返回值

运算符

算术运算符

Ps :? ①混合运算时，优先级顺序为：?**?高于?* / % //?高于?+ -?，为了避免歧义，建议使用 () 来处理运算符优先级。

????????②不同类型的数字在进行混合运算时，整数将会转换成浮点数进行运算。

????????③如果是两个字符串做加法运算，会直接把这两个字符串拼接成一个字符串；如果是数字和字符串做加法运算，会直接报错；如果是数字和字符串做乘法运算，会将这个字符串重复多次。

赋值运算符

1、基本赋值运算符

单个变量赋值? ? number=10

多个变量赋值? ? ?number1，number2 = 1 , 2? ?（系列解包赋值）;

? ????????????????????????a = b =10；（链式赋值）

?????????????????????????ｘ，ｙ＝ｙ，ｘ（ｘ，ｙ交换数值）

Ps : 变量的个数要和值的个数一一对应，否则就会出现赋值错误

2、复合赋值运算符

Ps：注意：赋值运算符是从右往左运算，将等号右边的值赋值给等号左边，所以，等号的左边一定不能是常量或者表达式。　　实例：ａ＋＝２＊１０——＞ａ＝２＊１０＋ａ

逻辑运算符

a = 1
b = 2
c = 0
print(a and b)  # 2
print(b and a)  # 1
print(a or b)  # 1
print(b or a)  # 2
print(a or c)  # 1
print(a and c)  # 0
print(b or c)  # 2
print(b and c)  # 0
?
print(45 and 28 and 'hello' and 0)  # 0　（取第一个为False的值）
print(0 or None)  # None（如果所有的值都为False,取最后一个值。）
print(0 or "" or None)  # None（如果所有的值都为False,取最后一个值。）

?

关系运算符

（ is 、< 、> 、<= 、>= 、!=? 、==）

关系运算符的运算结果是布尔值

Ps :赋值运算符中‘＝’、比较运算符中‘＝＝’、变量由三部分组成：标识，数值　　分析三者的区别

list1 = [11, 22, 33, 44]
list2 = [11, 22, 33, 44]
print(list1 == list2)  # True
print(list1, id(list1))  # [11, 22, 33, 44] 2126707372672
print(list2, id(list2))  # [11, 22, 33, 44] 2126707372224
print(list1 is list2)  # False

位运算符（——针对二进制的运算）

number1 = 6
number2 = 2
print(bin(number1), bin(number2))  # 0b110 0b10
print(number1 & number2)  # 2
print(bin(number1 & number2))  # 0b10
# 0&0——>0； 0&1——>0； 1&0——>0； 1&1——>1; 1为真，0为假，&类似and;对应数位都是1，结果才是1，否则为0

print(number1 | number2)  # 6
print(bin(number1 | number2))  # 0b110
# 0|1——>1;  1|1——>1; 0|0——>0; 1|0——>1; 1为真，0为假，|类似or；对应数位都是0，结果数位才是0，否则为1

print(number1 ^ number2)  # 4
print(bin(number1 ^ number2))  # 0b100
# 上下两个数为相同为0，不同为1，^——>异或

number = 2
print(4 << number)  # 向左移动 number位，相当于乘以2的number次方
# 左移位运算符 <<，高位溢出舍弃，低位补0
print(4 >> number)  # 向右移动 number位，相当于整除2的number次方
# 右移位运算符 >>，低位溢出舍弃，高位补0

#   ~取反；     判断是否是负的二进制的依据，看二进制的最高位，最高位为1则为负数，最高位为0则为正数
print(~7)  # 将7的二进制取反 ——>  -8
# ~7的十进制表示：1.先求+7的二进制0000 0111   2.反码 1111 1000  3.补码 1111 1001
print(~-5)  # 将-5的二进制取反 ——>  4
# ~ -5的十进制表示：1. 0000 0101——>： 2.取反： 1111 1010——>：3. +1：1111 1011     4.取反： 0000 0100
# 已知十进制负数，求二进制负数：1.正数的原码 2.原码取反 3. +1 ——>十进制负数的二进制表示
# 【例】 -9的二进制表示：00001001 ——> 11110110 ——> 11110111
# 已知二进制的负数，求对应的十进制表示： ——二进制负数的十进制表示
# 1.二进制负数 21.二进制-1 3.取反 4.原码：将原码转化为十进制，在十进制的前面添加 -
# 【例】11111101的十进制表示： 1.减1： 1111 1100   2.取反：0000 0011    3.原码0000 0011 4.十进制：-3

比较运算符

Ｐｓ：①数字和字符串做==运算结果是false,除了?==?以外的逻辑运算时，会直接报错。

　　　②如果是两个字符串进行比较，会将每个字符都转换成对应的编码，然后逐一进行对比。

str1='a' 
str2='ABC'
# 将字符转换成为对应的编码  a对应的编码是97,A对应的编码是65
print(str1 > str2)    ＃True

运算符的优先级

以下表格列出了从最高到最低优先级的所有运算符：

# 运算的优先级
a = 1
b = 2
x = 20
print(b > a + x < a + b)  # False
print(b > a + (x < a + b))  # True
print(a + False)  # 1

标准库

第三方库

控制结构

#随机数游戏
import random
computer=random.randint(1,6)
guess=int(input('请输入你的猜测结果:'))
if computer==guess:
    print('恭喜你猜对了')
else:
    print('对不起，你猜错了')
    print('正确答案是：',computer)

顺序结构

循环结构

for循环?

for?临时变量?in?序列:
????循环满足条件时执行的代码
序列——字符串、列表、元组、集合都可以；数字和布尔值不属于序列

for s in 'canjsbjh':
    print(s, end='-*-')
# 字符串的遍历——>  c-*-a-*-n-*-j-*-s-*-b-*-j-*-h-*-
print()
for s in 'cajh':  # 让for循环循环10次就需要in后面的字符串中有10个元素
    print('龙潜于渊，龙跃于天')
'''
龙潜于渊，龙跃于天
龙潜于渊，龙跃于天
龙潜于渊，龙跃于天
龙潜于渊，龙跃于天
'''

# for item in range(start,stop,step)  默认从start开始，到stop-1结束，step，即每次数值递增的值

# 用for循环打印1~100之间的数字的累积和
sum = 0
for item in range(1, 101):
    sum += item
    print("sum =", sum)
print("total_sum =", sum)


# for……else语句 —— 如果上面的for循环0~n-1没有出现中断(break),则在执行完for循环后执行else语句
for i in range(3):
    username = input("请输入用户名")
    password = input("请输入密码")
    if username == 'lx' and password == '123456':
        print('登陆成功')
        break
    print('用户名或者密码有误!\n')
else:
    print("账户被锁定")

while循环

while循环的格式
n = 0  # 初始化变量
while n <= 10:  # 循环条件的指定，True——>进入循环体
    print("龙潜于渊，龙跃于天")
    n += 2  # 改变变量/变量的自增或者自减
print("*" * 5)

# 打印1~50中可以被7整除的数字
n = 1
count = 0
while n <= 50:
    if n % 7 == 0:
        print('可以被7整除——→', n)
        count += 1
    n += 1
print('可以被7整除的有——→', count, '个')
print("*" * 5)
# 第二种方法
n = 0
while n <= 50 and n % 3 == 0:
    print("可以被7整除的有——→", n)
    n += 3

# 打印1~100之间的数字的累积和
n = 0
sum = 0
while n <= 100:
    sum += n
    n += 1
    print("n =", n, "sum =", sum)
print("sum =", sum)
print("*" * 5)


# while……else语句——else语句，不被中断则完成循环后执行else语句，被中断则不执行
n = 1
while n <= 10:
    print('n')
    n += 1
    if n == 5:
        break
else:
    print('over')

# while的嵌套语句
m=1
n=1
while m<=9:
    while n<=9:
        print('-*-'*n)
        n+=1
    m+=1

# while的嵌套语句
m=1
while m<=5:
    n=5
    while n>=m:
        print('-*-',end='')
        n-=1
    print()
    m+=1

Ps:?for循环和while循环的区别

1. 确定次数循环和不确定次数循环

2.if语句只会执行一次判断条件，条件成立以后，只会执行一次代码块；而while语句，会先执行一次判断条件，如果条件成立，会执行一次代码块，代码块执行完成以后，会再次判断条件语句，如果还成立，将会再执行代码语句... 直到最后条件不成立。

break语句

格式实例
number = 0
while True:
    print('yeah')
    number += 1
    if number == 5:
        break  # 跳出当前的循环结构

# 最多输入用户名和密码三次，如果三次没有登陆成功，则提示账户被锁定
for i in range(3):
    username = input("请输入用户名")
    password = input("请输入密码")
    if username == 'lx' and password == '123456':
        print('登陆成功')
        break
    print('用户名或者密码有误!\n')
if i == 2:
    print("账户被锁定")

# 去超市购物，允许买多件东西，计算商品价格总额
total_money = 0
total_quantity = 0
while True:
    price = float(input('输入价格'))
    quantity = int(input('输入数量'))
    total_money += price * quantity
    total_quantity += quantity
    answer = input("total_money=%.2f,是否继续(y/n)")
    if answer == "n":
        break
print("total_quantity=%d,total_money=%.2f" % (total_quantity, total_money))


# 产生随机数，可以猜多次，直到猜对为止，如果猜错了，会给提示
import random
computer = random.randint(1, 10)
count_game = 0
while True:
    guess = int(input("请输入你猜测的数字："))
    count_game += 1
    if guess == computer:
        print("恭喜你猜对了")
        break
    elif computer >= guess:
        print("猜错了，请再猜大些")
    else:
        print("猜错了，请再猜小些")
print("你总计猜测了%d次" % count_game)
if count_game >= 5:
    print("运气一般啊，再接再厉")
else:
    print("运气太棒了，欧皇非你莫属")
    print('— * - ' * 5)

continue语句

for i in range(10):
    if i %3==0:
        continue
    print(i)

for i in range(10):
    if i%3!=0:
        print(i)

for i in range(10):
    if i %3==0:
        break
    print(i)
'''
break和continue的区别：
break和continue的位置都是出现在循环中的，只能用于循环语句中；break和continue在嵌套循环中使用时，只对最内层循环有效。
break是跳出循环结构；continue是跳出本次循环，继续下一次循环，但是未必退出循环结构
一般情况下，循环语句和else共同出现时，在循环语句里都会配合break语句来使用。只要循环没有顺利完成，中间被break中断了则else里面的内容就不会执行。

'''

选择结构/分支结构

if……elif……else模块

条件：运算符构成，布尔值类型

条件语句

if 条件1：

? ? ? ? 条件1为True时执行的语句

elif 条件n:

????????条件n为True时执行的语句

……

else:

? ? ? ? 上述条件均不成立时的执行的语句

# 产生两个0~10的随机整数，判断两数之和是否大于8且两数之差小于3，如果是，显示：success，反之，显示“fail
import random

computer1 = random.randint(1, 10)
computer2 = random.randint(1, 10)
print("两个随机数字是,", computer1, computer2)
if (computer1 + computer2 > 8) and (computer1 - computer2 < 3 and computer2 - computer1 < 3):
    # abs(computer1 - computer2) < 3
    print('success')
else:
    print('fail')

'''
阿里巴巴商家节，用户名，消费总金额，账户金额，优惠券
输入购买总购买金额
如果金额0-500，则是lv1级别，随机赠送三张1~10元的优惠券；
如果500-2000元则是lv2，赠送2张50元优惠券，如果充值则送充值金额的10%，
2000元以上则是lv3，赠送2张100元优惠券，如果充值则送15%的金额
'''
user = "lx"
total = 1500  # 消费总金额
money = 0  # 账户金额
coupon = 0  # 优惠券
if 0 < total < 500:
    quan1 = random.randint(1, 10)
    quan2 = random.randint(1, 10)
    quan3 = random.randint(1, 10)
    coupon = quan1 + quan2 + quan3

elif 500 < total < 2000:
    coupon = 2 * 50
    recharge = input('是否充值，充值送充值金额的10%, y / n :\n')
    if recharge == "y":
        money += 1.1 * float(input("请输入充值金额(元):"))

elif total > 2000:
    coupon = 2 * 100
    recharge = input('是否充值，充值送充值金额的10%, y / n :\n')
    if recharge =='y':
        money += 1.15 * float(input("请输入充值金额(元):"))

if的嵌套循环

'''
默认username=admin，password=1234
是否记住密码bool类型，is_remember
如果用户名和密码正确，并且is_remember是True表示记住密码，则打印已经记住用户的密码，
否则打印 没有记住密码，需要下次继续输入
'''
username=input('admin')
password=input('1234')
is_remember==True
if username=='admin' and password=='1234':
    if is_remember:
        print('已经记住用户%s的密码了'%username)
    else:
        print('没有记住密码，需要下次继续输入')
else:
    print('用户名或者密码有误！')

'''
模拟超市付款：
1.键入商品单价、商品数量，计算应付总额
2.提示用户选择付款方式：现金支付无折扣、微信支付95折、刷卡满100减20、
'''
print('~~~~~~欢迎光临自强超市~~~~~')
price = float(input('商品单价：'))
number = int(input('商品数量：'))
total = price * number
choice = input('请选择付款方式：1.现金支付 2.微信支付 3.刷卡支付')
if choice == '1':
    print('现金支付没有折扣，应付金额是：%.2f' % total)
elif choice == '2':
    total = total * 0.95
    print('微信支付享有95折优惠,支付金额为：%.2f' % total)
elif choice == '3':
    if total > 100:
        total -= 20
        print('刷卡满100减20,支付金额为：%.2f' % total)
    else:
        print('消费未满100，无法享受优惠 ', total)
else:
    print('输入错误，请再次选择！')

if的知识补充

# if语句的区间比较
a = 10
print(9 < a <= 21)  # True
print(11 < a < 20)  # False
# 三元运算符
# 变量=value1 if 条件 else value2 当条件成立时，把value1的值赋给变量，否则将value2的值赋给变量
a=10
b=30
c=a if a>b else b
print('a和b两个数中的较大值是',c)
# 自动转换类型
'''if语句需要一个判断条件，这个判断条件的结果需要一个布尔值，
如果此时输入的判断条件不是一个布尔值，在代码执行的过程中，会将这个值自动转换成为一个布尔值'''
if 'hello':
    print('hello world!')
else:
    print('人生苦短，我学Python')
'''在Python中，只有空字符串''、“”、''''''、数字0，空字典{}，空列表[]，空元组()，
和空数据None会被转换成为False，其他的都会被转换成为True'''

对象

赋值语义

值语义

引用语义

四、库的调用

import keyword

print(keyword.kwlist)

字符串

字符串的定义

????????Python 要求字符串必须使用引号括起来，使用单引号也行，使用双引号也行，只要两边的引号能配对即可。字符串引号里面的的每个基本单元叫做字符，比如字符"abc"中，"a"、"b"和"c"就是字符串组成的基本单元，它们都是字符。

如下定义的变量，存储的是字符串类型的值

????a?=?"I'm?Bob"??#?一对双引号?
????b?=?'I?am?Bob'??#?一对单引号
????c?=?'He?said:I\'m?Bob'??#?当出现符号冲突时可以使用转义字符说明
????d?=?'''I'm?Bob'''??#?三个单引号
????e?=?"""I'm?Bob?"""??#?三个双引号

小总结：

• 双引号或者单引号中的数据，就是字符串

• 如果使用一对引号来定义字符串，当出现符号冲突时可以使用转义字符，比如变量c

• 使用三个单引号或者三个双引号定义的字符串可以包裹任意文本

字符串的运算

1.使用+运算符来实现字符串的拼接; 使用*运算符来重复一个字符串的内容

s1 = 'hello' + ' ' + 'world'
print(s1)    # 结果：hello world
s2 = '!' * 3
print(s2)    # 结果：!!!
s1 += s2     
print(s1)    # 结果：hello world!!!
s1 *= 2      
print(s1)    # 结果：hello world!!!hello world!!!

2.使用in和not in来判断一个字符串是否包含另外一个字符串。

str1 = 'bxah'
str2 = 'b'
str3 = 'bx'
str4 = 'bh'
print(str2 in str1)  # True ——>单个字符没有位置区分
print(str3 in str1)  # True
print(str4 in str1)  # False——>多个字符组成的新字符串有字符内在位置的区分
print(str4 not in str1) # True

3.对于两个字符串类型的变量，可以直接使用比较运算符比较两个字符串的相等性或大小。

Ps: ①因为字符串在计算机内存中也是以二进制形式存在的，那么字符串的比较其实比的是：每个字符对应的编码的大小。可以使用ord函数来获得字符对应的编码，例如ord('A')的值是65，而ord('赵')的值是36213。

? ? ? ②字符串的比较运算比较的是字符串的内容，Python中还有一个is运算符（身份运算符），如果用is来比较两个字符串，它比较的是两个变量对应的字符串是否在内存中相同的位置（内存地址id），简单的说就是两个变量是否对应内存中的同一个字符串。

【例】

1.A的编码是65， 而a的编码是97，所以'A' < 'a'的结果相当于65 < 97的结果，——>True；

2.'boy' < 'bad'，因为第一个字符都是'b'比不出大小，所以实际比较的是第二个字符的大小，显然'o' < 'a'的结果是False，所以'boy' < 'bad'的结果也是False。

索引与切片

Ps:1.在进行索引操作时，如果索引越界（正向索引不在0到N-1范围，负向索引不在-1到-N范围）会引发IndexError异常，错误提示信息为：string index out of range（字符串索引超出范围）

2.从字符串中取出多个字符，我们可以对字符串进行切片，运算符是[i:j:k]，其中i是开始索引，索引对应的字符可以取到；j是结束索引，索引对应的字符不能取到；k是步长，默认值为1，表示从前向后获取相邻字符的连续切片，所以:k部分可以省略。

3.假设字符串的长度为N，当k > 0时表示正向切片（从前向后获取字符），如果没有给出i和j的值，则i的默认值是0，j的默认值是N；当k < 0时表示负向切片（从后向前获取字符），如果没有给出i和j的值，则i的默认值是-1，j的默认值是-N - 1。第一个字符的索引是0或-N，最后一个字符的索引是N-1或-1，最中间的索引可以表示为len(name)//2

字符串的循环遍历

从字符串中取出每个字符，可以使用for循环对字符串进行遍历，有两种方式。

# 方法一
string='hello'
for index in range(len(string)):
     print(string[index],end='  ')

print()
# 方法二
string='hello'
for i in string:
    print(i,end='  ')

字符串的方法

在Python中，我们可以通过字符串类型自带的方法对字符串进行操作和处理，对于一个字符串类型的变量，我们可以用变量名.方法名()的方式来调用它的方法。所谓方法其实就是跟某个类型的变量绑定的函数

获取长度len

s = 'hello, world'
print(len(s))                  # 12
print(len('goodbye, world'))    # 14

查找内容find\rfind\index\rindex。

s?=?'hello,?world!'
'''
find方法从字符串中查找另一个字符串所在的位置,找到了返回匹配的字符串的首字母下标，没有找到则返回-1
'''
print(s.find('or'))????????#?8——>o的索引——字符串首字母的索引
print(s.find('good'))??????#?-1
# 通过方法的参数来指定查找的范围——查找不必从索引为0的位置开始
# find方法的逆向查找rfind，从右侧开始查找字符串,没有找到返回-1

#?index方法与find方法类似，#?找到了返回字符串中另一个字符串首字符的索引，找不到引发异常
print(s.index('or'))???????#?8
print(s.index('good'))?????#?ValueError:?substring?not?found
# 通过方法的参数来指定查找的范围——查找不必从索引为0的位置开始
# index方法的逆向查找rindex

s = 'hello good world!'
# 从前向后查找字符o出现的位置(相当于第一次出现)
print(s.find('o'))       # 4
# 从索引为5的位置开始查找字符o出现的位置
print(s.find('o', 5))    # 7
# 从后向前查找字符o出现的位置(相当于最后一次出现)
print(s.rfind('o'))      # 12

判断startwith\endswith\isalpha\isdigit\isalnum\isspace

s1 = 'hello, world!'

# startwith方法检查字符串是否以指定的字符串开头,返回布尔值
print(s1.startswith('He'))    # False
print(s1.startswith('hel'))   # True
# endswith方法检查字符串是否以指定的字符串结尾,返回布尔值
print(s1.endswith('!'))       # True

s2 = 'abc123456'

# isdigit方法检查字符串是否由数字构成,返回布尔值
print(s2.isdigit())    # False
# isalpha方法检查字符串是否以字母构成,返回布尔值
print(s2.isalpha())    # False
# isalnum方法检查字符串是否以数字和字母构成,返回布尔值
print(s2.isalnum())    # True
# isspace方法检查字符串是否是空白字符串，返回布尔值
print(s2.isspace())    # False

统计指定字符出现的个数count

web_string = 'https://cn.bing.com/images/search?q=%E5%9B%BE%E7%89%87&FORM\
        =IQFRBA&id=2A67B025EDB55DFCC3EAB049289AB0CD4D0A72B5'
times = web_string.count('%')
print(times)  # 6

替换内容repalce

切割字符串split\rsplit\splitiness\partition\rpartition

修改大小写capitalize\title\upper\lower

s1?=?'hello,?world!'

#?使用capitalize方法获得字符串首字母大写后的字符串
print(s1.capitalize())???#?Hello,?world!
#?使用title方法获得字符串每个单词首字母大写后的字符串
print(s1.title())????????#?Hello,?World!
#?使用upper方法获得字符串大写后的字符串
print(s1.upper())????????#?HELLO,?WORLD!
s2?=?'GOODBYE'
#?使用lower方法获得字符串小写后的字符串
print(s2.lower())????????#?goodbye

空格处理lstrip\rstrip\strip

去除空格

strip方法可以将原字符串修剪掉左右两端空格，通常用来将用户不小心键入的头尾空格去掉

lstrip方法可以将原字符串修剪掉左端空格；rstrip方法可以将原字符串修剪掉右端空格

字符串拼接join

字符串编码和解码

对字符串进行匹配检查，即检查字符串是否满足某种特定的模式。例如，一个网站对用户注册信息中用户名和邮箱的检查，就属于模式匹配检查。实现模式匹配检查的工具叫做正则表达式，Python语言通过标准库中的re模块提供了对正则表达式的支持

格式化字符串

1.在Python中，字符串类型可以通过center、ljust、rjust方法做居中、左对齐和右对齐的处理。

s = 'hello, world'

# center方法以宽度20将字符串居中并在两侧填充*
print(s.center(20, '*'))  # ****hello, world****
# rjust方法以宽度20将字符串右对齐并在左侧填充空格
print(s.rjust(20))        #         hello, world
# ljust方法以宽度20将字符串左对齐并在右侧填充~
print(s.ljust(20, '~'))   # hello, world~~~~~~~~
# 左对齐、右对齐、居中对齐 中的宽度、填充的字符可以自定义

2.

# 用print函数输出字符串时，对字符串进行格式化。
a = 321
b = 123
print('%d * %d = %d' % (a, b, a * b))

#用字符串的方法来完成字符串的格式。
a = 321
b = 123
print('{0} * {1} = {2}'.format(a, b, a * b))

#方法二、更简洁的形式
a = 321
b = 123
print(f'{a} * {b} = {a * b}')

变量值	占位符	格式化结果	说明
3.1415926	{:.2f}	'3.14'	保留小数点后两位
3.1415926	{:+.2f}	'+3.14'	带符号保留小数点后两位
-1	{:+.2f}	'-1.00'	带符号保留小数点后两位
3.1415926	{:.0f}	'3'	不带小数
123	{:0>10d}	0000000123	左边补0，补够10位
123	{:x<10d}	123xxxxxxx	右边补x?，补够10位
123	{:>10d}	' 123'	左边补空格，补够10位
123	{:<10d}	'123 '	右边补空格，补够10位
123456789	{:,}	'123,456,789'	逗号分隔格式
0.123	{:.2%}	'12.30%'	百分比格式
123456789	{:.2e}	'1.23e+08'	科学计数法格式

Ps：在Python中，字符串是不可变的！所有的字符串相关方法，都不会改变原有字符串，都是返回一个结果，在这个新的返回值里，保留了执行后的结果——>字符串是不可变类型,不能通过索引

运算修改字符串中的字符

x = string[15:60:9]
print(id(string), id(x))  # id不同

转义字符

列表

1、列表的特点：

①有序性

②一个索引对应一个列表元素，但是一个列表元素有两个索引

③列表可以储存任何类型的数据

④列表元素可以重复

2、列表的创建（列表名、赋值符号、列表元素）

???????? name=[value1,value2……];

???????? name=list()

????????列表生成式（生成列表的公式）??

[ i*i? ? ?for i in range(start,stop,step)](表示列表元素的相关表达式、自定义变量、可迭代对象)

注意：=表示列表元素的表达式中通常包含自定义变量

3、列表的查询——判断列表中是否存在要查找的元素

获取列表中单个元素的索引

index()函数? 如果列表存在多个相同元素，只返回相同元素的第一个元素索引；如果查询的元素在列表中不存在，则会抛出ValueError ; 还可以在指定的start和stop之间进行查找

正向索引? 从0到N-1

逆向索引? 从-N到-1

指定索引

判断指定元素是否在列表内? in/not in?

遍历（迭代）? for 迭代变量 in? 列表名

'''list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
list.count(obj) 统计某个元素在列表中出现的次数
obj in list 其实这个在前面说过，但是也可以用于判断'''

heros = ['探险家','河流之王','冰晶凤凰','荒漠屠夫','齐天大圣','冰晶凤凰','赛恩','冰晶凤凰']
# 判断'荒漠屠夫'是否在列表中存在
n = heros.index('荒漠屠夫')
print(n)  # 3

# 判断'牛头酋长'是否在列表中存在
n = heros.index('牛头酋长') 
print(n)
# 查找的元素不在列表中，会报错的，ValueError: '牛头酋长' is not in list。

# 也可以使用count判断个数
n = heros.count('冰晶凤凰')
print(n)  # 3

# 当然也可以使用：'荒漠屠夫' in heros
print('荒漠屠夫' in heros)  # True

4、列表的切片——获取列表中的多个元素——切片返回的是一个列表，可以理解为“子列表”。

[start,stop,step]

start和stop是左闭右开的区间，step表示的是步长，并且步长可以是正向（从左向右）也可以是逆向（从右向左）取元素。step如果是负数表示的是逆向，如果是正数表示的是正向。

如果stop省略则表示到列表最后一个元素，如果start省略表示从第一个元素开始

5.列表的运算

5、列表的修改

增加操作

append()? 在列表的末尾添加一个元素

extend()? ?在列表的末尾至少添加一个元素

insert()? ? ? 在列表的任意位置添加一个元素????????list.insert(index,value)

切片? ? ? ? ? 在列表的任意位置添加元素，该位置之后的元素会被替代

list = [10, 20, 30]
print('添加元素之前', type(list))  # 添加元素之前 <class 'list'>
list.append(100)
print('添加元素后', list, type(list))  # 添加元素后 [10, 20, 30, 100] <class 'list'>
list[2:] = [80, 90]
print('第二次修改之后', list)  # 第二次修改之后 [10, 20, 80, 90]
list[4:] = [110, 130]
print('第三次修改之后', list)  # 第三次修改之后 [10, 20, 80, 90, 80, 90]
# 切片的起始位置之后的所有列表元素会被切片赋值的元素所替代

list1 = [22, 44, 55, 88]
list2 = [33, 66, 99]
list.extend(list2)
print(list)  # [10, 20, 80, 90, 110, 130, 33, 66, 99]

删除操作

remove() 一次删除一个；重复元素只删除第一个；元素不存在则抛出异常

pop()? 删除一个指定索引位置上的元素；指定索引不存在抛出IndexError ; 不指定索引，删除列表中的最后一个元素

clear()清空列表

del()删除列表

切片一次至少删除一个元素

heros = ['探险家','河流之王','荒漠屠夫','齐天大圣','冰晶凤凰','赛恩','冰晶凤凰']
# 删除下标为1的元素
del heros[1]
print(heros) 
# 删除下标为1的元素，并获取返回值
element = heros.pop(1)
print(heros) 
print(element)
# 删除：'冰晶凤凰'
element = heros.remove('冰晶凤凰')
print(heros)
print(element)
# 注意这句话会报错的，ValueError: list.remove(x): x not in list
element = heros.remove('冰晶凤凰1')
print(heros)
'''可以看到remove的返回值是None，而且是只删除了从左向右的第一个遇到的元素，后面的没有删除。而且如果要删除的元素不在列表中存在则会报异常：ValueError。'''

['探险家', '荒漠屠夫', '齐天大圣', '冰晶凤凰', '赛恩','冰晶凤凰']

['探险家', '齐天大圣', '冰晶凤凰', '赛恩','冰晶凤凰']

荒漠屠夫

['探险家', '齐天大圣', '赛恩','冰晶凤凰']

None

列表数值的修改

一次修改一个值????????list[index]=value

一次修改多个值? ? ? ?list[start,stop,step]=[value1,value2,value3...]

6、列表的排序

指定关键字参数

reverse=False? 升序排列

reverse=True 降序排序

调用sort() 方法，列表中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True,进行降序排序

调用内置函数sorted() 可以指定reverse=True 进行降序排序，愿列表不发生改变

heros = ['探险家','河流之王','冰晶凤凰','荒漠屠夫','齐天大圣','冰晶凤凰','赛恩','冰晶凤凰']
# 倒序列表中的元素
heros.reverse()
print(heros)
# ['冰晶凤凰', '赛恩', '冰晶凤凰', '齐天大圣', '荒漠屠夫', '冰晶凤凰', '河流之王', '探险家']

# 对列表中的元素进行排序
heros.sort()
print(heros)
# ['冰晶凤凰', '冰晶凤凰', '冰晶凤凰', '探险家', '河流之王', '荒漠屠夫', '赛恩', '齐天大圣']

# 对列表中的元素进行排序，也可以降序
heros.sort(reverse=True)
print(heros)
# ['齐天大圣', '赛恩', '荒漠屠夫', '河流之王', '探险家', '冰晶凤凰', '冰晶凤凰', '冰晶凤凰']

元组

字典

递归

递归的组成部分

递归调用

递归终止条件

递归调用过程

每递归调用一次函数，都会在栈内存分配一个栈帧；每执行完一次函数，都会释放相应的空间

递归的优缺点

缺点：占用内存多，效率低下

优点：思路和代码简单

文件处理

文件格式：?.mp4、.mp3、txt.、md等

文件路径