列表list+深浅拷贝概念+for循环+列表生成器+break用法

列表

1.概述

变量：使用变量存储数据，但是，有一个缺点：一个变量每次只能存储一个数据

#需求：存储5个人的年龄，求他们的平均年龄
age1 = 29
age2 = 36
age3 = 37
age4 = 47
age5 = 10

average = (age1 + age2 + age3 + age4 + age5) / 5

解决方案：从内存的角度上分析，优化内存，使用列表存储数据

伪代码：列表 = [100个人的年龄]

num = 10

作用：列表相当于一个容器，可以同时存储多个数据

本质：列表是一个有序的集合

说明：有序指的是有顺序，并不是排序【数据在内存中的存储的顺序和存放的顺序是相同的】

注意：列表中实际上存储的仍然是变量

2.创建列表

创建列表其实就相当于定义一个列表类型的变量

语法：

​ 变量名 = 初始值

​ 列表名 = 列表 =====》列表名 = [数据1，数据2。。。。]

说明：

​ a.Python中使用[]表示列表

​ b.列表中存储的数据被称为元素

​ c.列表中的元素默认从头到尾进行编号，编号从0开始，编号的取值范围：0~元素的个数 -1，这些编号被称为索引，下标，角标

​ d.注意：索引的作用就是方便获取或者操作数据，如果在获取数据的过程中，超出索引的范围，则代码会报错【下标越界，索引越界】

代码演示：

#1.创建一个空列表
#list()
#注意：列表的命名一般使用listxxx，尽量不要直接使用list
list1 = []
print(list1)


#2.创建一个非空的列表
#有序的：列表中的元素是有序的【存放和在内存中的存储顺序相同】
list2 = [34,5,4,6,765,76]
print(list2)

#3.列表中可以存储重复数据
list3 = [34,34,5,5,6,7]
print(list3)

#4.列表中可以同时存储不同类型的数据【Python的特点：Python是动态类型的语言】
list4 = [23,"hello",True]
print(list4)

#注意：将需要存储的数据存储到列表中，不需要考虑列表的大小，
#如果数据量大的情况下，在运行代码的过程中，列表会进行自动的扩容

#list，tuple，dict，set被称为数据结构，最常用list和dict

3.列表元素的访问

通过索引进行访问列表中的元素

3.1获取值

语法：列表名[索引]

代码演示：

#1.获取元素
list1 = [3,54,5,45]   #索引：0~3
#列表中存储的实际上是变量，是变量的引用
num1 = list1[3]
print(num1)
print(list1[3])
print(id(num1) == id(list1[3]))  #True
print(num1 is list1[3])#True

"""
num1 = 10
num2 = num1
print(id(num1) == id(num2))  #True
"""

#注意：如果超过了索引的范围，则出现索引越界问题
#print(list1[5])   #IndexError: list index out of range

#列表的下标可以是正数【从前向后访问】，也可以是负数【从后向前访问】
#索引的取值范围：0~元素个数 - 1    或者    -1~ -（元素个数）
#print(list1[-5])

3.2替换值或者修改值

语法：列表名[索引] = 新的值

代码演示：

#2.替换或者修改
print(list1[3])
list1[3] = 100
print(list1[3])

#列表是可变的【一个列表一旦被定义之后，在代码运行的过程中，可以随时更改元素的值，也可以随时向列表中增加元素或者删除元素】

4.列表的操作

4.1列表组合

代码演示：

#1.列表组合：将两个或者两个以上的列表合并为一个列表 ：+
list1 = [3,4,5]
list2 = [34,6,56]
#注意：列表出现的顺序决定了组合之后的列表中元素的顺序
#注意：列表组合之后生成一个新的列表，原列表不受任何影响
list3 = list2 + list1
print(list3)
print(list1)

4.2列表元素的重复

代码演示：

#2.列表元素的重复
print("hello" * 3)
list4 = [34,5,56]
print(list4 * 3)

4.3判断元素是否在列表中

代码演示：

