阿里云天池python训练营2

一、数据类型
1. 简单数据类型
整型<class ‘int’>
浮点型<class ‘float’>
布尔型<class ‘bool’>

2. 容器数据类型
列表<class ‘list’>
元组<class ‘tuple’>
字典<class ‘dict’>
集合<class ‘set’>
字符串<class ‘str’>

二、列表
1. 列表的定义
列表事有序集合，没有固定大小，能够保存任意类型的Python对象，语法为[元素1, 元素2, …,元素n].

关键点：中括号括起来元素，逗号分隔
列表不像元组，列表内容可更改 (mutable)，因此附加 (append, extend)、插入 (insert)、删除 (remove, pop) 这些操作都可以用在它身上。
2. 列表的创建
2.1 普通创建
x = [1, 2, 3, 4]
1
2.2 利用range()创建
x = list(range(10))
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>

x = list(range(1, 11, 2))
print(x, type(x))
# [1, 3, 5, 7, 9] <class 'list'>

x = list(range(10, 1, -2))
print(x, type(x))
# [10, 8, 6, 4, 2] <class 
2.3 利用推导式创建列表
x = [0] * 5
print(x, type(x))
# [0, 0, 0, 0, 0] <class 'list'>

x = [0 for i in range(5)]
print(x, type(x))
# [0, 0, 0, 0, 0] <class 'list'>

x = [i for i in range(10)]
print(x, type(x))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>

x = [i for i in range(1, 10, 2)]
print(x, type(x))
# [1, 3, 5, 7, 9] <class 'list'>

x = [i for i in range(10, 1, -2)]
print(x, type(x))
# [10, 8, 6, 4, 2] <class 'list'>

x = [i ** 2 for i in range(1, 10)]
print(x, type(x))
# [1, 4, 9, 16, 25, 36, 49, 64, 81] <class 'list'>

x = [i for i in range(100) if (i % 2) != 0 and (i % 3) == 0]
print(x, type(x))
# [3, 9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99] <class 'list'>

注意：由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。
如：
[1,2,3]保存的是1，2，3三个指针，对应3个整数对象
x=[a]*4只是创建4个指向list的引用，一旦a改变，x中4个a也会改变

x = [[0] * 3] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>

a = [0] * 3
x = [a] * 4
print(x, type(x))
# [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]] <class 'list'>

# 把1赋值给列表的列表里的第一个元素
x[0][0] = 1
print(x, type(x))
# [[1, 0, 0], [1, 0, 0], [1, 0, 0], [1, 0, 0]] <class 'list'>

1
2.4 创建一个混合列表
mix = [1, 'lsgo', 3.14, [1, 2, 3]]
print(mix, type(mix))  
# [1, 'lsgo', 3.14, [1, 2, 3]] <class 'list'>

2.5 创建一个空列表
empty = []
print(empty, type(empty))  # [] <class 'list'>

3. 向列表中添加元素
3.1 list.append(obj)
list.append(obj)在列表末尾添加新的对象，只接收一个参数，参数可以是任何数据类型，被追加的元素在list中保持着原结构类型。添加的元素如果是一个list，那么这个list将作为一个整体进行追加。
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.append(['Thursday', 'Sunday'])
print(x)  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', ['Thursday', 'Sunday']]

print(len(x))  # 6

3.2 list.extend(seq)
list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
对比：
append是追加，把一个东西整体添加在列表后
extend是扩展，把一个东西里的所有元素添加在列表后
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.extend(['Thursday', 'Sunday'])
print(x)  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Thursday', 'Sunday']

print(len(x))  # 7

3.3 list.insert(index, obj)
在编号index位置插入obj
index从0开始
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
x.insert(2, 'Sunday')
print(x)
# ['Monday', 'Tuesday', 'Sunday', 'Wednesday', 'Thursday', 'Friday']

print(len(x))  # 6

4. 删除列表中的元素
4.1 list.remove(obj)
list.remove(obj)移除列表中某个值的第一个匹配项
x = ['Monday', 'Tuesday', 'Monday',  'Wednesday', 'Monday','Thursday', 'Friday']
x.remove('Monday')
print(x)  # ['Tuesday', 'Monday', 'Wednesday', 'Monday', 'Thursday', 'Friday']

4.2 list.pop([index=-1])
list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
y = x.pop()
print(y)  # Friday

y = x.pop(0)
print(y)  # Monday

y = x.pop(-2)
print(y)  # Wednesday
print(x)  # ['Tuesday', 'Thursday']

4.3 del var1[, var2…]
删除单个或多个对象
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
del x[0:2]
print(x)  # ['Wednesday', 'Thursday', 'Friday']

