Python基础教程笔记——列表和元组

拼搏现实的明天。 2022-08-20 03:18 330阅读 0赞

1 序列概览

说明：序列包括（列表，元组，字符串，buffer对象，xrange对象）

注意：列表可以修改，元组不能被修改。

例子：

>>> edward=\["Edward Gumby", 42\]

>>> bill =\["Bill Gunn", 30\]

>>> database = \[edward, bill\]

>>> database

\[\['Edward Gumby', 42\], \['Bill Gunn', 30\]\]

>>> database\[0\]

\['Edward Gumby', 42\]

2 通用序列操作

2.1 索引

说明：

索引值可正可负，正索引从0开始，从左往右；负索引从-1开始，从右往左。使用负数索引时，python会从最后一个元素开始计 数。最后一个元素的位置编号是-1；

字符串可以直接使用索引；

例子：

>>> str = "Test"

\#一般索引

>>> str\[0\]

'T'

>>> str\[1\]

'e'

\#负数索引

>>> str\[-1\]

't'

>>> str\[-2\]

's'

\#字符串直接索引

>>> "Test"\[0\]

'T'

>>> "Test"\[1\]

'e'

>>> "Test"\[-1\]

't'

2.2 分片

说明：使用分片操作来访问一定范围内的元素。分片通过冒号相隔的两个 索引来实现。

注意：

第一个索引是需要提取部分的第一个元素的索引值，而最后的索引 则是分片之后右侧剩下部分的第一个元素的索引；

如果右侧全部提取，则分片时，可以不写右侧索引，也可以将右侧索引 写最后一个元素的下一个索引；

如果左侧全部提取，刚分片时，左侧索引可以写0，也可以不写；

设置步长：不指明步长时，步长取1，也可以指定步长，步长不能为 0 ，步长也可以是负数，可以反序输出提取部分。

例子：

>>> data=\[1,2,3,4,5,6,7,8,9,10\]

\#提取序列的一部分

>>> data\[1:6\]

\[2, 3, 4, 5, 6\]

\#提取右侧全部

>>> data\[3:\]

\[4, 5, 6, 7, 8, 9, 10\]

>>> data\[7:10\]

\[8, 9, 10\]

\#提取左侧全部

>>> data\[:3\]

\[1, 2, 3\]

>>> data\[0:3\]

\[1, 2, 3\]

\#负索引提取

>>> data\[-3:-1\]

\[8, 9\]

>>> data\[-3:\]

\[8, 9, 10\]

\#设置步长

>>> data\[::2\]

\[1, 3, 5, 7, 9\]

>>> data\[1::2\]

\[2, 4, 6, 8, 10\]

\#步长也可以是负数

>>> data\[::-1\]

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

>>> data\[-1:-8:-1\]

\[10, 9, 8, 7, 6, 5, 4\]

>>> data\[8:1:-1\]

\[9, 8, 7, 6, 5, 4, 3\]

2.3 序列相加

说明：通过加号可以进行序列连接；

例子：

\#序列相加

>>> first=\[1,2\]

>>> second=\[3,4\]

>>> first+second

\[1, 2, 3, 4\]

2.4 乘法

说明：用一个正整型数乘以序列，可以得到一个新的重复了n次的序列

注意：

空列表可以简单地通过两个中括号进行表示（\[\]）

None 是Python关键字，表示“什么也没有”

例子：

\#10个python

>>> 'python ' \* 10

'python python python python python python python python python python '

\#10个空对象

>>> \[None\] \* 10

\[None, None, None, None, None, None, None, None, None, None\]

\#打印盒子

mystr = input("Please input a string:")

strLen = len(mystr)

lineStart = 20

print (" " \* lineStart + "+" + "-" \* strLen + "+")

print (" " \* lineStart + "|" + " " \* strLen + "|")

print (" " \* lineStart + "|" + mystr + "|")

print (" " \* lineStart + "|" + " " \* strLen + "|")

print (" " \* lineStart + "+" + "-" \* strLen + "+")

>>>

Please input a string:My name is Bill Gunn

+--------------------+

|                    |

|My name is Bill Gunn|

