Python容器：列表、元组、字典与集合

Python容器：列表、元组、字典与集合

posts 列表 元组 字典 集合 python容器

Python容器：列表、元组、字典与集合

1、列表和元组

2、列表

2.1、使用[]或list()创建列表

2.2、使用list()将其它数据类型转换成列表

2.3、使用[offset]获取元素

2.4、包含列表的列表

2.5、使用[offset]修改列表元素

2.6、指定范围并使用切片提取元素

2.7、使用append()添加元素至尾部

2.8、使用extend()或+=合并列表

2.9、使用insert()在指定位置插入元素

2.10、使用del删除指定位置的元素

2.11、使用remove()删除具有指定值的元素

2.12、使用pop()获取并删除指定位置的元素

2.13、使用index()查询具有特定值得元素位置

2.14、使用in判断值是否存在

2.15、使用count()记录特定值出现的次数

2.16、使用join()转换为字符串

2.17、使用sort()重新排序元素

2.18、使用len()获取长度

2.19、使用=赋值，使用copy()赋值

3、元组

3.1、使用()创建元组

4、字典

4.1、使用{}创建字典

4.2、使用dict()转换为字典

4.3、使用[key]添加或修改元素

4.4、使用update()合并字典

4.5、使用del删除具有制定键的元素

4.6、使用clear()删除所有元素

4.7、使用in判断是否存

4.8、使用[key]获取元素

4.9、使用keys()获取所有键

4.10、使用values()获取所有值

4.11、使用items()获取所有键值对

4.12、使用=赋值，使用copy()赋值

5、集合

5.1、使用set()创建集合

5.2、使用set()将其他类型转换为集合

5.3、使用in测试值是否存在

5.4、合并及运算符

6、建立大型数据结构

反馈与建议

1、列表和元组

大多数编程语言都有特定的数据结构来存储由一系列元素组成的序列，这些元素以他们所处的位置来索引：从第一个到最后一个依次编号。Python的字符串本质上是由字符组成的序列。

除了字符串外，Python还有另外两种序列结构：元组和列表。它们都可以包含零个或多个元素。于字符串不同的是，元组和列表并不要求所含元素的种类相同，每个类型都可以是Python类型的对象。

至于Python为什么会同时设置这两种序列，是因为元组所赋值的内容是不可变的，然而列表是可变可更改的，这意味着可以随意的在列表中插入或者删除其中那个的元素。2、列表

列表非常适合利用顺序和位置来定位某一元素，尤其是当元素的序列或内容经常发生变化时。列表可以对原始列表进行修改：添加新元素、删除或覆盖已有元素。列表允许相同值的元素出现多次。

2.1、使用[]或list()创建列表

列表可以有多个或多个元素组成，元素之间用逗号隔开，整个列表被方括号所包裹：>>> empty_list = [ ]

>>> weekdays = ['Monday','Tuesday','Wednesday','Thursday','Friday'] >>> big_birds = ['emu','ostrich','cassowary',]

>>> first_names = ['Graham','John','Terry','Terry','Michagel']

#列表允许重复相同的值

也可以使用list()函数来创建一个空列表：

>>> another_empty_list = list()

>>> another_empty_list

[]

提示：如果你仅仅想要记录一些互不相同的值，而不在乎它们之间的序列关系，集合（set）会是一个更好的选择。

2.2、使用list()将其它数据类型转换成列表

Python的list()函数可以将其他数据类型转换成列表类型。

>>> list('cat')

['c', 'a', 't']

下面的例子将一个元组转换成了列表：

>>> a_tuple = ['ready','fire','aim']

>>> list(a_tuple)

['ready', 'fire', 'aim']

使用split()可以依据分隔符将字符串切割成由若干子串组成的列表：

>>> birthday = '1/6/1952'

>>> birthday.split('/')

['1', '6', '1952']

如果在待分割的字符串中包含连续的分隔符，那么在列表中就会返回空串元素：>>> splitme = 'a/b//c/d///e'

>>> splitme.split('/')

['a', 'b', '', 'c', 'd', '', '', 'e']

如果将上面例子中的分隔符改成//会变成下面的结果：

>>> splitme = 'a/b//c/d///e'

>>> splitme.split('//')

['a/b', 'c/d', '/e']

2.3、使用[offset]获取元素

和字符串一样，通过偏移量可以从列表中提取对应位置的元素：

>>> marxes = ['Groucho','Chico','Harpo']

>>> marxes[0]

'Groucho'

>>> marxes[1]

'Chico'

>>> marxes[2]

'Harpo'

同样，负偏移量代表从尾部开始计数：

>>> marxes[-1]

'Harpo'

>>> marxes[-2]

'Chico'

>>> marxes[-3]

'Groucho'

提示：指定的偏移量对于待访问列表必须有效，该位置中的元素在访问前已经赋值，当制定的偏移量小于起始位置或者大于末尾位置时，会产生异常。

2.4、包含列表的列表

列表可以包含各种类型的元素，包括其他列表：

>>> small_birds = ['hummingbird','finch']

>>> extinct_birds = ['dodo','https://www.wendangku.net/doc/705727704.html,','Norwegian Blue'] >>> carol_birds = [3,'French hens',2,'turtledoves']

>>> all_birds = [small_birds,extinct_birds,'macaw',carol_birds]

查看all_birds列表的数据结构：

>>> all_birds

[['hummingbird', 'finch'], ['dodo', 'https://www.wendangku.net/doc/705727704.html,', 'Norwegia n Blue'], 'macaw', [3, 'French hens', 2, 'turtledoves']]

访问第一个元素：

>>> all_birds[0]

['hummingbird', 'finch']

第一个元素还是一个列表，其实第一个元素就是small_birds，也就是创建all_birds列表时设定的第一个元素，查看第二个元素：

>>> all_birds[1]

['dodo', 'https://www.wendangku.net/doc/705727704.html,', 'Norwegian Blue']

如果你想要访问extinct_birds的第一个元素，可以制定双重索引从all_birds中提取：>>> all_birds[1][0]

'dodo'

2.5、使用[offset]修改列表元素

就像可以通过偏移量访问某元素一样，你也可以通过赋值对他们进行修改：>>> names = ['https://www.wendangku.net/doc/705727704.html,','linux','centos']

>>> names[1]

'linux'

>>> names[1] = 'redhat'

>>> names[1]

'redhat'

>>> names

['https://www.wendangku.net/doc/705727704.html,', 'redhat', 'centos']

与之前一样，列表的位置偏移量必须是合法有效的。

提示：通过这种方式无法修改字符串中的制定字符，运维字符串是不可变的。列表是可变的，一次你可以改变列表中的元素个数，以及元素的值。

2.6、指定范围并使用切片提取元素

你可以使用切片提取列表的一个子序列：

>>> names = ['https://www.wendangku.net/doc/705727704.html,','linux','centos']

>>> names[0:2]

['https://www.wendangku.net/doc/705727704.html,', 'linux']

列表的切片仍然是一个列表。

2.7、使用append()添加元素至尾部

传统的向列表中添加元素的方法是利用append()函数将元素一个个添加到尾部。

