python基础语法（下）—— python中的元组、集合、字典、类与异常的处理

文章目录

- 8.python中的元组
- - 8.1元组的初始化
  - 8.2元组的解包
  - 8.3元组的比较运算
  - 8.4else
- 9.python中的集合
- - 9.1集合的初始化
  - 9.2集合的常用操作
  - 9.3使用for循环遍历集合
- 10.python中的字典
- - 10.1字典的初始化
  - 10.2字典的常见操作
  - 10.3使用for循环遍历字典
- 11.python中的类
- - 11.1类的定义
  - 11.2类变量和实例变量
  - 11.3类的继承
- 12.python中的异常处理

8.python中的元组

元组跟列表类似，只是不支持动态添加、删除元素，以及不能修改元素。

8.1元组的初始化

元组需要用小括号括起来，中间的元素用逗号隔开。注意，如果初始化只包含一个元素的元组，需要在该元素后添加逗号。

a = () #初始化一个空的元组
b = (1, 2) #含有2个整数的元组
print(type(b)) #看一下b的类型，得到输出：<class 'tuple'>
c = (1,) #注意不能写成(1)，(1)表示整数1
d = 6, "python", 3.14 #等价于（6，“python”，3.14）
e = 6 #等价于（6）
print(type(e)) #得到输出：<class 'int'>
print(a, b, c, d, e) #得到输出：() (1, 2) (1,) (6, 'python', 3.14) 6

8.2元组的解包

形如：

x = 6, "python", 3.14 #初始化一个元组
print(type(x)) #得到输出：<class 'tuple'>
a, b, c = x #解包操作
print(a, b, c) #输出结果：6 python 3.14

像平常我们同时给两个变量赋值，或者交换两个数，例如：a, b = b, a，都是元组解包的过程。还有，函数的返回值有多个的时候，本质上也是返回了一个元组，例如：

def fun(x, y):
    return x + y, x * y

print(fun(1, 2)) #输出结果：(3, 2)，返回的也是元组

8.3元组的比较运算

元组和列表均支持比较运算符：==、!=、>、<、>=、<=等，按字典序进行比较。

8.4else

元组的下标访问元素、循环遍历、切片、加法和乘法运算等操作，都与列表相同。

9.python中的集合

集合是Python中最常用的数据结构之一，用来存储不同元素。

注意，集合中的元素是无序的。

9.1集合的初始化

创建集合用花括号或set()函数。注意：创建空集合只能用set()，不能用{}，因为{}创建的是空字典，会在下一小节里介绍字典。集合常见的初始化方式有：

plate = {"apple", "pear", "orange", "apple", "orange", "banana", "apple"} #初始化一个集合
print(plate) #输出结果：{'banana', 'apple', 'orange', 'pear'} 无序且去重
x = set() #初始化一个空的集合
print(x) #输出：set()
a = [1, 2, 2, 4, 4, 5]
b = set(a) #将列表转换成集合，一般是为了去重，
print(b) #输出：{1, 2, 4, 5}
c = list(b) #再将集合转换成列表，
print(c) #输出：{1, 2, 4, 5}

x = "abracadabrac"
a = set(x) #将x转换成集合去重
print(a) #输出：{'c', 'd', 'r', 'b', 'a'}
b = str(a) #将集合转换成字符串
print(b) #输出：{'c', 'd', 'r', 'b', 'a'}

9.2集合的常用操作

假设a表示一个集合。

len(a) 返回集合中包含的元素数量
a.add(x) 在集合中添加一个元素。
a.remove(x) 删除集合中的x，如果x不存在，则报异常。
a.discard(x) 删除集合中的x，如果x不存在，则不进行任何操作。
x in a 判断x是否在a中。
x not in a 判断x是否不在a中。

例如：

a = {1, 2, 3}
print(len(a)) #输出：4
a.add(4) 
print(a) #输出：{1, 2, 3, 4}
a.remove(4)
print(a) #输出：{1, 2, 3}
a.discard(3)
print(a) #输出：{1, 2}

9.3使用for循环遍历集合

类似于列表，集合也可以用for … in …的形式遍历。例如：

a = {1, 2, 3}
for i in a:
    print(i, end=' ')

10.python中的字典

相当于C++中的哈希表。字典是Python中最常用的数据结构之一，用来存储映射关系。注意，字典中的元素是无序的。不同于列表，字典是以key进行索引的，可以将每个key映射到某个value。 key可以是任何不可变类型，常用可以作为key的类型有数字和字符串。列表因为是可变的，所以不能作为key。value可以是任意类型。

10.1字典的初始化

创建字典用花括号或dict()函数。

phone = {'jerry': 1596, 'tom': 1598}
print(phone) #输出：{'jerry': 1596, 'tom': 1598}

a = dict() #初始化一个空字典
a[1] = "apple"
a[2] = "banana"
a[3] = "orange"
print(a) #输出：{1: 'apple', 2: 'banana', 3: 'orange'}
b = list(a) #将字典转换成列表
print(b) #输出：[1, 2, 3]

10.2字典的常见操作

假设a表示一个字典。

