python基础教程 ppt_Python基础教程第2章ppt

2022年 11月 4日

python基础教程 ppt_Python基础教程第2章ppt

PPT内容

这是Python基础教程第2章ppt，包括了常量和变量，运算符和表达式，常用语句，序列数据结构等内容，欢迎点击下载。

第2章 Python语言基础

课程描述

本章将介绍Python语言的基本语法和编码规范，并重点讲解Python语言的数据类型、运算符、常量、变量、表达式和常用语句等基础知识，为使用Python开发应用程序奠定基础。

本章知识点

2.1 常量和变量

2.2 运算符和表达式

2.3 常用语句

2.4 序列数据结构

2.1 常量和变量

2.1.1 常量

2.1.2 变量

2.1.1 常量

【例2-1】

【例2-2】

变量值传递的例子。

a = “这是一个变量”;

b = a;

print(b);#此时变量b的值应等于变量a的值

print (“\n”);

a = “这是另一个变量”;

print(b); #对变量$a的操作将不会影响到变量b

运行结果如下：

这是一个变量

变量赋值过程的示意图

id()函数

可以使用id()函数输出变量的地址，语法如下：

id(变量名)

【例2-3】用id()函数输出变量地址的示例程序：

str1 = “这是一个变量”;

print(“变量str1的值是：”+str1);

print(“变量str1的地址是：%d” %(id(str1)));

str2 = str1;

print(“变量str2的值是：”+str2);

print(“变量str2的地址是：%d” %(id(str2)));

str1 = “这是另一个变量”;

print(“变量str1的值是：”+str1);

print(“变量str1的地址是：%d” %(id(str1)));

print(“变量str2的值是：”+str2);

print(“变量str2的地址是：%d” %(id(str2)));

2.1.3 类型转换

1．转换为数字

(1)使用int()函数将字符串转换为整数，语法如下：

int(x [,base ])

参数x是待转换的字符串，参数base为可选参数，指定转换后整数的进制，默认为10进制。

(2)使用long()函数将字符串转换为长整数，语法如下：

long(x [,base ])

参数的含义与int()函数相同。

(3)使用float()函数将字符串或数字转换为浮点数，语法如下：

float (x)

参数x是待转换的字符串或数字。

(4)使用eval ()函数计算字符串中的有效Python表达式，并返回结果，语法如下：

eval(str)

参数str是待计算的Python表达式字符串。

【例2-4】

a = “1”;

b = int(a)+1;

print(b);

【例2-5】

a = “1+2”;

print(eval(a));

运行结果为3。

2．转换为字符串

(1)使用str ()函数将数值转换为字符串，语法如下：

str (x)

参数x是待转换的数值。

(2)使用repr ()函数将对象转换为可打印字符串，语法如下：

repr(obj)

参数obj是待转换的对象。

1.2.2 执行Python脚本文件

(3)使用chr ()函数将一个整数转换为可对应ASCII的字符，语法如下：

chr(整数)

(4)使用ord()函数将一个字符转换为对应的ASCII，语法如下：

ord(字符)

【例2-6】

print(chr(65));

print(ord(‘A’));

运行结果为。

(5)使用hex()函数将一个整数转换为一个十六进制字符串，语法如下：

chr(整数)

(6)使用oct()函数将一个整数转换为一个八进制字符串，语法如下：

oct(字符)

【例2-7】

使用hex()函数和oct()函数打印8的十六进制字符串和八进制字符串。

print(hex(8));

print(oct(8));

输出的结果如下：

0x8

0o10

十六进制字符串以0x开头，八进制字符串以0o开头。

2.2 运算符和表达式

运算符是程序设计语言的最基本元素，它是构成表达式的基础。本节将介绍Python语言运算符和表达式。

2.2.1 运算符

Python支持算术运算符、赋值运算符、位运算符、比较运算符、逻辑运算符、字符串运算符、成员运算符和身份运算符等基本运算符。

1．算术运算符

2．赋值运算符

【例2-8】

x =3

x += 3

print(x)

x -= 3

print(x)

x *= 3

print(x)

x /= 3

print(x)

运行结果如下：

3.0

3．位运算符

