Python基本语法

2.1 基本语法

2.1.1 注释

​ # '''注释''' """注释"""

# 第一个注释
print("Hello World!")  # 第二个注释

def find_all(self):
    """Retuen all items."""
    return self.find('all')

2.1.2 行与缩进

if True:
    print ("True")
 else:
    print ("False")

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")
  print ("False")  # 缩进不一致，导致编译出现语法错误

​ 缩进时，绝对不要使用 tab，也不要 tab 和空格混用。

2.1.3 语句换行

​ 原则上每行代码长度不超过80个字符。对于过长的可以通过 {} [] () 隐式连接。

string = ("Python 是一种面向对象、解释型计算机程序设计语言，"
         "由 Guido van Rossum 于 1989 年底发明。"
         "第一个公开发行版发行于 1991 年，"
         "Python 源代码同样遵循 GPL (Gnu General Public License) 协议。")

2.2 变量与数据类型

2.2.1 变量与赋值

num_one = 100
num_two = 87
result = num_one + num_two

2.2.2 变量的类型

$$数据类型\{\begin{array}{c}数字类型(number)\{\begin{array}{l}整形(int)\\ \\ 浮点型(float)\\ \\ 复数(complex)\end{array}\\ \\ 布尔类型(bool)\\ \\ 字符串类型(string)\\ \\ 列表类型(list)\\ \\ 元组类型(tuple)\\ \\ 字典类型(dictionary)\end{array}$$

• 数字类型

  整型：0101	83	-239	0x80	299384938832
  浮点型：3.1415	4.2E-10	-2.34E-19
  复数型：3.12+1.23j	-1.23-98j
  

• 布尔类型

  True		1
  False 		0
  

• 字符串

  string_one = 'Python'
  string_two = "Python"
  string_three = '''Python'''  # """Python"""
  

• 列表和元组类型

  他们可以存储任意类型的值，这些值称为元素。列表 中元素用 [] 包含，元素个数和值可以随意修改。元组 中元素用 () 包含，元素不可被修改。

  list_name = [1, 2, 'hello']  # 列表
  tuple_name = (1, 2, 'hello')  # 元组
  

• 字典类型

  字典是映射数据类型，由键-值对组成。字典可以存储不同类型的元素，元素用{} 包含。键通常是字符串或者数值，值是任意的。

  dict_name = {"name" : "zhangsan", "age" : 18}  # 字典
  

>>> number = 5.2
>>> type(number)		# 使用type查看类型
<type 'float'>

2.3 标识符和关键字

2.3.1 标识符

1. 由字母数字下划线组成，不能以数字开头。
2. 区分大小写。
3. 不能是关键字。

• 起一个有意义的名称
• 对类命名时用大写字母开头的单词（CapWorld) 模块应是小写加下划线（low_with_under)。

2.3.2 关键字

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

>>> help()  # 进入帮助系统
help keywords  # 查看所有的关键字列表
help return  # 查看 return 这个关键字的说明
help quit  # 退出帮助系统

2.4 简单数值类型

2.4.1 整型

​ 十进制，二进制（以"0b" 或者 “0B” 开头），八进制（以 “0o” 开头），十六进制（以"0x" 或者 “0X” 开头）。

​ 32位计算机上的整型是32位，范围 -2³¹~2³¹-1。64位计算机上的整型是64位，范围 -2⁶³~2⁶³-1。

>>> bin(20)     # 将十进制 20 转为二进制
'0b10100'
>>> oct(20)		# 将十进制 20 转为八进制
'0o24'
>>> hex(20)		# 将十进制 20 转为十六进制
'0x14'

2.4.2 浮点型

​ <实数> e/E <整数>

​ 范围 -1.79E+308 ~ 1.79E+308

1.34E3	1.34 $\times$ 103
1.5E-3	1.5 $\times$ 10-3
1.2e5	1.2 $\times$ 105

2.4.3 布尔类型

​ 以下对象的布尔值都是False：

1. None
2. False
3. 0
4. 0L
5. 0.0
6. 0.0+0.0j
7. “” (空字符串)
8. [] (空列表)
9. () (空元组)
10. {} (空字典)

2.4.4 复数类型

1. 复数由实数和虚数两部分构成，real + imag j 或者 real + imag J 。
2. 复数的两部分都是浮点数。
3. a.conjugate() 返回 a 的共轭复数。

>>> a = 1+2j
>>> a
(1+2j)
>>> a.real  # 实数部分
1.0
>>> type (a.real)
<class 'float'>
>>> a.imag  # 虚数部分
2.0
>>> type (a.imag)
<class 'float'>

2.4.5 数字类型转换

函数	说明
int(x[,base])	将 x 转换为一个整数
float(x)	将 x 转换为一个浮点数
complex(real[,imag])	创建一个复数

# 将浮点数转换成整数
>>> a = 1.2
>>> int(a)
1
# 将整数转换成浮点数
>>> b = 2
>>> float(b)
2.0
# 创建一个复数
>>> complex(3.4)
(3.4+0j)

2.5 运算符

2.5.1 算术运算符