|                    |

+--------------------+

2.5 成员资格

说明：使用关键字 in 检查值是否在序列中。如果值在序列中返回 “True”，否则返回“False”。值可以是元素也可以是子序列。

例子：

\#检查值是否在序列中

>>> mystr="this is a string"

>>> 'this' in mystr

True

2.6 长度，最大值，最小值

说明：

len ：返回序列包含元素的数量；

min ：返回序列中的最小值；

max ：返回序列中的最大值；

\#min,max和len的用法

>>> data = \[12,31,2,1,3,12,3,13,131234,12\]

>>> min(data)

>>> max(data)

131234

>>> len(data)

3 列表：Python的“苦力”

3.1 list

说明：可以将字符串或其他序列转换成列表。

注意：list是类型，不是函数。

例子：

>>> list("This is a test string")

\['T', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't', ' ', 's', 't', 'r', 'i', 'n', 'g'\]

3.2 基本列表操作

说明：

元素赋值：使用索引标记来为某个特定的，位置明确的元素赋值；

元素删除：使用 del 语句；

分片赋值：

可以一次为多个元素赋值；

原片与新片可以长度不同；

分片赋值可以在指定位置插入新的元素；

例子：

>>> mylist = \[1,2,3,4,5\]

\#列表元素赋值

\#**索引必须在列表范围内**

>>> mylist\[10\] = 10

Traceback (most recent call last):

File "<pyshell\#2>", line 1, in <module>

mylist\[10\] = 10

IndexError: list assignment index out of range

>>> mylist\[0\] = 100

>>> mylist

\[100, 2, 3, 4, 5\]

**\#删除元素**

>>> del(mylist\[0\])

>>> mylist

\[2, 3, 4, 5\]

>>>

**\#分片赋值**

>>> mystr = list("Nale Gunn")

>>> mystr\[0:4\] = list("Bill")

>>> mystr

\['B', 'i', 'l', 'l', ' ', 'G', 'u', 'n', 'n'\]

\#**分片赋值时，原片与新片长度不同**

>>> mystr=list("Bill Gunn")

>>> mystr\[-5:\] = list("gunn@gmail.com")

>>> mystr

\['B', 'i', 'l', 'l', 'g', 'u', 'n', 'n', '@', 'g', 'm', 'a', 'i', 'l', '.', 'c', 'o', 'm'\]

>>>

\#**分片赋值可以在指定位置插入新的元素**

>>> mystr=list("Bill Gunn")

>>> mystr\[0:0\] = list("My name is ")

>>> mystr

\['M', 'y', ' ', 'n', 'a', 'm', 'e', ' ', 'i', 's', ' ', 'B', 'i', 'l', 'l', ' ', 'G', 'u', 'n', 'n'\]

>>>

3.3 列表方法

说明：

append：用于在列表末尾追加一个新的元素；列表调用该方法后，直接被该 方法修改；

count：用于统计某个元素在列表中出现的次数；

extend：在列表的末尾一次性追加另一个列表中的多个元素，该方法 也是直接修改原列表，这也是与列表连接操作的区别；

index：找出某个匹配项第一次出现的索引；

insert：在列表中插入新的对象；

pop：移除列表中的一个值（默认是最后一个），并返回该元素的值；

remove：用于移除某个值在列表中的第一个匹配项；

reverse：将列表中的值反向存放；

sort：**对列表进行排序**；

sorted内建函数：对序列进行反序，并返回一个列表

注意：

列表复制：用分片的方法复制比较有效率。

例子：

**\#append**

>>> lst = list("Test")

>>> lst.append(list("String"))

>>> lst

\['T', 'e', 's', 't', \['S', 't', 'r', 'i', 'n', 'g'\]\]

>>> lst.append("String")

>>> lst

\['T', 'e', 's', 't', \['S', 't', 'r', 'i', 'n', 'g'\], 'String'\]

>>> lst=list("Test")

>>> lst.append("!")

>>> lst

\['T', 'e', 's', 't', '!'\]

**\#count**

>>> lst.count('T')

>>> lst.count('t')

**\#extend**

>>> lst.extend(list("HaHa"))