remove和pop都可以删除元素，前者指定具体要删除的元素，后者指定一个索引；如果知道要删除的元素在列表中的位置，可使用del；如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。

5. 获取列表中的元素
通过元素的索引值，从列表获取单个元素，注意，列表索引值是从0开始的
通过将索引指定为-1，可让python返回最后一个列表元素，索引-2返回倒数第二个列表元素，以此类推
切片的通用写法start:stop:step
x = ['Monday', 'Tuesday', 'Wednesday', ['Thursday', 'Friday']]
print(x[0], type(x[0]))  # Monday <class 'str'>
print(x[-1], type(x[-1]))  # ['Thursday', 'Friday'] <class 'list'>
print(x[-2], type(x[-2]))  # Wednesday <class 'str'>
1
“start:” 以step为1(默认)从编号start往列表尾部切片
x = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(x[3:])  # ['Thursday', 'Friday']
print(x[-3:])  # ['Wednesday', 'Thursday', 'Friday']

“:stop” 以step为1(默认)从列表头部往编号stop切片
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:3])  # ['Monday', 'Tuesday', 'Wednesday']
print(week[:-3])  # ['Monday', 'Tuesday']

“start:stop” 以step为1(默认)从编号start往编号stop切片
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:3])  # ['Tuesday', 'Wednesday']
print(week[-3:-1])  # ['Wednesday', 'Thursday']

“start:stop:step” 以step从编号start往编号stop切片。注意最后把step设为-1，相当于将列表反向排序
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[1:4:2])  # ['Tuesday', 'Thursday']
print(week[:4:2])  # ['Monday', 'Wednesday']
print(week[1::2])  # ['Tuesday', 'Thursday']
print(week[::-1])  
# ['Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']


“:” 复制列表中的所有元素（浅拷贝）
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
print(week[:])  
# ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

在浅拷贝时，拷贝出来的新对象的地址和原对象是不一样的，但是新对象里面的可变元素（如列表）的地址和原对象里的可变元素的地址是相同的，也就是说浅拷贝它拷贝的是浅层次的数据结构（不可变元素），对象里的可变元素作为深层次的数据结构并没有被拷贝到新地址里面去，而是和原对象里的可变元素指向同一个地址，所以在新对象或原对象里对这个可变元素做修改时，两个对象是同时改变的，但是深拷贝不会这样，这个是浅拷贝相对于深拷贝最根本的区别。

list1 = [123, 456, 789, 213]
list2 = list1
list3 = list1[:]

print(list2)  # [123, 456, 789, 213]
print(list3)  # [123, 456, 789, 213]
list1.sort()
print(list2)  # [123, 213, 456, 789] 
print(list3)  # [123, 456, 789, 213]

list1 = [[123, 456], [789, 213]]
list2 = list1
list3 = list1[:]
print(list2)  # [[123, 456], [789, 213]]
print(list3)  # [[123, 456], [789, 213]]
list1[0][0] = 111
print(list2)  # [[111, 456], [789, 213]]
print(list3)  # [[111, 456], [789, 213]]

6. 列表的常用操作符
等号操作符：== 只有成员和成员位置都相同才返回true
连接操作符：+ 首尾拼接
重复操作符：* 复制拼接
成员关系操作符：in、not in
list1 = [123, 456]
list2 = [456, 123]
list3 = [123, 456]

print(list1 == list2)  # False
print(list1 == list3)  # True

list4 = list1 + list2  # extend()
print(list4)  # [123, 456, 456, 123]

list5 = list3 * 3
print(list5)  # [123, 456, 123, 456, 123, 456]

list3 *= 3
print(list3)  # [123, 456, 123, 456, 123, 456]

print(123 in list3)  # True
print(456 not in list3)  # False

append/extend/insert可对列表增加元素，它们没有返回值，是直接修改了原数据对象，而将两个list相加，是需要创建新的list对象，从而需要消耗额外的内存，特别是当list较大时，尽量不要使用“+”添加元素

7. 列表的其他方法
7.1 list.count(obj)
list.count(obj) 统计某个元素在列表中出现的次数
list1 = [123, 456] * 3
print(list1)  # [123, 456, 123, 456, 123, 456]
num = list1.count(123)
print(num)  # 3

7.2 list.index(x[, start[, end]])
list.index(x[, start[, end]]) 从列表中找到某个值第一个匹配项的索引位置
list1 = [123, 456] * 5
print(list1.index(123))  # 0
print(list1.index(123, 1))  # 2
print(list1.index(123, 3, 7))  # 4

7.3 list.reverse()
list.reverse() 反向列表中元素
x = [123, 456, 789]
x.reverse()
print(x)  # [789, 456, 123]

7.4 list.sort(key=None, reverse=False)
list.sort(key=None, reverse=False) 对原列表进行排序