#3.判断元素是否在列表中
#成员运算符：in   not in
#语法：元素  in/not  in   列表
print(5 in list4)
print(100 in list4)
#使用场景：一般应用在if判断中
if 43 in list4:
    print("yes")

4.4切片【截取】【掌握】

获取字列表的过程

语法：列表名[start:end:step]
说明：start和end表示截取元素的下标的区间
	 step表示步长
	 
举例：0~6
start=2
end=5
step=2

代码演示：

list1 = [54,6,5,65,6,"aa","bb"]


#列表名[start:end:step]


#指定区间
#包头不包尾，step如果不书写，则默认为1
print(list1[2:5])
print(list1[2:5:1])

#从指定下标到结尾,包括最后一个元素
print(list1[2:])  #[5, 65, 6, 'aa', 'bb']
print(list1[2:6]) #[5, 65, 6, 'aa']

#从开头获取到指定下标，包括开头，不包括指定下标
print(list1[:5])  #[54, 6, 5, 65, 6]
print(list1[0:5])  #[54, 6, 5, 65, 6]

#特殊情况1:如果end超出了下标的范围，则默认获取从指定下标开始到最后一个元素
#print(list1[100])
print(list1[2:100])

#特殊情况二：step可以是正数，也可以是负数
#下标的范围：0~6  或者   -7~ -1
print(list1[2:6:2])  #2 4
print(list1[0:5:-1]) #[]

print(list1[-1:-6])  #[]
print(list1[-1:-6:-1])

#需求;将指定的列表倒序输出
print(list1[-1::-1])
print(list1[::-1])

"""
结论：
1.不管start和end为正还是为负，如果省略step此时的step默认都是1
2.如果start和end都为正，step必须为正，否则获取出来的子列表为空
3.如果start和end都为负，step必须为负，否则获取出来的子列表为空
4.不管start和end为正还是为负，永远都包含start，不包含end
5.如果为正，则表示从前往后进行获取，如果为负，则表示从后向前获取
"""

#需求：按照要求完成下面的操作
"""
1.list2[:3]   abc aaa def
2.list2[2:]    def bbb
3.list2[::-1]   bbb def  aaa abc
4.list2[-1::-2]   bbb  aaa
5.list2[1::2]    aaa bbb
"""
list2 = ["abc","aaa","def","bbb"]

4.5简单遍历

遍历：将列表中的元素挨个访问出来

代码演示：

list1 = [2,34,35,5,45]
"""
num1 = list1[0]
num2 = list1[1]
num3 = list1[2]
"""

#0~4
index = 0
while index < 5:
    num = list1[index]
    print(num)
    index += 1

#需求：倒序输出列表中的元素
#方式一
print(list1[::-1])

#方式二
index = 4
while index >= 0:
    num = list1[index]
    print(num)
    index -= 1

5.列表的功能【重点掌握】

系统内置的功能

语法：

​ 列表名.功能名(xx)

​ 功能名(xx)

5.1添加元素

代码演示：

#一、添加元素 列表名.功能名（xx）
#1.append（）：追加,在列表的末尾添加元素
list11 = [11,22,33,44]
print(list11)
#1.1添加单个元素
list11.append(55)
print(list11)
#1.2添加多个元素
#注意：append中每次只能添加一个数据,如果要追加多个数据，可以采用列表的方式进行追加，但是，整个列表会被当做一个整体添加进去
list11.append([66,77,88])
print(list11)
print(list11[5])

print("***************")

#2.extend（）：扩展,在列表的末尾添加元素
list12 = [11,22,33,44]
print(list12)
#2.1添加单个元素
#注意：extend中添加的元素必须是可迭代的【可以使用for循环和while循环遍历的数据：list,tuple,dict,set】
#在extend中添加元素，目前只能添加列表
#工作原理：并没有将整个列表添加到原列表中，而是新的列表打碎，只将其中的元素添加到原列表中
list12.extend([55])
print(list12)
#2.2添加多个元素
list12.extend([66,77])
print(list12)

print("***************")