>>> lst

\['T', 'e', 's', 't', '!', 'H', 'a', 'H', 'a'\]

>>> lst.index('t')

>>>

**\#pop**

>>> lst = \[1,2,3\]

>>> lst.pop()

>>> lst

\[1, 2\]

>>> lst.pop(0)

>>> lst

\[2\]

>>>

\#pop

>>> lst = \[1,2,3\]

>>> lst.pop()

>>> lst

\[1, 2\]

>>> lst.pop(0)

>>> lst

\[2\]

**\#remove**

>>> lst=list("12345678")

>>> lst

\['1', '2', '3', '4', '5', '6', '7', '8'\]

\#删除不存在的对象会报错

>>> lst.remove(2)

Traceback (most recent call last):

File "<pyshell\#42>", line 1, in <module>

lst.remove(2)

ValueError: list.remove(x): x not in list

>>> lst.remove('2')

>>> lst

\['1', '3', '4', '5', '6', '7', '8'\]

**\#reverse**

>>> lst.reverse()

>>> lst

\['8', '7', '6', '5', '4', '3', '1'\]

**\#sort**

>>> lst.sort()

>>> lst

\['1', '3', '4', '5', '6', '7', '8'\]

>>> lst.sort(key=len)

>>> lst

\['1', '3', '4', '5', '6', '7', '8'\]

>>> lst = \['asdf','qwersf','aaf','s','afasfd','qre'\]

>>> lst.sort(key=len)

>>> lst

\['s', 'aaf', 'qre', 'asdf', 'qwersf', 'afasfd'\]

>>> lst.sort(key=len,reverse=True)

>>> lst

\['qwersf', 'afasfd', 'asdf', 'aaf', 'qre', 's'\]

>>>

\#列表复制

>>> x = list('123456')

\#下面的复制，只是让y也指向x指向的对象，所以修改x，也会影响y的值

>>> y = x

>>> x.reverse()

>>> y

\['6', '5', '4', '3', '2', '1'\]

\#**用分片的方法复制，x与y相互独立，修改x，不会影响y**

>>> y=x\[:\]

>>> y.sort()

>>> x

\['6', '5', '4', '3', '2', '1'\]

>>> y

\['1', '2', '3', '4', '5', '6'\]

>>>

4 元组

4.1 元组定义：

说明：**元组不可以修改，一般用圆括号括起来**

例子：

\#一般元组

>>> 1,2,3

(1, 2, 3)

>>> (1,2,3)

(1, 2, 3)

\#一个元素的元组

>>> (1,)

(1,)

>>> 2,

(2,)

\#空元组

>>> ()

()

>>>

\#**元组的乘法**

>>> 4\* (2,)

(2, 2, 2, 2)

>>>

4.2 tuple函数

说明：**以一个序列为参数，将其转换为元组；**

例子：

>>> tuple("CONSTANT")

('C', 'O', 'N', 'S', 'T', 'A', 'N', 'T')

>>> tuple(list("CONST"))

('C', 'O', 'N', 'S', 'T')

>>>

4.3 元组的意义：

元组可以在映射中当作键使用；

元组作为很多内建函数和方法的返回值存在。

1 字典定义：

说明：通过名字引用值的数据结构称为映射，字典是Python中唯一内建的 映射类型；

2 字典的使用:

说明：通过检查到特定的词语（键），查找到它的含义（值）；

注意：比较适合电话薄，词典这类实现

例子：

1:  \#用**列表**来实现电话薄

2:  >>> phoneNumbers = \['213123','542113','543231','974723'\]

3:  >>> names=\['Ada', 'Bill', 'Candy', 'David'\]

4:  >>> phoneNumbers\[names.index('Bill')\]

5:  '542113'

6:  >>>

3 创建和使用字典

说明：字典是由多个键以及其对应的值组成的键值对组成的，

**字典以左大 括号开始，并以右大括号结束，键与值之间用冒号分隔，键值对儿之间用 逗号分隔；**

注意：字典中的**键是唯一的**

例子：

1:  >>> mydict=\{'ada':'1111', 'Bill':'2222', 'Candy':'3333'\}

