Python 学习笔记（1）Python容器：列表、元组、字典与集合

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

列表：

　　1.列表 的创建

　　　　使用[ ] 或者 list()创建列表：empty_list = [ ]　　或者 empty_list= list()

　　　　使用list()将其他数据类型转换成列表　　方括号[ ]列表 圆括号( )元组

　　　　　　　　>>> list('cat')
　　　　　　　　['c', 'a', 't']

　　　　使用[offset]获取元素

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

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

>>> small_birds = ['hummingbird', 'finch']
>>> extinct_birds = ['dodo', 'passenger pigeon', 'Norwegian Blue']
>>> carol_birds = [3, 'French hens', 2, 'turtledoves']
>>> all_birds = [small_birds, extinct_birds, 'macaw', carol_birds]

=================================================================

　　　　　　　　

>>> all_birds
[['hummingbird', 'finch'], ['dodo', 'passenger pigeon', 'Norwegian Blue'], 'macaw',
[3, 'French hens', 2, 'turtledoves']]

　　　　　　　　获取列表中字子列表的元素：

>>> all_birds[1][0]
'dodo'

　　　2、列表操作

　　　使用[offset]修改元素

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

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

>>> marxes = ['Groucho', 'Chico,' 'Harpo']
>>> marxes[0:2]
['Groucho', 'Chico']

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

>>> marxes.append('Zeppo')
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo']

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

　　

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
>>> others = ['Gummo', 'Karl']
>>> marxes.extend(others)
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo', 'Gummo', 'Karl']

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

　　>>> marxes.insert(3, 'Gummo')
　　>>> marxes
　　['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo']
　　>>> marxes.insert(10, 'Karl')
　　>>> marxes
　　['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo', 'Karl']

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

　　　　del marxes[-1]

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

　　　　>>> marxes.remove('Gummo')

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

　　>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
　　>>> marxes.pop()
　　'Zeppo'
     >>> marxes
　　['Groucho', 'Chico', 'Harpo']
　　>>> marxes.pop(1)
　　'Chico'
　　>>> marxes
　　['Groucho', 'Harpo']

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

　　　　>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
　　　　>>> marxes.index('Chico')
　　　　1

　　使用in判断值是否存在

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

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

　　　　　　>>> marxes.count('Harpo')

　　使用join()转换为字符串

　　　　　　>>> marxes = ['Groucho', 'Chico', 'Harpo']
　　　　　　>>> ', '.join(marxes)
　　　　　　'Groucho, Chico, Harpo'

　　使用sort()重新排列元素：列表方法sort() 会对原列表进行排序，改变原列表内容；
　　　　　　　　　　　　　 通用函数sorted() 则会返回排好序的列表副本，原列表内容不变。

　　　　

　　使用len()获取长度

　　　　>>> marxes = ['Groucho', 'Chico', 'Harpo']
　　　　>>> len(marxes)
　　　　3

　　使用=赋值，使用copy()复制　　

　　　　>>> a = [1, 2, 3]
　　　　>>> a
　　　　[1, 2, 3]
　　　　>>> b = a
　　　　>>> b
　　　　[1, 2, 3]
　　　　>>> a[0] = 'surprise'
　　　　>>> a
　　　　['surprise', 2, 3]

　　元组和列表：

　　在许多地方都可以用元组代替列表，但元组的方法函数与列表相比要少一些——元组没有
　　append()、insert()，等等——因为一旦创建元组便无法修改。既然列表更加灵活，那为
　　什么不在所有地方都使用列表呢？原因如下所示：
　　　　• 元组占用的空间较小
　　　　• 你不会意外修改元组的值
　　　　• 可以将元组用作字典的键（详见3.4 节）
　　　　• 命名元组（详见第6 章“命名元组”小节）可以作为对象的替代
　　　　• 函数的参数是以元组形式传递的

字典：

　　字典新建：

>>> empty_dict = {}

　　使用dict() 转换： 　　

>>> lol = [ ['a', 'b'], ['c', 'd'], ['e', 'f'] ]
>>> dict(lol)
{'c': 'd', 'a': 'b', 'e': 'f'}

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

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

　　>>> lot = [ ('a', 'b'), ('c', 'd'), ('e', 'f') ]
　　>>> dict(lot)
　　{'c': 'd', 'a': 'b', 'e': 'f'}

