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是编译型+解释型语言。

编译原理：引论_燕双嘤-CSDN博客之前一直忙于比赛项目，疏忽对编译原理的学习，从此日更编译原理，往监督。一，万恶的开始语言特点举例高级语言符合人们的习惯，更容易理解和修改。int x = 2;汇编语言具有一定意义的文字命令，与机器语言一一对应。MOV x 2机器语言二进制命令，能被计算机直接识别。C706 0000 0002二，编...https://shao12138.blog.csdn.net/article/details/105181329#t2

解释型

解释型语言是指使用专门的解释器对源代码逐行解释成特定平台的机器码并立即执行的语言。解释型语言通常不会进行整体性的编译和链接处理，解释型语言相当于把编译型语言中的编译和解释过程混合到一起同时完成。

可以认为：每次执行解释型语言的程序都需要进行一次编译，因此解释型语言的运行效率通常较低，而不能脱离解释器独立运行。但解释型语言有一个优势，就是跨平台比较容易，只需提供特定平台的解释器即可，每个特定平台上的解释器都负责将源程序解释成特定平台的机器指令。解释型语言可以方便地实现源程序级的移植，但这是以牺牲程序执行效率为代价的。

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.2

exec()函数：可以执行由一个字符串对应的程序语句。如果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'))
# 返回该元素最小的索引，字符串中未有该元素返回-1print(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 次数不超过1print(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
我的编号是：12138

str()和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 timea = 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

Python：简介，变量，字符串，运算符相关推荐

  1. python的变量、运算符与数据类型(day1)

    python的变量.运算符与数据类型(day1) python的语法区分大小写,小括号和双引号需要在英文半角下输入. python的注释 单行注释用"#" (作用于整行) 语法如下 ...

  2. python定义变量字符串_Python学习笔记二（变量和字符串）

    2017年年终确定的从2018年开始学习一门新的语言.随着机器学习人工智能的日渐深入,是时候有必要掌握以下Python了.博客今天更新第二篇学习记录,关于Python的变量和变量中字符串的使用,所有学 ...

  3. c语言字符串用for语句去重,python简介、第一个python程序、变量、字符编码、用户交互程序、if...else、while、for...

    也愿大家永葆初心-- 已识乾坤大,犹怜草木青. 一.python简介 首先,我们普及一下编程语言的基础知识.用任何编程语言来开发程序,都是为了让计算机干活,比如下载一个MP3,编写一个文档等等,而计算 ...

  4. python变量运算符_Python(三) 变量与运算符

    一.什么是变量 变量 = [1,2] 二.变量的命名规则 字母,数字,下划线,首字母不能是数字 系统关键字 不能用在变量名中 保留关键字 区别大小写 a=1,   a='1',   a=(1,2),  ...

  5. Python基础—简介、变量、运算符

    文章目录 一.基础简介 1.Python简介 2.执行过程 二.变量 三.数据类型 1.数字 2.字符串 3.布尔bool 4.空值对象None 5.列表 6.字典 7.数据类型转换 重点 四.格式化 ...

  6. day1 简介,变量,用户输入,字符串拼接,列表,元组,字典

    1.python 简介 一.python简介 python的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的 ...

  7. 刻意练习：Python基础 -- Task01. 变量、运算符与数据类型

    背景 我们准备利用17天时间,将 Python 基础的刻意练习分为如下任务: Task01:变量.运算符与数据类型(1day) Task02:条件与循环(1day) Task03:列表与元组(2day ...

  8. python字符串与列表与运算_[Python学习笔记1]Python语言基础 数学运算符 字符串 列表...

    这个系列是我在学习Python语言的过程中记录的笔记,主要是一些知识点汇总,而非学习教程,可供有一定编程基础者参考.文中偏见和不足难以避免,仅供参考,欢迎批评指正. 本系列笔记主要参考文献是官网文档: ...

  9. python学习笔记一 一变量与运算符

    #声明的三种格式 #格式1 s1 = '我爱una' #格式2 s2 = s1 = 'i love una' #格式3 s1,s2,s3 = '我爱una','i love una',52099 变量 ...

  10. python有没有三元运算符_Python基础入门：从变量到异常处理（1）

    一.学习内容概括 二.具体学习内容 2.1 变量与运算符 2.2.1 注释 1. # #:单行注释,作用于整行. 2. 三引号 ''' '''或者""" "&q ...

最新文章

  1. 在PHP语言中使用JSON
  2. 高斯混合模型图像聚类、图像生成、可视化分析实战
  3. goland 报错 Main file has non-main package or doesn’t contain main function
  4. Linux下的kill函数的用法
  5. VTK：标记网格用法实战
  6. 阿里高级技术专家方法论：如何写复杂业务代码？
  7. pymssql 安装后只有 .disk-info_龙虎榜之防盗扣安装榜主—王兰香
  8. linux 运行库 编译参数,Linux/CentOS 升级C基本运行库CLIBC的注意事项（当想解决GLIBC_2.x找不到的编译问题）...
  9. Ant for Vue - input、select组件placeholder无法显示
  10. Android系统 miui主题6,miui主题工具-miui主题工具最新版v2.6.2 安卓版_永辉资源网
  11. lzg_ad:EWF RAM Reg模式原理介绍
  12. el table 固定表头和首行_再谈table组件：固定表头和表列
  13. 锐明部标视频设备和博实结设备对部标1078协议支持程度评测对比
  14. 课堂秩序难管理？这个方法造福师生
  15. 问题：阿里云RDS数据库Binlog日志一直增大，撑爆磁盘
  16. 机器学习算法——集成学习1（个体与集成）
  17. 如何使用《背景音乐提取器》提取歌曲中的伴奏
  18. 使​​用Hashicorp Vault管理PKI并颁发证书
  19. 基于java的社区志愿者服务系统
  20. java绝对值怎么取

热门文章

  1. 王者荣耀中的数学原理及游戏策略(一)防御篇(护甲|魔抗|伤害运算机制)
  2. 长虹电视机卡在android,长虹电视死机怎么办 长虹电视突然死机原因及解决方法...
  3. 【Http Referer】
  4. 仿拼多多拼单成功的弹幕队列消息提醒
  5. android note分析,随记你的掌上灵感 三星S Note功能解析
  6. 买房常识不得不知 你知道房子买第几层最好吗(图
  7. 【Vue学习】基础语法（五）
  8. 玩转云镜像制作之packer篇
  9. 供应链环境下企业采购管理的创新
  10. 微信小程序| 用小程序复刻微信Wechat