2:  >>> mydict\['Bill'\]

3:  '2222'

4:  >>>

3.1 dict函数

说明：用于创建字典的内建函数，参数可以是键与值的序列，可以是关键 字参数，也可以是其他的映射；

注意：**如果不给dict提供参数，则会返回一个空字典**

例子：

1:  **\#将序列转换成字典**

2:  >>> mylst=\[('name', 'Bill'),('age', 30)\]

3:  >>> mydict = **dict**(mylst)

4:  >>> mydict

5:  \{'age': 30, 'name': 'Bill'\}

6:  >>> mydict\['name'\]

7:  'Bill'

9:  **\#通过向dict函数传递参数来创建字典**

10:  >>> mylst = dict(height=183,weight=161,hair='black')

11:  >>> mylst\['hair'\]

12:  'black'

13:

14:  \#通过字典来创建另一个字典

15:  >>> mylst = dict(mydict)

16:  >>> mylst

17:  \{'age': 30, 'name': 'Bill'\}

18:  >>>

19:

3.2 基本字典操作

说明：

len（d）：获取字典中键值对的数量；

d\[k\]：键k对应的值；

d\[k\]=v：将值v赋给键k；

del d\[k\]：删除字典d中键为k的项；

k in d：判断字典d中是否包含键为k的项；

注意：

键类型：键类型可以是任意不可变类型，如整数，浮点数，字符串等；

自动添加：如果字典中不包含指定的键，可以通过赋值增加新项；

成员资格：k in d 是查找字典中是不是有键k对应的项，而列表是查 找的是值，v in l， 值v是不是在列表中；

字典中检查键的效率要比列表检查值的高效；

例子：

1:  \#电话薄

2:  people = \{

3:          'Bill Gunn':

4:          \{

5:              'phone': '123456',

6:              'addr': 'Tianjin'

7:              \},

8:          'Media Zhang':

9:          \{

10:              'phone': '999999',

11:              'addr': 'Beijing'

12:              \}

13:          \}

14:  \#输出内容

15:  lables = \{

16:          'phone' : 'phone number',

17:          'addr'  : 'address'

18:          \}

19:  \#用户名

20:  name = input('Name:')

21:  key = input('Phone number(p) or address(a):')

22:  if key == 'p' : key = 'phone'

23:  if key == 'a' : key = 'addr'

24:  if name in people:

25:      print("%s %s is %s" % (name, lables\[key\], people\[name\]\[key\]))

26:  input('Press enter!')

27:

28:  >>>

29:  Name:Bill Gunn

30:  Phone number(p) or address(a):a

31:  Bill Gunn address is Tianjin

32:  Press enter!

33:

3.3 用字典格式化字符串

说明：在格式化字符串中的格式化说明符后添加 键 ，并且 键 需要 用圆括号括起来；

例子：

1:  >>> table = \{

2:          'Alice' : '457819',

3:          'Bill'  : '929181',

4:          'Candy' : '826213'\}

5:  >>> print("Alice's phone number is %(Alice)s." % table)

6:  Alice's phone number is 457819.

7:  >>>

3.4 字典方法

3.4.1 clear

说明：用于清除字典中全部的键值对儿，调用完该方法后，原字典变成一 个空字典；

注意：该方法直接操作原字典，调用后不返回值（或者说直接返回 None ）

例子：

1:  \#字典清空函数的一般用法

2:  >>> mydict = \{'Bill':'8289213', 'Candy':'192831'\}

3:  >>> mydict.clear()

4:  >>> mydict

5:  \{\}

6:  >>>

8:  \#字典清空的情况一

9:  >>> x = \{'Bill':'213121'\}

10:  \#y和x指向同一个字典对象

11:  >>> y = x

12:  \# x 指向一个空字典

13:  >>> x = \{\}

14:  \# y 仍然指向原字典

15:  >>> y

16:  \{'Bill': '213121'\}

17:  >>>

18:

19:  \#字典清空的情况二

20:  >>> x = \{'Name' : 'Bill'\}

21:  \#y也指向字典

22:  >>> y = x

23:  \#对字典中的项操作