#3.insert（）：插入,在列表的任意索引处插入元素   列表名.insert(index,element)
list13 = [11,22,33,44]
print(list13)
#3.1添加单个元素
#在指定的位置插入指定的元素，原来的元素依次向后顺延
list13.insert(2,100)
print(list13)

#3.2添加多个元素
#和append类似，将整个列表插入到指定位置
list13.insert(2,[55,66])
print(list13)

#append相对而言使用最多

5.2删除元素

代码演示：

#二、删除元素   列表名。功能名(xx)
#1.pop() 弹出，移除列表中的指定位置的元素【通过索引移除元素】
list21 = [11,22,33,44,55]
print(list21)
#1.1pop如果不写索引，则默认删除最后一个元素
list21.pop()
print(list21)
#1.2删除指定下标的元素
list21.pop(2)
print(list21)
#1.3pop返回被删除的元素
num = list21.pop(2)
print(num)

#list21.pop(10)   #IndexError: pop index out of range

print("*******************")

#2.remove() 移除,移除列表中的指定元素
list22 = [11,22,33,44,55]
print(list22)
list22.remove(33)
print(list22)

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

#注意：remove只能删除列表中从左往右查找到的第一个元素
list222 = [11,22,33,44,55,33,44,55,44,44]
print(list222)  #[11, 22, 33, 44, 55, 33, 44, 55]
list222.remove(44)
print(list222)   #[11, 22, 33, 55, 33, 44, 55]
list222.remove(44)
print(list222)   #[11, 22, 33, 55, 33, 55]


#3.clear()  清除，将列表中的元素全部清空
list23 = [4,54,65,66]
list23.clear()
print(list23)


#需求：删除指定列表中指定的重复元素

5.3获取

代码演示：

#三、获取
#1.len():长度，length，获取列表的长度或者获取列表中元素的个数   功能名（列表名）
#索引的取值范围：0~len(列表) - 1
list31 = [43,54,5,454]
print(len(list31))

#2.max()，功能名（列表名），获取列表中的最大值
print(max(list31))

#3.min()，功能名（列表名），获取列表中的最小值
print(min(list31))

#需求：从控制台获取三个数，获取最大值
"""
n1 = int(input())
n2 = int(input())
n3 = int(input())
l1 = [n1,n2,n3]
print(max(l1))
"""

#4.index():索引，从列表中获取匹配到的第一个元素的下标   列表名.功能名(元素)  \
#查找指定元素在指定列表中的位置
list32 = [2,54,5,2,46,6,2]
index1 = list32.index(2)
print(index1)

#5.count()：个数，统计指定元素在指定列表中出现的次数
print(list32.count(2))

#需求：自己实现统计某个元素在列表中出现的次数
#记录次数
c = 0
#表示下标
i = 0
while i < len(list32):
    if list32[i] == 2:
        c += 1
    i += 1
print(c)

#优化需求：删除列表中的重复元素
"""
list3 = [11,22,33,44,55,33,44,55,44,44]
c = 0
while c < 4:
    list3.remove(44)
    c += 1
print(list3)
"""

list33 = [11,22,33,44,55,33,44,55,44,44]
num = 44
c = 0
all = list33.count(num)
while c < all:
    list33.remove(num)
    c += 1
print(list33)

5.4其他

代码演示：

#四、其他用法
#1.reverse(),反转，将列表中的元素倒序输出
list41 = [3,54,4,6]
print(list41)
list41.reverse()
print(list41)
print(list41[::-1])

#2.sort(),排序  列表名.sort(),默认为升序排序
#注意：在原列表中进行排序
list42 = [34,5,4,54,6,56]
#升序
#list42.sort()
#print(list42)

#降序
#方式一：sort(),reverse()
#方式二
list42.sort(reverse=True)
print(list42)


#3.sorted()，排序   sorted(列表),默认升序
#注意：排序之后生成一个新的列表
list43 = [34,5,4,54,6,56]

#升序
newList = sorted(list43)
print(newList)
print(list43)