　　包含双值列表的元组：

　　>>> tol = ( ['a', 'b'], ['c', 'd'], ['e', 'f'] )
　　>>> dict(tol)
　　{'c': 'd', 'a': 'b', 'e': 'f'}

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

　　>>> los = [ 'ab', 'cd', 'ef' ]
　　>>> dict(los)
　　{'c': 'd', 'a': 'b', 'e': 'f'}

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

　　>>> tos = ( 'ab', 'cd', 'ef' )
　　>>> dict(tos)
　　{'c': 'd', 'a': 'b', 'e': 'f'}

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

>>> pythons = {
... 'Chapman': 'Graham',
... 'Cleese': 'John',
... 'Idle': 'Eric',
... 'Jones': 'Terry',
... 'Palin': 'Michael',
... }
>>> pythons
{'Cleese': 'John', 'Jones': 'Terry', 'Palin': 'Michael',
'Chapman': 'Graham', 'Idle': 'Eric'}

#使用[KEY]值，添加元素
>>> pythons['Gilliam'] = 'Gerry'
>>> pythons
{'Cleese': 'John', 'Gilliam': 'Gerry', 'Palin': 'Michael',
'Chapman': 'Graham', 'Idle': 'Eric', 'Jones': 'Terry'}

#使用[KEY]值，修改元素

>>> pythons['Gilliam'] = 'Terry'
>>> pythons
{'Cleese': 'John', 'Gilliam': 'Terry', 'Palin': 'Michael',
'Chapman': 'Graham', 'Idle': 'Eric', 'Jones': 'Terry'}

使用update()合并字典

>>> pythons = {       #定义一个字典
... 'Chapman': 'Graham',
... 'Cleese': 'John',
... 'Gilliam': 'Terry',
... 'Idle': 'Eric',
... 'Jones': 'Terry',
... 'Palin': 'Michael',
... }
>>> pythons
{'Cleese': 'John', 'Gilliam': 'Terry', 'Palin': 'Michael',
'Chapman': 'Graham', 'Idle': 'Eric', 'Jones': 'Terry'}
#定义另一个字典
>>> others = { 'Marx': 'Groucho', 'Howard': 'Moe' }
#使用.update()，合并字典
>>> pythons.update(others)
>>> pythons
{'Cleese': 'John', 'Howard': 'Moe', 'Gilliam': 'Terry',
'Palin': 'Michael', 'Marx': 'Groucho', 'Chapman': 'Graham',
'Idle': 'Eric', 'Jones': 'Terry'}

使用del删除具有指定键的元素

>>> del pythons['Marx']  #删除字典中的元素
>>> pythons
{'Cleese': 'John', 'Howard': 'Moe', 'Gilliam': 'Terry',
'Palin': 'Michael', 'Chapman': 'Graham', 'Idle': 'Eric',
'Jones': 'Terry'}
>>> del pythons['Howard']
>>> pythons
{'Cleese': 'John', 'Gilliam': 'Terry', 'Palin': 'Michael',
'Chapman': 'Graham', 'Idle': 'Eric', 'Jones': 'Terry'}

使用clear()删除所有元素

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

>>> pythons.clear()
>>> pythons
{}
>>> pythons = {}
>>> pythons
{}

使用in判断是否存在

>>> pythons = {'Chapman': 'Graham', 'Cleese': 'John',
'Jones': 'Terry', 'Palin': 'Michael'}

#测试XXX是否在字典中
>>> 'Chapman' in pythons
True

使用[key]获取元素

>>> pythons['Cleese']
'John'

keys()、values()、items()、=、copy()

使用keys()获取所有键、使用values()获取所有值、使用items()获取所有键值、使用=赋值，使用copy()复制

