Python笔记（一） 基本的数据类型介绍

Strings

Sequence Operations

Basic
1
2
3
4
5
6
7
>>>S='Spam'
>>>len(S)
4
>>>S[0]
'S'
>>>S[-1]
'm'

直接用一个字符串型变量定义一串字符；**len()**为度量字符串长度的语句并得到一个整型数。

Python系统默认的字符串当中，是以0为计数开始的序列。字符串长度为n则有[0]…[n-1]。

Slicing

一种在字符串中提取部分元素的简单操作。切片的规则并不是唯一的，有若干种可能的形式：

  • X[I : J] 从下边界到上边界的所有元素（上边界并不包括在内）；

  • X[ : ] 在未给出的情况下，默认为从0到n-1之间的所有元素；

  • X[ : J] 从0到J-1之间的所有元素；

  • X[I : ] 从I到n-1之间的所有元素；

  • X[I : J : K] 索引从I到J之间的元素；每隔K个元素索引一次，默认为1。

1
2
3
4
5
6
7
8
>>>S[1:]       
'pam'
>>>S          #S itself hasn't changed
'Spam'
>>>S[0:3]     #S=0,p=1,a=2,m=3
'Spa'
>>>S[:-1]     #S=0,p=1,a=2,m=3=-1
'Spa'
Concatenation & Repeating
1
2
3
4
>>>S+'xyz'      #Concatenation
'Spamxyz'
>>>S*8			#Repeating
'SpamSpamSpamSpamSpamSpamSpamSpam'

Immutability

字符串中的每个既定元素不可改变，但是可以通过切片和组合形成新的字符串；同时可以将之转换成列表的形式变更元素。

1
2
3
4
>>>S[0]='z'       #immutable objects cannot be changed
...error...
>>>S='z'+S[1:]    #But we can run expressions to make new objects
'zpam'

Type-Specific Methods

1
2
3
4
5
6
7
>>>S='Spam'
>>>A=S.upper();B=S.lower()      #Upper- and lowercase conversions
'SPAM';'spam'
>>>S.isalpha()                #Content tests:isalpha,isdigit,etc.
True
>>>S._add_('NI!')
'SpamNI!'

Lists

Sequence Operations

列表与字符串的形式类似，包括计数规则、索引、切片等命令大致相似。

1
2
3
4
5
6
7
>>>L=[123,'spam',1.23]
>>>len[L];L[0];L[:-1]   #Count,index slice and return
3;123;[123,'spam']
>>>L+[4,5,6]
[123,'spam',1.23,4,5,6]
>>>L*2
[123,'spam',1.23,123,'spam',1.23]

Type-Specific Methods

1
2
3
4
5
6
7
8
9
>>>L.append('NI')		#Growing:add object at the end of list
[123,'spam',1.23,NI]	
>>>L.pop(2)				#Shrinking:delete an item in the middle
[123,'spam',NI]
>>>M=['bb','aa','cc']
>>>M.sort()				#Ordering the list in ascending fashion by default
['aa','bb','cc']
>>>M.reverse()			#Reversing it
['cc','bb','aa']

Warning: Bounds Checking

对超出列表范围的部分进行操作时，Python会报错。

Nesting

允许嵌套、允许嵌套检索。

1
2
3
4
5
6
7
>>>M=[[1,2,3],		#A 3X3 matrix,as nested lists
	  [4,5,6],
	  [7,8,9]]
>>>M[1]
[4,5,6]
>>>M[1][2]
6

