《Python札记》1_列表list

写于开始之前

笔者即将开始写一个系列的《Python札记》。本系列的札记主要是自学齐伟老师《跟老齐学Python轻松入门》一书整理而来。书第一遍断断续续花了5个月,第二遍边看边整理,保守3个月。

在此深深感谢齐伟老师带我入门Python工欲善其事,必先利其器,本札记的学习环境为:Python3.7.2 + pycharm + jupyter notebook

  • Python3取代了Python2,成为主流
  • 针对Python语言,Pycharm是最好的IDE
  • Jupyter notebook是利用Python进行机器学习的强大利器

本札记一定会在2个月之内完成,主要内容包含:

希望对Python感兴趣的朋友有所帮助,自己也在努力学习中,将来主要方向是:机器学习+数据挖掘+量化投资

良好的开始是成功的一半!Let`s go go go!!!


列表是Python中使用非常广泛的一种对象,用方括号[ ]来表示。括号里面可以是数字,字符串或者TrueFalse的布尔值,或者是多种不同类型的对象,里面也可以嵌套列表。如果列表是空的,用bool()来进行判断,会返回 False


一、索引、切片、反转

列表和字符串一样,都是序列,里面的元素是有序的,也有索引和切片。索引index左边从0开始,右边从-1开始,index()函数可以查看某个元素的索引编号。

索引

  • 左边0开始,右边-1开始
  • 通过index()函数查看索引编号
1
2
3
4
5
# lang = ['python', 'java', 'html']
# lang.index('python')
0  # 索引从0开始
# lang.index('html')
2

切片

  • 索引左边从0开始,右边-1开始
  • 含头不含尾
  • 步长可正可负
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
lst = [1, 2, 3, 4, 5, 6]
print(lst[:])     #  相当于是复制 lst
[1, 2, 3, 4, 5, 6]
print(lst[::2])  #  步长是2    [开始:结束:步长]
[1, 3, 5]
print(lst[-3:-1])

lst = [1,2,3,4,5,6]
print(lst[1:5:2])     # 常规用法
print(lst[-5:-2:2])   # 标号-5代表的是元素2,标号-2代表的是5,步长为2
print(lst[-5:4:2])
print(lst[1:-2:2])
[2,4]

反转

  • 通过步长-1进行反转,[::-1]
  • 通过reversed()进行反转,得到的是可迭代对象,并且将迭代对象转为为列表显示
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# 反转1
print(lst[::-1])  # 通过步长为-1进行反转
print(lst)   # 不影响原来对象
[6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 5, 6]

# 反转2
print(list(reversed(lst)))  # 通过reversed函数进行反转
[6,5,4,3,2,1]

print(list(reversed('abcde')))    # 对字符串进行反转,列表显示
['e', 'd', 'c', 'b', 'a']

二、操作列表

基本操作

  • len():求长度
  • +:连接两个序列
  • *:复制序列
  • in:判断元素是否在列表中
  • max()、min():按照元素的字典顺序进行排序

1、修改元素

列表中的元素可以进行修改,但是字符串中的不能进行修改。列表中修改的时候,直接通过索引号进行指定:

1
2
3
4
lst[2] = 7   # 指定第三个元素为7
print(lst)

[1, 2, 7, 4, 5, 6]

2、增加元素
追加元素的方法有两种,都是追加在末尾

  • append()函数进行追加
  • 切片的方式进行追加:a[len(a):] = [ x ]
1
2
3
4
lst.append(8)  
lst[len(lst):] = [8]
print(lst)
[1, 2, 7, 4, 5, 6, 8]   # 例子承接上面,第三个元素为7,不是3

3、列表函数

函数 作用
append 将单个元素追加到列表的最右边,即末尾部分;list[len(list):] = [x],x是待追加的元素; 没有返回值None
extend 两个列表进行合并,扩充列表的作用; 参数必须是可迭代对象list[len(list):] = L,L是待并入的列表; 完成追加过程,列表L不变,list发生变化; 没有返回值None
insert 指定位置添加元素 格式:list.insert(i,x),i是插入的位置,x是待追加元素 ; i如果是0,相当于是插在首位;i如果是len(list),相当于是插在最后面,则等价于append()函数
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# extend()函数
lst = [1, 2, 7, 4, 5, 6, 8]
print(id(lst))   # 查看lst的内存地址
lst1 = ['python', 'java', 'html']
lst.extend(lst1)
print(id(lst))   # 查看追加列表之后的内存地址,与原来系相同的
print("lst:", lst)
print("lst1:", lst1)

2435334264968
2435334264968
lst: [1, 2, 7, 4, 5, 6, 8, 'python', 'java', 'html']
lst1: ['python', 'java', 'html']

# append与extend区别
lst1 = [1, 2, 3]
lst2 = ['python', 'html', 'java']
lst1.append(lst2)
print(lst1)
[1, 2, 3, ['python', 'html', 'java']]   # 整建制,将lst2当做一个整体

lst1 = [1, 2, 3]
lst2 = ['python', 'html', 'java']
lst1.extend(lst2)
print(lst1)
[1, 2, 3, 'python', 'html', 'java']   # 个体化,将lst2的每个元素进行追加

结论:

  • 列表是可以进行修改的,原地修改
  • append是将一个元素加到列表的末尾,整建制追加
  • extend将两个列表进行合并,个体化扩编
  • extend方法执行之后,内存中id不变,只是在该id上的内容发生了变化
  • insert()函数中的i如果超过最大索引值,则自动追加到末尾,相当于是append()函数的作用
  • 三种方法均是原地修改,无返回值

函数 作用
count 查看元素重复出现的次数 如果不存在,返回0,而不是报错
index 查看索引编号,不存在则报错 检索的是元素第一次出现的位置
remove 删除元素,原地修改,无返回值; list.remove(x):如果x不存在,则会报错; 如果x出现多次,删除第一个x,剩下不变
pop pop([i]):参数是可选的; 为空,默认删除最后一个,并且将该元素作为返回值; 如果不为空,可删除索引为i的元素,并且将该元素作为返回值
reverse 原地反转,没有生成新的列表,没有返回值
reversed 类似reverse,区别:生成的列表能够用于迭代

remove和pop的区别

  • remove 没有返回值,pop有返回值
  • remove的参数是元素,pop的参数是索引
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
lst1 = [1, 2, 3, 4, 5, 6]
lst1.remove(2)
print(lst1)
# lst1.remove(7)
# print(lst1)   ValueError: list.remove(x): x not in list
lst1.pop(2)
print(lst1)

[1, 3, 4, 5, 6]   # 将元素2删除掉
[1, 3, 5, 6]      #  将索引为2的元素3删除掉,本步骤是接在上面的执行,即在列表[1, 3, 4, 5, 6] 中删除4

# 关于反转
lst = [1, 2, 3, 4, 5]
print(lst[::-1])   # 反转实现1
print(lst)          # 原来的列表对象不改变
lst.reverse()    # 反转实现2
print(lst)          # 原来的列表变成反转之后的新列表
lst1= reversed(lst)
print(lst1)       # lst1是一个列表反转迭代器对象:<list_reverseiterator object at 0x00000233C677F320>
print(list(lst1))    # 用list函数显示lst1的内容

函数 作用
sort 排序函数,用于列表list中,原地修改没有返回值默认从小到大;将reverse=True则变成从大到小排序sort(self, /, *, key=None, reverse=False)
sorted 所有可迭代对象进行操作,返回一个新的 list,不是在原来的list上进行操作 sorted(iterable[, cmp[, key[, reverse]]])
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# sort()
lst = [1, 4, 5, 8, 2, 6, 3]
lst.sort()
print(lst)
lst1 = ['python', Java, 'html', 'c', 'php']
lst1.sort(key=len)  # 列表中的字符串进行排序;如果长度相同,则按照出现的先后顺序
print(lst1)

[1, 2, 3, 4, 5, 6, 8]
['c', 'php', 'Java', 'html', 'python']

# sorted()
lst = [1, 4, 5, 8, 2, 6, 3]
lst1 = sorted(lst)
print(lst)  # 原对象不变
print(lst1) # 新列表为排序后的对象

lst2 =[('python', 'A'),('java', 'C'),('c', 'D'),('php', 'B')]
lst3 = sorted(lst2, key=lambda x: x[1])   # 由元组构成的复合列表,按照元组的第二个元素进行排序,通过匿名函数lamba()
print(lst3)
[('python', 'A'), ('php', 'B'), ('java', 'C'), ('c', 'D')]

lst4 = sorted(lst2, key=lambda x: len(x[0]))   # 通过元组中第一个元素的长度进行排序
print(lst4)
[('c', 'D'), ('php', 'B'), ('java', 'C'), ('python', 'A')]

自定义类中的元素进行排序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Student:
    def __init__(self, name, age, grade):
        self.name =  name
        self.age = age
        self.grade = grade
        
    def __repr__(self):
        return  repr((self.name, self.grade, self.age))
    
students_objects = [
    Student('Tom', 'B', 12),
    Student('xiaoming','A',17),
    Student('xiaohong', 'C', 12),
    Student('Peter', 'D', 8),
]

lst5 = sorted(students_objects, key=lambda t:t.age)   # 自定义类中,按照年龄进行排序
print(lst5)
lst6 = sorted(students_objects, key=lambda t:(t.age, t.grade))   # 使用元组,先根据年龄排序,若年龄相同按照grade排序
print(lst6)

[('xiaoming', 17, 'A'), ('Tom', 12, 'B'), ('xiaohong', 12, 'C'), ('Peter', 8, 'D')]
[('xiaoming', 17, 'A'), ('Tom', 12, 'B'), ('xiaohong', 12, 'C'), ('Peter', 8, 'D')]
原文链接
👇

《Python札记》1_列表list

https://blog.policx.com/posts/python3-notes01/

作者

江湖

发布于

2019-07-18

更新于

2019-07-18

许可协议

CC BY-NC 4.0

评论

Your browser is out-of-date!

Update your browser to view this website correctly.  Update my browser now

×