>>> signals = {'green': 'go', 'yellow': 'go faster', 'red': 'smile for the camera'}
>>> signals.keys()     #使用keys()获取所有键
dict_keys(['green', 'yellow', 'red'])
>>> list( signals.keys() )
['green', 'yellow', 'red']
>>> list( signals.values() )#使用values()获取所有值
['go', 'go faster', 'smile for the camera']
>>> list( signals.items() ) #使用items()获取所有键值对
[('green', 'go'), ('yellow', 'go faster'), ('red', 'smile for the camera')]
>>> save_signals = signals  #使用=赋值
>>> signals['blue'] = 'confuse everyone'
>>> save_signals
{'green': 'go', 'yellow': 'go faster', 'red': 'smile for the camera', 'blue': 'confuse everyone'}
#对字典内容进行的修改会反映到所有与之相关联的变量名上
#=================================
#  使用copy()复制
>>> signals = {'green': 'go', 'yellow': 'go faster', 'red': 'smile for the camera'}
>>> original_signals = signals.copy()
>>> signals['blue'] = 'confuse everyone'
>>> signals
{'green': 'go', 'yellow': 'go faster', 'red': 'smile for the camera', 'blue': 'confuse everyone'}
>>> original_signals
{'green': 'go', 'yellow': 'go faster', 'red': 'smile for the camera'}

集合：

　　1、使用set()创建集合

>>> empty_set = set()
>>> empty_set
set()
>>> even_numbers = {0, 2, 4, 6, 8}
>>> even_numbers
{0, 8, 2, 4, 6}
>>> odd_numbers = {1, 3, 5, 7, 9}
>>> odd_numbers
{9, 3, 1, 5, 7}    #集合中的元素是无序的

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

>>> set( 'letters' )
{'l', 'e', 't', 'r', 's'}  #转换以后，重复的元素会去重

　　　　用列表建立集合:

>>> set( ['Dasher', 'Dancer', 'Prancer', 'Mason-Dixon'] )
{'Dancer', 'Dasher', 'Prancer', 'Mason-Dixon'}

　　　　再试试元组：

>>> set( ('Ummagumma', 'Echoes', 'Atom Heart Mother') )
{'Ummagumma', 'Atom Heart Mother', 'Echoes'}  #使用元组建立集合

　　　　当字典作为参数传入set() 函数时，只有键会被使用：　　

>>> set( {'apple': 'red', 'orange': 'orange', 'cherry': 'red'} )
{'cherry', 'apple', 'orange'}

　　　　使用in测试值是否存在　　　　

>>> drinks = {
    'martini': {'vodka', 'vermouth'},
    'black russian': {'vodka', 'kahlua'},
    'white russian': {'cream', 'kahlua', 'vodka'},
    'manhattan': {'rye', 'vermouth', 'bitters'},
    'screwdriver': {'orange juice', 'vodka'}
    }
>>> for name, contents in drinks.items():   # 使用IN值测试值是否存在
    if 'vodka' in contents :                        # 使用IN值测试值是否存在

        print(name)

martini
black russian
white russian
screwdriver

>>> for name, contents in drinks.items():
    if 'vodka' in contents and not ('vermouth' in contents or 'cream' in contents):
        print(name)

black russian
screwdriver

合并及运算符

交集运算：&  或者 x.intersection

>>> a = {1,2}
>>> b = {3,4}
>>> a & b
set()
>>> a.intersection(b)
set()

异或运算

#使用^ 或者symmetric_difference() 可以获得两个集合的异或集
>>> a ^ b
{1, 3}
>>> a.symmetric_difference(b)
{1, 3}

#使用<= 或者issubset() 可以判断一个集合是否是另一个集合的子集（第一个集合的所有
元素都出现在第二个集合中）：
>>> a = {1,3}
>>> b = {2,4}
>>> c = {1}
>>> d = {2}
>>> a <= b
False
>>> b <= a
False
>>> c <= a
True
>>> c <= b
False
>>> d <= a
False
>>> d <=  b

# 超集与子集正好相反（第二个集合的所有元素都出现在第一个集合中），使用>= 或者
issuperset() 可以进行判断：
>>> a >= b
False
>>> a >= c
True
>>> a >=d
False

# 子集 真子集
>>> a > a
False
>>> a < a
False
>>> d > d
False
>>> d < d
False
>>> d == d
True
>>> a >= a
True
>>> d >= d
True
>>> a <= a
True
>>> a < a
False
>>> a > a
False

字典与集合:

用方括号（[]）创建列表，

使用逗号创建元组（，）

使用花括号（{}）创建字典

在每一种类型中，都可以通过方括号对单个元素进行访问：

自定义数据结构：

在创建自定义结构的过程中，唯一的限制来自于内置数据类型本身。

例如：字典的键必须为不可变对象，所以列表、字典以及集合都不能作为字典的键，但是元组可以作为字典的键。