1，Python简介
1.1，Python特点
Python是一种面向对象、解释型、弱类型的脚本语言，它也使一种功能强大而完善的通用性语言。相比其他编程语言（Java），Python代码非常简单，上手非常容易。比如我们想要完成某个功能，如果用Java需要100行代码，但用Python可能只需要20行代码，这是Python具有巨大吸引力的一大特点。
#交换两个变量 #Java int c = a a = b b = c #Python (a, b) = (b, a)Python的特点：
- Python是一种解释型语言，因此，Python代码在运行前不需要编译。
- Python是动态类型语言，在声明变量时，不需要指定变量的类型。
- Python 会自动管理内存，Python 有自己的管理内存和相关对象的方式。当在 Python 中创建一个对象的时候，内存动态地分配给它。当对象的生命周期结束的时候，其占用的内存会被收回。Python 的内存管理使得程序更加高效，不用为此操心。
- Python适合面向对象的编程，因为它支持通过组合和继承的方式定义类。
- 编写Python代码比较容易，但是运行速度比编译语言要慢。
- Python用途广泛，常被用作“胶水语言”，可帮助其他语言和组件改善运行状况。
- Python 具有很强的可移植性，使用 Python 编写的程序几乎可以在所有已知的平台（如 Windows、Linux 或 Mac 等）上运行。
- 程序员使用Python可以专注于算法和数据结构的设计，而不用处理底层的细节。
Python作为一门解释型语言，它天生具有跨平台的特征，只要为平台提供了相应的Python解释器，Python就可以在该平台上运行。（解释型语言几乎天然是跨平台的）
Python自然也具有解释型语言的一些弱点：
- 速度慢：Python比Java、C、C++等程序的运行效率都要慢，
- 源代码加密困难：不像编译型语言的源程序会被编译成目标程序，Python直接运行源程序，因此对源代码加密比较困难。
1.2，语言类型
动态语言和静态语言：
动态类型语言：运行期间才做数据类型检查的语言，即动态类型语言编程时，永远不用给任何变量指定数据类型。该语言会在第一次赋值给变量时，在内部将数据类型记录下来。例如：ECMAScript(JavaScript)、Ruby、Python、VBScript、php。Python和Ruby就是典型动态类型语言，其他各种脚本语言如VBScript也多少属于动态类型语言，优点是方便阅读，不需要写非常多的类型相关的代码；缺点是不方便调试，命名不规范时会造成读不懂，不利于理解等。
- 静态类型语言：编译期间做检查数据类型的语言，即写程序时要声明所有变量的数据类型，是固定的。使用数据之前，必须先声明数据类型（int ,float,double等）。相当于使用之前，首先要为它们分配好内存空间。例如：C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、JAVA等优点是结构非常规范，便于调试，方便类型安全；缺点是为此需要写更多类型相关代码，不便于阅读、不清晰明了。
强类型语言和弱类型语言：
- 强类型语言：一旦变量被指定某个数据类型，如果不经强制转换，即永远是此数据类型。举例：若定义了一个整型变量a，若不进行显示转换，不能将a当作字符串类型处理强类型语言是指需要进行变量/对象类型声明的语言，一般情况下需要编译执行。例如C/C++/Java/C#。
- 弱类型语言：数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。举例：在VBScript中，可以将字符串 '12' 和整数 3 进行连接得到字符串 '123'， 然后可以把它看成整数 123，而不需要显示转换。例如PHP/ASP/Ruby/Python/JavaScript等。
强类型语言在速度上略逊色于弱类型语言，使用弱类型语言可节省很多代码量，有更高的开发效率。而对于构建大型项目，使用强类型语言可能会比使用弱类型更加规范可靠。
【问题】Java不是允许int+String吗？
【答案】只要这门语言支持”运算符重载“，不管它是强类型、还是弱类型，也不管是它是静态检查、还是动态检查，都可以写出 20 - "4" 这种代码。
【问题】Python是弱类型还是强制类型？
【答案】弱类型，因为Python中变量无须声明即可直接赋值并且变量的数据类型可以动态改变。
【问题】作者都说是弱类型了：怎么理解python语言是强类型语言_为什么说 Python 是强类型语言？_weixin_39901412的博客-CSDN博客我看了两个问题下的所有回答，发现都没有提到 Guido van Rossum (Benevolent Dictator For Life (BDFL))的意见，这里贴一下，提供更多信息。“Weak typing is not really a fair description of what's going on in Python. It's really runtime typing beca...
https://blog.csdn.net/weixin_39901412/article/details/111082072【答案】python自己都说得都有些底气不足 ，python作者之所以不愿意承认Python是弱类型的语言，主要原因在于大部分人都觉得弱类型的语言往往属于脚本语言，难登大雅之堂。而实际上，按python作者的说法， 他希望把python称为“runtime typing”，那这世界上就没有弱类型语言了。Python作者这种暧昧的态度可能也是导致大部分菜鸟纠结、争论的原因之一，但对于python作者来说，可能他也乐见这种情况，毕竟有争议就有热度。
JS也是runtime typing，当你定义 let a = 5; 变量a有没有类型？等到运行时一样有类型。那Ruby也是runtime typing、VB也是runtime typing。按他这个逻辑也行，这世界上压根就没有弱类型的语言。既然大家都不喜欢”弱类型“的语言这个说法，那干脆咱们就说，JS、Ruby、VB、Python都是runtime typing。
判断一个东西，不是看它说什么，而是看它实际的表现。典型的强类型语言有两个特征：1、变量必须先声明、后使用。2、变量有明确的类型，一旦确定了变量的类型，在它的整个生命周期中，它的类型不可改变。C、C++、Swift、Kotlin、Java……都具有这样的特征。
1.3，Python程序的运行机制
Python是一门解释型的编程语言，因此它具有解释型语言的运行机制。计算机程序，其实就是一组计算机指令集，能真正驱动机器运行的是机器指令，但让普通开发者直接编写机器指令是不现实的，因此就出现了计算机高级语言。高级语言允许使用自然语言来编程，但高级语言最终必须被翻译成机器指令来执行。
编译型：编译型语言是指专门的编译器，针对特定平台（操作系统）将某种高级语言源代码一次性“翻译”成可被该平台硬件执行的机器码（包括机器指令和操作数），并包装成该平台所能识别的可执行程序的格式，这个转换过程称为编译。编译生成的可执行程序可以脱离开发环境，在特定的平台上独立运行。
有些程序编译结束后，还可能需要对其他编译好的目标代码进行链接，即组装两个以上的目标代码模块生成最终的可执行程序，通过这种方式实现低层次的代码复用。
因为编译语言是一次性编译成机器码的，所以可以脱离开发环境独立运行，而且通常运行效率较高。但因为编译型语言的程序被编译成特定平台上的机器码，因此编程生成的可执行程序通常无法移植到其他平台上运行；如果需要移植，则必须将源代码复制到特定平台上，针对特定平台进行修改，至少需要采用特定平台上的编译器重新编译。
现有的C、C++、Objective-C、Pascale等高级语言。Java是编译型+解释型语言。
解释型：解释型语言是指使用专门的解释器对源代码逐行解释成特定平台的机器码并立即执行的语言。解释型语言通常不会进行整体性的编译和链接处理，解释型语言相当于把编译型语言中的编译和解释过程混合到一起同时完成。
可以认为：每次执行解释型语言的程序都需要进行一次编译，因此解释型语言的运行效率通常较低，而不能脱离解释器独立运行。但解释型语言有一个优势，就是跨平台比较容易，只需提供特定平台的解释器即可，每个特定平台上的解释器都负责将源程序解释成特定平台的机器指令。解释型语言可以方便地实现源程序级的移植，但这是以牺牲程序执行效率为代价的。
Python语言属于解释型语言，因此运行Python程序时需要使用特定的解释器进行解释、执行。解释型的Python语言天生具有跨平台的能力，只要为Python提供相应平台的解释器即可。
1.4，Python2和Python3
Python的3.x版本相对于Python早期版本的大升级。为了不给系统引入过多的负担，Python3在设计时没有考虑向下兼容，即Python3和Python2不兼容。许多针对早期Python版本设计的程序无法在Python3上正常运行。为了照顾现有的程序，Python2.6作为一个过渡版本，基本使用了Python2的语法库，同时也考虑向Python3的迁移，支持部分Python3的语法与函数。
主要区别（部分）：
- print函数:（Python3中print为一个函数，必须用括号括起来；Python2中print为class）
通过
input()解析用户的输入：（Python3中input得到的为str；Python2的input的到的为int型，Python2的raw_input得到的为str类型）（Python3中/表示真除，%表示取余，//表示地板除（结果取整）；Python2中/表示根据除数被除数小数点位得到结果，//同样表示地板除）
在 Python 3 中，
range()是像xrange()那样实现以至于一个专门的xrange()函数都不再存在（在 Python 3 中xrange()会抛出命名异常）。在 Python 2 中xrange()创建迭代对象的用法是非常流行的。
2，变量
2.1，注释
Python中的注释有两种：单行注释&多行注释。
#我是单行注释 ''' 我是 多行注释 ''' """ 我也是 多行注释 """
2.2，变量名
变量就像是一个用来装东西的盒子，把要存储的东西放在这个盒子里面，再给这个盒子起一个名字。当需要用到盒子里的东西的时候，只要说出这个盒子的名字，就可以找到其中的东西了。
变量是存储在内存中的值。这就意味着，当创建变量时，会在内存中开辟一个空间。根据变量的数据类型，解释器会分配指定的内存，并决定什么数据可以存储在内存中。
Python中的变量是用标识对象或引用对象的。Python作为一种面向对象的编程语言，它的实例、函数、方法、类都是对象，所有的Python对象都拥有三个属性：身份、类型和值。
- 身份：每个对象都有一个唯一身份用于标识自己，可以使用内建函数id()来得到这个身份标识。
- 类型：对象的类型决定了该对象可以保存什么类型的值，可以进行怎样的操作，可以使用内建函数type()查看Python对象的类型。
- 值：对象所代表的内容，可以使用内建print()函数来打印对象的值。
Python需要使用标识符给变量命名，标识符必须以：字母、下划线（_）开头。后跟：字母、数字、下划线（_），区分大小写。
Python标识符规则：
- 标识符可以由字母、数字、下划线（_）组成，其中数字不能打头。
- 标识符不能是Python关键字，但可以包含关键字。解释器在加载上下文的时候，如果遇到一些预先设定的变量值，就会触发解释器内置的一些操作，这些预定的变量值就是关键字。
- 标识符不能包含空格。
- 变量名是区分大小写的。
除了上述变量命名方法之外，骆驼拼写法也很常用。就是将每个单词首字母大写，就像 NumberOfCandies 一样。之所以把这种拼写方法叫做骆驼拼写法，是因为这种形式看上去有点像是骆驼的驼峰。
2.3，关键字&内置函数
Python中包含了一系列关键字（None、False等）和内置函数（__foo__、_foo、__foo等），一般也不建议使用它们作为变量名。
- 如果开发者尝试使用关键字作为变量名，Python解释器会报错。
- 如果开发者使用内置函数的名字作为变量名，Python解释器倒不会报错，只是该内置函数就被这个变量覆盖了，该内置函数就不能使用了。
Python中的关键字
False None True and as assert 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 Python的内置函数
abs() all() any() basestring() bin() bool() bytearray() callable() chr() classmethod() cmp() compile() complex() delattr() dict() dir() divmod() enumerate() eval() execfile() file() filter() float() format() frozenset() getattr() globals() hasattr() hash() help() hex() id() input() int() isinstance() issubclass() iter() len() list() locals() long() map() max() memoryview() min() next() object() oct() open() ord() pow() print() property() range() raw_input() reduce() reload() repr() reversed() zip() round() set() setattr() slice() sorted() staticmethod() str() sum() super() tuple() type() unichr() unicode() vars() xrange() Zip() _import_() apply() buffer() coerce() intern exec()
eval()函数：可以对一个字符串对应的表达式求值。
s = '1+2*3-4/5' print(eval(s)) =============== 6.2exec()函数：可以执行由一个字符串对应的程序语句。如果exec(s)没有成功，因为s本身不是一个单纯的表达式，而是一组赋值语句。
s = "print('Hello')" exec(s) ==================== Hello
3，基本类型
Python的数据类型：基本类型、序列类型和映射类型。
- 基本类型：整型、浮点型、布尔型、复数型。
- 序列类型：列表、元组、字符串、Unicode字符串、buffer对象、range 对象。
- 映射类型：字典。
Python的数据类型分为可变和不可变的类型：
- 可变数据类型（列表、集合、字典）：表示允许变量的值发生变化，如果改变了该数据类型的对应变量的值，那么不会重新分配内存空间。即对象的标识（id）不会发生改变。
- 不可变数据类型（字符串、元组和基本类型）：标识不允许变量的值发生变化，如果改变了该数据类型的对象变量的值，那么将重新分配内存空间，相当于是新建了一个对象。
Python中数据类型转换函数：
- int(x)：将x转换为一个整数。
- float(x)：将x转换为一个浮点数。
- complex(real)：创建一个复数。
- str(x)：将对象x转换为字符串。
- repr(x)：将对象x转换为表达式字符串。
- eval(str)：用来计算在字符串中的有效Python表达式，并返回一个对象。
- tuple(s)：将序列s转换为一个元组。
- list(s)：将序列s转换为一个列表。
- set(s)：转换为可变集合。
- dict(d)：创建一个字典。d必须是一个序列(key,value)元组。
- frozenset(s)：转换为不可变集合。
- chr(x)：将一个整数转换为一个字符。
- ord(x)：将一个字符转换为它的整数值。
- hex(x)：将一个整数值转换为一个十六进制字符串。
- oct(x)：将一个整数转换为一个八进制字符串。
3.1，整型
Python3的整型支持各种整数值，不管是小的整数型，还是大的整数值，Python都能轻松处理（不像Java，short、int、long等整型增加了开发难度）。
a = 999999999999999999999999999999999999999999999999999999999999999999999 print(a,type(a)) ===================================== 999999999999999999999999999999999999999999999999999999999999999999999 <class 'int'>如上面程序，Python不会发生溢出等问题，这就是Python的魅力：不搞那些乱七八糟的底层细节，非专业人士也不用关心什么字节之类的细节。Python还允许数值（整型和浮点型）增加下画线作为分隔符，这些下画线并不影响数值本身。
a = 9999_99999999999_9999999999999_99999999999999999999999999999999999999999多个变量赋值，可以用一条语句，同时为多个变量赋值，例如，可以将变量 a、b 和 c 都设置为 1。
a=b=c=1 print(a,b,c) ============ 1 1 1增量赋值，在 Python 3 中，等号可以和一个算术操作符组合在一起，将计算结果重新赋值给左边的变量，这叫作增量赋值。
age=9+1 print(age) =========== 10另外，Python整型支持None值（空值）。
a = None print(a,type(a)) ====================== None <class 'NoneType'>
Python的整型数值有4中表现形式：
- 十进制形式：最普通的整数。
- 二进制形式：以0b或0B开头的整数就是二进制形式的整数。
- 八进制形式：以0o或0O开头的整数就是八进制形式的整数。
- 十六进制形式：以0x或0X开头的整数就是十六进制形式的整数，其中10~15分别以a~f来表示。
a = 0x13 b = 0XaF print(a,b) =================== 19 175
3.2，浮点型
浮点型数值用于保存带小数点的数值，Python的浮点数有两种表示形式：
- 十进制形式：这种形式就是平常简单的浮点数，例如5.12、512.0、0.512。浮点数必须包含一个小数点，否则会被当成整数类型处理。
- 科学计数形式：例如5.12e2（即5.12*10^2）、5.12E2（也是5.12*10^2）。
PS：只有浮点型数值才可以使用科学计数形式表示。例如51200是一个整型值，但512E2则是浮点型数值。Python中不允许除0.不管是整数还是浮点型值。
f1 = 1.2345556 print(f1, type(f1)) f2 = 1.12e2 print(f1) f3 = 5e3 print(f2, type(f2)) ================================ 1.2345556 <class 'float'> 1.2345556 112.0 <class 'float'> #虽然5e3的值是5000，但它依然是浮点型数值，而不是整型值——因为Python会自动将该数值变为5000.0。浮点型在运算使会先将数值转换成二进制的数值表示再做运算，但是在转换成二进制代码表示的时候，存储小数部分的位数会有不够的现象，即无限循环小数，故会有非常小的误差：
print(0.1+ 0.2) ======================= 0.30000000000000004
3.3，布尔型
布尔型是整型的子类，只有True和False两个值（注意大小写区别）。
PS：0、""、()、[]、{}、set()、None和False作为测试条件时均为False，以为是空。
x = False print(type(x)) print(int(x)) y = True print(int(y)) ============== <class 'bool'> 0 1
3.4，复数
Python中可以支持复数，复数的虚部用j或J来表示。如果需要在程序中对复数进行计算（基本不会用到），可导入Python的cmath模块，在该模块下包含了各种支持复数运算的函数。
import cmath a = 3 + 1j b = 4 - 5j print(a+b) print(cmath.sqrt(-1)) ===================== (7-4j) 1j
4，字符串
4.1，字符串和转义字符
字符串的内容几乎可以包含任何字符，英文字符也行，中文字符也行。字符串既可用单引号括起来，也可用双引号括起来，没有任何区别。但是如果需要换行则需要使用三引号。
- 单引号括起来的字符串：'hello'。
- 双引号括起来的字符串："hello"。
- 三引号括起来的字符串：'''hello'''。
注意
- 三引号括起来的字符串可以换行。
- 单引号里面不能再加单引号，但可以加双引号进行转义输出。
- 双引号里面不能再加双引号，但可以加单引号进行转义输出。
#如果字符串包含了单引号，则可以使用双引号将字符串括起来 a = "I'm a trash" b = "he say:'I'm a trash'" print(a,b) c = '''hello\nhello''' print(c) ========================= I'm a trash he say:'I'm a trash' hello hello
如果字符串内容本身包含了单引号或双引号，此时就需要进行特殊处理：
- 使用不同的引号将字符串括起来。
- 对引号进行转义。
常用转义字符：
字符 说明 \t 横向制表符 \n 换行符 \r 回车 \" 双引号 \' 单引号 \\ 反斜杠 \ 续行符 \ooo 值为八进制数的ooo的字符 \xhh 值为十六进制数hh的字符 #还可以使用转义字符 c = "he say:I/'m a trash" print(c) ======================== he say:I'm a trash
4.2，字符串方法
print(li.find('q')) # 返回该元素最小的索引，字符串中未有该元素返回-1 print(li.index('m')) # 返回该元素最小的索引，字符串中未有该元素报错 print(li.replace('name', 'mingzi', 2)) # 替换字符串中元素 print(li.split('i')) print(type(li.split('i'))) # 以liep来分割字符串，并返回列表。liep默认为None,分割默认为空格 print(li.replace('name', 'mingzi', 1)) # 替换 name 次数不超过1 print(li.split('i')) # 以i来分割字符串,并返回列表,分割默认为空格。 print(li.startswith('name', 3)) # 判断字符串是否以前缀开始，返回为bool值。 print(li.endswith('Amy')) # 判断字符串是否以尾缀结束，返回为bool值。 print(li.lower()) # 将字符串全部转为小写 print(li.upper()) # 将字符串全部转为大写 print(li.strip()) # 默认去掉字符串左右的空格 print(li.isalpha()) # 判断字符串是否全为字母，返回的是bool值 print(li.isdigit()) # 判断字符串是否全为数字，返回的是bool值 print(li.isalnum()) # 判断字符串是否全为数字或者字母，不存在特殊字符，返回的是bool值 print(' '.join(li)) # 将序列中的元素以指定的字符连接生成一个新的字符串
4.3，字符串拼接
字符串拼接字符串：Python使用（+）作为字符串的拼接运算符。
a = "I'm" b = "a trash" print(a+b) ============ I'ma trash
字符串拼接数值：在Python中不允许直接拼接数值和字符串，程序必须先将数值转换成字符串。为了将数值转换成字符串，可以使用str()或repr()函数。
a = "我的编号是：" b = 12138 print(a+str(b)) print(a+repr(b)) ================ 我的编号是：12138 我的编号是：12138str()和repr()函数都可以直接将数值转换成字符串。此外，repr还有一个功能，它会以Python表达式的形式来表示值。
a = "我的编号是：'12138'" print(str(a)) print(repr(a)) =================== 我的编号是：'12138' "我的编号是：'12138'"从结果可以看出，如果直接使用print()函数输出字符串，将只能看到字符串的内容，没有引号；但如果先使用repr()函数对字符串进行处理，然后再使用print()执行输出，将可以看到带引号的字符串——这就是字符串的Python的表达式形式。
4.4，格式化输出
Python提供了“%”对各种类型的数据进行格式化输出：
price = 108 print("the book's price is %s" %price) ====================================== the book's price is 108代码中的print函数包含三个部分：
- 第一部分是格式化字符串，包含一个“%s”占位符，它会被第三部分的变量或表达式的值代替；
- 第二部分固定使用“%”作为占位符，它会被第三部分的变量或表达式代替。“%s”指定将变量或值使用str()函数转换为字符串。
- 如果第三部分包含多个“%s”占位符，第三部分也应该对应提供多个变量。
price = 108 print("the book's name is %s price is %s" %("荒古遗精宝典",price)) ============================================== the book's name is 荒古遗精宝典 price is 108实际上，Python提供了大量的转换说明符：
转换说明符 说明 d，i 转换为带符号的十进制形式的整数 o 转换为带符号的八进制形式的整数 x 转换为带符号的十六进制形式的整数 X 转换为带符号的十六进制形式的整数 e 转换为科学计数法表示的浮点数（e小写） E 转换为科学计数法表示的浮点数（E大写） f，F 转换为十进制形式的浮点数 g 智能选择使用f或e格式 G 智能选择使用F或E格式 C 转换为单字符（只接受整数或单字符字符串） r 使用repr()将变量或表达式转换为字符串 s 使用str()将变量或表达式转换为字符串 x = -12138 print("%6i" %x) print("%6o" %x) print("%6x" %x) print("%6X" %x) print("%6s" %x) ================= -12138 -27552 -2f6a -2F6A -12138从结果可以看出，此时指定了字符串的最小宽度为6，因此程序转换数值时总宽度为6，程序自动在数值前面补充三个空格。
在默认情况下，转换出来的字符串总是右对齐，不够宽度时左边补充空格。Python也允许在最小宽度之前添加一个标志来改变这种行为，Python支持如下标志：
- - ：指定左对齐。
- +：表示数值总要带着符号。
- 0：表示不补充空格，而是补充0。
x = 12138 print("%-6i" %x) print("%-6o" %x) print("%-+6x" %x) print("%-06X" %x) print("%-6s" %x) ================== 12138 27552 +2f6a 2F6A 12138对于浮点数，Python还允许指定小数点后的数字位数；如果转换的是字符串，Python允许指定转换后的字符串的最大字符数。这个标志位被称为精度值，该精度值被放在最小宽度之后，中间用（.）隔开。
x = 1.213888888 print("%-6.1f" %x) print("%-6.2f" %x) print("%-+6.3f" %x) print("%-06.4f" %x) print("%-6.5s" %x) ==================== 1.2 1.21 +1.214 1.2139 1.213
还有另外的一种表示方式就是使用str.format()
print("{0} is taller than {1}.".format("燕双嘤","杜马")) ======================================================= 燕双嘤 is taller than 杜马.%和.format的区别：
c=(250,250) print("坐标：%s"%c) print("坐标：{}".format(c))其中%形式的输出会报错，需要进行调整。
print("坐标：%s"%(c,))所以一般情况下，使用%已经足够满足程序的需求，但是像上面这种需要在一个位置添加元素或列表类型的情况，最好选择format方法。
4.5，查找、替换
str还提供了如下常用的执行查找、替换等操作的方法。
- startswitch()：判断字符串是否可以指定子串开头。
- endswitch()：判断字符串是否以指定子串结尾。
- find()：查找指定子串在字符串中出现的位置，如果没有找到指定子串，则返回-1。
- index()：查找指定子串在字符串中出现的位置，如果没有找到指定子串，则引发ValueError错误。
- replace()：使用指定子串替换字符串中的目标。
- translate()：使用指定的翻译映射表对字符串进行替换。
s = "I am a trash" print(s.startswith("Y")) print(s.endswith("h")) print(s.find("am")) print(s.index("am")) print(s.replace("I am","You are")) ================================== False True 2 2 You are a trash映射表
#定义翻译映射表，根据ASCII s = "apple,banana,trash" table = {97:945,98:946,116:964} print(s.translate(table)) ========================= αpple,βαnαnα,τrαsh但是这种方式过于麻烦，需要开发者记住每个字符的编码，而且编码起来极其不便。
#定义翻译映射表，根据ASCII s = "apple,banana,trash" table = str.maketrans("abt","αβτ") print(s.translate(table))
4.6，分割、连接
Python还为str提供了分割和连接方法。
#定义翻译映射表，根据ASCII s = "apple banana trash ysy" print(s.split()) #最多只分割前两个词 print(s.split(None,2)) print(s.split(",")) list = s.split() print("/".join(list)) print("*".join(list)) ===================== ['apple', 'banana', 'trash', 'ysy'] ['apple', 'banana', 'trash ysy'] ['apple banana trash ysy'] apple/banana/trash/ysy apple*banana*trash*ysy
5，基本运算
运算符是一种特殊的符号，用来表示数据的运算、赋值和比较等。Python语言使用运算符将一个或多个操作数连接成可执行语句，用来实现特定功能。
Python语言中的运算符可分为如下几种：赋值运算符、算术运算符、位运算符、索引运算符、比较运算符、逻辑运算符。
5.1，赋值运算
赋值运算符用于为变量或常量指定值，Python使用“=”作为赋值运算符。通常，使用赋值运算符将表达式的值赋给另一个变量。
a = "Python" b = 3.14 c = True print(a, b, c) =============== Python 3.14 True除此之外，也可使用赋值运算符将一个变量的值赋给另一个变量。
a = "Python" b = c = d = e = a f = e + "3" print(a, b, c, d, e, f) ================================= Python Python Python Python Python Python3
5.2，算术运算
Python支持所有的基本算术运算符，这些算术运算符用于执行基本的数学运算，如加、减、乘、除和取余。
运算符 功能 例子 ** 乘方 3**2=9 + 正号（单目运算符） +5=5 - 负号（单目运算符） -5 * 乘法 3*2=6 / 除法 3/2=1.5 // 整除 5//2=2.0,5.9//2=2.0 % 取余 5%2=1 + 加法 3+4=7 - 减法 3-4=-1
取余：取余运算，Python不要求取余运算符的两个操作数都是整数，Python的求余运算符完成支持对浮点数求余。求余运算的结果不一定总是整数，它是使用第一个操作数除以第二个操作数，得到一个整除的结果后剩下的值就是余数。
print(5 % 3) print(5.2 % 3.1) print(-5.2 % -3.1) print(5.2 % -2.9) print(5.2 % -1.5) print(-5.2 % 1.5) print(5 % 0.0) ================= 2 2.1 -2.1 -0.5999999999999996 -0.7999999999999998 0.7999999999999998 Traceback (most recent call last): File "E:/Pycharm/WorkSpace/Study/main.py", line 7, in <module> print(5 % 0.0) ZeroDivisionError: float modulo这里有两个问题：
- 第一个问题：为什么预计5.2%-2.9的结果是-0.6呢？因为Python求余运算的逻辑是用被减数减去除数的N倍，此处的N是-2，因此得到的结果是-0.6。
- 第二个问题：为什么实际输出的是-0.5999999999999996呢？这是由浮点数的存储机制导致的。计算机底层的浮点数的存储机制并不是精确保存每一个浮点数的值，浮点数在Python中可能产生精度丢失的问题就行。比如，此处正常计算的结果应该是-0.6，但实际计算出来的结果是一个非常接近-0.6的值。
5.3，位运算
位运算通常在图形、图像处理和创建设备驱动等底层开发中使用。使用位运算符可以直接操作数值的原始bit位，尤其是在使用自定义的协议进行通信时，使用位运算符对原始数据进行编码和解码也非常有效。
Python支持的位运算符：
- &：按位与。
- |：按位或。
- ^：按位异或。
- ~：按位取反。
- <<：左位移运算符。
- >>：右位移运算符。
位运算法则：
第一个操作数 第二个操作数 按位与 按位或 按位异或 0 0 0 0 0 0 1 0 1 1 1 0 0 1 1 1 1 1 1 0 print(5 & 9) print(5 | 6) ============ 1 7
5.4，比较运算、身份运算符
Python提供了bool类型来表示真（True或1）或假（False或0），比较运算符用于判断两个值之间的大小，比较运算的结果是bool值。Python支持如下比较运算符：>、>=、<、<=、==、!=。
身份运算符：用于比较两个对象的存储单元。包括：is（变量所引用对象）、not is。
print(5 * 5 == 25) print(1 == True, 0 == False) ============================ True True True==与is看上去很相似，但有实质区别，==比较两个变量的值（value），但is要求两个变量引用同一个对象（id）。
import time a = time.gmtime() b = time.gmtime() print(a == b, a is b) ===================== True False实际上，Python提供了一个全局id()函数来判断变量所引用的对象的内存地址，如果两个对象所在的内存地址相同，则说明两个对象其实是同一个对象。由此可见，is判断其实就是要求通过id()函数计算两个对象时返回相同的地址。
import time a = time.gmtime() b = time.gmtime() c = 1 d = 1 print(id(a), id(b), id(c), id(d)) ================================= 2587347852960 2587380144600 1358200944 1358200944
浮点数比较
a = 1;b = 2;c = a + b;e = 3 print(c == e);print(id(c),id(e)) a = 0.1;b = 0.2;c = a + b;e = 0.3; print(c == e);print(c,e) ================================== True 140718566580688 140718566580688 False 0.30000000000000004 0.3用==从语法上说没错，但是本来应该相等的两个浮点数由于计算机内部表示的原因可能略有微小的误差，这时用==就会认为它们不等。简单来说，0.1在二进制下是一个无限循环小数0.00011，计算机在处理小数时，是通过二进制寄存器来存储和计算，长度有限，因此会丢失无限循环小数低位的数字。
所以，不同进制在转换过程中，可能存在失真。 表现为，小数的低位不准。因此使用两个浮点数之间的差异的绝对值小于某个可以接受的值来判断判断它们是否相等。
a = 0.1; b = 0.2 c = a + b ; e = 0.3 tol = 1E -15 # the tolerance print ( abs (c - e ) < tol ) # judgement
5.5，逻辑运算、三目运算、成员运算
逻辑运算符用于操作bool类型的变量、常量或表达式，逻辑运算符的返回值也是bool值。Python的逻辑运算符有三种：and、or、not。
print(1 or 2) print(1 and 2) ============== 1 #因为碰到1的时候就知道整个逻辑运算式的结果肯定为真。 2 #2为否，所以结果为否。print(1 < (2 == 2)) print(1 < 2 == 2) ================== False #(2==2)结果为True，即1,1<1为False。 True #在Python中是连续比较，(1<2)and(2==2)，所以为True。#连续比较 print(True==True==False) ======================== False #实际逻辑关系：(True==True) and (True==False)print("B" and "A" or "C") print(bool("A"), bool("B"), bool("C")) ========================= A #对于x or y来说，如x为真，那么值为x，否则为y。 True True True #对于x and y来说，如果x为真，那么值为y，否则为x。 #“A”为True的原因：“A”不是空字符串。
Python中实际上没有三目运算符，但是可以用if来代替。
- 三目运算符的语法：True_statement if expression else False_statement
- 三目运算符的规则：先对逻辑表达式expression求值，如果逻辑表达式返回True，则执行并返回True_statement的值；如果逻辑表达式返回False，则执行并返回False_statement的值。
a = 5 b = 3 flag = "a 大于 b" if a > b else "b 大于 a" print(flag) ======================================== a 大于 b
Python提供了in运算符，用于判断某个成员是否位于序列中。除此之外，Python还提供了not in。
a = "我是个废物" print("废物" in a) print("我" not in a) =================== True False
5.6，运算符的优先级
运算符说明 Python运算符 优先级 索引运算符 x[index]或x[index:index2[:index3]] 18、19 属性访问 x.attribute 17 乘方 ** 16 按位取反 ~ 15 符号运算符 +或- 14 乘、除 *、/、//、% 13 加、减 +、- 12 位移 >>、<< 11 按位与 & 10 按位或 | 9 比较运算符 ==、!=、>、>=、<、<= 8 is运算符 is、is not 7 in运算符 in、not in 6 逻辑非 not 4 逻辑与 and 3 逻辑或 or 2
扫一扫
1328
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
