Python 学习笔记(1)Python容器:列表、元组、字典与集合

时间:2021-01-15 08:42:55

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

字典与集合:

用方括号([])创建列表,

使用逗号创建元组(,)

使用花括号({})创建字典

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

自定义数据结构:

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

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