Python简要教程

简介

本教程适合有一定编程语言基础的读者,通过快速了解 Python 与其他语言共有的特性与独有的特点来快速掌握 Python,同时作为一个备忘录,许久不用之后快速回忆。

语句结构

强制以固定缩进代替括号,这是 Python 的特色。
缩进不需要固定为 4 空格,但需要保持一致。

1
2
3
4
5
6
7
8
9
10
11
12
# 注释以#开头,与shell相同
# if 语句
if 3 > 2:
# 输出
print("hello world")

# 逻辑操作符为 and, or, not 单词,而不是JS中的&&
if 3 > 2 and 2 < 4:
# 一样可以输出特殊转义字符
print("\n")
if 2 > 4:
print("test")

变量

  1. 变量名与大多数语言一样,只能由数字、字母、下划线组成,且首字符不能是数字,区分大小写。
  2. 变量声明赋值一步完成,不用写变量类型,自动根据赋值判断类型。
1
2
3
4
5
6
7
8
# int类型
a = 5
# string 类型
b = "hello"
# 字符串拼接使用 +
print(b + " world")
# 输出类型
print(type(a)) # <class 'int'>

不同类型的变量不能拼接,会报错,这与 JS 不同。
需要注意的是 Python 中所有东西都是 object,并且几乎所有对象都有属性和方法。这与 ruby 相似。

数字

根据赋值不同,数字类型分 3 种:

  • int
  • float
  • complex,也就是复数
1
2
3
4
5
6
7
8
# int
a = 3
# float
b = 3.2
# complex
c = 1j
# 通过type()查看类型
print(type(c))

字符串

单引号和双引号都可以表示字符串,含义是一样的。

字符串可以通过下标来当做字符数组使用,比如

1
2
a = "hello world"
print(a[0]) # 输出h

一些函数:

1
2
3
4
5
6
7
8
9
10
11
print(" test ".strip()) # 去除前后空格输出test

print(len("test")) # 输出长度 4

print("Hello".lower()) # 转为小写hello

print("hello".upper()) # 转为大写HELLO

print("Hello".replace("H", "T")) # 替换H为J

print(a.split(",")) # 类似于js的split,根据指定字符分割为数组,返回['Hello', ' World!'], python里叫这种类型List

通过 input()函数可以等待控制台输入:

1
2
a = input()
print(a)

类型转换

通过类型名加括号强制转换类型,比如 int(‘2’), float(‘1.1’), str(2),转换失败会报错。

运算符

算数运算符

1
2
3
4
5
6
7
+
-
*
/
%
** # 乘方
// # 除完向下取整

位运算符

1
2
3
4
5
6
&
|
^ # 异或
~
<<
>>

赋值运算符

同许多语言一样,a += 1 相当于 a = a + 1 ,除了算术运算符,还有一些位运算符也可以

1
2
3
4
5
&=
|=
^=
>>=
<<=

比较运算符

1
2
3
4
5
6
==
!=
>
<
>=
<=

逻辑运算符

这也算是 python 的特色吧,其他很多语言都是 &&, ||, !

1
2
3
and
or
not

同一性运算符

1
2
is  # 如果两个对象是同一对象返回True,类似于js中的===
is not

成员判断运算符

1
2
in  # 如果一个变量在另一个对象当中
not in

集合

Python 中有 4 种集合类型

List

类似于 JS 中 Array,不同的是,Python List 对象改变值的方法都会更改原始值,因为 Python 是真正面向对象的,其方法都是针对自身做改变。

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
ll = ["a", "b", "c"]
# 下标取每一项
print(ll[0])
# 输出长度
print(len(ll))
# 循环每一项
for x in ll:
print(x)

# 判断是否存在其中
if "apple" in ll:
print("Yes, 'apple' is in the fruits list")

# 尾部增加
ll.append("d")

# 指定位置增加
ll.insert(1, "ff")

# 去除指定的值
ll.remove("ff")

# 尾部去除
ll.pop()

# 删除指定位置的值
del ll[0]

# 删除整个list
del ll

# 清空list
ll.clear()