>>> names = ['https://www.wendangku.net/doc/705727704.html,','linux','centos']

>>> names

['https://www.wendangku.net/doc/705727704.html,', 'linux', 'centos']

>>> names.append('redhat')

>>> names

['https://www.wendangku.net/doc/705727704.html,', 'linux', 'centos', 'redhat']

2.8、使用extend()或+=合并列表

使用extend()可以将一个列表合并到另一个列表中：

>>> os = ['unix','linux','windows']

>>> mac = ['mac os']

>>> os.extend(mac)

>>> os

['unix', 'linux', 'windows', 'mac os']

也可以使用+=：

>>> os = ['unix','linux','windows']

>>> mac = ['mac os']

>>> os += mac

>>> os

['unix', 'linux', 'windows', 'mac os']

如果错误地使用了append()，那么mac会被当成一个单独的元素进行添加，而不是将其内容进行合并：

>>> os = ['unix','linux','windows']

>>> mac = ['mac os']

>>> os.append(mac)

>>> os

['unix', 'linux', 'windows', ['mac os']]

2.9、使用insert()在指定位置插入元素

append()函数只能将新元素插入到列表的尾部，而是用insert()函数可以将元素插入到列表中的任意位置中。

>>> Dev = ['Python','Java','PHP','Go','C']

>>> Dev

['Python', 'Java', 'PHP', 'Go', 'C']

>>> Dev.insert(3,'C++')

>>> Dev

['Python', 'Java', 'PHP', 'C++', 'Go', 'C']

2.10、使用del删除指定位置的元素

当列表中的一个元素被删除后，位于它后面的元素会自动往前移动填补出空的位置，且列表长度减1。

>>> Dev = ['Python','Java','PHP','Go','C']

>>> Dev

['Python', 'Java', 'PHP', 'Go', 'C']

>>> del Dev[2]

>>> Dev

['Python', 'Java', 'Go', 'C']

提示：del是Python语句，而不是列表的方法，无法通过Devp[3].del进行调用。

2.11、使用remove()删除具有指定值的元素

如果不确定或不关心元素在列表中的位置，可以使用remove()根据指定的值删除元素。

>>> Dev

['Python', 'Java', 'PHP', 'Go', 'C']

>>> Dev.remove('PHP')

>>> Dev

['Python', 'Java', 'Go', 'C']

2.12、使用pop()获取并删除指定位置的元素

使用pop()同样可以获取列表中制定位置的元素，但在获取完后，改元素会被自动删除。如果你为pop()指定了偏移量，它会返回偏移量对于的元素；如果不指定，则默认使用-1。因此，pop(0)将返回列表的头元素，而pop( )或pop(-1)则会返回列表的尾元素。

>>> Dev = ['Python','Java','PHP','Go','C']

>>> Dev.pop( )

'C'

>>> Dev

['Python', 'Java', 'PHP', 'Go']

>>> Dev.pop(1)

'Java'

>>> Dev

['Python', 'PHP', 'Go']

2.13、使用index()查询具有特定值得元素位置

如果想知道等于某一个值位于列表的什么位置，可以使用index()函数进行查询：>>> Dev = ['Python','Java','PHP','Go','C']

>>> Dev.index('Go')

3

2.14、使用in判断值是否存在

判断一个值是否在列表中存在有许多方式，其中最具有python风格的就是in：

>>> 'C++'in Dev

False

>>> 'C'in Dev

True

同一个值可能出现在列表的多个位置，但只要至少出现一次，in就会返回True：>>> Dev = ['Python','C','Java','PHP','Go','C']

>>> 'C'in Dev

True

2.15、使用count()记录特定值出现的次数

使用count()可以记录某一个特定的值在列表中出现的次数：

>>> Dev = ['Python','C','Java','PHP','Go','C']

>>> Dev.count('C')

2

>>> Dev.count('PHP')

1

>>> Dev.count('C++')

2.16、使用join()转换为字符串

>>> Dev = ['Python','C','Java','PHP','Go','C']

>>> ', '.join(Dev)

'Python, C, Java, PHP, Go, C'

join()实际上是一个字符串方法，而不是列表方法，不能通过Dev.join(‘,’)进行调用。

2.17、使用sort()重新排序元素

在实际应用中，经常需要将列表中的元素按值排序，而不是按照偏移量排序，Python为此提供了两个函数：

列表方法sort()会对元列表进行排序，改变元列表内容；

通用函数sorted()则会返回排好序的列表副本，元列表内容不变；

如果列表中的元素都是数字，它们会默认按照从小到大的升序，如果是字符串，则会按照字符表顺序排序：

>>> Dev = ['Python','C','Java','PHP','Go','C']

>>> sorted_Dev = sorted(Dev)

>>> sorted_Dev

['C', 'C', 'Go', 'Java', 'PHP', 'Python']

sorted_Dev是一个副本，它的创建并不会改变元列表的内容：

>>> Dev

['Python', 'C', 'Java', 'PHP', 'Go', 'C']

但对Dev列表调用sort()函数则会该表原始列表的内容：

>>> Dev.sort()

>>> Dev

['C', 'C', 'Go', 'Java', 'PHP', 'Python']

当列表中的所有元素都是用一种类型的时候，sort()会正常工作。有些时候甚至多种类型也可，例如整型和浮点型，只要它们之间能够自动的互相转换：

>>> number = [2,1,4.0,3]

>>> number

[2, 1, 4.0, 3]

>>> number.sort()

>>> number

[1, 2, 3, 4.0]

默认的排序是升序的，通过添加reverse=True可以改变为降序排列：

>>> number = [2,1,4.0,3]

>>> number.sort(reverse=True)

>>> number

[4.0, 3, 2, 1]

2.18、使用len()获取长度

len()可以返回列表长度：

>>> Dev = ['Python','C','Java','PHP','Go','C']

>>> len(Dev)

6

2.19、使用=赋值，使用copy()赋值

如果讲一个列表赋值给了多个变量，改变其中任何一处会造成其他变量对应的值也修改，如下实例：

>>> a = [1,2,3]

>>> a

[1, 2, 3]

>>> b = a

>>> b

[1, 2, 3]

>>> a[0] = 'surprise'

>>> a

['surprise', 2, 3]

>>> b

['surprise', 2, 3]

通过下面任意一种方法，都可以将一个列表的值赋值给另一个新的列表中：

列表copy()函数

list()转换函数

列表分片[:]

测试初始时我们的列表叫做a，然后利用copy()函数创建b，利用list()创建函数c，并使用列表分片创建d：

>>> a = [1,2,3]

>>> b = a.copy()

>>> c = list(a)

>>> d = a[:]

改变a不影响b、c、d

>>> a[0] = 'insert lists are boring'

>>> a

['insert lists are boring', 2, 3]

>>> b

[1, 2, 3]

>>> c

[1, 2, 3]

>>> d

[1, 2, 3]

3、元组

与列表类似，元组也是由任意类型元素组成的序列。于列表不同的是，元组是不可改变的，这意味着一但元组被定义，将无法再进行增加、删除或修改元素等。因此，元组就像是一个变量列表。