#降序
newList1 = sorted(list43,reverse=True)
print(newList1)

#key:自定义排序规则:按照字符串的长度进行排序
list44 = ["abc","gh","sghjghjahg","hello"]
newList2 = sorted(list44,key=len,reverse=True)
print(newList2)

5.5拷贝

浅拷贝，深拷贝

代码演示：

import  copy

#五、拷贝
"""
浅拷贝：拷贝了最外围的实体本身，内部的元素只是拷贝了一个引用，也就是说，把实体拷贝一遍，但是该实体中的其他实体不拷贝
深拷贝：外围和内部的实体都会被拷贝，拷贝是实体本身，而不是引用
"""

"""
变量  num = 10
引用  num
不可变实体:一旦创建就不能发生改变，包括数字，字符串，元组
可变实体：可以进行修改的实体，包括列表，字典
"""

#深浅拷贝的作用：减少内存的使用【以后做数据的清洗，修改或者其他操作的时候，对原数据拷贝一份，以防数据被修改之后，找不到原数据】

#一、对于不可变实体的深浅拷贝
a = (1,2,3)
#1.浅拷贝
#1.1浅拷贝：=
print("浅拷贝：=的拷贝")
b = a
print(a)
print(b)
print(id(a))
print(id(b))

#1.2浅拷贝：copy（）
#第一步：导入模块  import copy
print("浅拷贝：copy的拷贝")
c = copy.copy(a)
print(a)
print(c)
print(id(a))
print(id(c))

#2.深拷贝
#deepcopy()
d = copy.deepcopy(a)
print(a)
print(d)
print(id(a))
print(id(d))

print("**********************")

#二、可变实体的深浅拷贝
a = [1,2,3]
#1.浅拷贝
#1.1=
print("浅拷贝：=的拷贝")
b = a
print(a)
print(b)
print(id(a))
print(id(b))

#1.2copy
print("浅拷贝：copy的拷贝")
c = copy.copy(a)
print(a)
print(c)
print(id(a))
print(id(c))

#2.深拷贝
#deepcopy()
d = copy.deepcopy(a)
print(a)
print(d)
print(id(a))
print(id(d))

"""
总结：
a.深浅拷贝都是对原实体的拷贝，区别在于是 实体的拷贝还是引用的拷贝【堆空间还是栈空间】
b.不可变的实体：对于深浅拷贝毫无影响，最终的地址和值都是相等的
c.可变的实体：
    =浅拷贝：值相等，地址相等
    copy浅拷贝：值相等，地址不相等
    deepcopy深拷贝：值相等，地址不相等
"""

6.二维列表

实质上还是一个一维列表，只不过该列表中的元素仍然是一个列表

变量----》一维列表-------》二维列表

举例：

没钱 零买 1根 一个变量

稍微有钱 一包 一维列表 存储了20个变量

有钱 一条 二维列表 存储了10个一维列表

代码演示：

#二维列表
list1 = [[23,4,3,5],[34,54],[100,200]]

#二维列表中元素的访问
print(list1[2])   #[100,200]

subList1 = list1[1]
print(subList1)
num1 = subList1[1]
print(num1)

print(list1[1][1])

#二维列表的遍历：嵌套循环
#外层循环：遍历外层列表
i = 0
while i < len(list1):

    print(list1[i])
    #内层循环：遍历内层列表
    j = 0
    while j < len(list1[i]):
        print(list1[i][j])
        j += 1

    i += 1

二、循环语句之for循环

1.基本用法

while语句

初始化表达式

while 条件表达式：

​ 循环体

​ 循环之后的操作表达式

for语句

for 变量名 成员运算符 列表名：

​ 循环体

说明:for主要用来遍历可迭代实体【list，string，tuple，dict，set】

​ 成员运算符一般使用in

工作原理：按照顺序获取列表中的元素，赋值给变量，再执行循环体，如此循环往复，直到将列表中的所有元素遍历完成

代码演示：

list1= [23,35,43,54,54]

