组 合 、 复 杂 数 据 类 型 组合、复杂数据类型 组合、复杂数据类型

1 列表

1.1 列表的表达

  • 序列类型：内部元素有位置关系，能通过位置序号访问其中元素
  • 列表是一个可以使用多种类型元素，支持元素的增、删、查、改操作的序列类型
ls = ["Python", 1989, True, {"version": 3.7}]
ls

组合、复杂数据类型_python

  • 另一种产生方式：list(可迭代对象)
  • 可迭代对象包括：字符串、元组、集合、range()等

字符串转列表

list("人工智能是未来的趋势")

组合、复杂数据类型_元组_02
元组转列表

list(("我", "们", "很", "像"))

组合、复杂数据类型_变量名_03
集合转列表

list({"李雷", "韩梅梅", "Jim", "Green"})

组合、复杂数据类型_python_04

特殊的range()

for i in [0, 1, 2, 3, 4, 5]:
    print(i)

组合、复杂数据类型_变量名_05

for i in range(6):
    print(i)

组合、复杂数据类型_键值对_06

  • range(起始数字,中止数字,数字间隔)

如果起始数字缺省，默认为0

必须包含中止数字

数字间隔缺省，默认为1

for i in range(1, 11, 2):
    print(i)

组合、复杂数据类型_元组_07

  • range()转列表
list(range(1, 11, 2))

组合、复杂数据类型_键值对_08

1.2 列表的性质

  • 列表的长度——len(列表)
ls = [1, 2, 3, 4, 5]
len(ls)

组合、复杂数据类型_变量名_09

  • 列表的索引——与同为序列类型的字符串完全相同

变量名[位置编号]

正向索引从0开始
反向索引从-1开始

cars = ["BYD", "BMW", "AUDI", "TOYOTA"]

print(cars[0])
print(cars[-1])

组合、复杂数据类型_java_10

  • 列表的切片

变量名[开始位置：结束位置：切片间隔]

cars = ["BYD", "BMW", "AUDI", "TOYOTA"]
  • 正向切片
print(cars[:3])     # 前三个元素，开始位置缺省，默认为0；切片间隔缺省，默认为1

组合、复杂数据类型_python_11

print(cars[1:4:2])  # 第二个到第四个元素 前后索引差为2

组合、复杂数据类型_元组_12

print(cars[:])      # 获取整个列表，结束位置缺省，默认取值到最后

组合、复杂数据类型_元组_13

print(cars[-4:-2])  # 获取前两个元素

组合、复杂数据类型_变量名_14

  • 反向切片
cars = ["BYD", "BMW", "AUDI", "TOYOTA"]

print(cars[:-4:-1])      # 开始位置缺省，默认为-1
print(cars[::-1])        # 获得反向列表

组合、复杂数据类型_变量名_15

1.3 列表的操作符

  • 用** list1+lis2 **的形式实现列表的拼接
a = [1, 2]
b = [3, 4]
a+b            # 该用法用的不多

组合、复杂数据类型_python_16

  • 用 n*list 或 list*n 实现列表的成倍复制

初始化列表的一种方式

[0]*10

组合、复杂数据类型_变量名_17

1.4 列表的操作方法

1、增加元素

  • 在末尾增加元素——列表.append(待增元素)
languages = ["Python", "C++", "R"]

languages.append("Java")
languages

组合、复杂数据类型_变量名_18

  • 在任意位置插入元素——列表.insert(位置编号，待增元素)
    在位置编号相应元素前插入待增元素
languages.insert(1, "C")
languages

组合、复杂数据类型_键值对_19

  • 在末尾整体并入另一列表——列表1.extend(列表2)

append 将列表2整体作为一个元素添加到列表1中

languages.append(["Ruby", "PHP"])
languages

组合、复杂数据类型_java_20

extend 将待列表2内的元素逐个添加到列表1中

languages = ['Python', 'C', 'C++', 'R', 'Java']
languages.extend(["Ruby", "PHP"])
languages

组合、复杂数据类型_元组_21
2、删除元素

  • 删除列表i位置的元素  列表.pop(位置)
languages = ['Python', 'C', 'C++', 'R', 'Java']
languages.pop(1)
languages

组合、复杂数据类型_python_22

  • 不写位置信息，默认删除最后一个元素
languages.pop()
languages

组合、复杂数据类型_java_23

  • 删除列表中的第一次出现的待删元素 列表.remove(待删元素)
languages = ['Python', 'C', 'R', 'C', 'Java']
languages.remove("C")    
languages

