python简明教程_03

python编程语言简明教程，翻译自以下仓库：
Python-Lectures
原仓库是一系列的jupyter notebook，可以直接在jupyter环境下运行程序示例。我添加了中文注释，并改为了兼容python3

数据结构

列表list

列表中的内容应该用逗号隔开

a = []
print(type(a))

<class ‘list’>

直接将所有元素写出以构造列表：

x = ['apple', 'orange']

Indexing 索引

python的索引从0开始：

x[0]

‘apple’

倒序的索引从-1开始，即-1是orange，-2就是apple

x[-1]

‘orange’

y = ['carrot','potato']

x和y都是有两个元素的列表，如果用x和y以如下方式构造一个z，那么z将也是有两个元素的列表，不过z的每个元素都分别是一个两个元素的列表：

z  = [x,y]
print(z) #注意方括号

[[‘apple’, ‘orange’], [‘carrot’, ‘potato’]]

取z的第一个元素：

z1 = z[0]
print(z1)

[‘apple’, ‘orange’]

再取z1的第一个元素：

z1[0]

‘apple’

实际上z可以看作一个有两个“维度”的列表，因此可以用多维索引来访问元素：

z[0][0]

‘apple’

如果再多一维，可以用z[ ][ ][ ].

Slicing 切片

切片说的是从列表中取出一定范围内的元素

num = [0,1,2,3,4,5,6,7,8,9]
print(num[0:4])  # 从第0个到第4个元素，默认不包括最后一个元素
print(num[4:])   # 从第4个元素往后的所有元素

[0, 1, 2, 3]
[4, 5, 6, 7, 8, 9]

num[:9:3] # 表示从第0个元素开始到第9个元素，每隔3个元素取一个

[0, 3, 6]

list相关的内置函数

求列表长度

len(num)

10

min(num)

0

max(num)

9

用加号可以把两个列表组合成一个列表，注意，新生成的列表仍然是一维：

[1,2,3] + [5,4,7]

[1, 2, 3, 5, 4, 7]

检查某元素是否包含在列表内：

names = ['Earth','Air','Fire','Water']

'Fire' in names

True

'Rajath' in names

False

在一个元素都是string字符串的列表中，用max()返回的是ASCII值最大的string元素，min()返回的是ASCII值最小的string元素。当两个string元素第一个字符的ASCII值相等时，比较第二个字符的ASCII码值大小，以此类推。

mlist = ['bzaa','ds','nc','az','z','klm']
print(max(mlist))
print(min(mlist))

z
az

如果是数字组成的string元素，如以下列表：

nlist = ['1','94','93','1000']
print(max(nlist))
print(min(nlist))

94
1

注意，在这里max()返回的不是1000，因为1000的第一个字符“1”的ASCII码值小于“9”的ASCII码值，而“4”的ASCII码值大于“3”，所以返回的是94
如果要找长度最长或最短的字符串元素，可以用“key”这个参数来规定查找的规则为“len”，也就是长度。如下：

print(max(names, key=len))
print(min(names, key=len))

Earth
Air

注意，Water虽然也是5个字符的长度，但在这里max和min会返回列表中第一个出现的符合要求的元素。因为Earth出现在Water之前，所以max返回的是Earth。

一个字符串可以用list()函数转换成字符组成的列表，如下：

list('hello')

[‘h’, ‘e’, ‘l’, ‘l’, ‘o’]

append( ) 方法可以用来在列表最后添加元素：

lst = [1,1,4,8,7]
lst.append(1)
print(lst)

[1, 1, 4, 8, 7, 1]

count( ) 可以用来计算列表中某个元素出现的次数：

lst.count(1)

3

append( ) 还可以在列表末尾添加另一个列表。但添加的列表变成了一个元素：

lst1 = [5,4,2,8]
lst.append(lst1)
print(lst)

[1, 1, 4, 8, 7, 1, [5, 4, 2, 8]]

如果不需要以上这种把列表添加成一个元素的形式，需要将列表展开，则使用 extend( ) 函数：

lst.extend(lst1)
print(lst)

[1, 1, 4, 8, 7, 1, [5, 4, 2, 8], 5, 4, 2, 8]

index( ) 可以用来返回某个元素的序号，如果有多个同样值的元素，返回第一个该值的元素：

lst.index(1)

0

insert(x,y) 可以用来将y元素插入到指定位置x，而 append( ) 只是将元素放在最末尾

lst.insert(5, 'name')
print(lst)

[1, 1, 4, 8, 7, ‘name’, 1, [5, 4, 2, 8], 5, 4, 2, 8]

insert(x,y) 只是插入一个元素，如果要替换指定位置的元素，直接给该位置用等号赋值即可：

lst[5] = 'Python'
print(lst)

[1, 1, 4, 8, 7, ‘Python’, 1, [5, 4, 2, 8], 5, 4, 2, 8]

pop( ) 返回列表中的最后一个元素，与堆栈的原理相似，即列表中不再有最后这个被pop出来的元素了。

lst.pop()

8

还可以pop执行序号的元素：

lst.pop(0)

1

pop( ) 能根据序号取出一个指定的元素。也可以使用 remove( ) 去掉一个指定值的元素：

lst.remove('Python')
print(lst)

[1, 4, 8, 7, 1, [5, 4, 2, 8], 5, 4, 2]

单纯去除元素的话也可用 del 函数去掉指定序号的元素：

del lst[1]
print(lst)

[1, 8, 7, 1, [5, 4, 2, 8], 5, 4, 2]

可以用 reverse() 函数来反转整个列表：

