2018-08-27day06总结

list(列表)

1.列表是python中的容器类型，有序的，可变的容器-可变指的是列表中的元素和元素的位置可变
有序：可以通过下标来获取元素 可变：可以进行增删改
2.元素指的是列表中的每一个内容,列表中的元素可以是任意类型的数据
一个列表中的元素类型可以不一样

1.列表的声明

a.声明变量 赋一个列表值

scores = [121,124,90,99]
print(scores,type(scores))
输出:
[121, 124, 90, 99] <class 'list'>

person = ['江'，20，'死肥宅']
print(person)
输出:
['江', 20, '死肥宅']

[]--->空列表

name = []
print(name,type(name))
输出:
[] <class 'list'>

b.将其他数据类型转换成列表(只有序列才能转换：字符串和range，字典，元组，集合，生成式和迭代器)

chars = list('asdfafd')
print((chars))
numbers = list(range(10))
print(numbers)
输出:
['a', 's', 'd', 'f', 'a', 'f', 'd']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

列表元素的增删改查

1.查:获取元素列表

a.获取单个元素:列表[下标]，下标是不能越界的

movie_names = ['死亡飞车','速度与激情','金刚狼','黑客帝国']
print(movie_names[1])
print(movie_names[-1])
输出:
速度与激情
黑客帝国

b.获取部分元素(切片)：列表[下标1:下标2]/列表[::] 结果是列表
步进为正从前往后取，为负从后往前取

print(movie_names[1:3])
print(movie_names[-1:-4:-1])
print(movie_names[:3])
print(movie_names[2:])
print(movie_names[:])
输出:
['速度与激情', '金刚狼']
['黑客帝国', '金刚狼', '速度与激情']
['死亡飞车', '速度与激情', '金刚狼']
['金刚狼', '黑客帝国']
['死亡飞车', '速度与激情', '金刚狼', '黑客帝国']

c.遍历（一个一个的获取每个元素）
可以将列表直接放到for循环的in的后边，循环过程中for后面的变量取得的是列表中的每个元素

for item in movie_names:
    print(item)
输出:
死亡飞车
速度与激情
金刚狼
黑客帝国

例如：写一个列表来保存六个学生的成绩，统计成绩在80以上的人数

list1 = [80,79,81,78,82,76]
count = 0
for item in list1:
    if item > 80:
        count += 1
print(count)
输出:
2

2.改

语法：列表名[下标] = 新值 通过下标获取元素然后重新赋值

person  = ['马'，20，'money']
person[1] = 28
print(person)
输出:
['马', 18, 'money']

3.增：添加列表元素

列表中的元素个数发生改变后，列表中每个元素的下标会重新分配
a.列表.append(元素) 在列表最后添加

person.append('男')
print(person)
输出：
['马', 18, 'money', '男']

b.列表.insert(下标，元素)：在指定的下标前插入一个元素

person.insert(0,'007')
print(person)
输出:
['007', '马', 18, 'money', '男']

输入5个学生的成绩，并且保存在一个列表里

list2 = []
for x in range(5):
     score = int(input('输入学生成绩：'))
     list2.append(score)
print(list2)
输出:
输入学生成绩：90
输入学生成绩：89
输入学生成绩：91
输入学生成绩：88
输入学生成绩：92
[90, 89, 91, 88, 92]

4.删:删除列表中的元素

a.del列表[下标]---->根据下标删除列表中的元素
del语句是python中删除数据的语法，可以删除任何数据:del变量(删除变量) del列表(删除整个列表)

balls = ['羽毛球','乒乓球','网球','桌球','篮球','足球']
del balls[1]
print(balls)
输出：
['羽毛球', '网球', '桌球', '篮球', '足球']

b.列表.remove（元素）---->删除列表中的值，如果元素在列表中出现多次，只删除最前面的一个

balls.remove('足球')
print(balls)
输出:
['羽毛球', '网球', '桌球', '篮球']

c.列表.pop(下标) ----->将列表中下标对应的元素取出来

ball = balls.pop(2)   #将下标为2的元素取出来保存到ball中
print(balls,ball)
输出:
['羽毛球', '网球', '篮球'] 桌球

将一个保存成绩的列表中成绩低于60分的全部删除

list3 = [78,59,40,90,89,45,69,30]
for item in list3[:]:
    if item < 60:
        list3.remove(item)
print(list3)
输出：
[78, 90, 89, 69]

注意:以后遍历列表的元素的时候，我们一般遍历他的拷贝值([:])

列表数据的存储

python中，变量在存数据的值的时候，会根据数据类型的不同，使用两种方式来存值
值类型：变量存数据直接存值，例如：整型、浮点型、布尔、字符串
引用类型：变量存数据的时候，存的是数据在内存中的地址。例如：列表、字典、元祖、集合、函数、自定义

a = 10
b = a
print(a, b)
a = 100
print(a, b)
输出:
10 10
100 10

a1 = [1, 2]
#注意：引用类型赋值的时候赋的是地址
b1 = a1

注意： 先将列表a1中的元素拷贝一份存到一个新的地址中，然后把新的地址赋给c1
c1 = a1[:]
print(a1, b1)

a1.append(100)
print(a1, b1,c1)
输出:
[1, 2] [1, 2]
[1, 2, 100] [1, 2, 100] [1, 2]