24:  >>> x\['Name'\] = 'Candy'

25:  \# y 也跟着变化

26:  >>> y

27:  \{'Name': 'Candy'\}

28:  \#清空字典 x

29:  >>> x.clear()

30:  \#y也被清空了

31:  >>> y

32:  \{\}

33:  >>>

34:

3.4.2 copy

说明：用于创建一个新的字典，用两种复制方法：copy和deepcopy

注意：

**copy在复制过程中，**

**如果字典中的 值 对象是复杂对象，如列表， 字典等等，则拷贝完后，新的字典中的 值 指向的还是原字典中的 对象，所以修改新对象中的 值 ，同时也是修改原字典中的值，**

**但 是如果字典中的对象是普通类型，如是数字，字符串等，则修改新字 典不会影响原字典。**

例子：

1:  \#copy的用法和效果

2:  >>> x = \{'Name' : 'Bill', 'Colors': \{'red', 'green', 'blue'\}\}

3:  >>> y = x.copy()

4:  >>> y

5:  \{'Colors': \['blue', 'green', 'red'\], 'Name': 'Bill'\}

6:  \#删除颜色列表中的 ‘red’

7:  >>> x\['Colors'\].remove('red')

8:  >>> x

9:  \{'Colors': \['blue', 'green'\], 'Name': 'Bill'\}

10:  \#y字典中的颜色列表也发生的改变

11:  >>> y

12:  \{'Colors': \['blue', 'green'\], 'Name': 'Bill'\}

13:  >>>

14:

15:

16:**  \#deepcopy的用法和效果**

17:  >>> from copy import deepcopy

18:  >>> x = \{'colors':\['red','green','blue'\],'name':'Bill'\}

19:  >>> x

20:  \{'colors': \['red', 'green', 'blue'\], 'name': 'Bill'\}

21:  \#将x深拷贝给y

22:  >>> y = deepcopy(x)

23:  >>> y

24:  \{'colors': \['red', 'green', 'blue'\], 'name': 'Bill'\}

25:  \#修改x

26:  >>> x\['colors'\].remove('red')

27:  >>> x

28:  \{'colors': \['green', 'blue'\], 'name': 'Bill'\}

29:  \#y没有发生改变

30:  >>> y

31:  \{'colors': \['red', 'green', 'blue'\], 'name': 'Bill'\}

32:  >>>

33:

3.4.3 fromekeys

说明：**根据键创建新的字典；**

例子：

1:  >>> \{\}.fromkeys(\['name','age'\])

2:  \{'age': None, 'name': None\}

3:  >>> x.fromkeys(\['age'\])

4:  \{'age': None\}

5:  >>>

3.4.4 get

说明：是个更宽松的访问字典项的方法，如果键在字典中，则返回值， 如果不在，返回空，也可以给不存在的键指定默认值；

例子：

1:  >>> x = \{'name': 'Bill'\}

2:  \#字典中包含指定的键

3:  >>> x.get('name')

4:  'Bill'

6:  \#字典中不包含指定的键，返回空

7:  >>> x.get('age')

9:  \#为不包含的键指定默认值

10:  >>> x.get('age', 'N/A')

11:  'N/A'

12:  >>>

13:

3.4.5 has\_key

说明：可以检查字典中是否含有给出的键，python3中已经 不 包含此 项，可以用 k in dict 的方式代替；

3.4.6 items和iteritems