# 使用list()构造函数创建
ll = list(("a", "b", "c"))

# 连接另一数组
ll.extend(["d"])

# 反转
ll.reverse()

# 复制一份新的并返回
ll.copy()

# 排序
ll.sort()

# 找到指定值的位置
ll.index("2")

# 计算指定值在List中的个数
ll.count("apple")

Tuple

Tuple 翻译过来是元组,可以以 List 的方式来取值,循环,但不可更改内容,也不可删除,构造以圆括号构造:

1
2
3
4
5
6
7
8
9
10
11
12
13
thistuple = ("apple", "banana", "cherry")

print(len(thistuple))

# 计算指定值在元组中的个数
thistuple.count("apple")

# 找到指定值的位置
ll.index("banana")

# 以下操作会报错
thistuple[0] = 2
del thistuple[0]

Set

与 list 类似,不同点在于 Set 是无序的,自动去除重复成员。
因为是无序的,每次取值顺序是不固定的,所以使用 pop 删除的不知道是哪个值。
使用大括号构造:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
s = {"a", "b", "c"}

# 合并
s.update({1,2})

# 添加
s.add()

# 删除指定值,如果传入值没有,会报错
s.remove()

# 删除指定值,如果传入值没有,不会报错
s.discard()

# 返回不属于s2中只属于s的成员组成的set
s.difference(s2)

Dictionary

类似 JS 中的 Object,键值对的形式,不同的是 key 值必须是字符串,要使用引号引起来。

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
37
38
39
40
41
42
dic = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
# 构造函数创建
dic = dict(brand='Ford', model='Mustang', year=1964)

# 如果没有对应的key,会报错
print(dic['brand'])
# 使用get没有对应key的时候不会报错,并且可以设置默认值
dic.get("model", "")

# 遍历, n代表key
for n in dic:
print(dic[n])

# items相当于是键值对组成的list
for x, y in dic.items():
print(x, y)

# 根据key删除
dic.pop('model')
del dic['model']

# 删除最后一组
dic.popitem()

# 清空
dic.clear()

# 更新
dic.update()

# 返回keys list
dic.keys()

# values list
dic.values()

# 如果参数对象中有相同key就覆盖,没有就添加,有点像Object.assign
dic.update({'f': 2})

条件语句

写法 1,正常换行缩进:

1
2
3
4
5
6
7
8
a = 200
b = 33
if b > a:
print("b is greater than a")
elif a == b:
print("a and b are equal")
else:
print("a is greater than b")

写法 2,单行 if:

1
if a > b: print("a is greater than b")

写法 3,单行 if,执行语句前置:

1
2
3
print("A") if a > b else print("B")

print("A") if a > b else print("=") if a == b else print("B")

写法 4,增加逻辑运算符 and, or, not

循环语句

while

while 循环和其他语言基本相似,也存在 break 跳出,continue 进入下次循环。

1
2
3
4
5
6
7
i = 1
while i < 6:
print(i)
if i == 3:
# break跳出
break
i += 1

for

可以使用 for…in 循环集合和字符串,可以使用 break,continue:

1
2
3
4
5
6
7
8
9
fruits = ["apple", "banana", "cherry"]
for x in fruits:
print(x)
if x == "banana":
# 可以使用break跳出
break

for x in "banana":
print(x)

利用 range 函数限制循环次数:

1
2
3
4
5
6
7
8
9
10
11
# 输出整数0 到 5
for x in range(6):
print(x)

# 输出整数2 到 5
for x in range(2, 6):
print(x)

# 逐个输出从2到30的整数,每次增加3
for x in range(2, 30, 3):
print(x)

for…else 可以在循环结束后执行 else 之后的语句:

1
2
3
4
for x in range(6):
print(x)
else:
print("Finally finished!")

函数

1
2
3
4
# def定义,并设置参数默认值
def my_function(country = "Norway"):
print("I am from " + country)
return 1

lambda 表达式

可以看做是一句话匿名函数。

1
2
x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

lambda 可以用于创建高阶函数:

1
2
3
4
5
6
7
def myfunc(n):
return lambda a : a * n

mytripler = myfunc(3)