4．比较运算符

5．逻辑运算符

【例2-9】

x =True

y = False

print(“x and y = “, x and y)

print(“x or y = “, x or y)

print(“not x = “, not x)

print(“not y = “, not y)

运行结果如下：

x and y = False

x or y = True

not x = False

not y = True

6．字符串运算符

【例2-10】

b = “hello “;

a = b + “world!”;

print(a);

print (a*2);

print (r”hello\nworld!”);

运行结果如下：

hello world!

hello world!hello world!

hello\nworld!

7．运算符优先级

2.2.2 表达式

a = b + c;

a = b – c;

a = b * c;

a = b / c;

a = b % c;

a += 1;

b = a**2;

2.3 常用语句

2.3.1 赋值语句

2.3.2 条件分支语句

3.3.3 循环语句

2.3.4 try-except语句

2.3.1 赋值语句

赋值语句是Python语言中最简单、最常用的语句。通过赋值语句可以定义变量并为其赋初始值。在2.2.1小节介绍赋值运算符时，已经涉及到了赋值语句，例如：

a = 2;

b = a + 5;

【例2-11】

a = 10;

a += 1;

print (a);

a*= 10;

print (a);

a**= 2;

print (a);

运行结果如下：

110

12100

2.3.2 条件分支语句

1．if语句

if 条件表达式:

语句块

【例2-12】 if语句的例子

if a > 10:

print(“变量a大于10”);

如果语句块中包含多条语句，则这些语句必须拥有相同的缩进。例如：

if a > 10：

print(“变量a大于10”);

a = 10;

【例2-13】嵌套if语句的例子

if a > 10：

print(“变量a大于10”);

if a > 100:

print(“变量\$a大于100”);

}

2．else语句

if条件表达式:

语句块1

else:

语句块2

3．elif语句

if 条件表达式1

语句块1

elif 条件表达式2

语句块2

elif 条件表达式3

语句块3

……

else

语句块n

【例2-15】

import datetime

str = “今天是”;

d=datetime.datetime.now()

print(d.weekday())

if d.weekday()==0:

str += “星期一”;

elif d.weekday()==1:

str += “星期二”;

elif d.weekday()==2:

str += “星期三”;

weekday()方法的返回值

3.3.3 循环语句

1．while语句

while 条件表达式:

循环语句体

3.3.3 循环语句

1．while语句

2．for语句

3．continue语句

4．break语句

1．while语句

while 条件表达式:

循环语句体

【例2-16】

i = 1;

sum = 0;

while i<11:

sum += i;

i+= 1;

print(sum)

2．for语句

for i in range(start, end):

循环体

【例2-17】

i = 1;

sum = 0;

for i in range(1, 11):

print(i)

sum+=i

print(sum)

3．continue语句

【例2-18】如果只计算1~100之间偶数之和，可以使用下面的代码：

i = 1;

sum = 0;

for i in range(1, 101):

if i%2 == 1:

continue

sum+=i

print(sum)

4．break语句

【例2-19】将【例2-16】修改为使用break语句跳出循环体。

i = 1;

sum = 0;

while True:

if i== 11:

break;

sum += i;

i+= 1;

print(sum)

2.3.4 try-except语句

try:

except [, ,….] as :

finally:

【例2-20】

i = 10;

print(30 / (i – 10));

程序中存在一个30/0的错误，运行该程序会出现下面的报错信息。

Traceback (most recent call last):

File “D:\MyBooks\2014\python\源代码\02\例2-20.py”, line 2, in

print(30 / (i – 10));

【例3.21】

print(30 / (i – 10))

except Exception as e:

print(e);

finally:

print(“执行完成”);

2.4 序列数据结构

2.4.1 列表

2.4.2 元组(tuple)

2.4.1 列表

列表(List)是一组有序存储的数据。例如，饭店点餐的菜单就是一种列表。列表具有如下特性：

 和变量一样，每个列表都有一个唯一标识它的名称。

 一个列表的元素应具有相同的数据类型。

 每个列表元素都有索引和值两个属性，索引是一个从0开始的整数，用于标识元素在列表中的位置；值当然就是元素对应的值。

1．定义列表

