[toc]

码好python的每一篇文章.

)

1. 基础语法

1.1 注释

在编写代码的时候，有些代码不需要执行或增加代码说明，那么就需要用到注释了。

被注释的文本或代码是不会被执行的。

注释可以使用如下三种方式：

• \# 号

# 第一个注释，本行代码不会运行
print("hello world!") # 第二个注释

• ''' 三个单引号

也叫块注释，支持换行。

'''
第一行注释，本行代码不会运行
第二行注释，本行代码不会运行
第三行注释，本行代码不会运行
'''
print('hello world!')

• """ 三个双引号

也叫块注释，支持换行。

"""
第一行注释，本行代码不会运行
第二行注释，本行代码不会运行
第三行注释，本行代码不会运行
"""
print('hello world!')

1.2 转义字符

常用的转义符：

• \ 行尾，用于续行

>>> print("www\
.python.\
org")
# 输出结果
www.python.org

• ''\"，两个反双斜杠，转义为1个反斜杠 \

非正常结果 示例：

>>> str = 'c:\windows\note'
>>> print(str)
# 输出结果：' \n '当作换行来用了，才会出现如下情况
c:\windows
ote

正常结果 示例：

#把'\n'改成'\\n'就可以解决了
>>> str = 'c:\windows\\note'
>>> print(str)
# 修改后输出结果：
c:\windows\note

1.3 缩进

严格约定使用4个 空格 和一个 制表符 (tab)作为缩进，切记不能混用，否则报错IndentationError

def fun():
    print('hello world')
    print('hello world')

1.4 标识符

标识符的本质是对应具体数据结构的值，因该值不能被程序员直接访问，所以需要通过调用标识符来访问。

标识符格式定义的要求：

• 由字母(a~z)、数字(0~9)、下划线(_)组成；
• 不能以数字开头；
• 不能与python内置相同名；
• 字母大小敏感；
• 不能使用中文、也不建议用拼音

一切都是标识符。
错误标识符 示例：

# 报语法错误，标识符不能以数字开头
>>> 123 = '123'
  File "<stdin>", line 1
SyntaxError: can't assign to literal

# 报语法错误，class是python语言类用到的，不能作为标识符
>>> class = 'abc'
  File "<stdin>", line 1
    class = 'abc'
          ^
SyntaxError: invalid syntax

• 保留标识符

1.5 语言类型

• python是动态语言、强类型语言。

动态编译语言

# 标识符随意切换数据类型
x = 123        # 定义x为整数
x = '123'    # 定义x变为字符串

强类型语言
不同类型之间进行变量赋值时，需要显示地（强制）进行类型转换

>>> x = 123        # 定义x为整数
>>> y = '456'    # 定义y为字符串
# 报类型错误，不同类型不能相加
>>> print(x + y)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'    
# 重新强制修改下为同类型
>>> print(str(x) + y)
123456

• 不用事先声明数据类型，可以随意赋值其他数据类型；

  • 编程时不知道时什么类型，很难推断，这也是python的不好的地方，v3.8严格在这方便做改进；

1.6 运算符

1.6.1 算术运算符

常见的算术运算符：加(+)、减(-)、乘(*)、除(/)、取整(//)、取模(%)、幂(**)

• 加(+) 示例：

>>> test = 1 + 1
>>> print(test)
# 输出结果如下：
2

• 减(-) 示例：

>>> test = 1 - 1
>>> print(test)
# 输出结果如下：
0

• 乘(*) 示例：

>>> test = 1 * 1
>>> print(test)
# 输出结果如下：
1

• 除(/) 示例：

>>> test = 4 / 2
>>> print(test)
# 输出结果如下：
2.0    #结果是一个浮点类型

备注：注意python2.x /和//都是取整。

• 取整(//) 示例：

说明：又叫做向下取整、地板除（往数值小的方向取整数）

>>> test1 = 5 // 2
>>> test2 = -5 // 2
>>> print('test1的结果：',test1)
>>> print('test2的结果：',test2)
# 输出结果如下：
test1的结果： 2        # 实际结果为2.5，靠近2，所以取2
test2的结果： -3    # 实际结果为-2.5，靠近-3，所以取-3

• 取模(%) 示例：

如果都是正数，那么取余和取模都是余数，但特别要注意的地方是使用到正负数，这就要借助一个公式：

*模值*=x % y=x - [x // y] * y

>>> test1 =  5 % 3
>>> test2 = -5 % 3    #模值=-5 % 3=(-5)-[-5//3]*3=(-5)-(-2)*3=-5+6=1
>>> test3 =  5 % -3    #模值=5 % (-3)=5-[5//(-3)]*(-3)=5-(-2)*(-3)=5-6=-1
>>> test4 = -5 % -3    #模值=-5 % (-3)=-5-[-5//(-3)]*(-3)=-5-(1)*(-3)=-5+3=-2
>>> print('test1的结果：',test1)
>>> print('test2的结果：',test2)
>>> print('test3的结果：',test3)
>>> print('test4的结果：',test4)
# 输出结果如下：
test1的结果：  2
test2的结果：  1
test3的结果： -1
test4的结果： -2

• 幂(**) 示例：

>>> test =  2 ** 2
>>> print('tests的结果：',test)
# 输出结果如下：
test的结果： 4

1.6.2 位运算符

位与(&)、位或(|)、异或(^)、左移(<<)、右移(\>\>)

计算机的语言都是0 ,1 表示的二进制，位运算也是以二进制来计算的。

以下示例采用如下两个标识符进行计算:

x = 18    #10进制转为二进制：0001 0010
y = 20     #10进制转为二进制：0001 0100

• 位与(&) 示例：

说明：位与(&)是以二进制计算两者位都是 1 得 1 ,否则都是 0

>>> x = 18
>>> y = 20
>>> print('x & y 结果是：', x & y)
# 输出结果如下：
x & y 结果是： 16

• 位或(|)

说明：位或(|)是以二进制计算两者位有一个 1 得 1 ,否则都是 0

>>> x = 18
>>> y = 20
>>> print('x | y 结果是：', x | y)
# 输出结果如下：
x | y 结果是： 22

• 异或(^)

说明：异或(^)是以二进制计算两者位都有 1 得 0 ,有一个 1得1,其他为 0

>>> x = 18
>>> y = 20
>>> print('x ^ y 结果是：', x ^ y)
# 输出结果如下：
x ^ y 结果是： 6

• 左移(<<)

左移(<<)是整体向最高位(左边)移动位数。

>>> x = 18
>>> y = 20
>>> print('x 左移1位的结果是：', x << 1)
>>> print('y 左移2位的结果是：', y << 2)
# 输出结果如下：
x 左移1位的结果是： 36
y 左移2位的结果是： 80

• 右移(>>)

右移(>>)是整体向最低位(右边)移动位数。

>>> x = 18
>>> y = 20
>>> print('x 右移1位的结果是：', x >> 1)
>>> print('y 右移2位的结果是：', y >> 2)
# 输出结果如下：
x 右移1位的结果是： 9
y 右移2位的结果是： 5

1.6.3 比较运算符

常见的比较运算符：等于(==)、不等于(!=)、大于(>)、大于等于(>=)、小于(<)、小于等于(<=)，返回的结果是布尔(bool)类型。

比较运算只能用于同一数据类型比较(除了==和!=)，比如：同数值类型比较、同字符串比较等。

>>> x = '18'
>>> y = 20
>>> print('比较的结果是：', x < y)
# 输出结果如下：不同类型不能比较
TypeError: '<' not supported between instances of 'str' and 'int'

• 等于(==) 示例：

>>> x = 18
>>> y = 20
>>> print('比较的结果是：', x == y)
# 输出结果如下：
比较的结果是： False

• 不等于(!=) 示例：

>>> x = 18
>>> y = 20
>>> print('比较的结果是：', x != y)
# 输出结果如下：
比较的结果是： True

• 大于(>) 示例：

>>> x = 18
>>> y = 20
>>> print('比较的结果是：', x > y)
# 输出结果如下：
比较的结果是： False

• 大于等于(>=) 示例：

>>> x = 18
>>> y = 20
>>> print('比较的结果是：', x >= y)
# 输出结果如下：
比较的结果是： False

• 小于(<) 示例：

>>> x = 18
>>> y = 20
>>> print('比较的结果是：', x < y)
# 输出结果如下：
比较的结果是： True

• 小于等于(<=) 示例：

>>> x = 18
>>> y = 20
>>> print('比较的结果是：', x <= y)
# 输出结果如下：
比较的结果是： True

1.6.4 逻辑运算符

常见的逻辑运算符：与(and)、或(or)、非(not)

逻辑运算符返回的不一定是布尔类型(bool)，比如：1 and 'abc'返回的是‘abc’

另外，先提前了解下为假(False)对象有如下这些，易于理解：

• 与(and) 示例：

说明：所有条件为真(True)，返回结果才为真，否则为假(False)

x = 1
y = -1    #负数对象都是真(True)
if x and y:
    print('x and y 均为真')
else:
    print('x and y 其中有一个为假')
# 输出结果如下：
x and y 均为真
######################################
x = 1
y = ''    #空字符串对象都是假(False)
if x and y:
    print('x and y 均为真')
else:
    print('x and y 其中有一个为假')
# 输出结果如下：
x and y 其中有一个为假

• 或(or) 示例：

说明：只要有一个条件为真(True)，返回结果为真，否则为假(False)

x = 1
y = []
if x or y:
    print('x or y 为真')
else:
    print('x or y 都为假')
#输出结果如下：
'x or y 为真
######################################
x = 0
y = []
if x or y:
    print('x or y 为真')
else:
    print('x or y 都为假')
#输出结果如下：
x or y 都为假

• 非(not) 示例：

说明：将真假对象置为相反，比如not 对象为True，则变为False，not 对象为False，则变为True

x = 1
if not x:
    print('其实x对象为假')
else:
    print('其实x对象为真')
#输出结果如下：
其实x对象为真
######################################
x = {}
if not x:
    print('其实x对象是假的')
else:
    print('其实x对象是真的')
#输出结果如下：
其实x对象为假

1.6.5 赋值运算符

先来个示例：x = 1, 赋值就是=号右边的数值1赋值给左边的变量x（记住始终先运行右边表达式）。

常见的运算符：=、+=、-=、*=、=、%=、**=、\=

另外，还可以使用链式赋值：x=y=z=1，即x=1,y=1,z=1

简单赋值示例：

>>> x = 1    #右边数值1赋值给了左边X
>>> y = 'hello'    #右边字符串'hello'赋值给了左边y

复杂赋值示例：

>>> x = 1
>>> x += 1    #等价于：x = x + 1，先运行=号右边表达式，在赋值给左边X
>>> print('x的结果是：',x)
#输出结果如下：
2

1.6.6 成员运算符

常见的成员运算符：in 和 not in 。

in 表示x的成员是否在目标y对象里面，如果有则返回True，否则返回False。

>>> x = 'a'
>>> y = 'abcdefg'
>>> print('x的成员在y里面：', x in y)    
#输出结果如下：
x的成员在y里面： True    # x的成员字符串'a'在y的成员字符串里面，所以结果为True

not in 表示x的成员不在目标y对象里面，如果不在返回True，否则返回False。

>>> x = 'a1'
>>> y = 'abcdefg'
>>> print('x的成员不在y里面：', x not in y)
#输出结果如下：
x的成员不在y里面： True    # x的成员字符串'a'在y的成员字符串里面，所以结果为True

1.6.7 身份运算符

身份运算符使用is 和 is not来判断标识符是否在内存地址引用同一对象。

身份运算符经常在字面上容易让大家踩坑，首先要区分下==和 is的区别：

• ==：指的是赋值的内容是否一样；
• is：指的是标识符引用内存地址同一对象,使用id()函数来识别;

这里通过逻辑图演示一下，方便理解：

示例如下：

>>> x = ['a','b','c']
>>> y = ['a','b','c']
>>> print('x的ID是:',id(x))
>>> print('y的ID是:',id(y))
>>> print('x 和 y是否等价(=):',x == y)
>>> print('x 和 y是否在内存地址引用同一对象(id):',x is y)
#输出结果如下：
x的ID是: 1986422101448
y的ID是: 1986422101960
x 和 y是否等价(=): True
x 和 y是否在内存地址引用同一对象(id): False

1.6.8 运算优先级

我们先来看一个运算符例子,请问下该从哪一步算起、第二步...到最后返回的结果是啥？

-1 + 10 > 5 and 2 < 1
# 输出结果如下：
False

运算优先级，从上往下，优先级高到低：

1.7 内建函数

常见的内建函数：

• print 示例：

>>> print('www','python','org',sep='.',end='')    #字符串之间用sep='.'分割，end=''不换行
# 输出结果如下：
www.python.org

• input 示例：
• int 示例：

>>> x = '123'    # '123'为字符串
>>> y = int(x)    # int将字符串'123'转换为整数 123
>>> print('字符串转换为整数：',type(y), y)
# 输出结果如下：
字符串转换为整数： <class 'int'> 123

• str 示例：

>>> x = 123
>>> y = str(x)
>>> print('整数转换为字符串：',type(y), y)
# 输出结果如下：
整数转换为字符串： <class 'str'> 123

• type 示例：

>>> x = '123'
>>> y = 123
>>> print('x是什么类型',type(x))
>>> print('y是什么类型',type(y))
# 输出结果如下：
x是什么类型 <class 'str'>
y是什么类型 <class 'int'>

• isinstance 示例：

>>> x = '123'
>>> y = 123
>>> print('x是整数吗？',isinstance(x, int))
>>> print('y是整数吗？',isinstance(y,(int,str))    #(int,str)位元组，或关系
# 输出结果如下：
x是整数吗？ False
y是整数吗？ True

1.8 循环语句

一个程序能否正常运行，必须的有顺序、分支、循环运行，如果条件控制不对就会导致死循环。

正常的顺序：从上到下一条条执行；

分支：分单分支和多分支，如条件满足则执行条件下的语句；

• 单分支

if 条件:
    代码块

# 示例：
x = 1
if x > 0:    #如条件为真，执行下面代码块
    print('hello world!')

• 多分支

if 条件1:
    代码块
elif 条件2:
    代码块
elif 条件3:
    代码块
...
else:
    代码块

# 示例：
x = 1
if x < 0:
    print("x是负数")
elif x==0:
    print('x是零')
else:
    print('x是正数')

循环：条件满足就反复执行，不满足就不执行；

常见的循环语句：for语句、while语句、continue语句、break语句；

• for 语句

标准格式：

for [元素] in [可迭代对象]:
    代码块

for 语句结合range()函数 示例：
说明：range() 是惰性对象，需要去拨动它，拨一下便返回一个值

#range(stop)，range(5)表示[0,5)前包后不包,返回（0,1,2,3,4）序列，
for i in range(5):
    print(i)
# 输出结果如下：
0
1
2
3
4
#################################################
#range(start,stop,step),step表示步长
for i in range(0,10,2):
    print(i)
# 输出结果如下：
0
2
4
6
8

• while 循环

说明：多用于死循环或不明确知道循环次数的场景。
标准语句：

while 条件:
    代码块

死循环 示例：

#死循环
while 1:
    print('这是死循环')

正常循环 示例：

x = 3
while x:
    print(x)
    x -= 1
# 输出结果如下：
3
2
1

另外，思考下，上面结果为啥只有3 2 1。

• continue

说明：continue是跳过当前循环的当次循环，继续下一次循环

for x in range(10):
    if x % 2 == 0:
        continue
        print('这是不会执行的')    #永远都不会执行
    print(x)
    x -= 1
# 输出结果如下：
1
3
5
7
9

• break

说明：结束当前循环

x = 0
while True:
    x += 1
    if x > 3:
        break
    print(x)
# 输出结果如下：
1
2
3

如果遇到循环有多层嵌套，要注意break只影响当前循环

如果喜欢的我的文章，欢迎关注我的公众号：点滴技术，扫码关注，不定期分享