2020 最新python入门知识

1. 基础语法

1.1 注释

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

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

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

• # 号

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

• ''' 三个单引号

也叫块注释，支持换行。

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

• """ 三个双引号

也叫块注释，支持换行。

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

1.2 转义字符

常用的转义符：

转义字符	描述
\(行尾)	续行
\	反斜杠()
`	单引号(')
"	双引号(")
\n	换行
\r	回车
\t	Tab键(TAB)

• \ 行尾，用于续行

>>> 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
复制代码

• 保留标识符

FALSE	await	else	import	pass
None	break	except	in	raise
TRUE	class	finally	is	return
and	continue	for	lambda	try
as	def	from	nonlocal	while
assert	del	global	not	with
async	elif	if	or	yield

1.5 语言类型

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

  

  动态编译语言

  • 不用事先声明数据类型，可以随意赋值其他数据类型；
  • 编程时不知道时什么类型，很难推断，这也是python的不好的地方，v3.8严格在这方便做改进；

  # 标识符随意切换数据类型
  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入门到实战教程，可以去小编的Python解答交流群：1148633274 免费领取。相互讨论学习

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
复制代码

注意：光理论还是不够的，重点还是要实战，如果你没有最新的python入门到实战教程，可以去小编的Python解答交流群：1148633274 免费领取。相互讨论学习

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(value, sep=' ', end='\n')	将数据输出到控制台，默认使用空格作为分隔符(sep)、换行(\n)
input	input(value)	在控制台和用户交互，接收用户输入，并返回字符串
int	int(value)	将数据转换成整数(int本质是类class)
str	str(value)	将数据转换成字符串(str本质是类class)
type	type(value)	判断对象是什么类型(本质是元类)
isinstance	isinstance(obj,tuple)	判断对象的类型

• 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只影响当前循环

  

都明白了吗？ 如果你有不清楚的可以进我的Python解答交流群：1148633274相互讨论学习
---------本文来源于网络加上自己的见解，如有侵权，请联系我删除