下面就是一个列表的定义。

menulist = [‘红烧肉’, ‘熘肝尖’, ‘西红柿炒鸡蛋’, ‘油焖大虾’]

2．打印列表

print(列表名)

【例2-22】打印列表的内容。

menulist = [‘红烧肉’, ‘熘肝尖’, ‘西红柿炒鸡蛋’, ‘油焖大虾’]

print(menulist)

运行结果如下：

[‘红烧肉’, ‘熘肝尖’, ‘西红柿炒鸡蛋’, ‘油焖大虾’]

3．获取列表长度

Len(数组名)

4．访问列表元素

列表名[index]

【例2-23】访问列表元素的例子

menulist = [‘红烧肉’, ‘熘肝尖’, ‘西红柿炒鸡蛋’, ‘油焖大虾’]

print(menulist[0])

print(menulist[3])

程序打印列表中索引为0和3的元素，运行结果如下：

红烧肉

油焖大虾

5．添加列表元素

列表.append(新值)

【例2-24】通过append()函数添加列表元素的例子。

menulist = [‘红烧肉’, ‘熘肝尖’, ‘西红柿炒鸡蛋’, ‘油焖大虾’]

menulist.append(‘北京烤鸭’)

print(menulist)

程序调用append()函数在列表menulist的尾部添加元素’北京烤鸭’，运行结果如下：

[‘红烧肉’, ‘熘肝尖’, ‘西红柿炒鸡蛋’, ‘油焖大虾’, ‘北京烤鸭’]

insert()函数

列表. insert(插入位置, 新值)

【例2-25】通过insert()函数添加列表元素的例子。

menulist = [‘红烧肉’, ‘熘肝尖’, ‘西红柿炒鸡蛋’, ‘油焖大虾’]

menulist.insert(4, ‘北京烤鸭’)

print(menulist)

，运行结果如下：

[‘红烧肉’, ‘北京烤鸭’, ‘熘肝尖’, ‘西红柿炒鸡蛋’, ‘油焖大虾’]

extend()函数

列表1.extend(列表2)

【例2-26】通过extend()函数添加列表元素的例子。

menulist1 = [‘红烧肉’, ‘熘肝尖’]

menulist2 = [‘西红柿炒鸡蛋’, ‘油焖大虾’]

menulist1. extend (menulist2)

print(menulist1)

运行结果如下：

[‘红烧肉’, ‘北京烤鸭’, ‘熘肝尖’, ‘西红柿炒鸡蛋’, ‘油焖大虾’]

6．合并2个列表

可以使用+将2个列表合并，得到一个新的列表，具体方法如下：

列表3=列表1 + 列表2

【例2-27】合并2个列表的例子。

menulist1 = [‘红烧肉’, ‘熘肝尖’, ‘西红柿炒鸡蛋’]

menulist2 = [‘北京烤鸭’, ‘西红柿炒鸡蛋’, ‘油焖大虾’]

menulist3 = menulist1 + menulist2

print(menulist3)

运行结果如下：

[‘红烧肉’, ‘熘肝尖’, ‘西红柿炒鸡蛋’, ‘北京烤鸭’, ‘西红柿炒鸡蛋’, ‘油焖大虾’]

7．删除列表元素

del 列表名[索引]

【例2-28】使用del语句删除列表元素的例子。

menulist = [‘红烧肉’, ‘熘肝尖’, ‘西红柿炒鸡蛋’]

del menulist[0]

print(menulist)

运行结果如下：

[‘熘肝尖’, ‘西红柿炒鸡蛋’]

7．删除列表元素

del 列表名[索引]

【例2-28】使用del语句删除列表元素的例子。

menulist = [‘红烧肉’, ‘熘肝尖’, ‘西红柿炒鸡蛋’]

del menulist[0]

print(menulist)

运行结果如下：

[‘熘肝尖’, ‘西红柿炒鸡蛋’]

8．定位列表元素

可以使用index()函数获取列表中某个元素的索引。其基本语法如下：

列表.index(元素值)

函数返回元素值在列表中某个元素的索引，如果不存在，则会抛异常。

【例2-29】使用index ()函数的例子。

