Python 基础语法（和Java相比）
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
55
|
#数据类型
print
(
0xff00
);
#十六进制用0x前缀和0-9，a-f表示
print
(
1.23e9
);
# 对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x10^9就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
#在Python中，可以直接用True、False表示布尔值（请注意大小写）布尔值可以用and、or和not运算。
#空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
#----------------------------------------
#print语句
print
'hello, world'
print
'The quick brown fox'
,
'jumps over'
,
'the lazy dog'
#遇到逗号“,”会输出一个空格
print
'100 + 200 ='
,
100
+
200
#计算100 + 200的结果
#--------------------------------------------
#变量
a
=
1
#变量是用一个变量名表示，变量名必须是大小写英文、数字和_的组合，且不能用数字开头
#可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，称为动态语言
#-------------------------------------------
#可以使用转义字符 \ 、\n、\t等等
#-------------------------------------------
#raw字符串与多行字符串
print
(r
'\(~_~)/ \(~_~)/'
);
#我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了
#但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串
#如果要表示多行字符串，可以用'''...'''表示
print
(
'''Python is created by "Guido".
It is free and easy to learn.
Let's start learn Python in imooc!'''
);
#等同于'Line 1\nLine 2\nLine 3'
#---------------------------------------------------
#Python在后来添加了对Unicode的支持，以Unicode表示的字符串用u'...'表示，比如：
print
u
'中文'
#如果中文字符串在Python环境下遇到 UnicodeDecodeError，这是因为.py文件保存的格式有问题。可以在第一行添加注释(目的是告诉Python解释器，用UTF-8编码读取源代码。)
# -*- coding: utf-8 -*-
#---------------------------------------------------
#布尔类型
a
=
True
print
a
and
'a=T'
or
'a=F'
#计算结果不是布尔类型，而是字符串 'a=T'，这是为什么呢？
#因为Python把0、空字符串''和None看成 False，其他数值和非空字符串都看成 True，所以：
a
and
'a=T'
#计算结果是 'a=T'
print
a
and
'a=T'
or
'a=F'
#计算结果还是 'a=T'
#要解释上述结果，又涉及到 and 和 or 运算的一条重要法则：短路计算。
#1. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
#2. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。
#所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。
|
List和Tuple类型
|
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
|
#list是一种有序的集合，可以随时添加和删除其中的元素
#一个元素可以没有的list，就是空list：
empty_list
=
[]
#创建List
L
=
[
'Adam'
,
95.5
,
'Lisa'
,
85
,
'Bart'
,
59
]
print
L
#按照索引访问list
print
L[
4
]
#输出Bart，下标是从0开始
#倒序访问list
print
L[
-
2
]
#输出Bart，下标是从0开始
#添加新元素
L.append(
'Paul'
)
L.insert(
0
,
'Paul'
)
#添加到指定位置
#从list删除元素
L.pop()
#pop()方法总是删掉list的最后一个元素，并且它还返回这个元素
pop(
2
)
#删除指定位置元素
#替换元素
L[
2
]
=
'Paul'
#对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素
#---------------------------------------------------
#tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。
#创建tuple
t
=
(
'Adam'
,
'Lisa'
,
'Bart'
)
#创建tuple和创建list唯一不同之处是用( )替代了[ ]
#获取 tuple 元素的方式和 list 是一模一样的
#包含 0 个元素的 tuple，也就是空tuple，直接用 ()表示
t
=
()
#打印()
#创建包含1个元素的 tuple
t
=
(
1
,)
#打印(1,)，加上“，”是因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。
#“可变”的tuple
t
=
(
'a'
,
'b'
, [
'A'
,
'B'
])
#当我们把list的元素'A'和'B'修改为'X'和'Y'后,tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。
|
Dict和Set类型
|
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
55
56
57
|
#花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。由于dict也是集合，len() 函数可以计算任意集合的大小
d
=
{
'Adam'
:
95
,
'Lisa'
:
85
,
'Bart'
:
59
}
#访问dict
print
d[
'Adam'
]
#如果key不存在，会直接报错：KeyError。可以先判断一下 key 是否存在再取值
if
'Paul'
in
d:
print
d[
'Paul'
]
#也可以使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None
print
d.get(
'Bart'
)
#59
print
d.get(
'Paul'
)
#None
#dict的特点
#dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样(而list的查找速度随着元素增加而逐渐下降。不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。)
#由于dict是按 key 查找，所以，在一个dict中，key不能重复。
#dict的第二个特点就是存储的key-value序对是没有顺序的
#dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key
#更新dict
d[
'Paul'
]
=
72
#如果 key 已经存在，则赋值会用新的 value 替换掉原来的 value
#遍历dict
d
=
{
'Adam'
:
95
,
'Lisa'
:
85
,
'Bart'
:
59
}
for
name
in
d:
print
name,
':'
,d[name]
#---------------------------------------------------
#set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。
#创建
s
=
set
([
'A'
,
'B'
,
'C'
])
#访问set
#由于set存储的是无序集合，所以我们没法通过索引来访问。访问 set中的某个元素实际上就是判断一个元素是否在set中。
'Bart'
in
s
#返回True/False.（大小写敏感）
#set的特点
#set的内部结构和dict很像，唯一区别是不存储value，因此，判断一个元素是否在set中速度很快。
#set存储的元素和dict的key类似，必须是不变对象，因此，任何可变对象是不能放入set中的。
#最后，set存储的元素也是没有顺序的。
#遍历set
s
=
set
([
'Adam'
,
'Lisa'
,
'Bart'
])
for
name
in
s:
print
name
#更新set
s.add(
4
)
#元素已经存在于set中，add()不会报错，但是不会加进去了
s.remove(
4
)
#元素不存在set中，remove()会报错，所以remove()前需要判断。
|
条件判断和循环
|
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
|
#if语句
age
=
20
if
age >
=
118
:
print
'your age is'
, age
print
'adult'
else
:
print
'your age is'
, age
print
'END'
# Python代码的缩进规则。具有相同缩进的代码被视为代码块
# 缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。
#if-elif-else
age
=
12
if
age >
=
18
:
print
'adult'
elif
age >
=
6
:
print
'teenager'
elif
age >
=
3
:
print
'kid'
else
:
print
'baby'
# 这一系列条件判断会从上到下依次判断，如果某个判断为 True，执行完对应的代码块，后面的条件判断就直接忽略，不再执行了。(和Java一样)
#for循环 遍历一个list或tuple
L
=
[
'Adam'
,
'Lisa'
,
'Bart'
]
for
name
in
L:
print
name
#while循环
N
=
10
x
=
0
while
x < N:
print
x
x
=
x
+
1
#（都和Java一样用法）
#可以使用break退出循环
#continue继续循环
#多重循环
for
x
in
[
'A'
,
'B'
,
'C'
]:
for
y
in
[
'1'
,
'2'
,
'3'
]:
print
x
+
y
|
函数
|
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
|
#可以直接从Python的官方网站查看文档： http://docs.python.org/2/library/functions.html#ab
#调用函数
print
abs
(
-
2
)
#2
#编写函数
#在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。
def
my_abs(x):
if
x >
=
0
:
return
x
else
:
return
-
x
#如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return。
#递归函数
def
fact(n):
if
n
=
=
1
:
return
1
return
n
*
fact(n
-
1
)
#分析（很清晰）
=
=
=
> fact(
5
)
=
=
=
>
5
*
fact(
4
)
=
=
=
>
5
*
(
4
*
fact(
3
))
=
=
=
>
5
*
(
4
*
(
3
*
fact(
2
)))
=
=
=
>
5
*
(
4
*
(
3
*
(
2
*
fact(
1
))))
=
=
=
>
5
*
(
4
*
(
3
*
(
2
*
1
)))
=
=
=
>
5
*
(
4
*
(
3
*
2
))
=
=
=
>
5
*
(
4
*
6
)
=
=
=
>
5
*
24
=
=
=
>
120
#（扩展）使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，
#栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试计算 fact(10000)。
#定义默认参数 函数的默认参数的作用是简化调用
def
power(x, n
=
2
):
s
=
1
while
n >
0
:
n
=
n
-
1
s
=
s
*
x
return
s
print
power(
5
)
#由于函数的参数按从左到右的顺序匹配，所以默认参数只能定义在必需参数的后面：
# OK:
def
fn1(a, b
=
1
, c
=
2
):
pass
# Error:
def
fn2(a
=
1
, b):
pass
#定义可变参数
def
fn(
*
args):
print
args
#Python解释器会把传入的一组参数组装成一个tuple传递给可变参数，因此，在函数内部，直接把变量 args 看成一个 tuple 就好了。
|
切片
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
#取前3个元素
L
=
[
'Adam'
,
'Lisa'
,
'Bart'
,
'Paul'
]
L[
0
:
3
]
#['Adam', 'Lisa', 'Bart']
L[
1
:
3
]
#['Lisa', 'Bart']
L[:]
#表示从头到尾
L[::
2
]
#第三个参数表示每N个取一个，L[::2]表示每两个元素取出一个来
#倒序切片
L
=
[
'Adam'
,
'Lisa'
,
'Bart'
,
'Paul'
]
L[
-
2
:]
#['Bart', 'Paul']
L[:
-
2
]
#['Adam', 'Lisa']
L[
-
3
:
-
1
]
#['Lisa', 'Bart'] 倒数第三个开始切到倒数第一个
L[
-
4
:
-
1
:
2
]
#['Adam', 'Bart']
#tuple和字符切片也是一样的，只是返回的是tuple和字符
|
迭代
|
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
55
56
57
58
|
#普通迭代 for ... in完成
#索引迭代
L
=
[
'Adam'
,
'Lisa'
,
'Bart'
,
'Paul'
]
for
index, name
in
enumerate
(L):
print
index,
'-'
, name
#0 - Adam
#1 - Lisa
#2 - Bart
#3 - Paul
#扩展
#实际上，enumerate() 函数把：['Adam', 'Lisa', 'Bart', 'Paul'] 变成了类似： [(0, 'Adam'), (1, 'Lisa'), (2, 'Bart'), (3, 'Paul')]
#因此，迭代的每一个元素实际上是一个tuple：
for
t
in
enumerate
(L):
index
=
t[
0
]
name
=
t[
1
]
print
index,
'-'
, name
#如果我们知道每个tuple元素都包含两个元素，for循环又可以进一步简写为：
for
index, name
in
enumerate
(L):
print
index,
'-'
, name
#这样不但代码更简单，而且还少了两条赋值语句。
#迭代dict的value
#dict 对象有一个 values() 方法，这个方法把dict转换成一个包含所有value的list
d
=
{
'Adam'
:
95
,
'Lisa'
:
85
,
'Bart'
:
59
}
print
d.values()
# [85, 95, 59]
for
v
in
d.values():
print
v
# 85
# 95
# 59
#扩展
#如果仔细阅读Python的文档，还可以发现，dict除了values()方法外，还有一个 itervalues() 方法，用 itervalues() 方法替代 values() 方法，迭代效果完全一样：
d
=
{
'Adam'
:
95
,
'Lisa'
:
85
,
'Bart'
:
59
}
print
d.itervalues()
#
for
v
in
d.itervalues():
print
v
# 85
# 95
# 59
#那这两个方法有何不同之处呢？
#1. values() 方法实际上把一个 dict 转换成了包含 value 的list。
#2. 但是 itervalues() 方法不会转换，它会在迭代过程中依次从 dict 中取出 value，所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。
#3. 打印 itervalues() 发现它返回一个
#如果一个对象说自己可迭代，那我们就直接用 for 循环去迭代它，可见，迭代是一种抽象的数据操作，它不对迭代对象内部的数据有任何要求。
#迭代dict的key和value
for
key, value
in
d.items():
print
key,
':'
, value
#Lisa : 85
#Adam : 95
#Bart : 59
# values() 有一个 itervalues() 类似，items() 也有一个对应的 iteritems()，iteritems() 不把dict转换成list，而是在迭代过程中不断给出 tuple，所以， iteritems() 不占用额外的内存。
|
列表生成式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
#要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，我们可以用range(1, 11)：
#但如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做
L
=
[]
for
x
in
range
(
1
,
11
):
L.append(x
*
x)
#还可以用
[x
*
x
for
x
in
range
(
1
,
11
)]
#这种写法就是Python特有的列表生成式。利用列表生成式，可以以非常简洁的代码生成list
#条件过滤 如果我们只想要偶数的平方，不改动 range()的情况下，可以加上 if 来筛选：
[x
*
x
for
x
in
range
(
1
,
11
)
if
x
%
2
=
=
0
]
#有了 if 条件，只有 if 判断为 True 的时候，才把循环的当前元素添加到列表中。
#[4, 16, 36, 64, 100]
#多层表达式
[m
+
n
for
m
in
'ABC'
for
n
in
'123'
]
#['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
#相当于
L
=
[]
for
m
in
'ABC'
:
for
n
in
'123'
:
L.append(m
+
n)
|
参考
慕课网