列表的相关运算

1. +操作
   列表1 + 列表2：将列表1中的元素和列表2中的元素依次合并，产生一个新的列表

a = [1,2]
list1 = a + ['asd',100]
print(list1,a)
输出:
[1, 2, 'asd', 100] [1, 2]

2.*操作
列表 * N：将列表中的元素重复N次，产生一个新的列表

a = [1,2]
list2 = a * 3
print(list2)
输出:
[1, 2, 1, 2, 1, 2]

3.in / not in
元素 in 列表：判断一个元素是否在列表中

print(10 in [1,2,3,4,10])
输出:
True

4.获取列表的长度

len(序列)
print(len([1,2,34,5]))
name = ['羽毛球','乒乓球','网球','桌球','篮球','足球']
print(len(name))
输出:
4
6

5.相关的方法
5.1列表.count(元素)，统计指定元素在列表中有几个

number = [1, 2.3, 1, 45, 1]
print(number.count(1))
输出:
3

5.2 列表.extend(序列)：将序列中的元素添加到列表中

number = [1, 2.3, 1, 45, 1]
number.extend([1000,200])
print(number)
number.extend('xwr')
print(number)

number.append([300,400])
print(number)
输出:
[1, 2.3, 1, 45, 1, 1000, 200]
[1, 2.3, 1, 45, 1, 1000, 200, 'x', 'w', 'r']
[1, 2.3, 1, 45, 1, 1000, 200, 'x', 'w', 'r', [300, 400]]

5.3列表。index(元素)：获取指定元素在指定列表中第一次出现对应的下标

number = [1, 2.3, 1, 45, 1]
index1 = number.index(1)
print(index1)
输出：
0       #下标为0

5.4列表.pop():将列表中最后一个元素从列表中取出来

number = [1, 2.3, 1, 45, 1]
item = number.pop()
print(item,number)
输出:
[300, 400] [1, 2.3, 1, 45, 1, 1000, 200, 'x', 'w', 'r']

5.5列表.reverse():将列表中的元素反序

number1 = [1,22,3,4]
number1.reverse()
print(number1)
输出:
[4, 3, 22, 1]

5.6列表.sort():对列表元素进行排序(默认升序)
列表.sort(reverse = True):对列表进行降序排序

number1 = [1,22,3,4]
number1.sort()
print(number1)
输出：
[1, 3, 4, 22]

5.7列表.clear()：将列表中的元素全部清除

number1 = [1,22,3,4]
number1.clear()
print(number1)
输出:
[]

5.8列表.copy():将列表中的元素全部拷贝一份产生一个新的列表，相当于列表[:]

这的拷贝是浅拷贝 浅拷贝只拷贝列表里的值

number2 = [1,2,3,45]
number3 = number2.copy()
print(number3)
输出:
[1, 2, 3, 45]

6浅拷贝和深拷贝
浅拷贝：只是单纯的将值拷贝（如果是对象就直接拷贝对象的地址）
深拷贝：会拷贝对象地址对应的值，产生一个新的地址，然后将新的地址进行赋值

import copy
numbers1 = [1, 2]
numbers = [numbers1, 3, 4, 'abc']

# 浅拷贝
new_numbers = numbers.copy()
# 深拷贝
new_numbers2 = copy.deepcopy(numbers)

numbers1.append(100)
print(new_numbers)
print(new_numbers2)
输出:
[[1, 2, 100], 3, 4, 'abc']
[[1, 2], 3, 4, 'abc']

tuple(元组)

元组就是不可变的列表 列表中除了和可变的相关的内容以外，其他的全部适用于元组
不支持增，删，改 只支持和查相关的操作
1.声明元组

tuple1 = (1, 2, 'asd', True, [1,2])
print(tuple1,type(tuple1))
输出:
(1, 2, 'asd', True, [1, 2]) <class 'tuple'>

注意：如果要写一个元组元素个数是1字面量，需要在元素后面加逗号

t2 = (100,)
print(t2,type(t2),len(t2))
#()---->代表是空的元组
t3 = ()
print(t3,type(t3))
输出:
(100,) <class 'tuple'> 1
() <class 'tuple'>

2.查相关的

t3 = ('red','yellow','green','pink')
print(t3[1])
print(t3[0:3])
for item in t3:
    print(item)
输出:
yellow
('red', 'yellow', 'green')
red

特殊操作

point = (100,200)
print(point[0],point[1])
输出:
100 200

通过两个变量来获取元组中唯一的两个元素的值

x,y = point
print(x,y)
输出:
100 200

通过在变量前加*，获取元组/列表中的一部分元素值，结果是一个列表

user = ('小胖',90,89,97,87,'男')
name,*score,sex = user
print(name,score,sex)
输出:
小胖 [90, 89, 97, 87] 男

user1 = ('小江',67,68,69)
name,*score = user1
print(name,score)
输出:
小江 [67, 68, 69]

4,多个值之间用逗号隔开，对应的数据也是元组

a = 1,2,3,4    #相当于a = (1,2,3,4)
print(a,type(a))

x,y=100,200  #相当于x,y=100,200
print(x,y)
输出:
(1, 2, 3, 4) <class 'tuple'>
100 200