

首页  思维导图  详情



python学习

2026-04-15 14:31:34   0  举报





仅支持查看

AI智能生成

python学习

python

模版推荐

作者其他创作

大纲/内容

基础语法和开发环境搭建

主要工具安装

Pycharm安装

python程序包

注释方法：

# 单行注释

""" """/''' ''' 多行注释(三个单/双引号)

快捷键 ctrl+？

字符串

定义单行字符创

单引号

’

name = 'aliyun'

双引号

“

work = "hangzhou"

定义多行字符创

三引号

“”“

location = """ 阿里云 """

字符串中存在字符串单引号（需要用双引号包裹）

test = “I‘m conming”

字符串中存在字符串双引号（需要用单引号包裹）

test = 'say:"hhh.",wudi'

都含有用三引号

变量定义和赋值

变量的作用

存储数据

引用数据

类型灵活

变量赋值

a = 1

b = a

输出结果 b = 1

变量赋值规则

变量只能包含字母(a-z、A-Z)、数字(0-9)和下划线

python区分大小写（name和Name不是一个变量）

变量名不能以数字开头

变量不能以python关键字命名

for def 等等

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

注意import导入的时候需要注意:

import keyword

文件名不能使用keyword

关键字解析

控制流关键字

if，elif，else

条件判断

for，while

循环

break，continue

控制循环的进行

try，except，finally，raise

异常处理

定义和声明关键字

def

定义函数

class

定义类

lambda

定义匿名函数

import，from

导入模块

逻辑运算关键字

and，or，not

用于逻辑运算

is，in

比较运算

其他常见关键字

return

从函数返回值

yield

生成器函数，生成一个值并暂停函数的执行

global，nonlocal

声明变量的作用域

True，False，None

布尔值和空值

命名规范

见名知意

使用英语单词

使用下划线分割单词

避免使用保留字和内置函数名称

保持命名风格一致

变量命名长度适中

程序的输入和输出

输入函数：input

input()

基本语法：

name = input()

子主题 3

带提示的input函数

name = input('请输入您的姓名：')

输出函数：print

print()

将传入的内容输出到标准输出(控制台)

函数会将传入的值转换为字符串后输出，并默认在输出后加上一个换行符

基本用法

print('string类型')

print(a,'是a的值')

print('张三')

不换行输出:

print(a,'是testing 1',end='')

打印多个值:

a = 1 b = a+1 c = a+b

print(a,b,c)

数值和算数运算

数值类型

整数 int

a = 1 b = a+1 c = a+b

浮点数 float

a = 1.1 b = a+1.2 c = a+b+0.8

复数 complex

复数类型用于表示具有实部和虚部的数值，表示a+bj的形式，其中a是实部，b是虚部。

c = 1 + 2j

d = -3j

查看数据类型

内建函数type可以用来查看变量的类型

print(type('name')) print(type(8))

算数运算符

运算符有:

两个数相除

t = b / 1.01 print(t)

1.9801980198019802

两个数相除并取整

t = b / /1.01 print(t)

1.0

两个数相除并取余数

t = b % 1.01 print(t)

0.99

2**3

2的3次方

t = b % 1.01 f = 0.5**-2 print(t+f)

4.99

幂运算

a = 1 b = a+1 c = a+b

运算符优先级

乘法、除法、取余和幂运算符的优先级高于加法和减法运算符

()括号可以改变运算的顺序，括号里面的表达式是最先计算的

生产随机数

random模块用于生产随机数

生产随机整数

print(random.randint(1,1000))

随机整数

print(random.uniform(0,10.0))

随机浮点数

print(random)

965 8.530238449354622

练习题

1.编写一个程序，提示用户输入两个数字，然后输出它们的和、差、积、商、整数商、余数和幂运算结果。

2.编写一个程序，计算一个数值的平方和立方。

3.编写一个程序，提示用户输入一个半径，计算并输出对应圆的面积和周长。