#1.遍历列表
#while:通过索引遍历列表
i = 0
while i < len(list1):
    print(list1[i])

    i += 1


#for:直接获取元素
"""
for  变量名 in  列表名：

	循环体
"""
for j in list1:
    print(j)

#2.else分支
#for循环遍历完列表中的元素之后，会执行else分支
for num in [23,5,6,5,66,7]:
    print(num)
else:
    print("else被执行了")


#需求：已知列表，list1 = [3,35,45,4,56,4],将其中的偶数元素输出
list1 = [3,35,45,4,56,4]
i1 = 0
while i1 < len(list1):
    if list1[i1] % 2 == 0:
        print(list1[i1])
    i1 += 1

for i2 in list1:
    if i2 % 2 == 0:
        print(i2)

#需求：已知列表，list1 = [3,35,45,4,56,4],将下标为偶数的元素输出
i1 = 0
while i1 < len(list1):
    if i1 % 2 == 0:
        print(list1[i1])
    i1 += 1

2.列表生成器

range(start,end,step),注意：start和step可以省略，如果省略，start默认为0，step默认为1

start:开始数字

end：结束数字

step：步长

作用：生成具有一定规律的列表 【list(range())】

代码演示：

"""
range(100):其中的元素是0~99之间的所有的整数
range(1,100):其中的元素是1~99之间的所有的整数
range(1,100,2):其中的元素是1~99之间的所有的奇数
"""
#需求：已知列表，list1 = [3,35,45,4,56,4],将下标为偶数的元素输出
#0~len(list1) - 1
list1 = [3,35,45,4,56,4]

#操作索引
for i in range(0,len(list1)):
    print(list1[i])
#操作元素
for i2 in list1:
    print(i2)


#需求：求1~100之间所有偶数的和
#方式一
sum1 = 0
num1 = 0
while num1 <= 100:
    sum1 += num1
    num1 += 2


#方式二
sum2 = 0
num2 = 1
while num2 <= 100:
    if num2 % 2 == 0:
        sum2 += num2
    num2 += 1

#方式三
sum3 = 0
for num3 in range(1,101):
    if num3 % 2 == 0:
        sum3 += num3

#方式四
sum4 = 0
for num4 in range(0,101,2):
    sum4 += num4


#注意：for循环遍历列表，如果列表已经存在，则直接遍历，如果不存在，则通过range生成

3.列表的遍历方式

代码演示：

#使用for循环遍历列表
list1 = [2,5,5,4,545]
#1.操作元素
for num in list1:
    print(num)


#2.操作索引
for i in range(0,len(list1)):
    print(i,list1[i])


#3.同时遍历元素和索引
#借助于枚举enumerate【仍然是一个容器，存储是列表中的索引和元素】
for i,num  in enumerate(list1):
    print(i,num)

4.嵌套for循环

代码演示：

#嵌套for循环
#需求：打印九九乘法表
for i in range(1,10):
    for j in range(1,i + 1):
        print("%dx%d=%d" % (j,i,i * j),end=" ")

    print("")


#需求：遍历二维列表
list1 = [[23,4,3,5],[34,54],[100,200]]

for subList in list1:
    for num in subList:
        print(num)

5.break、continue、pass的用法

break:跳出当前循环

continue：结束当前正在进行的循环，继续下一次循环

pass：空语句，是为保证程序的完整性，占位的作用【if，while，for,函数】

代码演示：

i = 0
while i < 5:
    print(i)
    if i == 2:
        break
    i += 1

print("*************")

for j in range(0,5):
    print(j)
    if j == 2:
        break

#在while和for中，都表示直接跳出当前循环

#continue:结束当前正在进行的循环，继续下一次循环
#和brak类似，可以单独使用，后面的代码没有执行的机会，在实际的项目开发中，常用break

i = 0
while i < 5:

    if i == 2:
        i += 1
        continue
    print(i)
    i += 1

print("*************")


for j in range(0,5):

    if j == 2:
        continue

    print(j)



#pass
if True:
    pass

print("hello")