列表与for循环

一、list列表

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

列表与for循环的更多相关文章

踩的python列表及for循环一个坑儿
一个列表循环的问题,困扰了半个小时,我也是醉了,值得深思下面开始提需求: 一个列表mylist = [{'tag':1,'num' :5000},{'tag':2,num: 6000},{'tag' ...
数据类型---列表，for循环
定义:列表是一个数据的集合,集合内可以放任何数据类型,可对集合进行方便的增删改查操作. L1=[] #定义空列表 L2=[1,2,3,4] #存4个值,索引为0-3 L3= ["ab ...
python学习笔记(九)函数返回多个值，列表生成式，循环多个变量，入参格式声明
一.函数返回多个值 1.函数如果返回多个值的话,它会把这几个值放到一个元组里面2.函数如果返回多个值的话,也可以用多个变量来接收 def say(): num1 = num2 = num3 = ret ...
vue 列表渲染 v-for循环
v-for循环指令类似与html中C标签的循环,同样可以遍历数组,集合. 1.这里演示一下遍历数组的基本用法,代码如下 <!DOCTYPE html> <html> <h ...
迭代列表不要For循环，这是Python列表推导式最基本的概念
如果你还在使用 For 循环迭代列表,那么你需要了解了解列表推导式,看看它的基本概念都是什么. 列表解析式(List comprehension)或者称为列表推导式,是 Python 中非常强大和优雅 ...
jQuery 实现列表自动滚动循环滚动显示新闻通知
需求页面中一个小区域循环滚动展示通知(公告.新闻.活动.图片等),并且鼠标hover时停止滚动并提示,鼠标离开后,继续滚动. 效果图 https://www.iguopin.com/index.ph ...
python列表补充、循环
优先掌握部分切片l=['a','b','c','d','e','f']print(l[1:5])print(l[1:5:2])print(l[2:5])print(l[-1])了解print(l[- ...
自定义列表数据自动循环向下滚动view（类似于通知通报消息）
首先申明,这个自定义View不是本人写的,大神写的,本人仅限学习一级研究使用直接上代码吧!后面我再解释一遍 package com.egojit.android.gcoa.views; import ...
js 列表几种循环的比较
数组遍历普通遍历最简单的一种,也是使用频率最高的一种. let arr = ['a', 'b', 'c', 'd', 'e'] for (let i = 0; i < arr.length ...

随机推荐

Linux（以centos7为例）下自动挂载NTFS硬盘
Linux(以centos7为例)下自动挂载NTFS硬盘作者:子敬叔叔编写时间:2017年5月3日星期三需求: 为了熟悉Linux的使用,在自己的笔记本上新安装一个centos7, 但我 ...
noip第19课资料
32 bit 与 64 bit 程序（2）比较
32 bit 与 64 bit 程序(2)区别由于操作系统内存分配的不同,导致软件开发过程中,需要编译不同版本的软件. 几个重要概念: (1)这里所说的的32位与64位程序,是指经过编译器编译后 ...
做JAVA开发的同学一定遇到过的爆表问题，看这里解决
欢迎大家前往腾讯云+社区,获取更多腾讯海量技术实践干货哦~ 本文由净地发表于云+社区专栏记一次Java线上服务器CPU过载问题的排查过程,详解排查过程中用到的Java性能监测工具:jvisualvm ...
bootstrap的化妆页面
Glyphicons 字体图标所有可用的图标包括260个来自 Glyphicon Halflings 的字体图标.Glyphi cons Halflings 一般是收费的,但是他们的作者允许 Bo ...
docker中gitlab-runner配置
1.启动gitlab-runner docker run -d --name gitlab-runner --restart always \ -v /opt/data/gitlab-runner/c ...
WCF学习笔记一之通过配置web.config可以通过http访问接口
一.准备这里涉及到三个文件,现在只是简单的把代码贴出来,后面再详细的讲一下. 三个文件分别是(都是wcf服务应用程序项目下的): 1.IService1.cs 2.Service1.svc 3.We ...
MyBatis 源码分析系列文章导读
1.本文速览本篇文章是我为接下来的 MyBatis 源码分析系列文章写的一个导读文章.本篇文章从 MyBatis 是什么(what),为什么要使用(why),以及如何使用(how)等三个角度进行了说 ...
MySQL 组提交（group commit）
目录前言改进原理实现参数注意前言操作系统使用页面缓存来填补内存和磁盘访问的差距对磁盘文件的写入会先写入道页面缓存中由操作系统来决定何时将修改过的脏页刷新到磁盘确保修改已经持久化到 ...
天了噜，Java 8 要停止维护了！
前些天的中兴事件,已经让国人意识到自己核心技术的不足,这次的 JDK 8 对企业停止免费更新更是雪上加霜.. 以下是 Oracle 官网提示的 JDK8 终止更新公告. 原文内容:Oracle wil ...

列表与for循环

一、list列表

1.概述

2.创建列表

3.列表元素的访问

3.1获取值

3.2替换值或者修改值

4.列表的操作

4.1列表组合

4.2列表元素的重复

4.3判断元素是否在列表中

4.4切片【截取】【掌握】

4.5简单遍历

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

5.1添加元素

5.2删除元素

5.3获取

5.4其他

5.5拷贝【面试题】

6.二维列表

二、循环语句之for循环

1.基本用法

2.列表生成器

3.列表的遍历方式

4.嵌套for循环

5.break、continue、pass的用法

列表与for循环的更多相关文章

随机推荐

热门专题