运算符	描述
+	加：两个对象相加
-	减：两个数相减
*	乘：两个数相乘或者是返回一个被重复若干次的字符串 结果为 float
/	除：a 除 b
%	取余：返回除法的余数
**	幂：返回 a 的 b 次幂
//	取整除：返回商的整数部分

2.5.2 赋值运算符

=

>>> num = 1 + 2
>>> num
3

>>> x = y = z = 1
>>> x
1
>>> y
1
>>> z
1

>>> x, y = 1, 2
>>> x
1
>>> y
2

不支持自加(++)自减(–)

2.5.3 复合赋值运算符

运算符	描述
+=	加法赋值运算符
-=	减法赋值运算符
*=	乘法赋值运算符
/=	除法赋值运算符
%=	取模赋值运算符
**=	幂赋值运算符
//=	取整除赋值运算符

2.5.4 比较运算符

== != > < >= <=

2.5.5 逻辑运算符

运算符	逻辑表达式	描述	实例	结论
and	x and y	布尔“与”，若 x 的布尔值为False，则返回 x，否则返回 y	若 a = 10，b = 20(a and b) 结果为20	同True返回True
or	x or y	布尔“或”，若 x 的布尔值为True，则返回 x，否则返回 y	若 a = 10，b = 20(a and b) 结果为10	有True返回True
not	not x	布尔“非”，若 x 的布尔值为True，则返回 False，否则返回 True	若 a = 10(not a)结果为False	若True返回False，若False返回True

2.5.6 成员运算符

运算符	描述
in	如果在指定的序列中找到值返回True，否则返回False。
not in	如果在指定的序列中没有找到值返回False，否则返回True。

实测：

a = 10
b = 20
list_demo = [1, 2, 3, 4, 5]
# 判断变量 a 是否在给定的列表 list_demo 中
if a in list_demo:
    print("1—变量 a 在 list_demo 中")
else:
    print("1—变量 a 不在 list_demo 中")

# 判断变量 b 是否在给定的列表 list_demo 中
if b not in list_demo:
    print("2—变量 b 不在 list_demo 中")
else:
    print("2—变量 b 在 list_demo 中")

# 修改 a 的值
a = 2
if a in list_demo:
    print("3—变量 a 在 list_demo 中")
else:
    print("3—变量 a 不在 list_demo 中")

2.6 位运算

1. << 按位左移
2. >> 按位右移
3. & 按位与
4. | 按位或
5. ^ 按位异或
6. ~ 按位取反

2.6.1 按位左移

​ x << n x 的二进制位全部左移 n 位，高位丢弃，低位补 0。

>>> x = 9
>>> bin(x << 4)
'0b10010000'

​ 左移 n 位等价于 $\times 2^n$ 。

2.6.2 按位右移

​ x >> n x 的二进制位全部右移 n 位右边移出丢弃，左边补 0 或者符号位。

>>> a = 8 
>>> bin(a >> 2)
'0b10'

​ **右移 n 位等价于 $÷2^n$ **

2.6.3 按位与

​ & 二进制同 1 为 1，否则为 0。

>>> a = 9
>>> b = 3
>>> bin (a & b)
'0b1'

2.6.4 按位或

​ | 二进制有 1 则 1，否则为 0。当参操作数为负数时，均以补码形式出现。

>>> a, b= 8, 3
>>> bin(a | b)
'0b1011'

2.6.5 按位异或

​ ^ 二进制同为0，不同为1。

>>> a, b = 8, 4
>>> bin(a ^ b)
'0b1100'

2.6.6 按位取反

​ ~ 二进制 1 变 0，0 变 1。

​ 9 取反结果为 -10

​ 整数 源码 = 补码 = 反码

1. 9 二进制00001001
2. 取反11110110 补码
3. 10001010 源码即-10

>>> a = 9
>>> ~a
-10
>>> bin(~a)
'-0b1010'

对于整数 x 取反结果 -x -1

2.7 运算符优先级

运算符	描述
**	指数（最高优先级）
~ + -	按位取反 一元加号和减号（+@ -@）
* / % //	乘 除 取模 取整除
+ -	加 减
>> <<	右移 左移
&	按位与
^ |	位运算符
<= < > >=	比较运算符
== !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
(not) in	成员运算符
or and	逻辑运算符

a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d         # 等价于（30 * 15） / 5
print ("(a + b) * c / d 运算结果为： ", e)
e = ((a + b) * c) / d       # 等价于（30 * 15） / 5
print ("((a + b) * c) / d 运算结果为： ", e)
e = (a + b) * (c / d)       # 30 * (15 / 5)
print ("(a + b) * (c / d) 运算结果为： ", e)
e = a + (b * c) / d         # 20 + (150 / 5)
print ("a + (b * c) / d 运算结果为： ", e)

        or  and             |            逻辑运算符             |

a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d         # 等价于（30 * 15） / 5
print ("(a + b) * c / d 运算结果为： ", e)
e = ((a + b) * c) / d       # 等价于（30 * 15） / 5
print ("((a + b) * c) / d 运算结果为： ", e)
e = (a + b) * (c / d)       # 30 * (15 / 5)
print ("(a + b) * (c / d) 运算结果为： ", e)
e = a + (b * c) / d         # 20 + (150 / 5)
print ("a + (b * c) / d 运算结果为： ", e)