# 输出33
print(mytripler(11))

面向对象

这里不介绍面向对象的含义,只介绍用 python 如何实现。

class

python 作为面向对象的语言,对 class 有完整的实现方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Person:
# 构造函数
def __init__(self, name, age):
self.name = name
self.age = age

# 第一个参数是实例对象自身,self名字不是固定的
def myfunc(self):
print("Hello my name is " + self.name)

p1 = Person("John", 36)
p1.myfunc()

del p1.name
del p1

继承

创建子类时传入父类来继承:

1
2
3
4
5
6
class Student(Person):
# pass代表什么都不做
pass

x = Student("Mike", "Olsen")
x.printname()

修改子类构造函数:

1
2
3
4
5
6
7
8
9
class Student(Person):
def __init__(self, fname, lname, year):
# 为了继承父类构造函数,先调用父类构造函数
Person.__init__(self, fname, lname)
self.graduationyear = year

# 增加子类方法
def welcome(self):
print("Welcome", self.firstname, self.lastname, "to the class of", self.graduationyear)

Iterator

list, set, dict, tuple 都是可遍历对象,除了 for…in 遍历外,还可以使用 iter + next 来遍历。

1
2
3
4
5
6
mytuple = ("apple", "banana", "cherry")
myit = iter(mytuple)

print(next(myit))
print(next(myit))
print(next(myit))

同样 iter 也可以用于遍历字符串的每一个字符。

可以构造自己的对象支持 iter 遍历,

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
# 只需要实现__iter__,__next__两个方法。
class MyNumbers:
def __iter__(self):
self.a = 1
return self

# 决定每一次next调用返回的值
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
# 停止遍历
raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

myclass1 = MyNumbers()
myiter1 = iter(myclass)

for x in myiter1:
print(x)

模块

模块由单独文件组成,文件名即文件名,与其他语言相似。

创建模块

文件 mymodule.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
def greeting(name):
print("hello, " + name)

person1 = {
"name": "John",
"age": 36,
"country": "Norway"
}

# python mymodule.py 当做可执行文件执行时会直接执行这里的内容
if __name__ == "__main__":
import sys
print(int(sys.argv[1]))

可以通过创建一个目录,里面来存放我们所有的 module,然后组成一个 package。然后在目录下面加一个__init__.py 文件,我们 import 的时候会自动寻找其中中定义的模块,通常我们在这个文件中导入所有的子模块。有点类似 js import 一个目录的时候,自动寻找下面的 index.js。

引入模块

1
2
3
4
5
import mymodule

mymodule.greeting('tom')

print(mymodule.person1["age"])

引入时搜索顺序为:内置模块 => 根据 sys.path 的值搜索
sys.path 是一个 list,默认为 当前目录,PYTHONPATH 定义的值指向的目录,第三方包安装目录。
所以一般不要让自己定义的模块与第三方模块重名。

引入时重命名
1
2
3
4
import mymodule as mx

a = mx.person1["age"]
print(a)
按需导入
1
2
3
from mymodule import person1

print (person1["age"])

内置模块

python 提供了很多内置模块,这些模块提供了非常强大、便捷的功能。

1
2
3
4
5
6
7
import platform
# 查看操作系统
x = platform.system()
print(x)

# 使用dir可以查看模块中的方法和属性
print(dir(platform))

安装第三方模块

使用内置的 pip 可以管理本地的第三方模块,另外在 https://pypi.org 可以找到需要的库,类似 js 中的 npm。

1
2
3
pip install requests
pip uninstall requests
pip list

https://wiki.python.org/moin/UsefulModules 整理了最常用的一些第三方模块。

错误捕获

通过 try…except 捕获,except 可以指定具体错误,不指定就捕获之前所有未捕获的错误,finally 总会最后执行。

1
2
3
4
5
6
7
8
try:
print(x)
except NameError:
print('not defined')
except:
print('Something else went wrong')
finally:
print('finally')

else 可以在未发生错误时执行:

1
2
3
4
5
6
try:
print("Hello")
except:
print("Something went wrong")
else:
print("Nothing went wrong")