3.1、使用()创建元组

可以用()创建一个空元组

>>> empty_tuple = ()

>>> empty_tuple

()

创建一个或多个的元时，每一个元素后面都需要跟着一个逗号，即使只包含一个元素也不能省略：

>>> one_marx = 'Groucho',

>>> one_marx

('Groucho',)

如果创建的元组所包含的元素数量超过1，最后一个元素后面的逗号都可以省略: >>> marx_tuple = 'Groucho','Chico','Harpo'

>>> marx_tuple

('Groucho', 'Chico', 'Harpo')

可以一次将元组赋值给多个变量：

>>> marx_tuple = 'Groucho','Chico','Harpo'

>>> a,b,c = marx_tuple

>>> a

'Groucho'

>>> b

'Chico'

>>> c

'Harpo'

可以利用元组在一条语句中对多个变量的值进行交换，而不需要借助零时变量：>>> password = 'puhjjgfd'

>>> icecream = 'gbcbdgrdgdfg'

>>> password,icecream = icecream,password

>>> password

'gbcbdgrdgdfg'

>>> icecream

'puhjjgfd'

tuple()函数可以用其他类型的数据类创建元组：

>>> marx_list = ['Groucho','Chico','Harpo']

>>> tuple(marx_list)

('Groucho', 'Chico', 'Harpo')

4、字典

字典（dictionary）与列表类似，但其中元素的顺序无关紧要，因为他们不是通过像0或1的偏移量访问的，取而代之，每个元素拥有与之对应的互不相同的键（key），需要通过键来访问元素。键通常是字符串，但它还可以是Python中其它任意的不可变类型：布尔型、浮点型、元组、字符串，以及其它一些类型。字典是可变的，因此你可以增加、删除或修改其中的键值对。

提示：在其他语言中，字典可能会被称作关系型数组、哈希表或哈希图。在Python

中，字典还经常被简写成dict。

4.1、使用{}创建字典

用大括号({})将一系列以逗号隔开的键值对（key：value）包裹起来即可进行字典当的创建。最简单的字典是空字典，它不包含任何键值对：

>>> empty_dict = {}

>>> empty_dict

{}

创建一个字典：

>>> bierce = {

... "day":"you or in ?",

... "names":"https://www.wendangku.net/doc/705727704.html,",

... }

>>> bierce

#在交互式解释器中输入字典的名称就会打印出字典的内容：

{'day': 'you or in ?', 'names': 'https://www.wendangku.net/doc/705727704.html,'}

提示：Python允许在列表、元组或字典的最后一个元素后面添加逗号，这不会产生

任何问题。

4.2、使用dict()转换为字典

可以使用dict()将包含双值子序列的序列转换成字典，每个子序列的第一个元素作为键，第二个元素作为值：

>>> lol = [['a','b'],['c','d'],['e','f']]

>>> dict(lol)

{'e': 'f', 'a': 'b', 'c': 'd'}

#字典中元素的顺序是无关紧要的，实际存储顺序可能取决你添加元素的顺序。

可以对任何包含双值子序列的序列使用dict()，下面是其他的例子：

包含双值元组的列表：

>>> lot = [('a','b'),('c','d'),('e','f')]

>>> dict(lot)

{'e': 'f', 'a': 'b', 'c': 'd'}

包含双值列表的元组：

>>> tol = (['a','b'],['c','d'],['e','f'])

>>> dict(tol)

{'e': 'f', 'a': 'b', 'c': 'd'}

双字符的字符串组成的列表：

>>> los = ['ab','cd','ef']

>>> dict(los)

{'e': 'f', 'a': 'b', 'c': 'd'}

双字符的字符串组成的元组

>>> tos = ('ab','cd','ef')

>>> dict(tos)

{'e': 'f', 'a': 'b', 'c': 'd'}

4.3、使用[key]添加或修改元素

向字典中添加元素只需要指定该元素的键并赋予相应的值即可。如果该元素的键已经存在于字典中，那么该键对应的旧值会被新值取代，如果改元素的键并未在字典中出现，则会被加入字典。

建立一个包含大多数Monty Python成员的名字字典，用他们的姓当作键，名当作值：>>> pythons = {

... 'Chapman':'Graham',

... 'Cleese':'John',

... 'Idle':'Eric',

... 'Jones':'Terry',

... 'Palin':'Michael',

... }

>>> pythons

{'Chapman': 'Graham', 'Jones': 'Terry', 'Idle': 'Eric', 'Cleese':

'John', 'Palin': 'Michael'}

人员添加完成后貌似落下了一个人，生于美国的Terry Gilliam。下面是一个糟糕的程序员为了将Gilliam添加进字典而编写的代码，他粗心的将Gilliam的名字打错了：>>> pythons['Gilliam'] = 'Gerry'

>>> pythons