key：主要是用来进行比较的元素，只有一个参数，具体的参数取自于可迭代对象中，指定可迭代对象中的一个元素进行排序
reverse：排序规则，reverse=True降序；reverse=False升序(默认)
该方法没有返回值，但是会对列表中的对象进行排序
x = [123, 456, 789, 213]
x.sort()
print(x)
# [123, 213, 456, 789]

x.sort(reverse=True)
print(x)
# [789, 456, 213, 123]

# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]

x = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 按照list中每个元组中的第二个元素排序（升序）
x.sort(key=takeSecond)
print(x)
# [(4, 1), (2, 2), (1, 3), (3, 4)]

# 按照list中每个元组中的第一个元素排序（升序）
x.sort(key=lambda a: a[0])
print(x)
# [(1, 3), (2, 2), (3, 4), (4, 1)]

三、元组
定义语法：（元素1, 元素2, …, 元素n）

小括号把所有元素绑在一起
逗号将每个元素分隔
1. 创建和访问一个元组
元组与列表类似，不同在于tuple被创建后就不能对其进行修改，类似字符串
元组使用小括号，列表使用方括号
元组与列表都是用整数对它进行索引和切片
t1 = (1, 10.31, 'python')
t2 = 1, 10.31, 'python'
print(t1, type(t1))
# (1, 10.31, 'python') <class 'tuple'>

print(t2, type(t2))
# (1, 10.31, 'python') <class 'tuple'>

tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)
print(tuple1[1])  # 2
print(tuple1[5:])  # (6, 7, 8)
print(tuple1[:5])  # (1, 2, 3, 4, 5)
tuple2 = tuple1[:]
print(tuple2)  # (1, 2, 3, 4, 5, 6, 7, 8)

创建元组可以用小括号 ()，也可以什么都不用，为了可读性，建议还是用 ()。
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
x = (1)
print(type(x))  # <class 'int'>
x = 2, 3, 4, 5
print(type(x))  # <class 'tuple'>
x = []
print(type(x))  # <class 'list'>
x = ()
print(type(x))  # <class 'tuple'>
x = (1,)
print(type(x))  # <class 'tuple'>

# 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
print(8 * (8))  # 64
print(8 * (8,))  # (8, 8, 8, 8, 8, 8, 8, 8)

# 创建二维数组
x = (1, 10.31, 'python'), ('data', 11)
print(x)
# ((1, 10.31, 'python'), ('data', 11))

print(x[0])
# (1, 10.31, 'python')
print(x[0][0], x[0][1], x[0][2])
# 1 10.31 python

print(x[0][0:2])
# (1, 10.31)

2. 更新和删除一个元组
元组更新，采用“+”
week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week)  # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')

元组有不可更改性，因此不能直接给元组的元素复制，但是只要元组中的元素可更改，那么我们可以直接更改其元素。
t1 = (1, 2, 3, [4, 5, 6])
print(t1)  # (1, 2, 3, [4, 5, 6])

t1[3][0] = 9
print(t1)  # (1, 2, 3, [9, 5, 6])

t1[0] = (1,2)
print(t1)
# ---------------------------------------------------------------------------
# TypeError                                 Traceback (most recent call last)
# <ipython-input-2-6671405fa068> in <module>
#       5 print(t1)  # (1, 2, 3, [9, 5, 6])
#       6 
# ----> 7 t1[0] = (1,2)
#       8 print(t1)

# TypeError: 'tuple' object does not support item assignment

3. 元组相关操作符
等号操作符：== 只有成员和成员位置都相同时才返回True
连接操作符：+ 首尾拼接
重复操作符：* 复制拼接
成员关系操作符：in、not in
t1 = (123, 456)
t2 = (456, 123)
t3 = (123, 456)

print(t1 == t2)  # False
print(t1 == t3)  # True

t4 = t1 + t2
print(t4)  # (123, 456, 456, 123)

t5 = t3 * 3
print(t5)  # (123, 456, 123, 456, 123, 456)

t3 *= 3
print(t3)  # (123, 456, 123, 456, 123, 456)

print(123 in t3)  # True
print(456 not in t3)  # False

4. 内置方法
元组大小和内容都不可更改，因此只有count和index两种方法

count(元素) 记录在元组中该元素出现次数
index(元素) 找到该元素在元组中的索引
5. 解压元组
解压一维元组（有几个元素左边括号定义几个变量）
t = (1, 10.31, 'python')
(a, b, c) = t
print(a, b, c)
# 1 10.31 python

解压二维元组（按照元组李的元组结构来定义变量）
t = (1, 10.31, ('OK', 'python'))
(a, b, (c, d)) = t
print(a, b, c, d)
# 1 10.31 OK python