组合、复杂数据类型_java_24

languages = ['Python', 'C', 'R', 'C', 'Java']
while "C" in languages:
    languages.remove("C")    
languages

组合、复杂数据类型_java_25

3、查找元素

  • 列表中第一次出现待查元素的位置 列表.index(待查元素)
languages = ['Python', 'C', 'R','Java']
idx = languages.index("R") 
idx

组合、复杂数据类型_元组_26

4、修改元素

  • 通过"先索引后赋值"的方式，对元素进行修改 列表名[位置]=新值
languages = ['Python', 'C', 'R','Java']
languages[1] = "C++"
languages

组合、复杂数据类型_java_27
5、列表的复制

  • 错误的方式
languages = ['Python', 'C', 'R','Java']
languages_2 = languages
print(languages_2)

组合、复杂数据类型_java_28

languages.pop()
print(languages)
print(languages_2)

组合、复杂数据类型_变量名_29

  • 正确的方式——浅拷贝

  • 方法1：列表.copy()

languages = ['Python', 'C', 'R','Java']
languages_2 = languages.copy()
languages.pop()
print(languages)
print(languages_2)

组合、复杂数据类型_python_30

  • 方法2：列表[ : ]
languages = ['Python', 'C', 'R','Java']
languages_3 = languages[:]
languages.pop()
print(languages)
print(languages_3)

组合、复杂数据类型_键值对_31

6、列表的排序

  • 使用列表.sort()对列表进行永久排序
  • 直接在列表上进行操作，无返回值
ls = [2, 5, 2, 8, 19, 3, 7]
ls.sort()
ls

组合、复杂数据类型_键值对_32

  • 递减排列
ls.sort(reverse = True)
ls

组合、复杂数据类型_元组_33

  • 使用sorted(列表)对列表进行临时排序
  • 原列表保持不变，返回排序后的列表
ls = [2, 5, 2, 8, 19, 3, 7]
ls_2 = sorted(ls)
print(ls)
print(ls_2)

组合、复杂数据类型_变量名_34

sorted(ls, reverse = True)

组合、复杂数据类型_元组_35

7、列表的翻转

  • 使用列表.reverse()对列表进行永久翻转
  • 直接在列表上进行操作，无返回值
ls = [1, 2, 3, 4, 5]
print(ls[::-1])
ls

组合、复杂数据类型_变量名_36

ls.reverse()
ls

组合、复杂数据类型_python_37

8、使用for循环对列表进行遍历

ls = [1, 2, 3, 4, 5]
for i in ls:
    print(i)

组合、复杂数据类型_java_38

2 元组

2.1 元组的表达

  • 元组是一个可以使用多种类型元素，一旦定义，内部元素不支持增、删和修改操作的序列类型

通俗的讲，可以将元组视作“不可变的列表”

names = ("Peter", "Pual", "Mary")

2.2 元组的操作

* 不支持元素增加、元素删除、元素修改操作     
* 其他操作与列表的操作完全一致

2.3 元组的常见用处

打包与解包

  • 例1
def f1(x):              # 返回x的平方和立方
    return x**2, x**3   # 实现打包返回

print(f1(3))
print(type(f1(3)))      # 元组类型

组合、复杂数据类型_元组_39

a, b = f1(3)            # 实现解包赋值 
print(a)
print(b)

组合、复杂数据类型_python_40

  • 例2
numbers = [201901, 201902, 201903]
name = ["小明", "小红", "小强"]
list(zip(numbers,name))

组合、复杂数据类型_变量名_41

for number,name in zip(numbers,name):   # 每次取到一个元组，立刻进行解包赋值
    print(number, name)

组合、复杂数据类型_java_42

3 字典

3.1 字典的表达

  • 映射类型： 通过“键”-“值”的映射实现数据存储和查找
  • 常规的字典是无序的
students = {201901: '小明', 201902: '小红', 201903: '小强'}
students

字典键的要求

  • 1、字典的键不能重复
students = {201901: '小明', 201901: '小红', 201903: '小强'}
students

组合、复杂数据类型_键值对_43

  • 2、字典的键必须是不可变类型，如果键可变，就找不到对应存储的值了

  • 不可变类型：数字、字符串、元组。  一旦确定，它自己就是它自己，变了就不是它了。

  • 可变类型：列表、字典、集合。  一旦确定，还可以随意增删改。

d1 = {1: 3}
d2 = {"s": 3}
d3 = {(1,2,3): 3}

d = {[1, 2]: 3}

组合、复杂数据类型_python_44