menulist = [‘红烧肉’, ‘熘肝尖’, ‘西红柿炒鸡蛋’]

print(menulist.index(‘红烧肉’))

print(menulist.index(‘西红柿炒鸡蛋’))

运行结果如下：

9．遍历列表元素

遍历列表就是一个一个地访问列表元素，这是使用列表时的常用操作。

可以使用for语句和range()函数遍历列表索引，然后通过索引依次访问每个列表元素，方法如下：

for i in range(len(list)):

访问list[i]

【例2-30】

for语句和range()函数遍历列表。

list = [‘王二’, ‘张三’, ‘李四’, ‘王五’];

for i in range(len(list)):

print(list[i]);

程序的运行结果如下：

王二

张三

李四

王五

使用for语句和enumerate()函数同时遍历列表的元素索引和元素值

for 索引, 元素值in enumerate(list):

访问索引和元素值

【例2-31】 for语句和enumerate()函数遍历列表。

list = [‘王二’, ‘张三’, ‘李四’, ‘王五’];

for index,value in enumerate(list):

print(“第%d个元素值是【%s】” %(index, value));

程序的运行结果如下：

第0个元素值是【王二】

第1个元素值是【张三】

第2个元素值是【李四】

第3个元素值是【王五】

10．列表排序

列表排序操作值按列表元素值的升序、降序或反序重新排列列表元素的位置。

可以使用sort()函数对列表进行升序排列，其语法如下：

列表.sort()

【例2-32】

list = [‘apple’, ‘banana’, ‘pear’, ‘grape’];

list.sort()

print(list)

程序的运行结果如下：

[‘apple’, ‘banana’, ‘grape’, ‘pear’]

reverse()函数

可以使用reverse()函数对列表进行反序排列，其语法如下：

列表.reverse()

调用reverse ()函数后，列表元素被反序排列。

【例2-33】使用reverse ()函数对列表进行反序排列。

list = [‘apple’, ‘Banana’, ‘pear’, ‘grape’];

list.reverse()

print(list)

程序的运行结果如下：

[‘grape’, ‘pear’, ‘Banana’, ‘apple’]

【例2-34】

list = [‘apple’, ‘banana’, ‘pear’, ‘grape’];

list.sort()

list.reverse()

print(list)

程序的运行结果如下：

[‘pear’, ‘grape’, ‘banana’, ‘apple’]

11．产生一个数值递增列表

使用range()函数可以产生一个数值递增列表，它的基本语法结构如下：

range(start, end)

参数说明如下。

 start：一个整数，指定产生的列表的起始元素值。start为可选参数，默认值为0。

 end：一个整数，指定产生的列表的结束元素值。

range()函数返回一个列表，该列表由从start开始至end结束的整数组成。

【例2-35】

list1 = range(10)

list2 = range(11, 20)

#打印list1

for index,value in enumerate(list1):

print(“list1的第%d个元素值是【%s】” %(index, value));

#打印list2

for index,value in enumerate(list2):

print(“list2的第%d个元素值是【%s】” %(index, value));

12．定义多维列表

【例2-36】一个定义二维数列表的例子。

list2 = [[“CPU”, “内存”], [“硬盘”,”声卡”]];

【例2-36】中列表list2的内容

【例2-37】打印二维列表

list2 = [[“CPU”, “内存”], [“硬盘”,”声卡”]];

for i in range(len(list2)):

print(list2[i]);

运行结果如下：

[‘CPU’, ‘内存’]

[‘硬盘’, ‘声卡’]

【例2-38】

list2 = [[“CPU”, “内存”], [“硬盘”,”声卡”]];

for i in range(len(list2)):

list1 = list2[i];

for j in range(len(list1)):

print(list1[j])

运行结果如下：

CPU

内存

硬盘

声卡

使用下面的方法获取二维列表元素的值

列表名[索引1] [索引2]

【例2-39】

list2 = [[“CPU”, “内存”], [“硬盘”,”声卡”]];

for i in range(len(list2)):

for j in range(len(list2[i])):

print(list2[i][j])

运行结果

CPU

内存

硬盘

声卡

2.4.2 元组(tuple)