{'Chapman': 'Graham', 'Jones': 'Terry', 'Gilliam': 'Gerry', 'Pali

n': 'Michael', 'Idle': 'Eric', 'Cleese': 'John'}

下面是另一位颇具Python风格的程序员修改的代码：

>>> pythons['Gilliam'] = 'Terry'

>>> pythons

{'Chapman': 'Graham', 'Jones': 'Terry', 'Gilliam': 'Terry', 'Pali n': 'Michael', 'Idle': 'Eric', 'Cleese': 'John'}

使用通过相同的键(‘Gilliam’)将原本对应的值’Gerry’修改为为’Terry’。

4.4、使用update()合并字典

使用update()可以将一个字典的键值对合并到另一个字典中去。

首先创建一个包含所有成员的字典pythons：

>>> pythons = {

... 'Chapman':'Graham',

... 'Cleese':'John',

... 'Idle':'Eric',

... 'Jones':'Terry',

... 'Palin':'Michael',

... }

接着创建一个包含其他喜剧演员的字典，名为others：

>>> others = { 'Marx':'Groucho','Howard':'Moe' }

现在，出现了另一位糟糕的程序员，它认为others应该被归入Monty Python成员中：>>> pythons.update(others)

>>> pythons

{'Cleese': 'John', 'Idle': 'Eric', 'Marx': 'Groucho', 'Palin': 'Mic hael', 'Jones': 'Terry', 'Chapman': 'Graham', 'Howard': 'Moe'}

如果待添加的字典与待扩充的字典包含同样的键，新归入字典的值会取代原有的值：>>> first = { 'a':'1','b':'2' }

>>> second = { 'b':'platypus' }

>>> first.update(second)

>>> first

{'a': '1', 'b': 'platypus'}

4.5、使用del删除具有制定键的元素

创建一个字典：

>>> os = { 'Linux':'CentOS','Names':'https://www.wendangku.net/doc/705727704.html,','Window s':'Win XP' }

>>> os

{'Names': 'https://www.wendangku.net/doc/705727704.html,', 'Windows': 'Win XP', 'Linux': 'Cent OS'}

删除Linux：

>>> del os['Linux']

>>> os

{'Names': 'https://www.wendangku.net/doc/705727704.html,', 'Windows': 'Win XP'}

4.6、使用clear()删除所有元素

使用clear()，或者给字典变量重新赋值一空字典({})可以将字典中所有元素删除：>>> os

{'Names': 'https://www.wendangku.net/doc/705727704.html,', 'Windows': 'Win XP'}

>>> os.clear()

>>> os

{}

>>> os = {}

>>> os

{}

4.7、使用in判断是否存

如果你希望判断某一个键是否存在于一个字典中，可以使用in。

>>> os = { 'Linux':'CentOS','Names':'https://www.wendangku.net/doc/705727704.html,','Window s':'Win XP' }

>>> 'Linux'in os

True

#如果存在则返回True

>>> 'Centos'in os

False

#如果不存在则返回False

4.8、使用[key]获取元素

这是对字典最常进行的操作，只需要制定字典名和键即可获得对应的值：>>> os = { 'Linux':'CentOS','Names':'https://www.wendangku.net/doc/705727704.html,','Window s':'Win XP' }

>>> os['Linux']

'CentOS'

如果字典中不包含一个制定的键，会产生一个异常：

>>> os['redhat']

Traceback (most recent call last):

File "", line 1, in

KeyError: 'redhat'

有两种方法可以避免这种情况发生，第一种是在访问前通过in测试是否存在：>>> 'redhat'in os

False

另一种方法是使用字典函数get()：

>>> os.get('Linux')

'CentOS'

反之，若键不存在，如果你指定了可选值，那么get()函数将返回这可选值：>>> os.get('redhat','No')

'No'

否则，会得到None（在交互解释器中什么也不会显示）：

>>> os.get('redhat')

>>>

4.9、使用keys()获取所有键

使用kets()可以获得字典中所有的键。

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

>>> number.keys()

dict_keys(['c', 'a', 'b'])

在python2里，keys()会返回一个列表，而在python3里则会返回dict_keys()，它是键的迭代形式。这种返回形式对于大型的字典非常有用，应为他不需要时间和空间来创建返回的列表，有时你需要的可能就是一个完整的列表，而在python3中，你只能自己调用list()将

dict_keys()转换为列表类型。

>>> list(number.keys())

['c', 'a', 'b']

在python3里，你同样需要手动使用list()将values()和items()的返回值转换为普通的Python列表。

4.10、使用values()获取所有值

使用values()可以获取字典中的所有值：

>>> list(number.values())

['3', '1', '2']

4.11、使用items()获取所有键值对

使用items()函数可以获取字典中所有的键值对：

>>> list(number.items())

[('c', '3'), ('a', '1'), ('b', '2')]

每一个键值都会以元组的形式返回。

4.12、使用=赋值，使用copy()赋值

与列表一样，对字典内容进行修改会反映到所有与之相关联的变量名上：>>> signals = {'green':'go','yellow':'go faster','red':'smile for t he camera'}

>>> save_signals = signals

>>> signals['blue'] = 'confuse everyone'

>>> signals

{'green': 'go', 'red': 'smile for the camera', 'blue': 'confuse eve ryone', 'yellow': 'go faster'}

>>> save_signals

{'green': 'go', 'red': 'smile for the camera', 'blue': 'confuse eve ryone', 'yellow': 'go faster'}

若想避免这种情况，可以使用copy()将字典赋值到一个新的字典中：

>>> signals = {'green':'go','yellow':'go faster','red':'smile for t he camera'}

>>> origina_signals = signals.copy()

>>> signals['bule'] = 'confuse everyone'

>>> signals

{'bule': 'confuse everyone', 'green': 'go', 'red': 'smile for the c amera', 'yellow': 'go faster'}

>>> origina_signals

{'green': 'go', 'red': 'smile for the camera', 'yellow': 'go faste

r'}

5、集合

集合就像舍弃了值，仅剩下键的字典一样，键与键之间也不允许重复，如果你仅仅想知道某一个元素是否存在而不关心其他的，使用集合是一个非常不错的选择，如果需要为键附加其他信息的话，建议使用字典。

5.1、使用set()创建集合

你可以使用set()函数来创建一个集合，或者用大括号将一系列以逗号隔开的值包裹起来：

Python3 字典

字典是另一种可变容器模型，且可存储任意类型对象。 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中,格式如下所示： 键必须是唯一的，但值则不必。 值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。 一个简单的字典实例： 也可如此创建字典： 访问字典里的值 把相应的键放入到方括号中，如下实例: 实例 #!/usr/bin/python3dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} pri nt("dict['Name']: ", dict['Name'])print("dict['Age']: ", dict['Age']) 以上实例输出结果：

如果用字典里没有的键访问数据，会输出错误如下： 实例 #!/usr/bin/python3dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}; pr int("dict['Alice']: ", dict['Alice']) 以上实例输出结果： 修改字典 向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例: 实例 #!/usr/bin/python3dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} dic t['Age'] = 8; # 更新 Age dict['School'] = "菜鸟教程"# 添加信息print("dict[' Age']: ", dict['Age'])print("dict['School']: ", dict['School']) 以上实例输出结果： 删除字典元素

python列表(list)操作

列表在python中感觉是最灵活的有序集合对象类型，有点像其他语言的数组的类型 列表可以嵌套，索引和分片操作 嵌套：l3 = ['a',['b','cc']] 索引:l3[1] 分片：l3[2:4] 已知列表：a = [1,2,3,4,5] python list 索引: 列表索引的下标默认是从第0个开始的，比如我们需要获取第1个元素1，那我们可以用a[0].如果需要获取 最后一个元素，那可以通过a[-1]。 1 append()方法 向列表的尾部插入数据 有点像push操作 它可以push大部分数据，比如数字，字符串到列表里， 比如: a.append(6) a.append(7) a.append([1,3]) 如果你要进行列表的合并的话，用下面的extend方法 2 extend()方法

b = ['a','b'] a.extend(b) print a 输出列表a的结果是[1,2,3,4,5,a,b] 3 insert()方法 比如 a.insert(1,66) 输出结果是[1, 66, 2, 3, 4, 5, 'a', 'b'] 4 remove()方法 a.remove(66) 输出的结果是:[1, 2, 3, 4, 5, 'a', 'b'] 删除列表里面指定的值，如果没有的话，报错： Traceback (most recent call last): File " ", line 1, in ValueError: list.remove(x): x not in list 4 pop方法 a.pop() 输出的结果是'b' a.pop(2) 输出的结果是3 如果你没有指定参数的话，默然是返回列表的最后一个字符，如果指定的话，返回当前指定的索引的值 5 index方法 a.index(2)

Python中执行系统命令常见的几种方法

Python中执行系统命令常见的几种方法 (1)os.system #这个方法是直接调用标准C的system()函数，仅仅在一个子终端运行系统命令，而不能获取命令执行后的返回信息。 os.system(command)->exit_status Execute the command(a string)in a subshell. #如果再命令行下执行，结果直接打印出来 (2)os.popen #该方法不但执行命令还返回执行后的信息对象，是通过一个管道文件将结果返回。 popen(command[,mode='r'[,bufsize]])->pipeOpen a pipe to/from a command returning a file object. 例如： 好处在于：将返回的结果赋于一变量，便于程序的处理。 (3)使用模块commands模块 (status,result)=commands.getstatusoutput(cmd) status返回命令执行的返回值 result返回命令执行结果

注意1：在类unix的系统下使用此方法返回的返回值（status）与脚本或命令执行之后的返回值不等，这是因为调用了os.wait()的缘故，具体原因就得去了解下系统wait()的实现了。需要正确的返回值（status），只需要对返回值进行右移8位操作就可以了。 注意2：当执行命令的参数或者返回中包含了中文文字，那么建议使用subprocess。 (4)使用模块subprocess Subprocess是一个功能强大的子进程管理模块，是替换os.system,os.spawn*等方法的一个模块。 Class subprocess.Popen(args,bufsize=0,executable=None,stdin=None,stdout=None, stderr=None,preexec_fn=None, close_fds=True,shell=False,cwd=None,env=None,universal_newlines=False, startupinfo=None, creationflags=0,restore_signals=True,start_new_session=False,pass_fds=()) 有丰富的参数可以进行配置，可供我们自定义的选项多，灵活性高。之前我使用os.system 的时候遇到文件描述符被子进程继承的问题，后来通过close_fds=False这个参数来解决的。

《Python程序设计》习题与答案

《Python程序设计》习题与参考答案 第1章基础知识 1.1 简单说明如何选择正确的Python版本。 答： 在选择Python的时候，一定要先考虑清楚自己学习Python的目的是什么，打算做哪方面的开发，有哪些扩展库可用，这些扩展库最高支持哪个版本的Python，是Python 2.x还是Python 3.x，最高支持到Python 2.7.6还是Python 2.7.9。这些问题都确定以后，再做出自己的选择，这样才能事半功倍，而不至于把大量时间浪费在Python的反复安装和卸载上。同时还应该注意，当更新的Python版本推出之后，不要急于更新，而是应该等确定自己所必须使用的扩展库也推出了较新版本之后再进行更新。 尽管如此，Python 3毕竟是大势所趋，如果您暂时还没想到要做什么行业领域的应用开发，或者仅仅是为了尝试一种新的、好玩的语言，那么请毫不犹豫地选择Python 3.x系列的最高版本（目前是Python 3.4.3）。 1.2 为什么说Python采用的是基于值的内存管理模式？ 答： Python采用的是基于值的内存管理方式，如果为不同变量赋值相同值，则在内存中只有一份该值，多个变量指向同一块内存地址，例如下面的代码。 >>> x = 3 >>> id(x) 10417624 >>> y = 3 >>> id(y) 10417624 >>> y = 5 >>> id(y) 10417600 >>> id(x) 10417624 1.3 在Python中导入模块中的对象有哪几种方式？ 答：常用的有三种方式，分别为 import 模块名[as 别名]

●from 模块名import 对象名[ as 别名] ●from math import * 1.4 使用pip命令安装numpy、scipy模块。 答：在命令提示符环境下执行下面的命令： pip install numpy pip install scipy 1.5 编写程序，用户输入一个三位以上的整数，输出其百位以上的数字。例如用户输入1234，则程序输出12。（提示：使用整除运算。） 答： 1）Python 3.4.2代码： x = input('Please input an integer of more than 3 digits:') try: x = int(x) x = x//100 if x == 0: print('You must input an integer of more than 3 digits.') else: print(x) except BaseException: print('You must input an integer.') 2）Python 2.7.8代码： import types x = input('Please input an integer of more than 3 digits:') if type(x) != types.IntType: print 'You must input an integer.' elif len(str(x)) != 4: print 'You must input an integer of more than 3 digits.' else: print x//100

Python语句、函数与方法的使用技巧总结

Python语句、函数与方法的使用技巧总结 显示有限的接口到外部 当发布python第三方package时，并不希望代码中所有的函数或者class可以被外部import，在__init__.py中添加__all__属性，该list中填写可以import 的类或者函数名，可以起到限制的import的作用，防止外部import其他函数或者类。 #!/usr/bin/env python # -*- coding: utf-8 -*- from base import APIBase from client import Client from decorator import interface, export, stream from server import Server from storage import Storage from util import (LogFormatter, disable_logging_to_stderr, enable_logging_to_kids, info) __all__ = ['APIBase', 'Client', 'LogFormatter', 'Server', 'Storage', 'disable_logging_to_stderr', 'enable_logging_to_kids', 'export', 'info', 'interface', 'stream'] with的魔力

with语句需要支持上下文管理协议的对象，上下文管理协议包含__enter__和__exit__两个方法。with语句建立运行时上下文需要通过这两个方法执行进入和退出操作。 其中上下文表达式是跟在with之后的表达式，该表达式返回一个上下文管理对象。 # 常见with使用场景 with open("test.txt", "r") as my_file: # 注意, 是__enter__()方法的返回值赋值给了my_file, for line in my_file: print line 知道具体原理，我们可以自定义支持上下文管理协议的类，类中实现__enter__和__exit__方法。 #!/usr/bin/env python # -*- coding: utf-8 -*- class MyWith(object): def __init__(self): print "__init__ method" def __enter__(self):

python一些常用方法

1.list 方法 一、创建一个列表 只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示： 与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。 二、访问列表中的值 使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示： print "list1[0]: ", list1[0] print "list2[1:5]: ", list2[1:5] 以上实例输出结果： 三、更新列表 你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示： list = ['physics', 'chemistry', 1997, 2000]; print "Value available at index 2 : " print list[2]; list[2] = 2001; print "New value available at index 2 : " print list[2];

以上实例输出结果： 四、删除列表元素 可以使用del 语句来删除列表的的元素，如下实例： list1 = ['physics', 'chemistry', 1997, 2000]; print list1; del list1[2]; print "After deleting value at index 2 : " print list1; 以上实例输出结果： 五、Python列表脚本操作符 列表对+ 和* 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。如下所示： Python 表达式结果描述 len([1, 2, 3])3长度 [1, 2, 3] + [4, 5, 6][1, 2, 3, 4, 5, 6]组合 ['Hi!'] * 4['Hi!', 'Hi!', 'Hi!', 'Hi!']重复 3 in [1, 2, 3]True元素是否存在于列表中 for x in [1, 2, 3]: print x, 1 2 3迭代

Python中常见的数据结构可以统称为容器

Python中常见的数据结构可以统称为容器（container）。序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器。 一、序列（列表、元组和字符串） 序列中的每个元素都有自己的编号。Python中有6种内建的序列。其中列表和元组是最常见的类型。其他包括字符串、Unicode字符串、buffer对象和xrange对象。下面重点介绍下列表、元组和字符串。 1、列表 列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。 （1）、创建 通过下面的方式即可创建一个列表： 1 2 3 4list1=['hello','world'] print list1 list2=[1,2,3] print list2 输出： […hello?, …world?] [1, 2, 3] 可以看到，这中创建方式非常类似于javascript中的数组。 （2）、list函数 通过list函数（其实list是一种类型而不是函数）对字符串创建列表非常有效： 1 2list3=list("hello") print list3

输出： […h?, …e?, …l?, …l?, …o?] 2、元组 元组与列表一样，也是一种序列，唯一不同的是元组不能被修改（字符串其实也有这种特点）。（1）、创建 1 2 3 4 5 6t1=1,2,3 t2="jeffreyzhao","cnblogs" t3=(1,2,3,4) t4=() t5=(1,) print t1,t2,t3,t4,t5 输出： (1, 2, 3) (…jeffreyzhao?, …cnblogs?) (1, 2, 3, 4) () (1,) 从上面我们可以分析得出： a、逗号分隔一些值，元组自动创建完成； b、元组大部分时候是通过圆括号括起来的； c、空元组可以用没有包含内容的圆括号来表示； d、只含一个值的元组，必须加个逗号（,）； （2）、tuple函数 tuple函数和序列的list函数几乎一样：以一个序列（注意是序列）作为参数并把它转换为元组。如果参数就算元组，那么该参数就会原样返回： 1t1=tuple([1,2,3])

Python常见数据结构整理

Python常见数据结构整理 2014年10月15日tenking阅读23 次 Python中常见的数据结构可以统称为容器（container）。序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器。 一、序列（列表、元组和字符串） 序列中的每个元素都有自己的编号。Python中有6种内建的序列。其中列表和元组是最常见的类型。其他包括字符串、Unicode字符串、buffer对象和xrange对象。下面重点介绍下列表、元组和字符串。 1、列表 列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。 （1）、创建 通过下面的方式即可创建一个列表： 1 2 3 4list1=['hello','world'] print list1 list2=[1,2,3] print list2 输出： […hello?, …world?] [1, 2, 3] 可以看到，这中创建方式非常类似于javascript中的数组。（2）、list函数

通过list函数（其实list是一种类型而不是函数）对字符串创建列表非常有效： 1 2list3=list("hello") print list3 输出： […h?, …e?, …l?, …l?, …o?] 2、元组 元组与列表一样，也是一种序列，唯一不同的是元组不能被修改（字符串其实也有这种特点）。（1）、创建 1 2 3 4 5 6t1=1,2,3 t2="jeffreyzhao","cnblogs" t3=(1,2,3,4) t4=() t5=(1,) print t1,t2,t3,t4,t5 输出： (1, 2, 3) (…jeffreyzhao?, …cnblogs?) (1, 2, 3, 4) () (1,)从上面我们可以分析得出： a、逗号分隔一些值，元组自动创建完成； b、元组大部分时候是通过圆括号括起来的； c、空元组可以用没有包含内容的圆括号来表示； d、只含一个值的元组，必须加个逗号（,）；（2）、tuple函数

Python教程——字典

#Python教程——字典 ##### 什么是字典 字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值 (key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中，如同json一样 如何操作字典 操作字典前我们先创建一个字典 dictionary = { 'id':1, 'name':'Jhon', 'age':18 } 访问字典中的值 print("name为："+dictionary['name']) print(dictionary) 添加新的键值对 dictionary = { 'id':1, 'name':'Jhon', 'age':18 } dictionary['phone'] = 12345678 dictionary['address'] = 'beijing' print(dictionary) 修改字典中的值 修改字典中的值也很简单，只需要获取key就可以根据key来设定新的值dictionary = { 'id':1, 'name':'Jhon', 'age':18 } dictionary['age'] = 20 print(dictionary)

删除键值对 删除键值对也非常简单，如： dictionary = { 'id':1, 'name':'Jhon', 'age':20 } del dictionary['name'] print(dictionary) 遍历字典 dictionary = { 'id':1, 'name':'Jhon', 'age':18 } for key,value in dictionary.items(): print('key:'+key) print('value:'+str(value)) 注意，如果字典中key的值包含整数，不能直接输出，需要转换成字符串才能输出，不然会报错

python语言零基础入门-字典映射

1、字典dict 基本概念 字典是另一种可变容器模型，且可存储任意类型对象。 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 键必须是唯一的，但值则不必。 In [1]: {'小头爸爸': 35, '大头儿子': 6, '隔壁老王': 37} [{'age': 18, 'name': 'Tom'}, {'age': 19, 'name': 'Jack'}, {'age': 17, 'name': 'Ale x'}] # 什么是映射？什么是字典dict ？ name = ['大头儿子','小头爸爸','隔壁老王'] age = [6,35,37] # 首先虽然序列是有顺序的，但还是不能直接把名字和年龄关联起来，这里只是顺序对上，且并没有一对一的关系 dic = {'大头儿子':6, '小头爸爸': 35, '隔壁老王':37} print (dic,type (dic)) # 用{}来表示，按照key ：value 来表示字典中的元素，其中key 是键，value 是值，key-value 也就是键值对# 这里dic 就是一个字典类型的变量 dic = [{'name':'Tom', 'age':18},{'name':'Jack', 'age':19},{'name':'Alex', "age":17}] print (dic) # 一个以字典为元素的列表，有没有觉得键值对很像数据中的字段和字段值？

{'a': 2} {'var1': 1, 'var2': 'hello', 'var3': [1, 2, 3], 'var4': {'a': 1, 'b': 2}} {'var2': 'hello', 'var5': '添加一个值', 'var3': [1, 2, 3], 'var4': '任意修改其中一个 值'} {} # 字典的特点 dic = {'a':1,'b':2,'c':3} # 键值对，一定共同出现，不能只有一个 dic = {'a':1,'a':2} print (dic) # 不允许同一个键出现两次：创建时如果同一个键被赋值两次，后一个值会被记住 dic = {'var1':1, 'var2':'hello', 'var3':[1,2,3], 'var4':{'a':1,'b':2}} # key 必须是不可变对象，value 则可以是任意对象：数值，字符串，序列，字典 print (dic) # 字典是一个无序集合,序列由于没有key 来做对应，所以以顺序来对应值# 序列有顺序，字典没有！ dic['var5'] = '添加一个值' # 任意添加元素 dic['var4'] = '任意修改其中一个值' # 任意修改元素 del dic['var1'] # 任意删除元素 print (dic) dic.clear() # 清空词典所有条目 print (dic) del dic # 删除词典#print(dic)

Python常见数据结构整理

Python常见数据结构整理 Python中常见的数据结构可以统称为容器（container）。序列（如列表和元组）、映射（如字典） 以及集合（set）是三类主要的容器。 一、序列（列表、元组和字符串） 序列中的每个元素都有自己的编号。Python中有6种内建的序列。其中列表和元组是最常见的类型。其他包括字符串、Unicode字符串、buffer对象和xrange对象。下面重点介绍下列表、元组和字符串。 1、列表 列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。 （1）、创建 通过下面的方式即可创建一个列表： 输出： ['hello', 'world'] [1, 2, 3] 可以看到，这中创建方式非常类似于javascript中的数组。 （2）、list函数 通过list函数（其实list是一种类型而不是函数）对字符串创建列表非常有效： 输出： ['h', 'e', 'l', 'l', 'o'] 2、元组 元组与列表一样，也是一种序列，唯一不同的是元组不能被修改（字符串其实也有这种特点）。

输出： (1, 2, 3) ('jeffreyzhao', 'cnblogs') (1, 2, 3, 4) () (1,) 从上面我们可以分析得出： a、逗号分隔一些值，元组自动创建完成； b、元组大部分时候是通过圆括号括起来的； c、空元组可以用没有包含内容的圆括号来表示； d、只含一个值的元组，必须加个逗号（,）； （2）、tuple函数 tuple函数和序列的list函数几乎一样：以一个序列（注意是序列）作为参数并把它转换为元组。如果参数就算元组，那么该参数就会原样返回： 输出： (1, 2, 3) ('j', 'e', 'f', 'f') (1, 2, 3) Traceback (most recent call last): File "F:\Python\test.py", line 7, in t4=tuple(123) TypeError: 'int' object is not iterable 3、字符串

python常用函数年初大总结

1.常用内置函数：(不用import就可以直接使用) help(obj) 在线帮助, obj可是任何类型 callable(obj) 查看一个obj是不是可以像函数一样调用 repr(obj) 得到obj的表示字符串，可以利用这个字符串eval重建该对象的一个拷贝 eval_r(str) 表示合法的python表达式，返回这个表达式 dir(obj) 查看obj的name space中可见的name hasattr(obj,name) 查看一个obj的name space中是否有name getattr(obj,name) 得到一个obj的name space中的一个name setattr(obj,name,value) 为一个obj的name space中的一个name指向vale这个object delattr(obj,name) 从obj的name space中删除一个name vars(obj) 返回一个object的name space。用dictionary表示 locals() 返回一个局部name space,用dictionary表示 globals() 返回一个全局name space,用dictionary表示 type(obj) 查看一个obj的类型 isinstance(obj,cls) 查看obj是不是cls的instance issubclass(subcls,supcls) 查看subcls是不是supcls的子类 类型转换函数 chr(i) 把一个ASCII数值,变成字符 ord(i) 把一个字符或者unicode字符,变成ASCII数值 oct(x) 把整数x变成八进制表示的字符串 hex(x) 把整数x变成十六进制表示的字符串

Python程序设计基础教案16--列表类型2

授课教案

授课教案附页 教学设计说明一、旧课回顾 创建一个列表，列表中的元素依次为：姓名、班级，并完成： （1）输出该学生的基本信息（姓名、班级）； （2）增加语文成绩 （3）增加英语成绩和数学成绩 （4）将性别这一项插入到姓名后面 （5）修改班级为：software1801 （6）删除语文成绩 任务分析： ?题干： 创建一个列表。考察列表的概念：列表是将各种不同类型的元素用逗号分隔 开，放到一对中括号里构成的数据类型。 创建一个列表，列表中的元素依次为：姓名、班级。 代码示例： ?问题（1）：输出该学生的基本信息（姓名、班级） 考察列表中元素访问方法。列表中第i个元素可以用l[i]表示，因此可以使用 for循环，因此访问列表的第0个到第len(l)-1个元素。 代码示例1： 补充：列表本身可以当做一个序列。因此，访问列表中的每一个元素还有另 一种方法。 代码示例2：

方法一：使用range( )产生一个整数序列，表示列表l中每个元素的在列表中的位置（标号），然后用l[i]表示第i个元素。 方法二：直接把列表l本身看做一个序列，此时循环变量i表示列表l中的第i个元素。 ?问题（2）：增加语文成绩 考察列表中增加元素的方法。问题（2）仅增加语文成绩，即仅增加一个元素，使用l.append( )方法。 代码示例： ?问题（3）：增加英语成绩和数学成绩 考察列表中增加元素的方法。可以使用两次l.append( )方法，依次增加英文成绩和数学成绩。也可以使用l.extend( )函数，将英文成绩和数学成绩作为一个新的列表直接追加都原列表中。 代码示例： ?问题（4）：将性别这一项插入到姓名后面 考察l.insert( )的用法。l.insert(i,x)：把x查到列表的第i个位置。 代码示例： ?问题（5）：修改班级为：software1801 考察里列表元素的修改。l[i]=x：将列表中第i个元素修改为x。

Python 3语法小记 字典 dictionary

Python 3语法小记字典dictionary 字典是Python里面一种无序存储结构，存储的是键值对key - value。关键字应该为不可变类型，如字符串、整数、包含不可变对象的元组。 字典的创建很简单，用d = {key1 : value2, key2 : value2}的形式就可以创建一个新的字典，当然也可以通过dict 接受一个含有键，值的序列对或者关键字参数来创建字典。 键可以是多种类型，但键是唯一的不重复的，值可以不唯一 [python]view plain copy print? 1.>>> d = {'a':1, 'b':2} 2.>>> d 3.{'b': 2, 'a': 1} 4.>>> L = [('Jonh',18), ('Nancy',19)] 5.>>> d = dict(L) #通过包含键值的列表创建 6.>>> d 7.{'Jonh': 18, 'Nancy': 19} 8.>>> T = tuple(L) 9.>>> T 10.(('Jonh', 18), ('Nancy', 19)) 11.>>> d = dict(T) #通过包含键值的元组创建 12.>>> d 13.{'Jonh': 18, 'Nancy': 19} 14.>>> d = dict(x = 1, y = 3) #通过关键字参数创建 15.>>> d 16.{'x': 1, 'y': 3} 17.>>> d[3] = 'z' 18.>>> d 19.{3: 'z', 'x': 1, 'y': 3} 还有一个创建字典的方法就是fromkeys(S [ , v]) python里的解释是New dict with key from S and value equal to v ，即将S里的元素作为键，v作为所有键的值，v 的默认值为None。可以通过已存在的字典d 调用d.fromkeys(S [, v] ) 也可以通过类型调用 dict.fromkeys( S [, v] ) [python]view plain copy print? 1.>>> d 2.{3: 'z', 'y': 3} 3.>>> L1 = [1,2,3] 4.>>> d.fromkeys(L1) 5.{1: None, 2: None, 3: None}

黑马程序员Python教程：Python列表的6种操作实例

在使用Python的时候，经常会用到列表，列表(list)就是动态数组，相当于C++标准库的Vector。但不同的是，Python的列表可以存储多种数据类型于一身，非常强大。 下面介绍几种Python列表的常用用法： 一. 列表的创建： 使用[] 把数据包含起来，便可以创建一个列表了。 1. [ ] 可以不包含任何数据，则表示创建一个空列表 >>> name = [] 2. [ ] 也可以包含多种数据类型的数据 >>> name = ["damao", 30, "ermao"] 二. 列表的打印： 1. 使用内置函数print() 便可打印整个列表里的数据” >>> print(name) ["damao", 30, "ermao"] 2. 当然也可以打印列表的某个下标的数据： >>> print(name[0]) damao 3. 也可以分片打印列表的某段下标的数据 >>> print(name[0:2])

['damao', 30] #注意，没有打印name[2]的数据:) 4. 如果想要分别打印列表里的每个数据，只需要一个for就可以搞定： >>> for each in name: print(each) damao 30 ermao 5. 当然也可以直接打印出列表内数据的个数： >>> print(len(name)) 3 三、列表的扩展： 1. 我们可以在列表末尾追加一个任意数据类型数据： >>> name.append(["daoluan", 666]) >>> print(name) ['damao', 30, 'ermao', ['daoluan', 666]] 2. 也可以在列表末尾追加一个列表里的所有数据： >>> name.extend(["sanmao", 10, "simao"]) >>> print(name)

python一些常用方法

1.list方法 一、创建一个列表 只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示： 与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。 二、访问列表中的值 使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示： print"list1[0]:",list1[0] print"list2[1:5]:",list2[1:5] 以上实例输出结果： 三、更新列表 你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示： list=['physics','chemistry',1997,2000]; print"Value available at index2:" print list[2]; list[2]=2001; print"New value available at index2:" print list[2];

以上实例输出结果： 四、删除列表元素 可以使用del语句来删除列表的的元素，如下实例： list1=['physics','chemistry',1997,2000]; print list1; del list1[2]; print"After deleting value at index2:" print list1; 以上实例输出结果： 五、Python列表脚本操作符 列表对+和*的操作符与字符串相似。+号用于组合列表，*号用于重复列表。如下所示： Python表达式结果描述 len([1,2,3])3长度 [1,2,3]+[4,5,6][1,2,3,4,5,6]组合 ['Hi!']*4['Hi!','Hi!','Hi!','Hi!']重复 3in[1,2,3]True元素是否存在于列表中 for x in[1,2,3]:print x,123迭代

列表list——python

第 I 条列表： 节 1.01创建列表的方式： 1使用赋值运算符直接创建列表 1.1Listname=[元素1，元素2，……，元素n] 2创建空列表 3创建数值列表 节 1.02删除列表del： Is not defined 未被定义 注意：python自带垃圾回收机制，会自动销毁不用的列表，所以即使我们不手动删除，python 也会自动将其回收。 节 1.03访问列表元素：即获取列表中的内容 3种方法：1.直接使用print（）输出2.索引Indexing 3.切片Slicing Ctrl +S 保存文件 F5 运行文件

节 1.04遍历列表 方法：1.直接使用for循环（只能输出元素的值） 2.使用for循环和enumerate()函数（需要索引值时） 写两行的： 节 1.05添加元素或列表： 向列表里添加元素所用函数：

1. append（加到列表末尾） Listname.append() 2.insert() (向列表中制定位置插入元素) 没有append的执行效率高 将一个列表添加到另一个列表中的函数extend() (加到原列表的后面) 节 1.06修改元素： 找到索引值，直接修改就行 list1 = ['长亭外','古道边','芳草碧连天'] list1[2] = '一行白鹭上青天' print(list1) 节 1.07删除元素 (a)根据索引删除 和删除列表相似，用del语句 del的使用：del listname[] （语句放前面） (b)根据元素值删除(不知道索引值时) 使用remove()方法 listname.remove() （方法放后面） 节 1.08对列表进行统计 (a)获取制定元素出现的次数count() Llistname.coount(obj) (b)获取制定元素首次出现的下标index() Listname.index(obj)

PYTHON语言常用语法摘要

Python语言常用语法 在Python中有4种类型的数——整数、长整数、浮点数和复数。 使用变量时只需要给它们赋一个值。不需要声明或定义数据类型。 不要混合使用制表符和空格来缩进，因为这在跨越不同的平台的时候，无法正常工作。我强烈建议你在每个缩进层次使用单个制表符或两个或四个空格。 在Python中有三种控制流语句——if、for和while。 在Python中没有switch语句。你可以使用if..elif..else语句来完成同样的工作（在某些场合，使用字典会更加快捷。） Break:如果你从for或while循环中终止，任何对应的循环else块将不执行 函数通过def关键字定义。def关键字后跟一个函数的标识符名称，然后跟一对圆括号。圆括号之中可以包括一些变量名，该行以冒号结尾。接下来是一块语句，它们是函数体。下面这个例子将说明这事实上是十分简单的。 Global定义全局变量。在函数定义的形参名后加上赋值运算符（=）和默认值，从而给形参指定默认参数值。 重要 只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。 这是因为赋给形参的值是根据位置而赋值的。例如，def func(a,b=5)是有效的，但是def func(a=5,b)是无效的。 return语句用来从一个函数返回即跳出函数。我们也可选从函数返回一个值。 pass语句在Python中表示一个空的语句块。 Python有一个很奇妙的特性，称为文档字符串，它通常被简称为docstrings。DocStrings是一个重要的工具，由于它帮助你的程序文档更加简单易懂，你应该尽量使用它。你甚至可以在程序运行的时候，从函数恢复文档字符串！ 文档字符串的惯例是一个多行字符串，它的首行以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。强烈建议你在你的函数中使用文档字符串时遵循这个惯例。调用时用print函数名.__doc__(双下划线)。 __name__属性 当一个模块被第一次输入的时候，这个模块的主块将被运行。假如我们只想在程序本身被使用的时候运行主块，而在它被别的模块输入的时候不运行主块，我们该怎么做呢？这可以通过模块的__name__属性完成。 Dir()函数

python 字典操作详解(创建,访问,删除)

字典是最与php的数组相似的序列结构。python的列表只能是以索引数字开头并且顺序递增的序列。字典则可以是以字母为key的序列。 元组一般用圆括号来表示，如(1,2,3) 列表一般用方括号来表示，如[1,2,3] 而字典（dict）则用大括号来表示，如{…a?:1,?b':2,?c':3} 与php不同，php的key,value是用key=>value来表示，python而是用冒号“:”来分隔。 字典可以使用大括号书写键和值或使用dict函数来创建。 dict函数可以指定两个元组或列表来对应创建字典。如： items = [('name','gumby'),('age','42')] d = dict(items) 与列表的区别：

k in d(d为字典)，查找的是键，而非value，表达式v in l(l为列表)则用来查找值，而不是索引。 一些字典方法： clear 清除字典。“原地操作”，不会返回值，类似于列表的sort方法 copy方法返回一个相同键值对儿的新字典。浅复制。因为值本身就是相同的，而不是副本。在副本中替换值的时候，原始字典不受影响。但是如果修改了某个值，原始字典也会改变。避免这个问题的一种方法就是使用深度复制（deep copy）。 from copy import deepcopy deepcopy(d) d.fromkes方法使用给定的值创建新字典。每个键默认对应的是None get方法获取一个不存在的键时，不会报错，会返回None has_key方法相法于表达式k in d items方法将所有的字母项以列表的方式返回。这些列表中的每一项都来自于（键，值）。但是项在返回时没有特殊的顺序。 iteritmes的方法大致相同，但是会返回一个迭代器对象而不是列表。在很多情况下iteritems 效率更高。迭代器，相当于decode json之后的对象，而非数组、 keys方法将字典中的键以列表的形式返回。而iterkeys则返回针对键的迭代器。 pop弹出给定键的值。popitem会弹出最后一个元素（实际上是随机项），但如果想一个接一个地移除并处理字典，popitem效率就会高很多，因为不必先获取字典的键值列表。values和itervalues方法以列表或迭代器的形式返回字典中的值，返回值的列表可以包含重复项。 创建 方法二:从Python 2.2 版本起，可以使用一个工厂方法，传入一个元素是列表的元组作为参