popo

python-doc-语法

Posted on Edited on

编码

默认情况下，Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：

1
# -*- coding: utf-8 -*-

标识符

  • 第一个字符必须是字母表中字母或下划线 _ 。
  • 识符的其他的部分由字母、数字和下划线组成。
  • 标识符对大小写敏感。

算术运算符

运算符 描述 实例
+ 两个对象相加 1+3 # 4
- 得到负数或是一个数减去另一个数 4-3 # 1
* 两个数相乘或是返回一个被重复若干次的字符串 1*3 # 3
/ x 除以 y 3/2 # 1.5
% 取模,返回除法的余数 3%2 # 1
** 幂,返回x的y次幂 2**3 # 8
// 取整除,向下取接近除数的整数 9//4 #2

逻辑运算符

运算符 逻辑表达式 描述 实例
and x and y 布尔”与” - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 10 and -1 # -1
or x or y 布尔”或” - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 10 or -1 # 10
not not x 布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(10 and -1) # False

成员运算符

运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 1 in [1, 2, 3] # True
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 1 not in [1, 2, 3] # False

身份运算符

运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。

注释

单行注释#,多行注释'''或"""

1
2
3
4
5
6
7
8
9
# 单行注释

'''
多行注释
'''

"""
多行注释
"""

多行语句

如果语句很长，我们可以使用反斜杠\来实现多行语句

1
2
3
sum = one + \
	two + \
	three

删除对象

删除一些对象引用使用deldel var1[,var2[,var3[....,varN]]]

1
2
del a
del b, c

end关键字

关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符

1
2
3
4
5
6
a, b = 0, 1
while b < 1000:
	print(b, end=',')
	a, b = b, a+b

# 1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

if

  • 每个条件后面要使用冒号:，表示接下来是满足条件后要执行的语句块。
  • 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
  • 在Python中没有switch – case语句。

一般形式

1
2
3
4
5
6
if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3
1
2
3
4
5
6
7
i = 10
if i == 0:
	print("等于0")
elif i == 5:
	print("等于5")
else :
	print("等于其它")

while

一般形式

1
2
while 判断条件：
    语句
1
2
3
4
5
6
7
8
9
n = 100

sum = 0
counter = 1
while counter <= n:
	sum = sum + counter
	counter += 1

print(sum) # 5050

while else

while … else 在条件语句为 false 时执行 else 的语句块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
count = 0
while count < 5:
	print (count, "：小于 5")
	count = count + 1
else:
	print (count, "：大于或等于 5")

# 结果
# 0 ：小于 5
# 1 ：小于 5
# 2 ：小于 5
# 3 ：小于 5
# 4 ：小于 5
# 5 ：大于或等于 5

for

一般形式

1
2
3
4
for <variable> in <sequence>:
    <statements>
else:
    <statements>
1
2
3
4
5
6
7
8
9
li = [1, 2, 3, 4]
for i in li:
	print(i)

# 结果
# 1
# 2
# 3
# 4

for else

for语句执行结束后会调用else语句块，break打断for会跳过else语句块执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
li = [1, 2, 3, 4]
for i in li:
	print(i)
else:
	print(5)

# 结果
# 1
# 2
# 3
# 4
# 5

li = [1, 2, 3, 4]
for i in li:
	if i == 2:
		break

	print(i)
else:
	print(5)

# 1

pass 语句

pass是空语句，是为了保持程序结构的完整性。
pass不做任何事情，一般用做占位语句。

1
2
class AA:
	pass # 等待补充

函数

  • 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
  • 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
  • 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
  • 函数内容以冒号起始，并且缩进。
  • return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

一般形式

1
2
def 函数名（参数列表）:
	函数体

参数

  • 必需参数
    必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样

  • 关键字参数
    关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
    使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/python3

import sys

def AAA( name, age ):
	print ("name is : ", name)
	print ("age is :", age)

	return

#调用printinfo函数
AAA(11, 22)
AAA( age=33, name="44" )
AAA( age=55, name="6" )

# 结果打印
# name is :  11
# age is : 22
# name is :  44
# age is : 33
# name is :  6
# age is : 55
  • 默认参数
    调用函数时，如果没有传递参数，则会使用默认参数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/python3

import sys

def AAA( name, age, sex="男"):
	print ("name is : ", name)
	print ("age is :", age)
	print ("sex is :", sex)

	return

AAA(11, 22)
AAA(33, 44, "女")

# 结果打印
# name is :  11
# age is : 22
# sex is : 男
# name is :  33
# age is : 44
# sex is : 女
  • 不定长参数
    函数调用的时候能传递比当初声明时更多的参数

不定参数在声明的时候在变量前加*，这样参数就会以元组形式导入，存放所有未命名的变量参数，在定义了不定参数后，如果没有传惨，那么不定参数就是一个空元组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/python3

import sys

def AAA( a, b, *c):
	print("a is :", a)
	print("b is :", b)
	print("c is :", c)

	return

AAA(11, 22)
AAA(333, 444, 555, "666", 777)

# 结果打印
# a is : 11
# b is : 22
# c is : ()
# a is : 333
# b is : 444
# c is : (555, '666', 777)

在参数在声明的时候加**，这样参数就以字典的形式导入。

1
2
3
4
5
6
a is : 11
b is : 22
c is : {}
a is : 333
b is : 444
c is : {'c1': 555, 'c2': '666', 'c3': '777'}

不定参数如果不放在函数参数末尾，那么传参的时候需要用关键字形式补充后面的必需关键之。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/usr/bin/python3

import sys

def AAA( a, b, *c, d):
	print(a + b + d)

	return

# AAA(11, 22, 33) # 报错
AAA(11, 22, d=33)

# 结果打印
# 66

匿名函数

匿名函数不需要用def定义，直接写表达式定义.

  • lambda 只是一个表达式，函数体比 def 简单很多。
  • lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
  • lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。

一般形式

1
lambda [arg1 [,arg2,.....argn]]:expression
1
2
3
4
5
6
7
8
9
10
#!/usr/bin/python3

import sys

sum = lambda arg1, arg2: arg1 + arg2

print (sum( 10, 20 ))

# 结果打印
# 30

变量作用域

python变量作用域有4种

  • L （Local） 局部作用域
  • E （Enclosing） 闭包函数外的函数中
  • G （Global） 全局作用域
  • B （Built-in） 内置作用域（内置函数所在模块的范围）

以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内置中找。
Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问。也就是if等内部定义的变量，在if块也能访问，但函数内定义变量，在这个函数块外部能访问。

1
2
3
4
5
6
7
8
9
10
11
12
13
#!/usr/bin/python3

import sys

def F1():
	if 2 > 1:
		num1 = 3

	print(num1)

F1()
# 结果打印
# 3

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
函数内如果定义了一个与外部一样的名称的变量，那么函数内的变量将会成为新变量，与外部作用域的变量不想关。
当想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
global用于修改全局作用域变量，而nonlocal用于修改函数变量的作用域。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#!/usr/bin/python3

import sys

glo1 = 1
glo2 = 2

def F1():
	global glo2

	local1 = 3
	local2 = 4

	def F2():
		nonlocal local2

		local1 = 333
		local2 = 444

	glo1 = 111
	glo2 = 222

	F2()

	print("local1 is :", local1)
	print("local2 is :", local2)

F1()

print("glo1 is :", glo1)
print("glo2 is :", glo2)
# 结果打印
# local1 is : 3
# local2 is : 444
# glo1 is : 1
# glo2 is : 222