元组与列表非常相似，它具有如下特性：

 一经定义，元组的内容不能改变。

 元组元素可以存储不同类型的数据，可以是字符串、数字，甚至是元组。

 元组元素由圆括号括起来，例如：

t = (1, 2, 3, 4)

1．访问元组元素

与列表一样，可以使用索引访问元组元素，方法如下：

元组[索引]

【例2-40】访问元组元素的例子。

t = (1, 2, 3, 4)

print(t[0])

print(t[3])

程序打印元组中索引为0和3的元素，运行结果如下：

2．获取元组长度

元组长度指元组中元素的数量。可以通过len()函数获取元组的长度，方法如下：

Len(元组名)

【例2-41】打印元组的长度。

t = (1, 2, 3, 4)

print(len(t))

运行结果为4。

3．遍历元组元素

for i in range(len(tuple)):

访问tuple [i]

【例2-42】 for语句和range()函数遍历列表。

t = (‘王二’, ‘张三’, ‘李四’, ‘王五’);

for i in range(len(t)):

print(t[i]);

程序的运行结果如下：

王二

张三

李四

王五

使用for语句和enumerate()函数同时遍历列表的元素索引和元素值

for 索引, 元素值in enumerate(list):

访问索引和元素值

。

【例2-43】 for语句和enumerate()函数遍历列表

list = [‘王二’, ‘张三’, ‘李四’, ‘王五’];

for index,value in enumerate(list):

print(“第%d个元素值是【%s】” %(index, value));

程序的运行结果如下：

第0个元素值是【王二】

第1个元素值是【张三】

第2个元素值是【李四】

第3个元素值是【王五】

4．排序

因为元组的内容不能改变，所以元组没有sort()函数。可以将元组转换为列表，然后再对列表排序，最后将排序后的列表赋值给元组。

可以使用下面的方法将元组转换为列表。

列表对象 = list(元组对象)

将列表转换为元组的方法如下：

元组对象 = tuple(列表对象)

【例2-44】对元组进行排列。

t = (‘apple’, ‘banana’, ‘pear’, ‘grape’);

l = list(t);

l.sort();

t = tuple(l);

print(t)

程序的运行结果如下：

(‘apple’, ‘banana’, ‘grape’, ‘pear’)

使用reverse()函数对元组进行反序排列

元组.reverse()

调用reverse ()函数后，元组元素被反序排列。

【例2-45】使用reverse ()函数对元组进行反序排列。

t = (‘apple’, ‘banana’, ‘pear’, ‘grape’);

l = list(t);

l.reverse()

t = tuple(l);

print(t)

2.4.3 字典

1．定义字典

字典元素使用{}括起来，例如，下面的语句可以定义一个空字典。

d1 = {};

也可以在定义字典时指定里面的元素，每个元素由键和值组成，键和值之间由冒号(:)分割，元素间由逗号(,)分割。例如：

d2={‘name’:’小明’, ‘sex’:’男’,’age’:’18’, ‘score’:’80’}

2．打印字典

可以直接使用print()函数打印字典，方法如下：

print(字典名)

【例2-46】打印字典的内容。

d={‘name’:’小明’, ‘sex’:’男’,’age’:’18’, ‘score’:’80’}

print(d)

运行结果如下：

{‘score’: ’80’, ‘name’: ‘小明’, ‘age’: ’18’, ‘sex’: ‘男’}

3．获取字典长度

Len(字典名)

【例2-47】打印字典的长度。

d={‘name’:’小明’, ‘sex’:’男’,’age’:’18’, ‘score’:’80’}

print(len(d))

运行结果为4。

4．访问字典元素

字典由字典元素组成。对字典的管理就是对字典元素的访问和操作。可以通过下面的方法获取字典元素的值：

字典名[key]

key是元素的键。

【例2-48】

d={‘name’:’小明’, ‘sex’:’男’,’age’:’18’, ‘score’:’80’}

print(d[‘name’])

print(d[‘sex’])

print(d[‘age’])

print(d[‘score’])

程序打印列表中索引为0和3的元素，运行结果如下：

小明

男

5．添加字典元素

可以通过赋值在字典中添加元素，具体方法如下：

字典[键] = 值

