[Python知识库]阶段性总结pycharm快捷键和列表相关

碎片知识总结

• 1、pycharm快捷键：

  • 1. 格式化代码 【Ctrl + Alt + L】
  • 2. 多行代码合并为一行【Crtl+Shift+J】
  • 3. 快速注释/取消注释【Crtl+/】
  • 4. 向右缩进一个制表位【Tab】
  • 5.向左缩进一个制表位【Shift + Tab
  • 6.在上方插入新行【Ctrl + Alt + Enter】（这个非常有用）
  • 7.在下方插入新行【Shift + Enter】（这个非常有用）
  • 8.将选中代码上下移动【Alt + Shift + 上、下键】（这个非常有用）
  • 9.直接在下一行复制代码【Ctrl + D】（这个非常有用）
  • 10.折叠代码【Ctrl + -】
  • 11.展开代码【Ctrl + +】
  • 12.重命名文件【Shift+F6】（需要重命名文件名时，可以选择对应文件按下【Shift+F6】，再输入框输入新的文件名再点击【Refactor】即可）
  • 13.替换/全局替换【Ctrl+R / Ctrl + Shift+R】（当前文件的替换可以按下【Ctrl+R 】并在第一栏输入要替换的关键字就会高亮包含关键字的代码，第二栏输入要替换为的关键字，在按下【replace】或【replace All】(替换全部)）
  • 14.快速跳转报错的代码【F2】（当出现代码报错的时候，可以按下F2快速跳转到报错的代码处）
  • 15.代码小写转大写【Ctrl + Shift+U】
  • 16.全选一行并移至行尾【Shift + End】（关闭小键盘）
  • 17.将光标移动到方法体或循环的开始【Ctrl + {】（当循环体很长时）
  • 18.将光标移动到方法体或循环的结束【Ctrl + }】（当循环体很长时）

• 2、迭代器的概念：只要是容器都可以叫做迭代器，例如（列表、字符串、元组、字典、集合）

• 3、in和not in：
  语法： x in 容器（x not in 容器）
  作用：判断x是否在容器中（x 是否不在容器中）

• 4、地址问题

# 地址的概念
# 1.变量中存储的是数据的地址
num = 10
print(id(num),id(10))   #2642734836304 2642734836304

# 2.列表中存储的是数据的地址,列表地址和列表第一个元素地址不同
numlist = ['abc',10,True]
print(id(numlist))      #2642737115712
print(id(numlist[0]),id('abc'))   #2642737012272 2642737012272
print(id(numlist[2]),id(True))   #140728402172008 140728402172008

• 5、is 和 is not

# 3.is和is not
"""
is:判断两个变量的地址是否相同
==：判断两个变量的值是否相同
# a.不可变的数据类型：int/float/bool/str/tuple
n1 = 10
n2 = 10
# 比较值
print(n1 == n2)  # True
# 比较地址
print(n1 is n2)  # True
print(id(n1) == id(n2))  # True

# b.可变的数据类型：list/dict/set
list1 = [10,20,30]
list2 = [10,20,30]
# 比较值
print(list1 == list2)   # True
# 比较地址
print(list1 is list2)   # False
print(id(list1) == id(list2)) # False

"""
结论：
    两个变量的地址相同，则这两个变量的值一定相同
    两个变量的值相同，则这两个变量的地址不一定相同
