Python 基础语法(和Java相比) Python变量和数据类型 List和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
|
#数据类型 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 #变量是用一个变量名表示,变量名必须是大写和小写英文、数字和_的组合。且不能用数字开头
#能够把随意数据类型赋值给变量。同一个变量能够反复赋值,并且能够是不同类型的变量,称为动态语言 #------------------------------------------- #能够使用转义字符 、
、 等等 #------------------------------------------- #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
Line 2
Line 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 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 的逗号能够省略。 d = {
'Adam' : 95 ,
'Lisa' : 85 ,
'Bart' : 59
} #訪问dict print d[ 'Adam' ]
#假设key不存在,会直接报错:KeyError。 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是按 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存储的是无序集合,所以我们没法通过索引来訪问。 '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,运行完相应的代码块,后面的条件推断就直接忽略,不再运行了。 #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。 #递归函数 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()
# <dictionary-valueiterator object at 0x106adbb50> for v in d.itervalues():
print v
# 85 # 95 # 59 #那这两个方法有何不同之处呢? #1. values() 方法实际上把一个 dict 转换成了包括 value 的list。 #2. 可是 itervalues() 方法不会转换,它会在迭代过程中依次从 dict 中取出 value,所以 itervalues() 方法比 values() 方法节省了生成 list 所需的内存。 #3. 打印 itervalues() 发现它返回一个 <dictionary-valueiterator> 对象。这说明在Python中,for 循环可作用的迭代对象远不止 list,tuple,str。unicode,dict等。不论什么可迭代对象都能够作用于for循环。而内部怎样迭代我们通常并不用关心。 #假设一个对象说自己可迭代。那我们就直接用 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特有的列表生成式。
#条件过滤 假设我们仅仅想要偶数的平方,不改动 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)
|
參考
慕课网