如果字典中不存在指定键，则添加；否则修改键值。

【例2-49】添加字典元素的例子。

d={‘name’:’小明’, ‘sex’:’男’,’age’:’18’}

d[‘score’] = ’80’

print(d)

运行结果如下：

{‘sex’: ‘男’, ‘age’: ’18’, ‘name’: ‘小明’, ‘score’: ’80’}

6．合并2个字典

可以使用update()函数将2个字典合并，具体方法如下：

字典1.update(字典2)

【例2-50】合并2个字典的例子。

d1={‘name’:’小明’, ‘sex’:’男’}

d2={‘age’:’18’, ‘score’: ’80’}

d1.update(d2)

print(d1)

运行结果如下：

{‘age’: ’18’, ‘name’: ‘小明’, ‘score’: ’80’, ‘sex’: ‘男’}

7．删除字典元素

使用pop()方法可以删除指定的字典元素，并返回删除的元素值。具体方法如下：

字典名.pop(键)

【例2-51】使用pop()方法删除字典元素的例子。

d={‘age’: ’18’, ‘name’: ‘小明’, ‘score’: ’80’, ‘sex’: ‘男’}

d.pop(‘score’)

print(d)

运行结果如下：

{‘name’: ‘小明’, ‘sex’: ‘男’, ‘age’: ’18’}

8．判断字典是否存在元素

可以使用in关键字判断字典中是否存在指定键的元素。其基本语法如下：

键 in 字典

如果字典中存在指定键的元素，则表达式返回True；否则返回False。

【例2-52】使用in关键字的例子。

d={‘age’: ’18’, ‘name’: ‘小明’, ‘score’: ’80’, ‘sex’: ‘男’}

if ‘name1’ in d:

print(d[‘name1’])

else:

print(‘不包含键位name1的元素’)

运行结果如下：

不包含键位name1的元素

9．遍历字典元素

可以使用for.. in语句遍历字典的键和值，方法如下：

for key in 字典.keys(): # 遍历字典的键

访问字典[key]

for key in 字典.values(): # 遍历字典的值

访问字典[key]

【例2-53】

d={‘age’: ’18’, ‘name’: ‘小明’, ‘score’: ’80’, ‘sex’: ‘男’}

for key in d.keys(): # 遍历字典的键

print(‘键’+key+ ‘的值：’+ d[key]);

程序的运行结果如下：

键score的值：80

键name的值：小明

键sex的值：男

键age的值：18

【例2-54】

d={‘age’: ’18’, ‘name’: ‘小明’, ‘score’: ’80’, ‘sex’: ‘男’}

for value in d.values(): # 遍历字典的值

print(value);

程序的运行结果如下：

小明

男

10．清空字典

使用clear()方法可以清空指定的字典所有元素。具体方法如下：

字典名.clear()

【例2-55】使用clear ()方法清空字典元素的例子。

d={‘age’: ’18’, ‘name’: ‘小明’, ‘score’: ’80’, ‘sex’: ‘男’}

d. clear()

print(d)

运行结果如下：

{}

11．字典的嵌套

字典里面还可以嵌套字典，例如

{‘name’:{‘first’:’Johney’,’last’:’Lee’},’age’:40}

可以通过下面的方式访问嵌套字典。

字典[键][键]

【例2-56】

d={‘name’:{‘first’:’Johney’,’last’:’Lee’},’age’:40}

print(d[‘name’][ ‘first’])

运行结果如下：

Johney

2.4.4 集合

集合由一组无序排列的元素组成，可以分为可变集合(set)和不可变集合(frozenset)。可变集合创建后可以添加元素，修改元素和删除元素。而不可变集合创建后则不能改变。

1．创建集合

创建可变集合的例子。

s = set(‘python’)

【例2-57】创建可变集合的例子。

s = set(‘python’)

print(type(s))

print(s)

运行结果如下：

{‘t’, ‘o’, ‘y’, ‘p’, ‘n’, ‘h’}

使用frozenset ()方法创建不可变集合

s = frozenset(‘python’)

【例2-58】创建不可变集合的例子。

fs = frozenset(‘python’)

print(type(fs))