"""

• 6、要查看某一个系统功能时，按住ctrl，用鼠标单击该系统功能关键字

列表的遍历

• 遍历：依次获取迭代器【列表，字符串，元组，字典，集合。。。。】中的每个元素

# 1.访问列表中的元素
list1 = [34,5,6,67]
# print(list1[0])
# print(list1[1])
# print(list1[2])
# print(list1[3])

# 2.遍历列表
# 方式一
i = 0
while i < len(list1):
    print(list1[i])
    i += 1

# 方式二:直接获取元素        ******
for n in list1:
    print(n)

# 方式三：获取索引             ******
for i in range(len(list1)):
    print(i,list1[i])

• 枚举（enumerate /??nju?m?re?t/ vt. 列举；枚举；）

# 方式四：同时获取索引和元素
# r = enumerate(list1)    # enumerate(x)将x容器转换为一个新的容器【枚举】，新的容器中的元素包括索引和元素
# print(list(r))   # [(0, 34), (1, 5), (2, 6), (3, 67)]
for index,ele in enumerate(list1):
    print(index,ele)

# a,b = (10,20)   # 拆包
# print(a,b)  # 10  20

列表的系统功能

• 列表“增”的3种方法：append（v. <正式>附加，增补）、extend（v. 延伸；扩大，延长；）、insert（v. 插入，嵌入）

"""
注意
    a.列表.append()可以添加任意类型的元素
      列表.extend()只能添加可迭代对象的元素，可迭代对象：本质是一个容器，可以通过for循环遍历其中的元素，如：列表，字符串，元组，字典，集合.....
    b.列表.append()：如果添加的是容器，则整个容器会被添加到原列表中
      列表.extend()：只会将指定容器中的元素添加到原列表中