d = {{1:2}: 3}

组合、复杂数据类型_元组_45

d = {{1, 2}: 3}

组合、复杂数据类型_变量名_46

3.2 字典的性质

  • 字典的长度——键值对的个数
students = {201901: '小明', 201902: '小红', 201903: '小强'}
len(students)

组合、复杂数据类型_元组_47

  • 字典的索引

通过 字典[键] 的形式来获取对应的值

students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201902]

组合、复杂数据类型_键值对_48

3.3 字典的操作方法

1、增加键值对

  • 变量名[新键] = 新值
students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201904] = "小雪"
students

组合、复杂数据类型_键值对_49

2、删除键值对

  • 通过del 变量名[待删除键]
students = {201901: '小明', 201902: '小红', 201903: '小强'}
del students[201903]
students

组合、复杂数据类型_元组_50

  • 通过变量名.pop(待删除键)
students = {201901: '小明', 201902: '小红', 201903: '小强'}
value = students.pop(201903)   # 删除键值对，同时获得删除键值对的值
print(value)
print(students)

组合、复杂数据类型_元组_51

  • 变量名.popitem() 随机删除一个键值对，并以元组返回删除键值对
students = {201901: '小明', 201902: '小红', 201903: '小强'}
key, value = students.popitem()
print(key, value)
print(students)

组合、复杂数据类型_键值对_52

3、修改值

  • 通过先索引后赋值的方式对相应的值进行修改
students = {201901: '小明', 201902: '小红', 201903: '小强'}
students[201902] = "小雪"
students

组合、复杂数据类型_python_53

4、d.get( )方法

d.get(key,default) 从字典d中获取键key对应的值，如果没有这个键，则返回default

  • 小例子：统计"牛奶奶找刘奶奶买牛奶"中字符的出现频率
s = "牛奶奶找刘奶奶买牛奶"
d = {}
print(d)
for i in s:
    d[i] = d.get(i, 0)+1
    print(d)
# print(d)

组合、复杂数据类型_java_54

5、d.keys( ) d.values( )方法

students = {201901: '小明', 201902: '小红', 201903: '小强'}
print(list(students.keys()))
print(list(students.values()))

组合、复杂数据类型_变量名_55

6、d.items( )方法及字典的遍历

print(list(students.items()))
for k, v in students.items():
    print(k, v)

组合、复杂数据类型_python_56

4 集合

4.1 集合的表达

  • 一系列互不相等元素的无序集合
  • 元素必须是不可变类型：数字，字符串或元组，可视作字典的键
  • 可以看做是没有值，或者值为None的字典
students = {"小明", "小红", "小强", "小明"}   #可用于去重
students

组合、复杂数据类型_java_57

4.2 集合的运算

  • 小例子 通过集合进行交集并集的运算
Chinese_A = {"刘德华", "张学友", "张曼玉", "钟楚红", "古天乐", "林青霞"}
Chinese_A

组合、复杂数据类型_键值对_58

Math_A = {"林青霞", "郭富城", "王祖贤", "刘德华", "张曼玉", "黎明"}
Math_A

组合、复杂数据类型_元组_59

  • 语文和数学两门均为A的学员
  • S & T 返回一个新集合，包括同时在集合S和T中的元素
Chinese_A & Math_A

组合、复杂数据类型_键值对_60

  • 语文或数学至少一门为A的学员
  • S | T 返回一个新集合，包括集合S和T中的所有元素
Chinese_A | Math_A

组合、复杂数据类型_键值对_61

  • 语文数学只有一门为A的学员
  • S ^ T 返回一个新集合，包括集合S和T中的非共同元素
Chinese_A ^ Math_A

组合、复杂数据类型_元组_62

  • 语文为A，数学不为A的学员
  • S - T 返回一个新集合，包括在集合S但不在集合T中的元素
Chinese_A - Math_A

组合、复杂数据类型_python_63

  • 数学为A，语文不为A的学员
Math_A - Chinese_A

组合、复杂数据类型_python_64

4.3 集合的操作方法

  • 增加元素——S.add(x)
stars = {"刘德华", "张学友", "张曼玉"}
stars.add("王祖贤")
stars

组合、复杂数据类型_变量名_65

  • 移除元素——S.remove(x)
stars.remove("王祖贤")
stars

组合、复杂数据类型_键值对_66

  • 集合的长度——len(S)
len(stars)

组合、复杂数据类型_python_67

  • 集合的遍历——借助for循环
for star in stars:
    print(star)

组合、复杂数据类型_java_68