lst.reverse()
print(lst)

[2, 4, 5, [5, 4, 2, 8], 1, 7, 8, 1]

列表元素 [5,4,2,8] 里边的元素不会被反转；

Python里可以用 sort( ) 函数来对列表元素排序，默认是小到大的正序：

slst = [2, 4, 5, 1, 7, 8, 1]
slst.sort()
print(slst)

[1, 1, 2, 4, 5, 7, 8]

降序的话使用reverse参数：

slst.sort(reverse=True)
print(slst)

[8, 7, 5, 4, 2, 1, 1]

字符串元素的列表也可以用sort

names.sort()
print(names)
names.sort(reverse=True)
print(names)

[‘Air’, ‘Earth’, ‘Fire’, ‘Water’]
[‘Water’, ‘Fire’, ‘Earth’, ‘Air’]

以字符串长度为标准排序：

names.sort(key=len)
print(names)
names.sort(key=len,reverse=True)
print(names)

[‘Air’, ‘Fire’, ‘Water’, ‘Earth’]
[‘Water’, ‘Earth’, ‘Fire’, ‘Air’]

Copying a list 复制列表

大部分python的初学者都可能会犯一个错误。比如，如果我们创建一个列表：

lista= [2,1,4,3]
listb = lista
print(listb)

[2, 1, 4, 3]

然后让listb等于lista，listb就有了lista中的全部元素。现在我们来对lista进行操作：

lista.pop()
print(lista)
lista.append(9)
print(lista)

[2, 1, 4]
[2, 1, 4, 9]

print(listb)

[2, 1, 4, 9]

然后发现，listb也被改变了。这是因为单纯的listb=lista并没有新开辟一块内存给listb，再储存lista的元素进去，而只是将listb这个名字同样指向了lista指向的内存。

如果要将lista真正复制给listb，即listb不再受lista的影响，可以采用如下这种用：序号切片的方式：

lista = [2,1,4,3]
listb = lista[:]
print(listb)

[2, 1, 4, 3]

lista.pop()
print(lista)
lista.append(9)
print(lista)

[2, 1, 4]
[2, 1, 4, 9]

print(listb)

[2, 1, 4, 3]

元组Tuples

元组与列表相似，但是元组内的元素不可修改。将元组视为对于特定事物必须为True且对于其他任何值都不能为True的事物。

以下使用求余函数divmod

xyz = divmod(10,3)
print(xyz)
print(type(xyz))

(3, 1)
<class ‘tuple’>

因为10除以3，得出商为3余数为1的结果是唯一的，不会有其他结果，因此返回的结果是用元组表示的
可以用小括号()或tuple()定义一个元组

tup = ()
tup2 = tuple()

用一个元素加一个逗号，默认定义为一个元组：

27,

(27,)

用一个数乘以元组，只会将元组的元素个数扩大：（不会等于54）

2*(27,)

(27, 27)

可以用列表或字符串给元组做初始赋值：

tup3 = tuple([1,2,3])
print(tup3)
tup4 = tuple('Hello')
print(tup4)

(1, 2, 3)
(‘H’, ‘e’, ‘l’, ‘l’, ‘o’)

可以和列表一样通过索引序号来访问元组的元素：

print(tup3[1])
tup5 = tup4[:3]
print(tup5)

2
(‘H’, ‘e’, ‘l’)

元组间赋值：

(a,b,c)= ('alpha','beta','gamma')
print(a,b,c)

### 其中a、b、c每一个都是字符串类型str

alpha beta gamma

d = tuple('RajathKumarMP')
print(d)

(‘R’, ‘a’, ‘j’, ‘a’, ‘t’, ‘h’, ‘K’, ‘u’, ‘m’, ‘a’, ‘r’, ‘M’, ‘P’)

元组的内置函数

count() 函数计算元组中特定值的元素出现的次数

d.count('a')

3

index() 函数返回特定值的元素的序号，如果有多个元素有同样的值，返回第一个元素

d.index('a')

1

集合Sets

集合可以用来消除序列/列表中的重复元素。集合还可以执行一些标准的集合操作。

set()可以声明一个空集合。用set([序列])的方式创建有内容的集合。

set1 = set()
print(type(set1))

<class ‘set’>

set0 = set([1,2,2,3,3,4])
print(set0)

{1, 2, 3, 4}

可以看到，重复的元素 2,3 只保留了一个。

set的内置函数

set1 = set([1,2,3])
set2 = set([2,3,4,5])

union( ) 求并集：

set1.union(set2)

{1, 2, 3, 4, 5}

add( ) 可以在集合中增加一个元素，但是元素的位置不一定。

set1.add(0)
set1

{0, 1, 2, 3}

intersection( ) 求交集：

set1.intersection(set2)

{2, 3}

difference( ) 求在 set1 中而不在 set2 中的元素.

set1.difference(set2)

{0, 1}

symmetric_difference( ) 求只在一个集合中存在的元素.

set2.symmetric_difference(set1)

{0, 1, 4, 5}

issubset( ), isdisjoint( ), issuperset( ) 判断是否为子集、不交集、超集：

set1.issubset(set2) ### set2是否为set1的子集

False

set2.isdisjoint(set1)  ### set1与set2是否为不交集

False

set2.issuperset(set1)  ### set1是否为set2的超集

False

pop( ) 去除了集合中的任一元素

set1.pop()
print(set1)

{1, 2, 3}

remove( ) 删除指定元素

set1.remove(2)
set1

{1, 3}

clear( ) 去除所有元素

set1.clear()
set1

set()