"""
# 1.append(obj):在列表末尾追加新的元素,注意：obj可以是任意的类型          
list1 = [11,22,33]
print(list1)
list1.append('aaa')
print(list1)
list1.append([55,66])
print(list1)

# 2.extend(seq)：在列表末尾一次性追加另一个序列（迭代器）中的多个值（用新列表扩展原来的列表）
list2 = [11,22,33]
print(list2)
# list2.extend(10)   # TypeError: 'int' object is not iterable可迭代对象
# print(list2)
list2.extend('abc')
print(list2)   # [11, 22, 33, 'a', 'b', 'c']
list2.extend([55,66])
print(list2)
list2.extend((55,66))
print(list2)
list2.extend(range(3))
print(list2)

# 3.insert(index,obj)：将元素插入到列表的指定位置
# 注意：在指定列表的指定索引处插入一个元素，原来的元素向后顺延，index可以越界，越界则obj会插入到列表尾部
# 如果索引越界，insert作用就相当于append
list3 = [11,22,33]
print(list3)
list3.insert(1,44)
print(list3)   # [11, 44, 22, 33]
list3.insert(10,[55,33,44])
print(list3)   # [11, 44, 22, 33, 55, [55, 33, 44]]

• 列表“删”的4种方法：remove（vt. 移开，拿开；除去）、pop（popup v. 弹出）、clear、del（n. 删除文件；）
  remove是通过匹配列表元素进行删除，pop是通过列表索引进行移除，clear是清空列表，del删除对象。

# 1.remove(元素):移除列表中某个值的第一个匹配项          *******
list1 = [23,5,34,5,5,10]
print(list1)
list1.remove(5)
print(list1)

list1.remove(100)   # ValueError: list.remove(x): x not in list

# 2.pop(索引):移除列表中指定索引处的元素（默认最后一个元素），并且返回该元素的值     *****
list2 = [23,5,34,5,5,10]
print(list2)
# a.如果未指定索引，默认删除最后一个元素
list2.pop()
print(list2)
# b.如果指定索引，则删除指定索引处的元素
list2.pop(1)
print(list2)
# c.区别于remove，pop只是将元素从列表中移除，但是在内存中存在,所以可以用变量将值接出来
r1 = list2.remove(5)
print(r1)   # None
r2 = list2.pop(1)
print(r2)

# 3.clear()：清空列表
list3 = [23,5,34,5,5,10]
print(list3)
list3.clear()
print(list3)   # []

# 4.del  xxx
# a.del 列表[索引]
list3 = [23,5,34,5,5,10]
print(list3)
del list3[1]    # 等价于list3.pop(1)
print(list3)    # [23, 34, 5, 5, 10]

# b.del 列表
del list3
# print(list3)   # NameError: name 'list3' is not defined

• 列表删除注意事项：
  通过列表循环遍历进行删除（remove、pop）时，一般不使用原列表，因为列表是可变的，可以通过列表复制的方法：

list1 = [34,5,5,67,7,8,5,5,243,5,78,5]
for num in list1.copy():   #这里的copy是系统功能
    if num == 5:
        list1.remove(5)
print(list1)

• 列表“改”的3种方法：reverse（v. 逆转）、sort（n. 分类，排序；）、sort(severse = True)、list(x)（将容器x转列表）

# 1.reverse():反转/翻转                 *******
list1 = [34,45,5,67,100,50]
print(list1)
list1.reverse()
print(list1)

#2、sort()：升序降序:
'''
sort()方法是在原地对列表排序，是对原列表的直接操作，并不会返回一个新的列表。
sort()方法需要单独使用，如果和赋值，打印等方法一起使用，结果会返回None。
'''
#升序
list1 = [34,45,5,67,100,50]
print(list1)
list1.sort()
print(list1)	#[5, 34, 45, 50, 67, 100]
#降序
list1 = [34,45,5,67,100,50]
print(list1)
list1.sort(reverse=True)
print(list1)	#[100, 67, 50, 45, 34, 5]


# 3.list(x)：将x转换为列表，但是x只能是容器
print(list('abc'))
print(list(range(5)))

• 列表‘查’的3种方法：len（length n. 长度）、index（n. 索引；）、count（v. （按顺序）数数；计数）

numlist = [34,6,56,6,6,7,6,134,50,30]

# 1.len():获取列表的长度                       ******
print(len(numlist))

# 2.max()/min():获取列表中元素的最值
print(max(numlist))
print(min(numlist))

# 3.index(ele,[start,end]):获取一个元素在列表中第一次出现的索引           *****
r1 = numlist.index(6)
print(r1)
# r1 = numlist.index(100)   # ValueError: 100 is not in list

numlist = [34,6,56,20,7,6,134,50,30]
# a.全局查找
r1 = numlist.index(6)
print(r1)

# b.局部查找,仍然符合包头不包尾的规则，返回的仍然是原列表中的索引
r1 = numlist.index(6,1,5)
print(r1)    # 1
# r1 = numlist.index(6,2,5)
# print(r1)    # ValueError: 6 is not in list

# 4.count():统计一个元素在列表中出现的次数             ******
r = numlist.count(6)
print(r)

列表推导式

• 列表推导式，就是指的轻量级循环创建列表
• 列表推导式/列表生成式:是Python特有的语法，通过循环和if语句专门用来创建列表
• 特点：根据一个已知的Iterable,使用一行代码实现简单的逻辑，生成一个新的列表
• 语法：[新列表中的元素规律 for循环 if语句]
• 工作原理：执行for循环，获取已知Iterable的元素，结合if判断，最终得到新的列表中元素的规律

l1 = [1,2,3,4,3,3,6]
l2 = [i-1 for i in l1 if i == 3]
print(l2)   #[2, 2, 2]

列表拷贝

# 1.=引用赋值
# a.一维列表
list1 = [11,22,33]
list2 = list1
print(list1 is list2)  # True
list1[1] = 100
print(list1 is list2)  # True
print(list1)    # [11, 100, 33]
print(list2)    # [11, 100, 33]

# b.二维列表
list1 = [[11,22,33],[44,55]]
list2 = list1
print(list1 is list2)  # True
list1[0][1] = 100
print(list1 is list2)  # True
print(list1)    # [[11,100,33],[44,55]]
print(list2)    # [[11,100,33],[44,55]]

"""
结论1：
    无论是一维列表还是多维列表，如果使用引用赋值的方式操作，
    只要通过一个变量修改了列表中的元素，则另一个变量访问的列表也会随着修改