Comprehensions

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>>col1=[row[1] for row in M]    #在M的所有嵌套子列表中遍历第二个元素并且返回一个新列表
[2,5,8]
>>>col2=[row[1]+1 for row in M]   #以上语法允许加入相关运算
[3,6,9]
>>>col3=[row[1] for row in M if row[1]%2==0]     #以上语法允许加入条件并实现条件输出
[2,8]
>>>col4=[M[i][i] for i in [0,1,2]]    #以上语法允许加入循环并实现循环查找
[1,5,9]
>>>col5=[c*2 for c in 'spam']     #允许实现不同数据类型的固定范围操作
['ss','pp','aa','mm']
>>>col6=list(range(4))				#指定生成以0为起点、固定长度且间隔为1的列表
[0,1,2,3]
>>>col7=list(range(-6,7,2))         #I和J之间的、以I为起点，每K数为一组生成一个数并且返回一个新列表
[-6,-4,-2,0,2,4,6]
>>>col8=[[x,x/2,x*2] for x in range(-6,7,2) if x>0]      #允许综合使用条件和循环语句，并作综合处理

Dictionaries

Mapping Operations

字典类型是列表类型的推广普遍形式。字典里面的每一个元素都依赖于我们为之设定的唯一的“钥匙”来对应，并且其中元素支持运算。

1
2
3
4
5
6
7
>>>D={}
>>>D['name']='Bob'
>>>D['job']='dev'
>>>D['age']=40
{'age':40,'job'='dev','name'='Bob'}
>>>D['age']+=1
{'age':41,'job'='dev','name'='Bob'}

字典类型的常用写法：

1
2
3
4
>>>bob1=dict(name='Bob',job='dev',age=40)
{'name': 'Bob', 'job': 'dev', 'age': 40}
>>>bob2=dict(zip(['name','job','age'],['Bob','dev',40]))
{'name': 'Bob', 'job': 'dev', 'age': 40}

Nesting Revisited

字典类型的数据允许嵌套以及嵌套检索；同时其支持以列表形式实现元素的增删。

1
2
3
4
5
6
7
8
9
10
>>>rec={'name':{'first':'Bob','last':'Smith'},
        'jobs':['dev','mgr'],
        'age':40.5}
>>>rec['name'];rec['name']['last']
{'first': 'Bob', 'last': 'Smith'} ;'Smith'

>>>rec['jobs'][-1]
'mgr'
>>>rec['jobs'].append('janitor')
{'name': {'first': 'Bob', 'last': 'Smith'}, 'jobs': ['dev', 'mgr', 'janitor'], 'age': 40.5}

Missing Keys: if Tests

可以通过增补钥匙的方式检索初始阶段没有定义的钥匙；但是不能直接检索没有被定义过的钥匙。

1
2
3
4
5
>>>D={'a':1,'b':2,'c':3}
>>>D['f']
...error...
>>>'f' in D
False

同时，我们也可以实现单个钥匙的增减、赋值与条件判断。

1
2
3
4
>>>value=D.get('x',0)
0
>>>value=D['x'] if 'x' in D else 1937165838
1937165838

Sorting Keys: for Loops

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
>>>Ks=list(D.keys())
['a','b','c']
>>>for key in Ks:
	print(key,'=>',D[key])
a => 1
b => 2
c => 3

>>>for c in 'spam':
    print(c.upper())
S
P
A
M

>>>x=4
>>>while x>0:
    print('spam!'*x)
    x-=1
spam!spam!spam!spam!
spam!spam!spam!
spam!spam!
spam!

Tuples

与字符串、列表、字典等数据类型类似，数组类型也可以进行计算长度、索引、整体增删等操作。

1
2
3
4
5
6
>>>T=(1,2,3,4)
>>>len(T)
4

>>>T=T+(5,6)
(1,2,3,4,5,6)

同样地，我们能对数组类型的数据进行元素位置索引、元素数量统计等操作。

1
2
>>>T.index(4);T.count(4)
3 1

类似于字符串类型数据，我们能够对其进行“切片化”处理并且返回新数组。

1
2
>>>T=(2,)+T[1:]
(2,2,3,4)

同一个数组当中可以存放不同类型的数据，同样可以实现嵌套索引。但是需要注意：append语句不适用。

1
2
3
>>>T='spam',3.0,[11,22,33]
>>>T[2][1]
22