python 列表元素连接 python 列表 元素

一、列表

Python中， 

list类提供的，列表是有序的。列表的特点具体如下: 

 

1. 可存放多个值
2. 按照从左到右的顺序定义列表元素，下标从0开始顺序访问
3. 列表是有序的
4. 列表也是可变化的，也就是说可以根据列表的索引位置来修改列表的值

 

针对列表的工厂函数，下面结合具体案例演示如下:

1.添加:
#append:把添加的元素默认在最后一位
#insert:按照索引来添加对象

# 添加:
#append:把添加的元素默认在最后一位
#insert:按照索引来添加对象
list1=[1,1009.09,"lisi",True]
#append
list1.append("girl")
print(list1)
#insert
list1.insert(0,"first")
print(list1)

2.删除:
# pop:默认删除最后一位元素并且返回删除的元素
# remove:可以删除任何一个位置的元素

# 删除:
# pop:默认删除最后一位元素并且返回删除的元素
# remove:可以删除任何一个位置的元素
list1=[1,1009.09,"lisi",True]
# #pop
print(list1.pop())
print(list1)
# remove
list1.remove(1)
print(list1)

  

3.clear 清空

#clear
list1=[1,1009.09,"lisi",True]
list1.clear()
print(list1)

 

4.copy 复制

#copy
list1=[1,1009.09,"lisi",True]
list2=list1.copy()
print(list2)

查看复制后的list2: [1, 1009.09, 'lisi', True]

5. count 查看元素的总数

6. index 查看元素的索引

# count
list3=[1, 1009.09, 'lisi',True,False,'lisi']
print(list3.count("lisi"))
# index
print(list3.index(False))
print(list3.index(True))

 

7.sort 排序(相同的数据类型）

8.reverse 反转

#sort:排序(相同的数据类型）
list4=[10.90,9,40,3,100]
list4.sort()
print(list4)
# reverse 反转
list4.reverse()
print(list4)

[3, 9, 10.9, 40, 100]
[100, 40, 10.9, 9, 3]

　　

9.extend 合并

1 #extend 合并
2 list1=[2,40,4,19,7,12,32]   #定义列表list1赋值为--"2,40,4,19,7,12,32"
3 list2=[23,"python",34,1,"tang"]   #定义列表list2赋值为--23,"python",34,1,"tang"
4 list1.extend(list2)   #合并列表list2到列表list1中
5 print("list1与list2合并之后的结果:",list1)

list1与list2合并之后的结果: [2, 40, 4, 19, 7, 12, 32, 23, 'python', 34, 1, 'tang']

　　

二、列表实战

 1.需求：循环list1

1 list1=["C","Python","Java","Net","Go","PHP"]
2 #循环
3 for item in list1:
4     print(item)

 

2.需求:判断索引为2并且字符串的内容为"Java",输出:Java你好👋

得到对象的索引和内容：enumerate()

1 '''
2 需求:判断索引为2并且字符串的内容为"Java",输出:Java你好👋
3 '''
4 list1=["C","Python","Java","Net","Go","PHP"]
5 #enumerate
6 for index,item in enumerate(list1):
7     if index==2 and item=="Java":
8         print("Java你好👋")

 

3.切片(处理列表的部分元素)

1 '''切片'''
 2 list1=["C","Python","Java","Net","Go","PHP"]
 3 #需求:输出Python
 4 print(list1[1])
 5 #需求:输出"C","Python","Java"
 6 print(list1[0:3])
 7 #需求:输出"Python","Java","Net"
 8 print(list1[1:4])
 9 #需求:获取列表的最后一位(-1)
10 print(list1[-1])
11 #需求:获取"Net""Go"
12 print(list1[-3:-1]) #取不到最后一位

 

4.需求:把list3中>3的放到list4

1 '''再探索列表的方法'''
2 #需求:把list3中>3的放到list4
3 list3=[x for x in range(10)]
4 print(list3)
5 list4=[]
6 for item in list3:
7     if item>3:
8         list4.append(item)
9 print(list4)

 

5.列表复杂的数据结构

列表中多个层级的输出

1 '''列表复杂的数据结构'''
 2 list4=[
 3     ["Go","Python",["Python实战",["Good"]]],
 4     [1,2,3]
 5 ]
 6 #需求:输出Go
 7 print(list4[0][0])
 8 #需求:输出3
 9 print(list4[1][2])
10 #需求:输出Python实战
11 print(list4[0][2][0])
12 #需求:输出Good
13 print(list4[0][2][1][0])

 

三、元组

     list的是可变的，而tuple是不可变的，但是tuple里面的对象内容是可变的，这点需要特别的注意。当tuple 里面的对象并且只有一个的时候，记得需要加逗号如果不加的话，就不再是tuple的数据类型，而是字符串的数据类 型，具体案例代码如下: 

1 '''元组的关键字：tuple'''
2 '''元组和列表的区别：列表是可变的，元组是不可变的'''
3 tuple1=("go",[1,2,3])
4 #count
5 print("go的个数:",tuple1.count("go")) #查看元组的元素的数量
6 print("go的索引:",tuple1.index("go")) #查看元组的元素的索引

 

注意事项:当元组里面只有一个元素的时候，一定要加逗号，如果不加的话，就不再是tuple的数据类型，而是字符串的数据类

1 '''注意事项:当元组里面只有一个元素的时候，一定要加逗号'''
2 
3 tuple2=("go",)
4 print(type(tuple2))

元组的不可变指的是：他往里面添加新的元素，也不能对原有的元素进行删除
但是可以修改元组里面元素的值

1 '''
 2 元组的不可变指的是：他往里面添加新的元素，也不能对原有的元素进行删除
 3 但是可以修改元组里面元素的值
 4 '''
 5 tuple2=["go",[1,2,3]]
 6 #需求:输出3
 7 print(tuple2[1][2])
 8 #元组中列表里的元素可以修改
 9 #需求:将3修改为4
10 tuple2[1][2]="4"
11 print(tuple2)