"""
# 浅拷贝:只拷贝列表的最外层
# 2.列表.copy():浅拷贝,系统拷贝
# a.一维列表
list1 = [11,22,33]
list2 = list1.copy()
print(list1 is list2)   # False
list1[1] = 100
print(list1)   # [11,100,33]
print(list2)   # [11,22,33]

# b.二维列表：因为是浅拷贝，两个列表外层指向不同（新建了一个外层列表，地址会变），但两个列表内层列表指向都是相同的。
list1 = [[11,22,33],[44,55]]
list2 = list1.copy()
print(list1 is list2)  # False
list1[0][1] = 100
print(list1 is list2)  #  False
print(list1)    # [[11,100,33],[44,55]]
print(list2)    # [[11,100,33],[44,55]]

print("*" * 80)

import  copy	#需要调用模块
# 3.copy.copy(要拷贝列表)：浅拷贝
# a.一维列表
list1 = [11,22,33]
list2 = copy.copy(list1)
print(list1 is list2)   # False
list1[1] = 100
print(list1 is list2)   # False
print(list1)   # [11,100,33]
print(list2)   # [11,22,33]

# b.二维列表
list1 = [[11,22,33],[44,55]]
list2 = copy.copy(list1)
print(list1 is list2)  # False
list1[0][1] = 100
print(list1 is list2)  #  False
print(list1)    # [[11,100,33],[44,55]]
print(list2)    # [[11,100,33],[44,55]]

"""
结论2：列表.copy() 和 copy.copy(列表) 和 切片
    一维列表：如果一个变量修改列表中的元素，对另一个列表没有任何影响
    二维列表：如果一个变量修改内层列表中的元素，则另一个列表中的元素会随着发生修改    
"""


# 深拷贝：不管列表嵌套了几层，都会拷贝
# 4.copy.deepcopy(要拷贝列表)：深拷贝
# a.一维列表
list1 = [11,22,33]
list2 = copy.deepcopy(list1)
print(list1 is list2)   # False
list1[1] = 100
print(list1 is list2)   # False
print(list1)   # [11,100,33]
print(list2)   # [11,22,33]

# b.二维列表
list1 = [[11,22,33],[44,55]]
list2 = copy.deepcopy(list1)
print(list1 is list2)  # False
list1[0][1] = 100
print(list1 is list2)  #  False
print(list1)    # [[11,100,33],[44,55]]
print(list2)    # [[11,22,33],[44,55]]

"""
结论3：copy.deepcopy()
    无论是一维列表还是多维列表，如果使用copy.deepcopy()的方式操作，
    通过一个变量修改了列表中的元素，另一个变量访问的列表没有影响
"""
# 注意：不管是浅拷贝还是深拷贝，都会生成一个新的列表，所以列表的地址都会发生改变

列表切片

• 切片：根据指定的区间，指定的步长，在列表，元组或字符串等有序集合中进行截取，形成一个新的列表，元组或字符串
• 语法：
  列表名[start: end:step]
  start:开始索引，可以省略，默认为0，不省略的情况下包含在内
  end:结束索引，可以省略，默认为索引的结束,不省略的情况下不包含在内
  step：表示步长，可以省略，默认为1

# 切片
"""
语法：
	列表名[start:end:step]
    start:开始索引，可以省略，默认为0，不省略的情况下包含在内
    end:结束索引，可以省略，默认为索引的结束【len - 1  或 -len】,不省略的情况下不包含在内
    step：表示步长，可以省略，默认为1

注意：
    1.只要符合切片的语法，代码永远不会报错，只是结果列表是否为空
    2.能获取到元素的前提下，只要step为负数，则表示逆序获取
"""
"""
  0   1   2   3   4   5   6   7     8
 -9   -8  -7  -6  -5  -4  -3  -2   -1
 11   22  33  44  55  66  77  88   99
"""
numlist = [11,22,33,44,55,66,77,88,99]

# 一、基本使用
# 1.省略start或end或step
# 注意1：start包含在内的，end如果定义出来不包含在内
print(numlist[1:])   # [1::1]   [22, 33, 44, 55, 66, 77, 88, 99]
print(numlist[1:8])  # [22, 33, 44, 55, 66, 77, 88]

print(numlist[:6])   # [11, 22, 33, 44, 55, 66]

# 注意2：如果end超出索引的范围，默认取到结尾     *******【面试题】
print(numlist[1:100])   # [22, 33, 44, 55, 66, 77, 88, 99]
print(numlist[1:9])     # [22, 33, 44, 55, 66, 77, 88, 99]

# 注意3：numlist[:]表示将原列表拷贝了一份,经常用于一维列表的备份   *******

print(numlist[:])   #[11, 22, 33, 44, 55, 66, 77, 88, 99]
print(numlist[::])  #[11, 22, 33, 44, 55, 66, 77, 88, 99]
print(numlist[::1]) #[11, 22, 33, 44, 55, 66, 77, 88, 99]
print(numlist[::2])   # [11, 33, 55, 77, 99]



list1 = [24,56,67,8]
print(list1)
list2 = list1[:]    #创建一个备份
list3 = list1
print(list2)
list1[1] = 100
print(list1)  # [24, 100, 67, 8]
print(list2)  # [24, 56, 67, 8]
print(list3)  # [24, 100, 67, 8]

print("*" * 30)

# 2.start和end同正负
"""
规律1：如果start和end同正负
    a.计算start+step
    b.判断上述结果是否在start和end区间内
    c.如果在区间内，则按照规律获取元素，如果不在区间内，则结果直接为[]
