一、Python解释器
| 解释器 | 说明 |
|---|---|
| Cpython | 官方，C语言开发，最广泛的Python解释器 |
| Ipython | 一个交互式、功能增强的Cpython |
| pypy | Python语言写的Python解释器，JIT技术，动态编译Python代码 |
| Jython | Python的源代码编译成Java的字节码，跑在JVM上 |
| IronPython | 与Jython类似，运行在.Net平台上的解释器，Python代码被编译成.Net的字节码 |
| Satckless | Python的增强版本解释器，不使用CPython的C的栈，采用微线程（协成）概念编程，并发编程 |
二、基础语法
1、注释
#井号标注的文本
2、数字
1、整数int
Python3开始不再区分long、int，long被重命名为int，所以只有int类型了
进制表示：
- 十进制10
- 十六进制0xa
- 八进制0010
- 二进制0b10
2、bool类型
有2个值True、False
3、浮点数float
- 1.2、3.1415、-0.12,1.46e9等价于科学计数法1.46*109
- 本质上使用了C语言的double类型
4、复数complex
- 1+2j或1+2]
3、字符串
-
使用' "单双引号引用的字符的序列
-
"和""单双三引号，可以跨行、可以在其中自由的使用单双引号
示例：
a = 'abc'
print(a)
abc
b = 'abcd'
print(b)
abcd
c = "abc'de"
print(c)
abc'de
d = 'abc\'de' # 反斜杠称为转义字符，使他不能成为当前默认意义
print(d)
abc'de
e = '''abcde'
fg'''
print(e) # 三引号可以换行，当使用print函数打印时会自动换行
abcde'
fg
>>> '''abcde'
... fg'''
"abcde'\nfg" # 控制台打印会输出换行符
- r前缀：在字符串前面加上r或者R前缀，表示该字符串不做特殊的处理
- f前缀：3.6版本开始，新增F前缀，格式化字符串
示例：
dir = 'c:/windows/nt' # windows支持\/
print(dir)
c:/windows/nt
>>> d = 'c:\windows\nt'
>>> d
'c:\\windows\nt' # \本义是转义符，在他前面加一个\,它就是指我就是反斜杠了
d = 'c:\windows\nt' # \n代表换行
print(d)
c:\windows
t
e = 'c:\\windows\\nt'
print(e)
c:\windows\nt
f = r'c:\windows\nt' # r前缀将字符串不转义
print(f)
c:\windows\nt
a = 'abc'
b = 123
c = f'{a}****{b}' # f前缀，插值字符串
print(c)
abc****123
4、转义序列
-
\\ \t \n \' \" -
前缀r，把里面的所有字符当普通字符对待，则转义字符就不转义了。
转义：让字符不再是它当前的意义，例如\t,t就不是当前意义字符t了，而是被\转成了tab键
示例：
print("a\tb\nc\td e") # \t \n space为不可见字符（空白字符），代表一个字符
a b
c d e
5、缩进
- 未使用C等语言的花括号，而是采用缩进的方式表示层次关系
- 约定使用4个空格缩进
6、续行
- 在行尾使用\，注意\之后除了紧跟着换行之外不能有其他字符
- 如果使用各种括号，认为括号内是一个整体，其内部跨行不用\
示例
a = 'abcdef' \
'gh'
print(a)
abcdefgh
7、标识符
1、标识符
- 1、一个名字，用来指代一个值
- 2、只能是字母、下划线和数字
- 3、只能以字母或下划线开头
- 4、不能是python的关键字，例如def、class就不能作为标识符
- 5、Python是大小写敏感的
标识符约定：
- 不允许使用中文，也不建议使用拼音
- 不要使用歧义单词，例如class_
- 在python中不要随便使用下划线开头的标识符
2、常量
- 一旦赋值就不能改变值的标识符
- python中无法定义常量
3、字面常量
- 一个单独的不可变量，例如12、"abc"、'2341356514.03e-9'
4、变量
赋值后，可以改变值的标识符
5、标识符本质
每一个标识符对应一个具有数据结构的值，但是这个值不方便直接访问，程序员就可以通过其对应的标识符来访问数据，标识符就是一个指代。一句话，标识符是给程序员编程使用的。
8、语言类型
python 是动态语言，强类型语言。
1、静态语言
- 事先声明变量类型，之后变量的值可以改变，但值的类型不能再改变
- 编译时检查
2、动态语言
- 不用事先声明类型，随时可以赋值为其他类型
- 编程时不知道是什么类型，很难推断
3、强类型语言
- 不同类型之间操作，必须先强制类型转换为同一类型。
print('a'+1)
4、弱类型语言
- 不同类型间可以操作，自动隐式转换，JavaScript中
console.log(1+'a')
但是要注意的是，强与弱只是一个相对概念，即使是强类型语言也支持隐式类型转换。
例如
>>> type('1')
int
>>> type('abc')
str
>>> type(1 + 2)
int
>>> type(1 + 2.1 + True) # int+ float => float 隐式类型转换
float
a = str(1) + 'a' # 字符串的加法就是拼接，1无法直接和'a'相加，必须通过str(1)进行强制类型转换
print(a)
1a
9、进制
常见进制有二进制、八进制、十进制、十六进制。应该重点掌握二进制、十六进制。
十进制逢十进一；十六进制逢十六进一；二进制逢二进一
每8位（bit)为1个字节（byte)。
一个字节能够表示的整数的范围：
无符号数0~0XFF，即0到255，256种状态
有符号数，依然是256种状态，去掉最高位还剩7位，能够描述的最大正整数为127,那么负数最大就为-128。也就是说负数有128个，整数有127个，加上0,共256种。
| 特殊二进制数0b | 十进制 | 十六进制0x |
|---|---|---|
| 1 | 1 | 1 |
| 11 | 3 | 3 |
| 111 | 7 | 7 |
| 1111 | 15 | F |
| 11111 | 31 | 1F |
| 111111 | 63 | 3F |
| 1111111 | 127 | 7F |
| 11111111 | 255 | FF |
| 100000000 | 256 | 100 |
二进制中最低位为1，一定是奇数；最低位为0，一定是偶数
| 特殊十六进制0x | 十进制 |
|---|---|
| 9 | 9 |
| A | 10 |
| D | 13 |
| 20 | 32 |
| 30 | 48 |
| 31 | 49 |
| 41 | 65 |
| 61 | 97 |
| 7F | 127 |
| FF | 255 |
| FE | 254 |
10、码制
1、原码
- 5=>0b101，1=>0b1，-1=>-0b1，bin(-1)
二进制 十六进制 八进制
>>> bin(1),hex(1),oct(1)
('0b1', '0x1', '0o1')
2、反码
- 正数的反码与原码相同
- 负数的反码符号位不变其余按位取反
3、补码
- 正数的补码与原码相同
- 负数的补码符号位不变其余按位取反后+1
- 补码的补码就是原码
4、负数表示法
- 早期数字电路的CPU中的运算器实现了加法器，但是没有减法器，减法要转换成加法
- 负数在计算机中使用补码存储，-1的补码为1111 1111
- 5-1=>5+(-1)直觉上是0b101-0b1，其实计算机中是0b101+0b11111111，溢出位舍弃
11、False等价
| 对象/常量 | 值 |
|---|---|
| " " | 假 |
| "string" | 真 |
| 0 | 假 |
| >=1 | 真 |
| <=-1 | 真 |
| ()空元组 | 假 |
| []空列表 | 假 |
| {}空字典 | 假 |
| None | 假 |
False等价布尔值，相当于bool(value)
例如
>>> bool(0.1), bool(-0.000001), bool(0.0000)
(True, True, False)
- 空容器
- 空集合set
- 空字典dict
- 空列表list
- 空元组tuple
- 空字符串
- None
- 0
12、逻辑运算真值表
13、运算符Operator
1、算术运算符
- +、-、*、/、//向下取整整除、%取模、**幂
注：在Python2中/和//都是整除。
示例：
>>> 1/2 # 除法
0.5
>>> 1//2 # 整除
0
>>> 2 ** 3 # 2的3次方
8
>>> 2**0.5 # 2的开方
1.4142135623730951
2、位运算符
- &位与、|位或、^异或、<<左移、>>右移
- ~按位取反，包括符号位
>>> 10 % 2, 10 % 3
(0, 1)
>>> 5 & 3, 5 | 3, 5 ^ 3
(1, 7, 6)
>>> 1 << 0, 1 << 1, 1 << 2
(1, 2, 4)
>>>
>>> ~12
-13
>>> 10 ^ 9, 10 ^ -9
(3, -3)
3、比较运算符
==、!=、>、>=、<、<=
链式比较： 4 > 3 > 2
比较运算符，返回一个bool值，要求同类型比较
>>> 1 == 'abc', 'a' != 100
(False, True)
4、逻辑运算符
与and、或or、非not
逻辑运算符也是短路运算符
-
and 如果前面的表达式等价为False，后面就没有必要计算了，这个逻辑表达式最终一定等价为 False
-
or 如果前面的表达式等价为True，后面没有必要计算了，这个逻辑表达式最终一定等价为True 1 or False or None
-
特别注意，返回值。返回值不一定是bool型
-
把最频繁使用的，做最少计算就可以知道结果的条件放到前面，如果它能短路，将大大减少计算量
>>> 1 and 'abc' # 把所操作的数值当做真或假来进行逻辑运算，完了之后返回的还是原来的值
'abc'
>>> 1 and 'xyz' and 0.0
0.0
5、赋值运算符
a = min(3, 5)
+=、 -= 、*=、/=、%=、//= 等
x = y = z = 10
6、成员运算符
in、not in
7、身份运算符
is 、is not
14、运算符优先级
| 运算符 | 描述 | 运算符 | 描述 |
|---|---|---|---|
| 'expr' | 字符串转换 | x+y,x-y | 加，减 |
| {key:expr,...} | 字典 | x<<y,x>>y | 移位 |
| [expr1,expr2...] | 列表 | x&y | 按位与 |
| (exprl,expr2,...) | 元组 | x^y | 按位异或 |
| function(expr,...) | 函数调用 | xly | 按位或 |
| x[index:index] | 切片 | x<y,x<=y,x==y,x!=y,x>=y,x>y | 比较 |
| x[index] | 下标索引取值 | x is y , x is not y | 等同测试 |
| x.attribute | 属性引用 | x in y , x not in y | 成员判断 |
| ~x | 按位取反 | not x | 逻辑否 |
| +X,-X | 正，负 | x and y | 逻辑与 |
x**y | 幂 | x or y | 逻辑或 |
| x*y,x/y,x%y | 乘，除，取模 | lambda arg,...:expr | Lambda匿名函数 |
- 单目运算符 > 双目运算符
- 算数运算符 > 位运算符 > 比较运算符 > 逻辑运算符
- -3 + 2 > 5 and 'a' > 'b'
- 搞不清楚就使用括号。长表达式，多用括号，易懂、易读
15、表达式
由数字、符号、括号、变量等的组合。有算数表达式、逻辑表达式、赋值表达式、lambda表达式等。
Python中，赋值即定义。Python是动态语言，只有赋值才会创建一个变量，并决定了变量的类型和值。
如果一个变量已经定义，赋值相当于重新定义。
三、内建函数
| 内建函数 | 函数签名 | 说明 |
|---|---|---|
| print(value, ..., sep=' ', | ||
| end='\n') | 将多个数据输出到控制台，默认使用空格分隔、 \n换行 | |
| input | input([prompt]) | 在控制台和用户交互，接收用户输入，并返回字符串 |
| int | int(value) | 将给定的值，转换成整数。int本质是类 |
| str | str(value)) | 将给定的值，转换成字符串。str本质是类 |
| type | type(value) | 返回对象的类型。本质是元 |
| isinstance | isinstance(obj,class or tuple | 比较对象的类型，类型可以是obj的基类 |
print(1, 2, 3, sep='\n', end='***') # 以换行作为分隔符，以***结尾
1
2
3***
type(1) # 返回的是类型，不是字符串
type('abc') # 返回的是类型，不是字符串
type(int) # 返回type,意思是这个int类型由type构造出来
type(bool) # 返回type,也是类型
type(str) # 返回type,也是类型
type(type) # 也是type
print(isinstance(1, int)) # True
print(isinstance(False, bool)) # True
print(isinstance(False, int)) # True
isinstance(True, (str, int, bool)) # True
type(1 + True) <class 'int'>
type(1 + True + 2.0) # 什么类型？<class 'float'>#即使是强类型语言，也会有隐式类型转换
四、数值型
- int、float、complex、bool都是class,1、5.0、2+3j都是对象即实例
- int：python3的int就是长整型，且没有大小限制，受限于内存区域的大小
- float：由整数部分和小数部分组成。支持十进制和科学计数法表示。C的双精度型实现
- complex：有实数和虚数部分组成，实数和虚数部分都是浮点数，3+4.2J
- bool：int的子类，仅有2个实例True、False对应1和0,可以和整数直接运算
1、类型转换
- int、float、complex、bool也可以当做内建函数对数据进行类型转换
- int(x)返回一个整数
- float(x)返回一个浮点数
- complex(x)、complex(x,y)返回一个复数
- bool(x)返回布尔值，前面讲过False等价的对象
2、整除
math模块的floor()、ceil()函数；内建函数int()、round()；运算符//
# 整除，向下取整
print(3 // 2, 5 // 2, 7 // 2)
print(-3 // 2, -5 // 2, -7 // 2)
print(7 // 2, 7 // -2, -7 // 2, -(7 // 2))
1 2 3
-2 -3 -4
3 -4 -4 -3
# int 整数
print('int ------------')
print(int(1.4), int(1.5), int(1.6))
print(int(-1.4), int(-1.5), int(-1.6))
int ------------
1 1 1
-1 -1 -1
# ceil floor
print('ceil floor ---------------1')
import math # 导入math模块使用
print(math.floor(2.5), math.floor(-2.5)) # floor作用是地板
print(math.ceil(2.5), math.ceil(-2.5)) # ceil作用是天花板
ceil floor ---------------1
2 -3
3 -2
# round 正好.5的时候找离他最近的偶数，四舍六入五取偶
print('round -------------')
print(round(1.4), round(-1.4), round(-1.6), round(1.6))
print(round(2.4), round(-2.4), round(2.6), round(2.6))
print('round .5---------')
print(round(0.5), round(1.5), round(2.5), round(3.5))
print(round(-0.5), round(-1.5), round(-2.5), round(-3.5))
round -------------
1 -1 -2 2
2 -2 3 3
round .5---------
0 2 2 4
0 -2 -2 -4
- round(),四舍六入五取偶
- math.floor()向下取整
- math.ceil()向上取整
- int()取整数部分
- //整除且向下取整
3、常用数值处理函数
- min()、max()
- pow(x,y)等于
x**y - math.sqrt()等于
x**0.5 - 进制函数，返回值是字符串
- bin()、oct()、hex()
- math模块
- math.pi π
- math.e自如常数
- math模块中还有对数函数、三角函数等
print(max([1, 2, 3]))
print(min(['a', 'b', 'c']))
3
a
五、程序控制
- 顺序
- 按照先后顺序一条条执行
- 例如，先洗手，再吃饭，再洗碗
- 分支
- 根据不同的情况判断，条件满足执行某条件下的语句
- 例如，先洗手，如果饭没有做好，玩游戏；如果饭做好了，就吃饭；如果饭都没有做，叫外卖
- 循环
- 条件满足就反复执行，不满足就不执行或不再执行
- 例如，先洗手，看饭好了没有，没有好，一会来看一次是否好了，一会儿来看一次，直到饭 好了，才可是吃饭。这里循环的条件是饭没有好，饭没有好，就循环的来看饭好了没有
1、单分支
if condition:
代码块
if 1 < 2: # if True:
print('1 less than 2') # 代码块
- condition必须是一个bool类型，这个地方有一个隐式转换bool(condition)，相当于False等价
- if 语句这行最后，会有一个冒号，冒号之后如果有多条语句的代码块，需要另起一行，并缩进
- if、for、def、class等关键字后面都可以跟代码块
- 这些关键后面，如果有一条语句，也可以跟在这一行后面。例如if 1>2: pass
2、多分支
if condition1:
代码块1
elif condition2:
代码块2
elif condition3:
代码块3
......
else:
代码块
例如
a = 5
if a < 0:
print('negative')
elif a == 0: # 相当于 a >= 0
print('zero')
else: # 相当于 a > 0
print('positive')
- 多分支结构，只要有一个分支被执行，其他分支都不会被执行
- 前一个条件被测试过，下一个条件相当于隐含着这个条件
# 嵌套
a = 5
if a == 0:
print('zero')
else:
if a > 0:
print('positive')
else:
print('negative')
3、while循环
while循环多用于死循环，或者不明确知道循环次数的场景
while cond:
block
while True: # 死循环
pass
a = 10
while a: # 条件满足则进入循环
print(a)
a -= 1
4、for语句
for element in iteratable: # 可迭代对象中有元素可以迭代，进入循环体
block
for i in range(0, 10): # 遍历，容器中所有的元素不重复的取一遍
print(i)
| 内建函数 | 函数签名 | 说明 |
|---|---|---|
| range | range(stop) range(start, stop[, step]) | 返回惰性的对象可以生成一个序列，遍历它就可以得到这个序列的一个个 元素/前包后不包 |
# 计数器
for i in range(0):
print(i)
print('---------')
for i in range(-2):
print(i)
print('---------')
for i in range(1):
print(i)
range(i)，i大于0，相当于计数器。
例如
打印1到10
for i in range(10):
print(i + 1)
1
2
3
4
5
6
7
8
9
10
for i in range(1,11):
print(i)
打印10以内的奇数
for i in range(0, 10):
if i % 2 != 0: # 或者if i % 2 == 1:，
print(i)
1
3
5
7
9
for i in range(1, 10, 2):
print(i)
打印10以内的偶数
for i in range(0, 10):
if i % 2 == 0:
print(i)
0
2
4
6
8
for i in range(0, 10, 2):
print(i)
倒着打印10以内的奇数或偶
for i in range(8, -1, -2):
print(i)
8
6
4
2
0
for i in range(9, 0, -2):
print(i)
9
7
5
3
1
打印2的0次寡到10次寡的值
for i in range(11):
print(i, 2 ** i)
0 1
1 2
2 4
3 8
4 16
5 32
6 64
7 128
8 256
9 512
10 1024
5、continue
跳过当前循环的当次循环，继续下一次循环
for i in range(0, 10):
if i % 2 != 0: continue
print(i)
0
2
4
6
8
for i in range(10):
if i % 2 != 0:
continue
print(i)
for i in range(10):
if i & 1: continue
print(i)
6、break
结束当前循环
练习：计算1000以内的被7整除的前20个正整数（for循环）
count = 0
for i in range(7, 1000, 7):
count += 1
if count >= 20:
print(count, i)
break
总结:
- continue和break是循环的控制语句，只影响当前循环，包括while、for循环
- 如果循环嵌套，continue和break也只影响语句所在的那一层循环
- continue和break 只影响循环，所以 if cond: break 不是跳出if，而是终止if外的break所在的循环
- 分支和循环结构可以嵌套使用，可以嵌套多层。
7、else子句
如果循环正常结束，else子句会被执行，即使是可迭代对象没有什么元素可迭代
for i in range(0): # 可迭代对象没有迭代
pass
else:
print('ok')
for i in range(0, 10):
break
else:
print('ok')
for i in range(0, 10):
continue
else:
print('ok')
有上例可知，一般情况下，循环正常执行，只要当前循环不是被break打断的，就可以执行else子句。 哪怕是range(0)也可以执行else子句。
7、三元表达式
在Python中，也有类似C语言的三目运算符构成的表达式，但python中的三元表达式不支持复杂的语句
真值表达式 if 条件表达式 else 假值表达式
三元表达式比较适合简化非常简单的if-else语句。
# 判断用户的输入的值，如果为空，输出"empty"，否则输出该值
value = input('>>>')
if value:
print(value)
else:
print('empty')
value = input('>>>')
print(value if value else 'empty')
评论区