【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、其他类型转换

eval(str)	用来计算在字符串中的有效Python表达式，并返回一个对象
chr(x)	将一个整数转换为一个Unicode字符
ord(x)	将一个字符转换为它的ASCII整数值
tuple(s)	将序列 s 转换为一个元组
list(s )	将序列 s 转换为一个列表

 三、使用函数 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)

函数的返回值

运算符

算术运算符

运算符	描述	实例
+	加	print(10+20)      # 30
-	减	print(10-20)        # -10
*	乘	print(10*5)        #50                print(!*5)        #!!!!! Ps :  数字和字符串做乘法运算，会将这个字符串重复多次
/	除	print(8/2)        #4.0
//	取整	返回商的整数部分    print(11//2)        #5        print(-9//4)        # -3
%	取余	返回除法的余数        print(11%2)        #1
**	指数	a**b 为a的b次方        print(2**10)        #1024
()	小括号	提高运算优先级         print((2+5)//3)        #2

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

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

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

赋值运算符

1、基本赋值运算符

=

赋值运算符

把 = 号右边的结果 赋给 左边的变量，如 num = 1 + 2 * 3，结果num的值为7

单个变量赋值    number=10

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

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

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

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

2、复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
//=	取整除赋值运算符	c //= a 等效于 c = c // a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a

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

逻辑运算符

运算符	逻辑表达式	描述	实例
and	x and y	见假则假，全真为真 做取值运算时，取第一个为False的值，如果所有的值都为True,取最后一个值。	1 and 2 and 3-->结果是3
or	x or y	见真为真，全假为假 做取值运算时，取第一个为True的值，如果所有的值都为False,取最后一个值。	1 or 0 or 2-->结果是1
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not（２ and ８) 返回 False

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

比较运算符

运算符	描述	实例（ａ＝１，ｂ＝５）
==	等于                　 比较对象是否相等（比较数值）	(a == b) 返回 False.
!=	不等于                 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于                 比较两个对象是否不相等	(a <> b) 返回 true，类似 !=
>	大于                    返回x是否大于y	(a > b) 返回 False。
<	小于                    返回x是否小于y。              比较运算符返回1表示真，返回0表示假，与变量True和False等价	(a < b) 返回 true。
>=	大于等于         　 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于　        返回x是否小于等于y。	(a <= b) 返回 true。

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

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

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

运算符的优先级

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

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not>and>or	逻辑运算符

# 运算的优先级
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 item in range(start,stop,step)  默认从start开始，到stop-1结束
# 用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),执行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语句，不被中断则执行，被中断则不执行
n = 1
while n <= 10:
    print('n')
    n += 1
    if n == 5:
        break
else:
    print('over')

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

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

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语句

选择结构/分支结构

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)

列表

1、列表的特点：

①有序性

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

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

④列表元素可以重复

2、列表的创建

         name=[]; name=list()

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

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

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

3、列表的查询

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

获取列表中的单个元素

获取列表中的多个元素

正向索引  从0到N-1

逆向索引  从-N到-1

指定索引

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

遍历  for 迭代变量 in  列表名

4、列表的切片——获取列表中的多个元素

【start,stop,step】

5、列表的修改

增加操作

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

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

insert()      在列表的任意位置添加一个元素

切片          在列表的任意位置添加至少一个元素

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]

删除操作

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

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

clear()清空列表

del()删除列表

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

列表数值的修改

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

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

6、列表的排序

指定关键字参数

reverse=False  升序排列

reverse=True 降序排序

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

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

元组

字典

递归

递归的组成部分

递归调用

递归终止条件

递归调用过程

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

递归的优缺点

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

优点：思路和代码简单

文件处理

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

文件路径