"""
# a.start和end都是正数索引
print(numlist[1:5:1])   # [22...55]
print(numlist[1:5:-1])  # []

print(numlist[5:1:1])   # []
print(numlist[5:1:-1])  # [66...33]

# b.start和end都是负数索引
print(numlist[-1:-5:1])   # []
print(numlist[-1:-5:-1])  # [99...66]

print(numlist[-5:-1:1])   # [55...88]
print(numlist[-5:-1:-1])  # []

# 3.start和end一个为正数，一个为负数
"""
规律2：start和end一个为正数，一个为负数（其中出现0，0当做正看待）
    a.观察start的正负，索引的使用和start的正负保持一致
    b.如果start为正，则使用正数索引；如果start为负，则使用负数索引
    c.将end的索引转换为和start同符号的索引
    d.继续使用规律1判断
"""
print(numlist[1:-5:1])      # [1:4:1]  -----》[22...44]
print(numlist[1:-5:-1])     # [1:4:-1]---->[]

print(numlist[-1:5:1])      # [-1:-4:1]----->[]
print(numlist[-1:5:-1])     # [-1:-4:-1]---->[99...77]

print(numlist[-5:1:1])      # [-5:-8:1]----->[]
print(numlist[-5:1:-1])     # [-5:-8:-1]---->[55...33]

print(numlist[0:-1:1])  # [0:8:1] ---->[11...88]
print(numlist[0:-1:-1]) # [0:8:-1]--->[]

print(numlist[-1:0:1])  # [-1:-9:1]---->[]
print(numlist[-1:0:-1]) # [-1:-9:-1] ----->[99...22]

# 二、特殊情况
# 1.
"""
规律3：如果start和end“都”被省略
    a.如果step为正数，则从左往右获取【顺序获取】
    b.如果step为负数，则从右往左获取【逆序获取】
"""
print(numlist[::1]) # [11, 22, 33, 44, 55, 66, 77, 88, 99]
print(numlist[::2]) # [11, 33, 55, 77, 99]

print(numlist[::-1])    # [99, 88, 77, 66, 55, 44, 33, 22, 11]
print(numlist[::-2])    # [99, 77, 55, 33, 11]

# 2.
# print(numlist[100])    # IndexError
print(numlist[1:100])   #[22, 33, 44, 55, 66, 77, 88, 99]
print(numlist[100:])    # []    面试题     *********

# 3.
"""
规律4：列表[start::step]
    a.如果step为正数，则从star开始，从左往右获取【顺序获取】
    b.如果step为负数，则从star开始，从右往左获取【逆序获取】
"""
print(numlist[5::1])    # [66, 77, 88, 99]
print(numlist[5::-1])   # [66, 55, 44, 33, 22, 11]
print(numlist[-5::1])   # [55, 66, 77, 88, 99]
print(numlist[-5::-1])  # [55, 44, 33, 22, 11]

# 4.end:结束索引，可以省略，默认为索引的结束【-len】的情况
print(numlist[2::-1])  # [33, 22, 11]

# 练习：
names = ['old_driver','rain','jack','shanshan','peiqi','black_girl']
# 取出names列表中索引4-7的元素
print(names[4:8])
# g.取出names列表中索引2-10的元素，步长为2
print(names[2:11:2])
# h.取出names列表中最后3个元素
print(names[-3:])
print(names[:2:-1])