Python札记1_列表list

写于开始之前

笔者即将开始写一个系列的《Python札记》。本系列的札记主要是自学齐伟老师《跟老齐学Python轻松入门》一书整理而来。书第一遍断断续续花了5个月，第二遍边看边整理，保守3个月。在此深深感谢齐伟老师带我入门Python。工欲善其事，必先利其器，本札记的学习环境为：Python3.7.2 + pycharm + jupyter notebook：

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

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

学习笔记整理
代码实战练习
各种练习题
利用Python实现常用算法机器学习_Python算法

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

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

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

一、索引、切片、反转

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

索引

左边0开始，右边-1开始
通过index()函数查看索引编号

# lang = ['python', 'java', 'html']
# lang.index('python')
0  # 索引从0开始
# lang.index('html')
2

切片

索引左边从0开始，右边-1开始
含头不含尾
步长可正可负

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
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、修改元素

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

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

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

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

append()函数进行追加
切片的方式进行追加：a[len(a):] = [ x ]

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()函数

# 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的参数是索引

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]]])

# 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')]

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

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')]