Python-列表总结

目录

• 列表

  • 创建列表

    • 字面量语法

    • list() 内置函数

    • 创建数值列表

  • 在列表中添加元素

    • 在列表末尾添加元素

    • 在列表中插入元素

  • 从列表中删除元素

    • 使用del语句删除元素

    • 使用方法pop()删除元素

    • 根据值删除元素

  • 组织列表

    • 使用sort()对列表进行永久性排序

    • 使用函数sorted()对列表进行临时排序

  • 操作列表

    • 遍历列表

    • 复制列表

  • 元组

    • 创建元组

    • 修改元组变量

  • 理解列表的可变性

列表

创建列表

字面量语法

>>> numbers = [1, 2, 3, 4]

PS：给列表指定一个表示复数的名称（如letters 、digits 或names ）是个不错的主意。

list() 内置函数

内置函数 list(iterable) 则可以把任何一个可迭代对象转换为列表，比如字符串：

>>> list('foo') 
['f', 'o', 'o']

创建数值列表

• 使用函数range() 遍历1~10的平方值

  squares = []
  for value in range(1,11):
    squares.append(value**2)
  print(squares)  #[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
  

  • range(2,11,2)表示从2开始数，然后不断地加2，直到达到或超过终值（11）

  • range(1,11)：从1开始数，然后不断地加1，直到达到或超过终值11

  列表解析

  1. 生成1~10的平方值

     squares = [value**2 for value in range(1,11)]
     

  2. 剔除列表里面的奇数，并将所有数字乘以 100

     results = [n * 100 for n in numbers if n % 2 == 0]
     

在列表中添加元素

在列表末尾添加元素

1. append方法，不要再返回

   motorcycles.append('ducati')
   

2. 先创建空列表，再添加元素

   motorcycles =[]
   motorcycles.append ('honda')
   

在列表中插入元素

motorcycles = ['honda','yamaha','suzuki']
motorcycles.insert (0,'ducati')            
#now: ['ducati','honda','yamaha','suzuki']

从列表中删除元素

使用del语句删除元素

motorcycles = ['honda','yamaha','suzuki']
del motorcycles[0]

使用方法pop()删除元素

1. pop()弹出最后一个元素

   motorcycles = ['honda','yamaha','suzuki']
   popped_motorcycle = motorcycles.pop()
   print(motorcycles)  #['honda','yamaha']
   print(popped_motorcycle)  #suzuki
   

2. pop(index)弹出列表中任何位置处的元素

   motorcycles = ['honda','yamaha','suzuki']
   first_owned = motorcycles.pop(0)
   print(first_owned) #honda
   

根据值删除元素

有时候，你不知道要从列表中删除的值所处的位置。如果你只知道要删除的元素的值，可使用方法remove()。

motorcycles = ['ducati','honda','yamaha','suzuki']
motorcycles.remove('ducati')

组织列表

使用sort()对列表进行永久性排序

cars = ['bmw','audi','toyota','subaru']
cars.sort()
print(cars)  #['audi', 'bmw', 'subaru', 'toyota']

• 现在，汽车是按字母顺序排列的，再也无法恢复到原来的排列顺序

• 还可以按与字母顺序相反的顺序排列列表元素，为此，只需向sort()方法传递参数reverse=True

使用函数sorted()对列表进行临时排序

cars = ['bmw','audi','toyota','subaru']
print(sorted(cars))  #['audi', 'bmw', 'subaru', 'toyota']
print(cars)  #['bmw','audi','toyota','subaru']

操作列表

遍历列表

1. for循环

   magicians = ['alice', 'david', 'carolina']
   for magician in magicians:
     print(magician)
   
   

   • 别遗漏了冒号，这种错误虽然易于消除，但并不那么容易发现，程序员为找出这样的单字符错误，花费的时间多得令人惊讶。

2. 在遍历列表时获取下标

   names = ['foo', 'bar']
   for index, s in enumerate(names):
     print(index, s)
   
   ```
   0 foo 
   1 bar
   ```
   

   • enumerate()接收一个可选的 start 参数，用于指定循环下标的初始值（默认为 0）： for index, s in enumerate(names, start=10):

   • enumerate() 适用于任何“可迭代对象”，因此它不光可以用于列表，还可以用于元组、字典、字符串等其他对象。

复制列表

my_foods = ['pizza', 'falafel', 'carrot cake']
friend_foods = my_foods[:]

• 要复制列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引

• 倘若我们只是简单地将my_foods 赋给friend_foods ，就不能得到两个列表，因为这两个变量都指向同一个列表。

元组

创建元组

• 字面量语法

  dimensions = (200, 50)
  

  • 不可变的列表被称为元组，使用圆括号而不是方括号来标识。

• tuple内置函数

  >>> t = tuple('foo') 
  >>> t 
  ('f', 'o', 'o')
  

修改元组变量

dimensions = (200, 50)
dimensions[0] = 250      #Error!
dimensions = (400, 100)  #Right!

• 虽然不能修改元组的元素，但可以给存储元组的变量赋值。

理解列表的可变性

• Python 里的内置数据类型，大致上可分为可变与不可变两种。

  • 可变（mutable）：列表、字典、集合。

  • 不可变（immutable）：整数、浮点数、字符串、字节串、元组。

• 列表是可变的。当我们初始化一个列表后，仍然可以调用 .append()、.extend() 等方法来修改它的内容。

• 而字符串和整数等都是不可变的——我们没法修改一个已经存在的字符串对象。

• 示例

  • 为字符串追加内容

    def add_str(in_func_obj): 
      in_func_obj += ' suffix' 
      print(in_func_obj)  #"foo suffix"
    
    orig_obj = 'foo'
    add_str(orig_obj)
    print(orig_obj)       #"foo"
    
    

  • 为列表追加内容

    def add_list(in_func_obj): 
      in_func_obj += ['baz']
      print(in_func_obj)     #['foo', 'bar', 'baz']
      
    
    orig_obj = ['foo', 'bar']
    add_list(orig_obj)
    print(orig_obj)         #['foo', 'bar', 'baz']
    
    

    • 当操作对象变成列表后，函数内的 += 操作居然可以修改原始变量的值 !

• 示例解释

  • Python 在进行函数调用传参时，采用的既不是值传递，也不是引用传递，而是传递了“变量所指对象的引用”（pass-by-object-reference）

  • 换个角度说，当你调用 func(orig_obj) 后，Python 只是新建了一个函数内部变量 in_func_obj，然后让它和外部变量 orig_obj 指向同一个对象，相当于做了一次变量赋值：
    

  • 所以，当我们在函数内部执行 in_func_obj += ... 等修改操作时，是否会影响外部变量，只取决于in_func_obj所指向的对象本身是否可变。

  • 对字符串对象执行 += 操作
    

    未执行+=操作时如左图。在对字符串进行 += 操作时，因为字符串是不可变类型，所以程序会生成一个新对象（值）：'foo suffix'，并让 in_func_obj 变量指向这个新对象；旧值（原始变量 orig_obj 指向的对象）则不受任何影响，如图右侧所示。

  • 对列表对象执行 += 操作
    

    如果对象是可变的（比如列表），+= 操作就会直接原地修改 in_func_obj 变量所指向的值，而它同时也是原始变量 orig_obj 所指向的内容。

  • 由此可见，Python 的函数调用不能简单归类为“值传递”或者“引用传递”，一切行为取决于对象的可变性。