说明：items以列表方式返回字典中的键值对，iteritems以迭代器对象 返回键值对儿(Python3中不再支持）；

例子：

1:  >>> x

2:  \{'name': 'Bill'\}

3:  >>> x.items()

4:  dict\_items(\[('name', 'Bill')\])

6:  \#python3中不再包含iteritems

7:  >>> x.iteritems()

8:  Traceback (most recent call last):

9:    File "<pyshell\#66>", line 1, in <module>

10:      x.iteritems()

11:  AttributeError: 'dict' object has no attribute 'iteritems'

12:

3.4.7 keys

说明：返回字典中的 键

例子：

1:  >>> x = \{'Name':'Bill', 'Age':'30'\}

2:  >>> x

3:  \{'Age': '30', 'Name': 'Bill'\}

4:  >>> x.keys()

5:  dict\_keys(\['Age', 'Name'\])

6:  >>>

3.4.8 pop

说明：用于获取给定键的值，并将该键值对从字典中移除

例子：

1:  >>> x = \{'a':1,'b':2\}

2:  >>> x

3:  \{'a': 1, 'b': 2\}

4:  >>> x.pop('a')

5:  1

6:  >>> x

7:  \{'b': 2\}

8:  >>>

3.4.9 popitem

说明：用于随机弹出字典中的键值对儿；

例子：

1:  >>> x = \{'a': '1', 'c': '3', 'b': '2'\}

2:  >>> while len(x) > 0:

3:          x.popitem()

4:  ('a', '1')

5:  ('c', '3')

6:  ('b', 2)

7:  >>> x

8:  \{\}

3.4.10 setdefault

说明：可以获得给定键的值，如果字典中没有给定键，可以在字典中添 加给定键。如果没有指定给定键的默认值，并且给定键也不在字典中， 则在添加给定键后，将其值设置为 None 。

例子：

1:  >>> x = \{'a':'1','b':'2','c':'3'\}

2:  >>> x

3:  \{'a': '1', 'c': '3', 'b'/span>: '2'\}

4:  \#字典中包含 a，所以返回键a对应的值1

5:  >>> x.setdefault('a')

6:  '1'

7:  \#因为字典中有键a，所以setdefault方法不会改变键a对应的值

8:  >>> x.setdefault('a', 'A')

9:  '1'

10:  >>> x

11:  \{'a': '1', 'c': '3', 'b': '2'\}

12:  \#字典中没有键d，调用setdefault方法时也没有设置默认值，

13:  \#所以调用后，在字典中添加了键为d的键值对儿，并返回空。

14:  >>> x.setdefault('d')

15:  >>> x

16:  \{'a': '1', 'c': '3', 'b': '2', 'd': None\}

17:  \#调用setdefault时带默认值

18:  >>> x.setdefault('e', '5')

19:  '5'

20:  >>> x

21:  \{'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': None\}

22:  >>> x.setdefault('d', '4')

23:  >>>

24:

3.4.11 update

说明：将新字典中的键值对儿更新到原字典中，如果新字典中有的键值 对儿，原字典中没有，则会在原字典中增加新键值对儿；

例子：

1:  >>> x = \{'a':'1','b':'2','c':'3'\}

2:  >>> x

3:  \{'a': '1', 'c': '3', 'b': '2'\}

4:  >>> y = \{'a':'A', 'z':'zoo'\}

5:  >>> x.update(y)

6:  \#键‘a’被更新到字典中，‘z’被添加到字典中

7:  >>> x

8:  \{'a': 'A', 'c': '3', 'b': '2', 'e': '5', 'd': None, 'z': 'zoo'\}

9:  >>> z=\[('g','11'),('q','12')\]

10:  >>> x.update(z)

11:  >>> x

12:  \{'a': 'A', 'q': '12', 'c': '3', 'b': '2', 'e': '5', 'd': None, 'g': '11', 'z': 'zoo'\}

13:  >>>

14:

3.4.12 values和itervalues

说明：values返回字典中的值，itervalues已经不被python3支持。

例子：

1:  >>> x

2:  \{'a': 'A', 'q': '12', 'c': '3', 'b': '2', 'e': '5', 'd': None, 'g': '11', 'z': 'zoo'\}

3:  >>> x.values()

4:  dict\_values(\['A', '12', '3', '2', '5', None, '11', 'zoo'\])

5:  >>>

Python基础教程笔记——列表和元组

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Python基础：列表和元组混淆案例

相关 Python列表和元组

相关【Python基础】列表和元组

相关 Python学习笔记之列表和元组

相关【python学习笔记】2.列表和元组

相关 Python3 菜鸟教程笔记3 -- 列表和元组

相关 python基础之元组，列表

相关 Python基础教程笔记——列表和元组

相关 python基础：Python元组、列表

相关 Python编程-基础知识-列表和元组