len(a)：返回字典中的元素对数。
a[x]：获取关键字x对应的值，如果x不存在，会报异常。
a.get(x)：获取关键字x对应的值，如果x不存在，会返回None，不会报异常。
a.get(x, y)：获取关键字x对应的值，如果x不存在，会返回默认值y，不会报异常。
a[x] = y：在字典中插入一对元素，如果关键字x已存在，则将它之前映射的值覆盖掉。
del a[x]：删除关键字x对应的元素对，如果x不存在，会报异常。
x in a：检查字典中是否存在关键字x。
x not in a：检查字典中是否不存在关键字x。
a.keys()：返回字典的所有key。
a.values()：返回字典的所有value。
a.items()：返回字典的所有由key和value组成的元组。

例如：

a = {"apple": 1, "banana": 2, "cherry": 3}
print(len(a)) #输出：3
print(a["apple"]) #输出：1
print(a.get("cherry")) #输出：3
print(a.get("orange"), 2) #“orange‘不在，输出：None 2
a["apple"] = 6
print(a) #输出：{'apple': 6, 'banana': 2, 'cherry': 3}
del a["cherry"]
print(a) #输出：{'apple': 6, 'banana': 2}
print("banana" not in a) #输出：False
print(a.values()) #输出：dict_values([6, 2])
print(a.keys()) #输出:dict_keys(['apple', 'banana'])
print(a.items()) #输出：dict_items([('apple', 6), ('banana', 2)])

10.3使用for循环遍历字典

类似于列表，字典也可以用for … in …的形式遍历。例如：

a = {'abc': 1, 'def': 2, 'python': 3}  # 初始化一个字典

for k in a:  # 遍历key
    print(k, end=' ')
print()  # 输出：abc def python

for k in a.keys():  # 遍历key
    print(k, end=' ')
print()  # 输出：abc def python 

for v in a.values():  # 遍历value
    print(v, end=' ')
print()  # 输出：1 2 3 

for k, v in a.items():  # 遍历key-value对
    print("(%s, %d) " % (k, v), end=' ')
print()  # 输出：(abc, 1)  (def, 2)  (python, 3)

11.python中的类

类似于C++中的类；类可以将变量、函数打包在一起，让代码在逻辑上更加清晰。
类名称一般采用驼峰命名法，函数一般采用下划线命名法。类中函数的第一个参数都是self（相当于C++中的this指针，只不过self不是指针，相当于解引用的操作），用来调用类本身的变量和函数。当调用类中函数的时候，第一个参数self不需要自己传递，Python会自动传递这个参数。

11.1类的定义

class Hero:
    hero_count = 0 #类变量

    def __init__(self, name, level=10): #构造函数
        self.name = name
        self.level = level
        print("Hero %s has been created" % name)
        Hero.hero_count += 1

    def __str__(self): #定义str函数
        return "Hero: %s " % self.name

    def greet(self):
        print("%s: Hi!" % self.name)

    def move(self):
        print("%s: move" % self.name)

    def get_level(self): #获得该英雄的等级
        return self.level

    def next_level(self):
        return self.get_level() + 1

zeus = Hero("Zeus")
athena = Hero("Athena")
zeus.greet()
athena.move()
print(zeus.name, athena.get_level(), athena.next_level())
print(str(zeus), athena.get_level(), athena)
print(Hero.hero_count)

在这里插入图片描述

11.2类变量和实例变量

每个类可以创建任意多实例。例如上面的Hero类，可以创建zeus和athena等实例。类变量由所有实例共享，一般通过类名访问，例如Hero.hero_count。实例变量与每个具体的实例绑定，一般通过具体实例来访问，例如zeus.name。

11.3类的继承

子类可以继承父类的变量和函数。self可以调用自身和父类中的变量和函数，super()可以调用父类中的函数。
如果子类和父类的变量或函数重名，优先使用子类的变量和函数。

class Hero:
    hero_count = 0 #类变量

    def __init__(self, name, level=10): #构造函数
        self.name = name
        self.level = level
        print("Hero %s has been created" % name)
        Hero.hero_count += 1

    def __str__(self): #定义str函数
        return "Hero: %s " % self.name

    def greet(self): #问候
        print("%s: Hi!" % self.name)

    def move(self): #移动
        print("%s: move" % self.name)

    def get_level(self): #获得该英雄的等级
        return self.level

    def next_level(self):
        return self.get_level() + 1

class Zeus(Hero): #继承了Hero这个类
    hero_name = "Zeus"

    def __init__(self, level):
        super().__init__(Zeus.hero_name, level) #通过super()调用父类的构造函数

    def greet(self):
        print("%s: Hi!(from child class)" % self.name) #调用父类的name

class Athena(Hero): #继承了Hero这个类
    hero_name = "Athena"

    def __init__(self, level):
        super().__init__(Athena.hero_name, level) #通过super()调用父类的构造函数

    def greet(self):
        print("%s: Hi!(from child class)" % self.name) #使用的是父类的name

zeus = Zeus(6)
athena = Athena(8)
print(zeus.name, athena.name, Hero.hero_count)
zeus.greet()
athena.greet()
print(zeus.name, athena.name)

在这里插入图片描述

12.python中的异常处理

当某段代码出现异常时，代码会被终止。此时如果不想让代码终止，可以用try … except … 语句来处理异常。

例如，将字符串转化成整数时，可能会出现异常：

s = input()

try:
    x = int(s)
    print(x)
except Exception as e:
    print(e)

print("Finished!")

当除以0时，也会出现异常：

x, y = map(int, input().split())

try:
    z = x / y
    print(z)
except Exception as e:
    print(e)

print("Finished!")