print(fs)

运行结果如下：

frozenset({‘n’, ‘y’, ‘h’, ‘o’, ‘p’, ‘t’})

2．获取集合长度

Len(集合名)

【例2-59】打印集合的长度。

s = set(‘python’)

print(len(s))

运行结果为6。

3．访问集合元素

【例2-60】遍历集合元素的例子。

s = set(‘python’)

for e in s:

print(e)

运行结果如下：

4．添加集合元素

可以通过调用add()方法在集合中添加元素，具体方法如下：

集合.add(值)

【例2-61】添加一个集合元素的例子

s = set(‘python’)

s.add(‘0’)

print(s)

运行结果如下：

{‘t’, ‘y’, ‘h’, ‘p’, ‘o’, ‘0’, ‘n’}

update()方法将另外一个集合的元素添加到指定集合中

集合. update(值)

【例2-62】添加多个集合元素的例子。

s = set([1, 2, 3])

s.update([4, 5, 6])

print(s)

运行结果如下：

{1, 2, 3, 4, 5, 6}

5．删除集合元素

可以使用remove()方法删除指定的集合元素。具体方法如下：

集合名. remove(值)

使用clear()方法可以清空指定的集合所有元素。具体方法如下：

集合名.clear()

【例2-63】

s = set([1, 2, 3])

s.remove(1)

print(s)

s.clear()

print(s)

运行结果如下：

{2 ,3}

set()

6．判断集合是否存在元素

可以使用in判断集合中是否存在指定键的元素。其基本语法如下：

值 in 集合

如果集合中存在指定值的元素，则表达式返回True；否则返回False。

【例2-64】判断集合是否存在元素的例子。

s = set([1, 2, 3])

if 2 in s:

print(‘存在’])

else:

print(‘不存在’)

运行结果如下：

存在

7．遍历集合元素

可以使用for.. in语句遍历集合的值，方法如下：

for element in 集合:

访问 element

【例2-65】使用for.. in语句遍历集合。

s = set([1, 2, 3])

for e in s: # 遍历集合

print(e);

程序的运行结果如下：

8．子集和超集

【例2-66】

s1 = set([1, 2])

s2 = set([1, 2, 3])

if s1!=s2:

if s1

print(‘s1是s2的真子集’)

if s2>s1:

print(‘s2是s1的超集’)

运行结果如下：

s1是s2的真子集

s2是s1的超集

9．集合的并集

可以使用|操作符计算两个集合的并集。例如：

s = s1 | s2

【例2-67】使用|操作符计算两个集合的并集。

s1 = set([1, 2])

s2 = set([3, 4])

s = s1 | s2

print(s)

运行结果如下：

{1, 2, 3, 4}

使用union()方法计算两个集合的并集

s = s1.union(s2)

【例2-68】使用union()方法计算两个集合的并集。

s1 = set([1, 2])

s2 = set([3, 4])

s = s1.union(s2)

print(s)

运行结果如下：

{1, 2, 3, 4}

10．集合的交集

集合的交集由所有既属于集合A又属于集合B的元素组成。

可以使用&操作符计算两个集合的交集。例如：

s = s1 & s2

【例2-69】

s1 = set([1, 2, 3])

s2 = set([3, 4])

s = s1 & s2

print(s)

运行结果如下：

{3}

使用intersection ()方法计算两个集合的并集

s = s1. intersection (s2)

【例2-70】使用intersection()方法计算两个集合的并集。

s1 = set([1, 2, 3])

s2 = set([3, 4])

s = s1.intersection(s2)

print(s)

11．集合的差集

集合的差集由所有属于集合A但不属于集合B的元素组成。

可以使用-操作符计算两个集合的差集。例如：

s = s1 – s2

【例2-71】使用-操作符计算两个集合的差集。

s1 = set([1, 2, 3])

s2 = set([3, 4])

s = s1 – s2

print(s)

运行结果如下：

{1, 2}

使用difference ()方法计算两个集合的差集

s = s1. difference(s2)

【例2-72】使用difference()方法计算两个集合的并集。

s1 = set([1, 2, 3])

s2 = set([3, 4])

s = s1. difference(s2)

print(s)