4.编写一个程序，提示用户输入三个边长，计算并输出三角形的周长和面积(使用 Heron's公式计算面积)

注意点

标点符号都要英文格式的

input输入的都是字符类型

变量不能和关键重名

字符串不能直接和数值类型进行算数运算

字符串格式的数值可以转换为对应的数值类型

num1 = float('1.88') num2 = int('11') print(num1,type(num1)) print(num2,type(num2))

1.88 <class 'float'> 11 <class 'int'>

a = 100 b = float(input("请输入价格:")) c = a * b print(c)

请输入价格:10.8 1080.0

数据类型

字符串的使用

字符串

string1 = 'test1'

string2 = str()

空字符串

字符串的切片和索引取值

索引取值

正向索引

从0开始，s[2]表示第三个字符

反向索引

从-1开始，例如s[-1]获取最后一个字符

例子

string1 = 'I love python' print(string1[-3]) print(string1[2])

h l

字符串切片

通过索引值，获取字符串的部分内容

语法：

string1 = 'I love python'

print(string1[2:6])

love

print(string1[2:])

love python

print(string1[:6])

I love

子主题 2

切片的步长

string2 = 'abcdefghijklmnop' print(string2[0:6:4]) print(string2[0:12:2])

ae acegik

print(string2[a:b:c])

理解：从a到b中间通过c走多少步，从0开始

注意点：

切片包含起始索引，不包含结束索引

如果不写起始索引，则从字符串开头开始

如果不写结束索引，则截取到字符串末尾

字符串拼接

使用+拼接

other1 = 'I am' name = 'zhaohaiwang' kg = ' ' age = '18 years old' ad = 'and' total = other1 + kg + name + kg + other1 + kg + age + '.' print(total)

I am zhaohaiwang I am 18 years old.

join和+，都只能对字符串拼接，如果有年龄是int类型的，需要加上str(intnum)

使用join拼接

other1 = 'I am' name = 'zhaohaiwang' kg = ' ' age1 = 18 total1 = ''.join([other1,kg,name,kg,str(age1)]) print(total1)

I am zhaohaiwang 18

‘ ’ 空格

表示用空格连接

字符串格式化输出

使用f表达式

#字符串格式化输出 Name = 'zhaohaiwang' Age = 26 Height = '171.6' #使用f表达式 formatter_str = f'姓名:{Name},年龄: {Age}岁, 身高:{Height}cm' print(formatter_str)

姓名:zhaohaiwang,年龄: 26岁, 身高:171.6cm

使用format方法

#字符串格式化输出 Name = 'zhaohaiwang' Age = 26 Height = '171.6' #使用format方法 formatter_str1 = '姓名: {} ,年龄: {} ,身高: {:.2f} cm'.format(Name,Age,float(Height)) print(formatter_str1)

姓名: zhaohaiwang ,年龄: 26 ,身高: 171.60 cm

更多格式化功能

5.111111

{:.2f}

5.11

保留小数点后两位

0.25

{:.2%}

25.00%

百分比格式

{:<10}

左对齐(占位符宽度为10)

{:>10}

右对齐(占位符宽度为10)

{:^10}

中间对齐(占位符宽度为10)

#保留两位小数 formatter_strpi = f'圆周率:{pi:.2f}' print(formatter_strpi)

圆周率:3.14

特殊字符

换行符

水平制表符

四个字符

关闭转义

r''或者r"”

raw_string = r'hello \n python'

print(raw_string)

#结果：hello \n python

字符串常用方法

join

字符串拼接(见上面字符串拼接)

find

查找元素的第一次出现的下标

0-n

print(string1.find('w'))

count

查找元素的个数

string3 = '***sss***bbbb***' print(string3.count('s'))

replace

替换字符

# replace 替换 string1 = 'wwwwwwwwweeeeeeeeeerrrrrrr' res2 = string1.replace('w','2')

222222222eeeeeeeeeerrrrrrr

split

字符串分割

# split方法 code = 'name=张三;age=18' res1 = code.split(';') print(res1)

['name=张三', 'age=18']

format

格式化输出

upper

将字母转大写

lower

将字母转成小写

strip

默认去除首尾空格

# strip 去除首尾空格 string2 = ' s b ' print(string2.strip())

s b

去除指定字符

string3 = '***sss***bbbb***' print(string3.strip('*'))

sss***bbbb

练习题

练习1

# 创建不同形式的字符串变量，包括单引号、双引号、三引号和空字符串。然后，打印它们的内容。 a = '1=1' b = "2=2" c = '''wc= wc''' d="""nihao =sb""" e=str() #空字符串 print(a + '\n' + b + '\n' + c + '\n' + d + '\n' + e)

1=1 2=2 wc= wc nihao =sb

练习2

# 创建一个字符串赋值给变量text，并执行以下操作: # 提取字符串中的第3到第6个字符。 # 提取从第5个字符到字符串结尾的子串。 # 提取从字符串开头到第4个字符的子串。 # 使用负索引提取最后三个字符。 text = 'I like to eat vegetable.' words1 = text[2:6] words2 = text[4:] words3 = text[:4] words4 = text[-3:] print(words1) print(words2) print(words3) print(words4)

like ke to eat vegetable. I li le.

练习3

# 创建几个字符串变量并执行以下操作: # 使用 +进行字符串拼接。 # 使用 join()方法将多个字符串拼接在一起。 stringText1 = 'Best' stringText2 = 'Wish' stringText3 = 'For' stringText4 = 'You' # join print(' '.join([stringText1, stringText2, stringText3, stringText4])) # 加号 '+' print(stringText1+' '+stringText2+' '+stringText3+' '+stringText4)

Best Wish For You Best Wish For You

练习4

# 使用 f表达式和format()方法进行字符串格式化使用 f 表达式输出一个包含名字、年龄和城市的字符串。 # 使用 format()方法输出一个包含相同信息的字符串。 name = 'zhaohaiwang' age = 26 city = 'Hunan' # f表达式 info_f = f"name: {name}, age: {age}, city: {city}" #format()方法 info_format = "name: {}, age: {}, city: {}".format(name,age,city) print(info_f) print(info_format)

name: zhaohaiwang, age: 26, city: Hunan name: zhaohaiwang, age: 26, city: Hunan

练习5

# 对一个字符串 data 执行以下操作: # 查找字符串中某个子串的位置。 # 统计子串在字符串中出现的次数。 # 替换字符串中的某个子串 # ·使用 split()方法将字符串分割成多个部分。去除字符串两端的空格，并转换为大写和小写 data = ' I am Chinese,but he is British not Chinese ' print(data.find('Chinese')) print(data.count('Chinese')) #替换1次 print(data.replace('Chinese','Russians',1)) #替换2次 print(data.replace('Chinese','Russians',2)) #全部转大写 print(data.strip().upper()) #全部转小写 print(data.strip().lower())

8 2 I am Russians,but he is British not Chinese I am Russians,but he is British not Russians I AM CHINESE,BUT HE IS BRITISH NOT CHINESE i am chinese,but he is british not chinese

列表的使用

列表的定义

列表是一种内置的数据结构，用于存储多个数据项。他使用中括号[]表示，且可以包含不同数据类型的数据

定义一个列表

array = [ '张三',18,'男' ]

查看列表的数据类型

print(type(array))

列表的基本操作

索引取值

索引从0开始，用于访问列表中的元素，负数表示从末尾-1开始

切片操作

切片用于获取列表的子集，包括其实索引，不包含结束索引，切片出来的还是列表

list1 = [11,22,33,44,55,66,77,88,99,'aa','bb'] # 切片操作 result = list1[3:6] result1 = list1[1:9:4] print(result) print(result1)

[44, 55, 66] [22, 66]

通过索引修改值

通过缩影修改列表中的某个元素的值

# 修改列表值通过索引直接修改 li = [1,2,3,4,5,6,7,8,9] li[3] = 999 print(li)

[1, 2, 3, 999, 5, 6, 7, 8, 9]

列表的增删改查

添加数据

使用append方法添加单个到列表末尾

使用insert方法在指定位置插入元素

使用extend方法一次性添加多个元素

li = [1, 2, 3, 999, 5, 6, 7, 8, 9] # 末尾添加数据 li.append(10) print(li) # 指定位置添加数据 li.insert(4,555) print(li) # extend 末尾添加多个值 li.extend([22,33,44,'sea','sad']) print(li)

[1, 2, 3, 999, 5, 6, 7, 8, 9, 10] [1, 2, 3, 999, 555, 5, 6, 7, 8, 9, 10] [1, 2, 3, 999, 555, 5, 6, 7, 8, 9, 10, 22, 33, 44, 'sea', 'sad']

删除数据

使用 remove 方法删除指定元素(仅删除第一个匹配项)

使用 pop 方法根据索引删除元素，并返回该元素。

使用 del关键字删除指定索引的元素。

# 删除列表数据 li = [1,2,3,4,5,6,7,8,9] del li[2] print(li) # 直接删除列表数据 li.remove(1) print(li) # pop:删除指定索引的数据，并且返回删除的数据 data = li.pop(1) print(li) print(data)

[1, 2, 4, 5, 6, 7, 8, 9] [2, 4, 5, 6, 7, 8, 9] [2, 5, 6, 7, 8, 9] 4

修改数据

使用索引修改列表的某个元素的值

查找数据

使用index方法查找某个值的索引(若不存在则报错)

# 列表的查询操作 list1 = [1,2,3,4,5,6,7,8,2,2,2] # 方式1: index 查询指定数据在列表的索引，如果查询的数据不存在，则报错 res = list1.index(22) res2 = list1.index(2) print(res) print(res2)

ValueError: 22 is not in list

不存在

存在

1是索引

使用count方法统计某个值的出现次数

# count print(list1.count(2))

其他操作

排序

使用sort方法对列表进行排序

反向

使用reverse方法将列表反转

# 正向排序 score = [100,920,180,170,600,50] score.sort() print(score) # 反向排序 score.reverse()

[50, 100, 170, 180, 600, 920] [920, 600, 180, 170, 100, 50]

练习

# 练习题 1 # 创建一个列表colors，包含几个颜色名称。然后: # 使用 append()方法添加一个新的颜色。 # 使用 insert()方法在列表的第二个位置插入一个颜色。 colors = ['red', 'green', 'blue', 'pick'] colors.append('black') print(colors) colors.insert(1,'yellow') print(colors)

['red', 'green', 'blue', 'pick', 'black'] ['red', 'yellow', 'green', 'blue', 'pick', 'black']

# 练习题 2 # 创建一个列表 numbers，包含一些整数。 # 然后:使用 remove()方法删除指定的整数。 # 使用 pop()方法删除并返回指定位置的整数。 # 使用 del 关键字删除指定位置的整数。 numbers = [1,2,3,4,5,6,7,8,9] numbers.remove(2) print(numbers) numbers.pop(-2) print(numbers) del numbers[5] print(numbers)

[1, 3, 4, 5, 6, 7, 8, 9] [1, 3, 4, 5, 6, 7, 9] [1, 3, 4, 5, 6, 9]

# 练习题 3 # 创建一个列表names，包含若干个名字。 # 然后使用 index()方法查找某个名字的索引位置。 # 使用count()方法统计某个名字出现的次数 names = ['xiaoA','xiaoB','xiaoC','xiaoA','xiaoA','xiaoA','xiaoD'] print(names.index('xiaoD')) print(names.count('xiaoA'))

6 4

# 练习题4 # 创建一个列表 grades，包含学生的成绩。然后: # 修改指定位置的成绩。 # 使用切片更新多个位置的成绩。 grades = [90, 80, 70, 60, 50, 40, 30, 20, 10] grades[2] = 77 print(grades) grades[3:8] = [66, 55, 44, 33, 22] print(grades)

[90, 80, 77, 60, 50, 40, 30, 20, 10] [90, 80, 77, 66, 55, 44, 33, 22, 10]

# 练习题5 # 创建一个列表 items ，包含若干个元素。然后: # 使用切片操作提取列表的前五个元素。 # 使用切片操作提取列表的最后三个元素。 # 使用切片操作更新列表中的某一部分。 items = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve'] print(items[0:5]) print(items[-3:]) print(items[2:5])

['one', 'two', 'three', 'four', 'five'] ['ten', 'eleven', 'twelve'] ['three', 'four', 'five']

字典的使用

字典的定义

字典是通过{}表示的，包括键值对，格式为{key:value}

#定义一个字典 worker = { "name": "zhaohaiwang", "age": 18, "sex": "man", "address": "Guangxi" }

字典的常用操作

添加数据

直接添加

# 定义一个空字典 dic = {} # 请输入姓名 dic['name'] =input( "请输入姓名:"+"") dic['age'] = input("请输入年龄:") dic['addr'] = input("请输入家庭地址:"+"") print(dic)

请输入姓名:zhaohaiwang 请输入年龄:17 请输入家庭地址guangxi {'name': 'zhaohaiwang', 'age': '17', 'addr': 'guangxi'}

dic2 = {} dic2['name'] = 'TheShy' dic2['age'] = 18 print(dic2)

{'name': 'TheShy', 'age': 18}

使用update()方法

原始数据上修改

dic2 = {} dic2['name'] = 'TheShy' dic2['age'] = 18 dic2.update({'name':'uzi','age':19}) print(dic2)

{'name': 'uzi', 'age': 19}

原始数据上添加

dic2 = {} dic2['name'] = 'TheShy' dic2['age'] = 18 dic2.update({'local':'top'}) print(dic2)

{'name': 'TheShy', 'age': 18, 'local': 'top'}

修改数据

通过键修改对应的值

#修改数据 dic = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6} dic['one'] = 9 print(dic)

{'one': 9, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}

删除数据

使用pop()方法删除指定的键值对

使用popitem()删除字典中的最后一对键值对

使用del删除指定键值对

# 删除数据 # pop() 删除指定 dic1 = {'one': 1, 'two': 2, 'three': 3, 'four': 4} dic1.pop('one') print(dic1) #popitem 删除最后一个 dic1.popitem() print(dic1) # del 删除指定键 del dic1['two'] print(dic1)

{'two': 2, 'three': 3, 'four': 4} {'two': 2, 'three': 3} {'three': 3}

查找数据

使用键索引值

使用get()方法查找值，不存在时不会报错

#查找数据 #使用索引键值 number = {'one':1, 'two':2, 'three':3, 'four':4, 'five':5, 'six':6, 'seven':7} result = number['one'] print(result) #使用get()方法查找值，不存在时不会报错 result2 = number.get('three') result3 = number.get('fourth') print(result2) print(result3)

1 3 None

查不到就会输出None

字典的其他方法

获取所有键

dict_keys(['one', 'two', 'three', 'four', 'five', 'six', 'seven'])

获取所有值

dict_values([1, 2, 3, 4, 5, 6, 7])

获取所有键值对

dict_items([('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5), ('six', 6), ('seven', 7)])

# 获取所有键 number1 = {'one':1, 'two':2, 'three':3, 'four':4, 'five':5, 'six':6, 'seven':7} keys = number1.keys() print(keys) # 获取所有值 values = number1.values() print(values) # 获取所有键值对 items = number1.items() print(items)

练习

# 1.创建字典并添加数据 # 创建一个字典 student ，并添加以下信息: # ·姓名(name):"王五" # ·年龄(age): 23 # ·电话号码(phone):"13987654321" student = {'name':'王五','age':23,'phone':'13987654321'} print(student) # 2.修改字典中的数据 # 在字典 student 中，将电话号码修改为“13888888888" student['phone']='13888888888' print(student) # 3.删除字典中的数据 # 从字典 student中删除键为"age"的项。 del student['age'] print(student) # 4.查找字典中的数据 # 从字典 student 中查找并打印键为“name"的值。 name = student['name'] print(name) # 5.使用 get方法查找数据 # 使用 get 方法查找字典 student 中键为"phone”的值。如果键不存在，返回"未找到" res = student.get("phone","未找到") print(res) # 6.添加多项数据 # 使用update方法，将以下信息添加到字典 student中: # 性别(gender):"男" # 地址(address):"北京市海淀区" student.update({'gender':'男','address':'北京市海淀区'}) print(student) # 7.获取并打印字典student的所有键 keys = student.keys() print(keys) # 8.获取并打印字典student的所有值 values = student.values() print(values) # 9.获取并打印字典student的所有键值对 key_values = student.items() print(key_values) # 10.字典的清空操作 # 创建一个字典info,并添加一些数据，然后使用clear方法清空字典中的所有数据 info = {'age':18,'phone':'10010','sex':'man'} info.clear() print(info)

{'name': '王五', 'age': 23, 'phone': '13987654321'} {'name': '王五', 'age': 23, 'phone': '13888888888'} {'name': '王五', 'phone': '13888888888'} 王五 13888888888 {'name': '王五', 'phone': '13888888888', 'gender': '男', 'address': '北京市海淀区'} dict_keys(['name', 'phone', 'gender', 'address']) dict_values(['王五', '13888888888', '男', '北京市海淀区']) dict_items([('name', '王五'), ('phone', '13888888888'), ('gender', '男'), ('address', '北京市海淀区')]) {}

元组和集合

元组的定义

元组是用小括号()定义的数据结构

支持多种数据类型，包括数字、字符串、列表等

元组中的元素在创建后不可修改(不可变)

创建元组

#创建一个包含数据类型的元组 t = (11,22,33,44,55)

元组基本操作

索引取值

元组支持索引操作，索引从0开始

print(t[2]) #输出：33

切片操作

可以通过切片获取元组的子元组

print(t[1:3]) #输出：(22,33)

查找元素索引

使用index()方法统计某个值在元组中出现的次数。

res2 = t.count(22) print(res2) #输出：1

注意点

元组中的元素在定义后不可更改，因此适合存储固定数据

元组可以嵌套，包含其他元组或列表等数据结构

示例

#创建一个嵌套元组 test = (1,2,(3,4),[5,6]) print(test[2]) #输出：(3,4) print(test[3][0]) #输出：5

集合的定义

集合使用大括号{}定义的数据结构

集合中的数据结构为{value1,value2,...}

集合的特点

集合不支持索引取值

创建空集合需要使用set()

集合中的元素是唯一的(自动去重)

集合中的元素是无序的

创建集合

创建一个包含不同数据类型的集合

set2 = {11,22,'aa','ss'}

创建一个空集合

set1 = set()

set1 = set() set2 = {1,2,'22','aa'} print(set1,type(set1)) print(set2,type(set2))

set() <class 'set'> {1, 2, '22', 'aa'} <class 'set'>

集合基本操作

添加元素

使用add()方法向集合中添加单个元素

set2.add(77) print(set2) #输出：{1, 2, 77, '22', 'aa'}

删除元素

随机删除一个元素使用pop()方法。若集合为空，将引发KeyError

KeyError: 'pop from an empty set'

#随机删除一个元素 set2.pop() print(set2) # set1.pop() # print(set1)

{2, 'asd', '22', 'aa'}

{2, 1, '22', 'asd'}

删除指定元素使用remove()方法。若指定元素不存在，将引发KeyError

set2.remove('22w')

KeyError: '22w'

不存在

# 指定删除一个元素 set2.remove('asd') # set2.remove('22w') print(set2)

{1, 2, 'aa', '22'}

删除指定元素使用discard()方法。若指定元素不存在，不会引发错误

set2.discard('asd') set2.discard('sss') print(set2)

{1, 2, 'aa', '22'}

集合运算

交集、并集、差集、对称差集

定义两个集合

s1 = {1,2,3,43,6,7,99} s2 = {1,2,3,'4','5','aa'}

print(s1 | s2) print(s1 & s2) print(s1 - s2) print(s1 ^ s2)

{1, 2, 99, 3, '5', 6, 7, 'aa', 43, '4'} {1, 2, 3} {43, 99, 6, 7} {99, '5', 6, 7, 'aa', 43, '4'}

集合并集适应 | 运算符

集合交集使用&运算符

集合差集使用-运算符

集合对称差集使用^运算符

注意点

集合中的元素无序，因此不可进行索引操作。

集合中的元素必须是可哈希的(不可变类型)

练习

练习1：元组的基本操作 1.创建一个包含以下元素的元组：(10, 20, 30, 40, 50)。 2.访问并打印元组中的第三个元素。 3.尝试修改元组中的一个元素，并观察结果。 4.创建一个新元组，通过连接两个元组 (1, 2, 3) 和 (4, 5, 6) 实现。

my_tuple = (10, 20, 30, 40, 50) print(my_tuple) print(my_tuple[2]) # 尝试修改元组中的第一个元素 try: my_tuple[0] = 100 except TypeError as e: print(f"错误：{e}") tuple1 = (1, 2, 3) tuple2 = (4, 5, 6) new_tuple = tuple1 + tuple2 print(new_tuple)

(10, 20, 30, 40, 50) 30 错误：'tuple' object does not support item assignment (1, 2, 3, 4, 5, 6)

练习2：元组解包 1.创建一个元组 student = ('Alice', 20, 'Computer Science')。 2.使用元组解包将 student 元组中的值赋给 name, age, major 三个变量。 3.打印这些变量的值。

student = ('Alice', 20, 'Computer Science') print(student) name, age, major = student print(f"Name: {name}") print(f"Age: {age}") print(f"Major: {major}") # 总结: # 元组解包是一种简洁的方式，可以将元组中的值分别赋值给多个变量。 # 变量的数量必须与元组中的元素数量一致，否则会引发错误。

('Alice', 20, 'Computer Science') Name: Alice Age: 20 Major: Computer Science

练习3：集合的基本操作 1.创建一个包含以下元素的集合：{1, 2, 3, 4, 5}。 2.向集合中添加元素 6。 3.从集合中移除元素 3，并打印集合。 4.创建一个包含以下元素的集合：{4, 5, 6, 7, 8}，然后求出两个集合的交集、并集和差集

# 创建第一个集合 my_set = {1, 2, 3, 4, 5} # 添加元素 6 my_set.add(6) # 移除元素 3 my_set.remove(3) # 创建第二个集合 set2 = {4, 5, 6, 7, 8} # 交集 intersection = my_set.intersection(set2) print(f"交集: {intersection}") # 并集 union = my_set.union(set2) print(f"并集: {union}") # 差集 difference = my_set.difference(set2) print(f"差集: {difference}")

集合是无序且不重复的数据结构。支持添加、删除、交集、并集、差集等操作。

交集: {4, 5, 6} 并集: {1, 2, 4, 5, 6, 7, 8} 差集: {1, 2}

练习4：集合的去重 1.给定一个列表 numbers = [1, 2, 2, 3, 4, 4, 5]，使用集合去除列表中的重复元素。 2.将去重后的集合转换回列表，并打印结果。

# 给定的列表 numbers = [1, 2, 2, 3, 4, 4, 5] # 使用集合去除重复元素 unique_numbers = set(numbers) # 将集合转换回列表 unique_numbers_list = list(unique_numbers) # 打印结果 print(unique_numbers_list)

[1, 2, 3, 4, 5]

set(numbers)：将列表 numbers 转换为集合，自动去除重复元素。 list(unique_numbers)：将集合 unique_numbers 转换回列表。 print(unique_numbers_list)：打印去重后的列表

练习5：元组和集合的组合使用 1.创建一个元组列表，students = [('Alice', 'Math'), ('Bob', 'Physics'), ('Catherine', 'Chemistry')]。 2.创建一个空集合 subjects，然后将所有学生的科目添加到集合中。 3.打印集合 subjects 的内容，观察科目是否有重复。

# 1. 创建一个元组列表 students = [('Alice', 'Math'), ('Bob', 'Physics'), ('Catherine', 'Chemistry')] # 2. 创建一个空集合 subjects = set() # 将所有学生的科目添加到集合中 for student, subject in students: subjects.add(subject) # 3. 打印集合 subjects 的内容 print(subjects)

从输出中可以看出，集合 subjects 中的科目没有重复，因为集合（set）是一个无序且不重复的元素集。这就是元组和集合组合使用的一个简单示例。

练习6：使用集合进行数据筛选 1.给定两个列表 list1 = [10, 20, 30, 40, 50] 和 list2 = [30, 40, 50, 60, 70]，使用集合操作找到两个列表中的共同元素。

list1 = [10, 20, 30, 40, 50] list2 = [30, 40, 50, 60, 70] # 将列表转换为集合 set1 = set(list1) set2 = set(list2) # 使用交集操作找到共同元素 common_elements = set1 & set2 # 或者使用 intersection 方法 # common_elements = set1.intersection(set2) # 将结果转换回列表（如果需要） common_elements_list = list(common_elements) print(common_elements_list)

数据类型总结

以下是 Python 主要数据类型的总结及对比分析： --- ### **1. 基本数据类型** #### **数字类型** - **int (整数)** - 特点：不可变、有序（数学意义上的大小关系） - 示例：`42`, `-3` - **float (浮点数)** - 特点：不可变、有序（数学意义上的大小关系） - 示例：`3.14`, `-0.5` - **complex (复数)** - 特点：不可变、有序（数学意义上的大小关系） - 示例：`1 + 2j` - **bool (布尔)** - 特点：`True`/`False`，本质是 `int` 的子类（`True=1`, `False=0`） - 示例：`True`, `False` #### **NoneType** - **None** - 特点：表示空值，不可变，唯一实例。 - 示例：`None` --- ### **2. 序列类型** #### **字符串 (str)** - 特点：**不可变**、有序（索引访问）、可迭代。 - 示例：`"hello"`, `'Python'` - 用途：文本处理。 #### **列表 (list)** - 特点：**可变**、有序、可重复、可嵌套。 - 示例：`[1, 2, 3]`, `["a", 2, True]` - 用途：存储动态数据集合。 #### **元组 (tuple)** - 特点：**不可变**、有序、可重复、可嵌套。 - 示例：`(1, "a", True)` - 用途：固定数据存储（如坐标、配置项）。 --- ### **3. 集合类型** #### **集合 (set)** - 特点：**可变**、无序、元素唯一、不可嵌套集合。 - 示例：`{1, 2, 3}` - 用途：去重、集合运算（交集、并集）。 #### **冻结集合 (frozenset)** - 特点：**不可变**版本集合，可哈希。 - 示例：`frozenset({1, 2})` - 用途：作为字典的键。 --- ### **4. 映射类型** #### **字典 (dict)** - 特点：**可变**、键唯一、键不可变（需可哈希），Python 3.7+ 后**保持插入顺序**。 - 示例：`{"name": "Alice", "age": 30}` - 用途：键值对存储（如JSON数据）。 --- ### **5. 二进制类型** #### **字节 (bytes)** - 特点：不可变、表示二进制数据。 - 示例：`b'hello'` #### **字节数组 (bytearray)** - 特点：可变版本的 `bytes`。 - 示例：`bytearray(b'hello')` --- ### **关键区别总结** 1. **可变性**： - 可变类型：`list`, `dict`, `set`, `bytearray`。 - 不可变类型：`int`, `float`, `str`, `tuple`, `frozenset`, `bytes`。 2. **有序性**： - 有序：`str`, `list`, `tuple`（支持索引和切片）。 - 无序：`set`, `dict`（虽然字典在 Python 3.7+ 记录插入顺序）。 3. **唯一性**： - 元素唯一：`set`, `frozenset`。 - 键唯一：`dict`。 4. **哈希性**： - 可哈希类型才能作为字典的键或集合的元素（如 `int`, `str`, `tuple`）。 --- ### **使用场景建议** - 需要修改数据：使用 `list`、`dict`、`set`。 - 数据需不可变：使用 `tuple`、`frozenset`。 - 键值对存储：优先选 `dict`。 - 去重操作：使用 `set`。 - 二进制处理：`bytes` 或 `bytearray`。希望这份总结能帮助你快速区分不同数据类型的特点！

### **对比表格** | 类型 | 可变性 | 有序性 | 唯一性 | 可哈希 | 典型用途 | |-------------|--------|--------|--------|--------|------------------------| | **int** | 不可变 | 有序 | - | 是 | 数学运算 | | **float** | 不可变 | 有序 | - | 是 | 浮点计算 | | **str** | 不可变 | 有序 | - | 是 | 文本处理 | | **list** | 可变 | 有序 | 可重复 | 否 | 动态数据集合 | | **tuple(元组)** | 不可变 | 有序 | 可重复 | 是 | 不可变数据存储 | | **set(集合)** | 可变 | 无序 | 唯一 | 否 | 去重、集合运算 | | **dict(字典)** | 可变 | 有序* | 键唯一 | 否 | 键值对存储 | | **bytes(字节)** | 不可变 | 有序 | - | 是 | 二进制数据 | > *注：字典在 Python 3.7+ 后保持插入顺序，但本质仍是“无序”类型（不能通过数值范围索引）。* ---

程序流程控制

条件语句

条件运算

布尔型

true

false

布尔型（bool）表示条件的真假，只有两个取值：True（真）和 False（假）。

比较运算符

不等于

用于比较相同类型的数据，结果为布尔型。

逻辑运算符

and