num1, num2, num3 = input(“请输入num1,num2,num用逗号隔开：.split(“,”)
list1 = [int(num1), int(num2), int(num3)]
list1.sort()
print(list1)
4.3数据输出
数据输出可以通过两种方式实现：第一种是在交互模式下使用表达句来输出表达值，但这种方式不能在脚本模式下使用，另一种是使用内置函数print()这种方法可用于交互模式和脚本模式。
name = “张三”

print("my name is ", name)

print(“my name i 张三”)

age = 18
print(“my name is”, name, “my age is”, age)

print(“hello”,end=" ")
print(“world”)

print(“my name is”, name, “my age is”, age,sep=“&”)

print(“my name is {} my age is {}”.format(name, age))
也可以指定变量输出，只需要在{}里面指定索引即可.
print(“my name is {1} my age is {1}”.format(name, age))

print(f"my name is {name} my age is {age}")

if num % 2 == 0:
print(“偶数”)
else:
print(“奇数”)

if num%2==0:
 print("偶数")

else:
print(“奇数”)

if num%2!=0:
print(“奇数”)
else:
print(“偶数”)

if num%21:
print(“奇数”)
else:
print(“偶数”)
python提供了一种简化的条件运算，条件运算符是一种三目运算符，它有3个运算对象，语法格式如下:
表达式1 if 表达式 else 表达式2
条件运算的规则：首先计算if后面表达式的值，如果值为True,则计算表达式1，并将表达式1的值作为条件运算的结果。否则将表达式2的值作为条件运算的结果。
x, y = 30, 90
res = x if x > y else y
print(“x和y中的最大值:”, res)
例3：
键盘输入一个三位数的整数,判断是否为水仙花。例如：153 它的13+53+3**3153 因此是水仙花。
代码演示：

num = int(input(“请输入三位数的整数:”))
a = num // 100 # 百位
b = num // 10 % 10
c = num % 10
if a ** 3 + b ** 3 + c ** 3 == num:
print(“{}是水仙花”)
else:
print(“{}不是水仙花”)
方法2：
num = input(“请输入三位数的整数:”)

if int(num[0])**3 + int(num[1])**3+int(num[2])**3==int(num):
print(“{}是水仙花”.format(num))
else:
print(“{}不是水仙花”.format(num))

4.6.3多分支选择结构
多分支选择结构用于处理多个条件、多个分支的情况，可以用if-elif-else语句来实现。语法格式如下：
if 表达式1:
语句块1
elif 表达式2：
语句块2
elif 表达式3：
语句块3
elif 表达式m:
语句块m
……
[else:
语句块 n]
if-elif-else 语句的执行流程如下:首先计算表达式1的值，如果表达式1的值为True,则执行语句块1，否则计算表达式2的值；如果表达式2的值为True，则执行语句块2，否则计算表达式3的值，以此类推。如果所有的表达式的值都为False，那么执行else后面的语句块n,整个执行流程图如下：

例1：
将成绩划分为4个等级：85分以上代表优秀，70_{84分代表良好，60}69分为及格，60分以下为不及格。要求从键盘输入成绩后输出相应的等级。
代码演示:
score = eval(input(“请输入学生成绩:”))
if score < 60:
print(“不及格”)
elif score < 70:
print(“及格”)
elif score < 85:
print(“良好”)
else:
print(“优秀”)
例2：
18岁或以上：adult,6岁或以上：teenager,6岁以下：kid
age = int(input(“请输入年龄:”))
if age >= 18:
print(“adult”)
elif age >= 6:
print(“teenager”)
else:
print(“kid”)
例3：
键盘输入身高height(单位m)和体重weight(单位kg)，按照公式:体重除以身高的平方来计BIM的值.如果BIM小于18.5则是过轻，18.5<=BIM<=25则是正常，2532，则是严重肥胖。
height = float(input(‘请输入身高(m):’))
strong = float(input(‘请输入体重(kg):’))
BIM = strong / height ** 2
if BIM < 18.5
print(‘过轻’)
elif 18.5 <= BIM <= 25:
print(‘正常’)
elif 25 < BIM <= 28:
print(‘过重’)
elif 28 < BIM <= 32:
print(‘肥胖’)
else:
print(‘严重肥胖’)
4.6.4选择结构的嵌套
如果有多个条件并且条件之间存在递进关系，则可以在一个选择结构中嵌入另一个选择结构，形成选择结构的嵌套。在内部的选择结构中还可以继续嵌入选择结构，嵌套的深度是没有限制的。
其语法结构如下:

例1：
从键盘输入用户名和密码，然后对输入的用户名进行验证，如果用户名正确，再对输入的密码进行验证。
代码演示:

USERNAME = “admin”
PASSWORD = “123456”

username = input(“请输入用户名:”)

if username == USERNAME:
# 从键盘输入密码
password = input(“请输入密码:”)
# 验证密码
if password == PASSWORD:
print(“登录成功！”)
else:
print(“密码错误！”)
else:
print(“用户名错误！”)
4.7 循环结构
循环结构是控制一个语句块重复执行的程序结构，由循环条件和循环体两部分组成，循环结构的特点是:在一定条件下重复执行某些语句，直至重复到一定次数或该条件不再成立为止。
4.7.1 for语句
for语句是一个通用的序列迭代器，可以用于遍历任何序列对象中的所有元素。语法格式如下：
for 循环变量 in 序列对象:
语句块（循环体）
[else:
语句块]
序列对象常见的有:字符串、列表、元组、集合、字典。
如果for循环正常结束才会执行else语句块，如果for语句块里面有break且执行了break子句而导致中断循环,则不会执行else子句。
例1：
使用for循环，找出1~10(包含10)之间的偶数.
for i in range(1, 11):
if i % 2 == 0:
print(i, end=" “)
例2：
键盘输入一个自然数，判断它是不是素数（素数只能被1或本身整除，2是最小的素数）
num = int(input(“请输入一个自然数:”))
flag = True # 默认是素数
if num >= 2:
for i in range(2, num):
if num % i == 0:
flag = False
break
if flag:
print(”{}是素数".format(num))
else:
print(“{}不是素数”.format(num))
else:
print(“输入有误!”)
4.7.1 while语句
While语句的功能是在满足指定条件时执行一个语句块，其语法格式如下：
While 表达式:
语句块(循环体)
[else:
语句块]
表达式的bool值为True，则执行循环体，直到表达式的bool值为False退出循环体。当循环体只包含单个语句时，也可以将该语句与while写在同一行；当循环体包含多个语句时，这些语句具有相同的缩进量。
这里else的语句块是否执行，取决于while循环里面是否正常退出，如果是break中断循环，则不会执行。
例1：
使用while打印出九九乘法表
代码演示:
i = 1
while i <= 9:
j = 1
while j <= i:
print(“{}*{}={}”.format(j, i, j * i), end=“\t”)
j += 1
print()
i += 1
例2：
使用while计算1~20的累加和
i = 1
s = 0
while i <= 9:
s += i
i += 1
print(s)
4.7.2 循环控制语句
1.break语句
break语句用来终止当前的循环，
break语句用在while和for循环中，通常与if语句一起使用，可以用来跳出当前所在的循环结构，即使循环还在执行，也会立即停止执行的循环语句，跳出循环体（如果有else子句，则不会执行）,执行循环下面的语句。
例1：
计算前100个自然数之和
i, s = 1, 0
while True:
s += i
i += 1
if i == 101:
break
print(s)

例2：
从键盘连续输入数字进行累加，直到输入-1表示退出累加，输出累加和。
s = 0
while True:
num = int(input(“请输入数字(-1退出累加):”))
if num == -1:
break
s += num
print(“累加和:”, s)
2.continue语句
continue用于跳出本次循环，continue也是用在while和for循环中，通常也是与if语句一起使用，但是与break有所不同，continue语句用来跳出当前循环的剩余语句，然后继续执行下一轮循环，而break语句则是用于跳出整个循环。
例1：
展示continue与break的区别
for i in range(1, 10):
if i == 5:
continue
print(i, end=" “)
print()
for i in range(1, 10):
if i == 5:
break
print(i, end=” ")

例2：
输出1~80之间不能被5整除的整数,运行结果如下:

for i in range(1, 81):
if i % 5 == 0:
print()
continue
print(str(i), end=“\t”)
3.pass语句
为了保持程序结构的完整性，Python提供了一个空语句pass,pass语句一般仅作为占位语句，不做任何事。
例1：
for x in “python”:
if x == “h”:
pass
print(“在这里遇到了pass空语句”)
print(“当前字母:{}”.format(x))
print(“Over!”)

x, y = eval(input(“请输入两个数字:”))
try:
z = x / y
print(z)
except Exception as e:
print(“程序发生异常！”, e)
2. 多分支异常处理
多分支异常处理的语法格式如下:
try:
语句块
except 异常类1 [as 错误描述]:
异常处理语句块1
except 异常类2 [as 错误描述]:
异常处理语句块2
…
except 异常类n [as 错误描述]:
异常处理语句块n
except:
默认异常处理语句块
else:
语句块
多分支异常处理语句可针对不同的异常类型进行不同的处理，其执行流程如下:
执行try后面的语句块，如果未发生异常，则执行该语句块后执行else后面的语句块,然后执行try-ecxept语句的后续语句；如果引发异常，则依次检查各个except语句，试图找到匹配的异常类型；如果找到了，则执行相应的异常处理语句块；如果未找到，则执行最后一个except语句中的默认异常处理语句块，异常处理完成后执行try-except语句的后续语句。
例1：
整数除法中的多分支异常处理
x, y = eval(input(“请输入两个数字:”))
try:
z = x / y
print(z)
except TypeError as te:
print(“数据类型错误！”, te)
except ZeroDivisionError as zde:
print(“0不能作为除数！”, zde)
except:
print(“程序发生异常!”)
else:
print(“程序正常结束.”)
4.7.4.3 try-finally语句
try-finally语句用于指定无论是否发生异常都会执行的代码，其语法格式如下:
try:
语句块
except:
异常处理语句块
else:
语句块
finally:
语句块
例1：
整数除法中的异常处理,展示finally子句的应用示例:
x, y = eval(input(“请输入两个数字:”))
try:
z = x / y
print(z)
except Exception as e:
print(“程序发生异常!”,e)
else:
print(“程序正常结束.”)
finally:
print(“执行finally子句”)
如果在try子句中发生异常，但是异常没有被except子句处理，或者在except或else子句中发生了异常，则在finally子句执行完后会将异常依旧会引发。
章节习题

4.8数据结构
4.8.1字符串
字符串是python内置的有序序列，字符串是一种不可变的对象，字符串中的字符是不能被改变的，每当修改字符串时都将生成一个新的字符串对象，对于字符串可以进行各种操作，主要包括通过索引访问指定位置的单个字符，通过切片从给定的字符串中获取子串，将两个或多个字符串连接成一个新的字符串，对两个字符串进行比较，使用for循环遍历字符串。
4.8.1.1 字符串的索引
访问字符串上的指定字符，其语法格式如下:
字符串[索引]
举例说明：S=“python”
S[0] S[1] S[2] S[3] S[4] S[5]
p y t h o n
S[-6] S[-5] S[-4] S[-3] S[-2] S[-1]
从上面可以看出:
最后一个字符的索引为-1
当索引为正整数，那么最后一个字符的索引是字符串的长度减1
求字符串的长度使用内置函数len( )求出。
无论使用正向索引还是反向索引，索引值都不能越界。否则将会出现错误信息”IndexError:string index out of range”,即字符串索引超出范围。

s=“Hello Python”
s[0]
‘H’
s[1]
‘e’
s[-1]
‘n’
s[-2]
‘o’
s[12]
Traceback (most recent call last):
File “”, line 1, in
IndexError: string index out of range

因为字符串属于不可变对象，所以索引只能读取字符串指定位置上的字符，而不能修改该位置上的字符。即字符串不支持赋值操作。
例1：
从键盘输入一个字符串，然后以相反顺序输出该字符串。
s = input(“请输入字符串:”)
i = -1
while i >= -len(s):
print(s[i], end=“”)
i -= 1

str1 = input(“请输入字符串”)
n = len(str1)
str2 = “” # 空字符串
for i in range(1, n + 1):
str2 += str1[-i]
print(str2)

str1 = “hello”
n = len(str1)
str2 = “”
for i in range(-1, -n - 1, -1):
str2 += str1[i]
print(str2)

4.8.1.2 字符串的切片
如果要从字符串中提取一部分字符串（子串），则可以通过切片（slice）操作来实现，其一般语法格式如下:
字符串对象[开始位置:结束位置:步长]
步长默认为1，不包含结束位置。

s=“python language”
s[1:10:1]
‘ython lan’
s[1:10:2]
‘yhnln’
s[:5] # 取出索引为0~4的字符
‘pytho’
s[2:] # 从索引为2的字符开始，直至字符串结束
‘thon language’
s[:] #取出所有字符
‘python language’
s[::] #取出所有字符
‘python language’
s[::2] # 步长为2，隔一个取一个
‘pto agae’
s[::-1] # 步长为-1，逆序取出所有字符
‘egaugnal nohtyp’
s[:100] # 结束位置越界，切片到字符串结束
‘python language’
s[100:] # 开始位置越界，返回空字符串
‘’

由于字符串是不可变对象，因此不能对字符串切片赋值，否则会出现错误信息: TypeError: ‘str’ object does not support item assignment.
4.8.1.3 字符串的连接
字符串的连接可以使用加法运算符”+”或乘法运算符”*”来实现。
加法运算符可以将两个字符串连接成一个新的字符串，乘法运算符可以将一个字符串自身重复连接若干次形成一个新的字符串。
1.基本连接
在python中，“+”运算符有3个作用:
A:作为双目运算符用于数值对象，进行加法运算
B:作为单目运算符，表示正号
C: 作为双目运算符用于字符串对象，进行字符串的连接
运算符”+”作为字符串连接运算符使用时，可以将字符串常量、字符串变量以及返回字符串的函数表达式等字符串数据进行连接。
运算符”+”两侧必须是相同数据类型，若将字符串与数值连接，就需要用内置函数str( )将数值转为字符串。例如:

str(2022)+”年”+str(5)+”月”
2.重复连接
在python中，“”运算符有2个作用:
A:作为双目运算符用于数值对象，进行乘法运算
B: 作为双目运算符用于字符串和正整数对象，进行字符串的重复连接操作。
重复连接的语法:
字符串正整数 （正整数字符串）
其中字符串可以是字符串类型的常量、变量或函数，正整数用于指定这个字符串重复连接的次数。
举例：
str1 = “python”
str13
‘pythonpythonpython’
3*str1
‘pythonpythonpython’
“5”*3
‘555’
例1：
从键盘连续循环输入，当输入quit退出循环，后将连续输入的单词组成句子。
sentence = “”
while True:
word = input(“请输入单词(输入quit退出):”)
if word == “quit”:
break
sentence += " " + word
print(“组成的句子:{}.”.format(sentence))
4.8.1.4字符串的关系运算
字符串的关系运算主要包括：1.字符串比较. 2.成员运算符in来判断一个字符串是不是另外一个字符串的子串。
1.比较字符串
将两个字符串从左向右逐个进行比较，直到比较出哪边对应的字符ASCII值大则哪边的字符串大。
“hello”>“hellp”
False
“abc”>“bbc”
False
“abc”>“bad”
False
比较两个长度不相同的字符串时，首先在较短的字符串尾部补上一些空格字符，使两个字符串具有相同的长度，然后再使用上面的规则进行比较。
2.判断子串
使用成员运算符判断一个字符串是否为另一个字符串的子串。
‘yt’ in ‘python’
True
‘mn’ in ‘python’
False
例2：
从键盘输入两个字符串，比较它们的大小并判断第一个字符串是不是第二个字符串的子串。
str1 = input(“请输入第一个字符串:”)
str2 = input(“请输入第二个字符串:”)

if str1 == str2:
print(“{}等于{}”.format(str1, str2))
elif str1 > str2:
print(“{}大于{}”.format(str1, str2))
else:
print(“{}小于{}”.format(str1, str2))

if str1 in str2:
print(“{}是{}的子串”.format(str1, str2))
elif str2 in str1:
print(“{}是{}的子串”.format(str2, str1))
else:
print(“{}和{}没有子串的关系”.format(str1, str2))

4.8.2字符串的常用方法
4.8.2.1 字母大小写转换
若要进行字母的大、小写转换，则可以通过以下方法返回一个新字符串。
str.upper() 全部转为大写
str.lower() 全部转为小写
str.swapcase() 大小写互换
str.capitalize() 整个字符串的首字母变成大写，其余字母变成小写。
str.title() 每个单词的首字母大写，其余字母均为小写

str = “hello WORLD”
print(str.upper()) # HELLO WORLD
print(str.lower()) # hello world
print(str.swapcase()) # HELLO world
print(str.capitalize()) # Hello world
print(str.title()) # Hello World

str1 = input(“请输入一个语句:”)

str1_1 = str1[0].upper()

print(str1_1 + str1[1:])

str1 = input(“请输入一个语句:”)
list_word = str1.split()
words = “” # 空字符串用于后面的字符串拼接
for word in list_word:
word_1 = word[0].upper() # 首字母大写
word_2 = word[1:].lower() # 其余字母均为小写
new_word = word_1 + word_2
words += new_word + " "
print(words)

4.8.2.1 字符串中的搜索和替换
1.str.find(substr,[,start,end]) 用于检测substr 是否在str中，若在则返回开始的索引值，否则返回-1，若用start和end指定范围，则在str[start:end]中搜索。
str1 = “hello python”
print(str1.find(“llo”)) # 2
print(str1.find(“llo”, 5, 8)) # -1
2.str.index(substr,[,start,end]) 用法与find()相同，只是当substr不在str中会报一个异常。
str1 = “hello python”
print(str1.index(“llo”)) # 2
print(str1.index(“llo”, 5, 8)) # ValueError: substring not found
3.str.rfind(substr,[,start,end]) 用法与find()相同，只是从右边开始查找。
str1 = “hello python llo”
print(str1.rfind(“llo”)) # 13
print(str1.rfind(“llo”, 5, 8)) # -1
4.str.rindex(substr,[,start,end])用法与index()相同，只是当substr不在str中会报一个异常。
str1 = “hello world wor”
print(str1.rindex(“wor”)) # 12
print(str1.rindex(“op”)) # ValueError: substring not found
5.str.count(substr,[,start,end])用于返回substr在str中出现的次数，若用start和end指定范围，则返回在str[start:end]中出现的次数。
str1 = “hello world world”
print(str1.count(“world”)) # 2
print(str1.count(“o”)) # 3
print(str1.count(“o”, 5, 20)) # 2
print(str1.count(“o”, 5, )) # 2
print(str1.count(“o”, 20, 30)) # 0
print(str1.count(“o”, 20, )) # 0
6.str.startswith(prefix,[,start,end])用于检查字符串是否以prefix开头，若是则返回True,否则返回False.如果用start和end指定范围，则在该范围内检查。
str1 = “hello python”
print(str1.startswith(“h”)) # True
print(str1.startswith(“hel”)) # True
print(str1.startswith(“hello”)) # True
print(str1.startswith(“hellop”)) # False
print(str1.startswith(“py”, 6, 20)) # True
print(str1.startswith(“py”, 6, )) # True
7.str.endswith(suffix,[,start,end]) 用于检查字符串是否以suffix结尾，若是则返回True,否则返回False.如果用start和end指定范围，则在该范围内检查。
str1 = “hello python”
print(str1.endswith(“n”)) # True
print(str1.endswith(“on”)) # True
print(str1.endswith(“python”)) # True
print(str1.endswith(“pthon”)) # False
print(str1.endswith(“n”, 0, 20)) # True
print(str1.endswith(“py”, 0, 6)) # False
4.8.2.2 字符串的拆分和组合
1.str.split(sep[,num])以sep为分隔符将str拆分成列表，默认的分隔符为空格；num指定拆分的次数，默认值为-1，表示无限制拆分。
str1 = “helpo worpold”
print(str1.split()) # 默认以空格分隔
print(str1.split(“po”)) # 分隔的对象有几个就分隔几个，无限制
print(str1.split(“po”, 1)) # 限制分隔一次，并且是自左向右
2.str.rsplit(sep[,num])与split()类似，只是从右边开始拆分
str1 = “hello worldllo”
print(str1.rsplit(“llo”)) # 如果没有分隔限制，那和split()没有什么差异。
print(str1.rsplit(“llo”, 1)) # 如果有分隔限制，从右边开始分隔。
3.s.join(seq)以s作为分隔符，将序列seq中的所有元素合并成一个新的字符串。
str1 = “hello”
print("".join(str1)) # hell*o
4.8.2.3 字符串内容的测试
1.str.isalnum( ):字符串str中全是字母或数字，则返回True，否则返回False
str1 = “hello123”
print(str1.isalnum()) # True
str1 = “hello123!”
print(str1.isalnum()) # False
2.str.isalpha( ):字符串str中全是字母则返回True，否则返回False.
str1 = “hello123”
print(str1.isalpha()) # False
str1 = “hello”
print(str1.isalpha()) # True
3.str.isdecimal( ):字符串str中只包含十进制的数字则返回True，否则返回False.
str1 = “0b1010”
print(str1.isdecimal()) # False
str1 = “123”
print(str1.isdecimal()) # True
str1 = “123hello”
print(str1.isdecimal()) # False
4.str.isdigit( ):字符串str中只包含数字则返回True，否则返回False.
str1 = “0b1010”
print(str1.isdigit()) # False
str1 = “123”
print(str1.isdigit()) # True
str1 = “123hello”
print(str1.isdigit()) # False
5.str.islower( ):字符串str中的字母全是小写字母，则返回True，否则返回False.
str1 = “hello World”
print(str1.islower()) # False
str1 = “hello world”
print(str1.islower()) # True
str1 = “hello world123你好”
print(str1.islower()) # True
6.str.isupper( ):字符串str中的字母全是大写字母，则返回True，否则返回False.
str1 = “hello World”
print(str1.isupper()) # False
str1 = “HELLO WORLD”
print(str1.isupper()) # True
str1 = “HELLO WORLD123你好”
print(str1.isupper()) # True
7.str.isspace( ):字符串str中只包含空格，则返回True，否则返回False.
str1 = "hello "
print(str1.isspace()) # False
str1 = " "
print(str1.isspace()) # True
8.str.isascii( ):判断是否不含中文，没有中文返回True,有中文返回False
str1 = “hello world123%@”
print(str1.isascii()) # True
str1 = “hello world123%@你好”
print(str1.isascii()) # False

4.9数据结构
4.9.1列表
列表(list)可变的数据类型，是一个容器，可以存放任意数据类型，里面的每一个数据项称为一个元素。
4.9.1.1创建列表的方法
1.使用list( )内置函数来创建列表，可以将字符串、元组或其他可迭代对象类型转为列表,例如：
list1 = [] # 创建空列表的方法1
list2 = list() # 创建空列表的方法2
print(list1, list2)
str1 = “hello”
print(list(str1))
tup1 = (1, 2, 3, 4)
print(list(tup1))
set1 = (4, 5, 6, 7)
print(list(set1))
dict1 = {“hello”: 1, “world”: 2}
print(list(dict1))
print(list(dict1.keys())) # 默认将字典的键转为列表的元素
print(list(dict1.values()))
print(list(dict1.items()))
4.9.1.2列表的基本操作
1.通用操作

1. 索引 通过索引对列表中的元素进行访问,语法格式如下:
   列表名[索引] 索引不能越界，否则会出现IndexError的错误
   元素的索引取值和字符串的索引取值原理一样。请参考前面的4.8.1.1 字符串的索引
2. 切片 通过切片操作可以从列表中取出某个范围的元素.从而构成新的列表。语法格式如下:
   列表名[起始索引:终止索引:步长]
   步长默认值为1，如果步长为正数，则从左向右提取元素，如果步长为负数，则从右向左提取元素。

x=[1,2,3,4,5]
x[1:4]
[2, 3, 4]
x[1:6:2]
[2, 4]
x[0:6:2]
[1, 3, 5]
x[1:5:-1]
[]
x[-1:-5:-1]
[5, 4, 3, 2]
x[5:1:-1]
[5, 4, 3]
3)加法连接 语法格式如下:
列表1+列表2
[1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]
4)乘法连接 语法格式如下:
列表整数 或 整数列表
[1,2,3]3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
2[“AB”,“CD”]
[‘AB’, ‘CD’, ‘AB’, ‘CD’]
5)比较两个列表 比较的规则如下：首先比较两个列表的第一个元素，如果这两个元素相等，则继续后面的对应的两个元素；如果这两个元素不相等，则返回这两个元素的比较结果。重复这个过程，直至出现不相等的元素或比较完所有元素为止.
[1,2,3,4]<[1,2,1,2,3]
False
[2,5,8]>[1,2,6,1]
True
6)检查成员资格 使用in 运算符可以判断一个值是否包含在列表中，语法格式如下:
值 in 列表
1 in [1,2,3]
True
9 in [1,2,3]
False
6 not in [1,2,3]
True
[1] in [1,2,3] # 将[1]看作整体
False
[1] in [[1],2,3]
True
7)遍历列表 要访问列表中的每个元素，可以通过while和for循环来实现。

list1=[1,2,3,4,5]
n = len(list1)
i=0
while i<=len(list1)-1:
print(list1[i])
i+=1

n = len(list1)
for i in range(0,n):
print(list1[i])
8)拆分赋值 例如:
x,y,z = [1,2,3]
print(x,y,z)
当进行拆分赋值时，要求变量个数必须与列表元素个数相等，否则会出现ValueError的错误，当变量个数小于列表个数时，可以在变量名前面加星号"*",这样会将多个元素赋值给相应的变量，例如:
x, *y, z = [1, 2, 3, 4, 5, 6]
print(x) # 1
print(y) # [2,3,4,5]
print(z) # 6
2.专用操作
列表对象是可变的序列，对列表除了可以使用序列的通用操作，还可以进行一些专用的操作，例如元素赋值、切片赋值、元素删除等。
1)元素赋值
lst = [1, 2, 3, 4]
lst[1] = 100
lst[2] = 200
print(lst)
2)切片赋值
通过切片赋值可以使用一个值列表来修改指定范围的一组元素的值。
当提供的值列表长度等于切片的长度，对应的值会被修改。

list1=[1,2,3,4,5,6]
list1[1:4] = [200,300,400]
list1
[1, 200, 300, 400, 5, 6]

当提供的值列表长度不等于切片的长度，对应的值会被修改。
1.如果提供的值列表长度大于切片的长度，则会插入新的元素。例如:

list1=[1,2,3,4,5,6]
list1[1:4]=[120,130,140,150,160]
list1
[1, 120, 130, 140, 150, 160, 5, 6]

2.如果提供的值列表长度小于切片的长度，则会删除多出的元素。例如:

list1=[1,2,3,4,5,6]
list1[1:4]=[200,300]
list1
[1, 200, 300, 5, 6]

3.当进行切片赋值的时候，如果步长不等于1，则要求提供的值列表长度必须与切片长度相等，否则将出现ValueError错误，例如:

list1=[1,2,3,4,5,6,7,8,9,10]
list1[0:10:2]=[11,22,33,44,55]
list1
[11, 2, 22, 4, 33, 6, 44, 8, 55, 10]
list1[0:10:2]=[100,200,300]
Traceback (most recent call last):
File “”, line 1, in
ValueError: attempt to assign sequence of size 3 to extended slice of size 5
3)元素删除 从列表中删除指定的元素，可以使用del语句来实现。例如:
list1=[1,2,3,4,5,6]
del list1[2]
list1
[1, 2, 4, 5, 6]

若要从列表删除指定范围内的元素，也可以通过切片赋值来实现，例如:

list1=[1,2,3,4,5,6]
list1[1:4]=[]
list1
[1, 5, 6]
4)列表推导式【列表解析】
可以通过列表推导式快速高效的创建新的列表.有两种语法格式:
[表达式 for 迭代变量 in 可迭代对象]
[表达式 for 迭代变量 in 可迭代对象 if 条件表达式]
例如：列出1~10所有数字的平方
list1=[ii for i in range(1,11)]
list1
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
如要列出1~10中能被2整除的数的平方
list1=[ii for i in range(1,11) if i%2==0]
list1
[4, 16, 36, 64, 100]
4.9.1.3列表的常用函数
1适用于序列对象的内置函数
为了便于使用列表，Python提供了一些内置函数，这些函数不仅可以应用于列表，还可以应用于其他可迭代类型，例如字符串、元组等。

1. len( ) 返回序列的长度 既序列中包含的元素个数 例如:

list1=[1,2,3,4,5]
len(list1)
5

2. max( ) 返回序列中的最大元素，例如:

list1=[1,2,3,4,5]
max(list1)
5
当列表中的元素是字符，则返回ASCII最大的元素
list1=[“a”,“b”,“c”]
max(list1)
‘c’
当列表中的元素是字符串，则返回元素的首字符ASCII最大的元素
list1=[“hello”,“world”,“python”]
max(list1)
‘world’

3. min( ) 返回序列中的最小元素，例如:

list1=[1,2,3,4,5]
min(list1)
1
当列表中的元素是字符，则返回ASCII最小的元素
list1=[“a”,“b”,“c”]
min(list1)
‘a’
当列表中的元素是字符串，则返回元素的首字符ASCII最小的元素
list1=[“hello”,“world”,“python”]
min (list1)
‘hello’

4. sorted(iterable,key=None,reverse=False )对可迭代对象进行排序操作并返回排序后的新列表，原始列表不变，参数iterable表示可迭代类型，参数key指定一个函数，实现自定义排序，默认为None,参数reverse用于指定规则，设置为True则按降序排序，默认为False的话表示按升序排序。例如:

list1=[10,3,1,2,6,4]
list2=sorted(list1)
list2
[1, 2, 3, 4, 6, 10]
list2=sorted(list1,reverse=True)
list2
[10, 6, 4, 3, 2, 1]

5. sum(iterable[,start]) 对序列进行求和计算，参数iterable表示可迭代类型；start是可选项，用以指定相加的参数，默认为0，例如:

list1=[1,2,3,4]
sum(list1)
10
sum(list1,10)
20
例1：
从键盘连续输入数字，当输入字母q或者Q表示退出循环。退出循环后计算出数字的累加和。并求出输入的数字的最大值，最小值，并将输入的数字按照从大到小的顺序进行排序。
s = 0
list1 = []
while True:
num = input(“请输入数字:”)
if num == “q” or num == “Q”:
break
num = int(num) # 将字符串类型的数字转为整型数据
list1.append(num)
s += num
print(“数字的累加和:”, s)
print(“输入的数字最大值:”, max(list1))
print(“输入的数字最小值:”, min(list1))
list2 = sorted(list1, reverse=True)
print(“输入的数字从大到小的顺序:”,end=" “)
for i in list2:
print(i, end=” ")
2适用于序列对象的成员方法

1. lst.append(x) 使用该方法可以在列表lst末尾添加元素x,等价于执行复合赋值语句lst+=[x].列如:

lst=[“C”,“Python”,“PHP”]
lst.append(“Java”)
lst
[‘C’, ‘Python’, ‘PHP’, ‘Java’]

2. lst.extend(L) 使用该方法可以在列表lst末尾添加另一个列表，等价于执行复合赋值语句lst+=L 例如:

lst=[“C”,“Python”,“PHP”]
lst.extend([“Java”,“Go”])
lst
[‘C’, ‘Python’, ‘PHP’, ‘Java’, ‘Go’]

3. lst.insert(i,x)使用该方法可以在列表lst的i位置插入元素x,如果i大于列表的长度，则将元素x插入到列表末尾。例如:

lst=[1,2,3]
lst.insert(1,100)
lst
[1, 100, 2, 3]
lst.insert(5,100)
lst
[1, 100, 2, 3, 100]

4. lst.remove(x) 使用该方法可以从列表lst中删除第一个值为x的元素，如果列表中不存在这样的元素则会出现ValueError错误，例如:

lst=[1,2,3,4,5,6,2]
lst.remove(2)
lst
[1, 3, 4, 5, 6, 2]
lst.remove(7)
Traceback (most recent call last):
File “”, line 1, in
ValueError: list.remove(x): x not in list

5. lst.pop(i) 使用该方法可以从列表lst中弹出索引为i的元素，然后删除并返回该元素；如果未指定参数i,则会弹出列表中的最后一个元素；如果指定的参数i越界，则会出现IndexError的错误，例如:

lst=[1,2,3,4,5,6]
lst1=lst.pop(3)
lst1
4
lst
[1, 2, 3, 5, 6]
lst.pop()
6
lst
[1, 2, 3, 5]

5. lst.count(x) 使用该方法可以返回元素x在列表lst中出现的次数。例如:

list1=[1,2,3,4,2,5,2]
list1.count(2)
3

6. lst.index(x[,start,end]) 使用该方法返回元素x在列表lst中第一次出现的索引值，如果元素x未包含在列表lst中，则会出现ValueError的错误。例如:

lst=[“a”,“b”,“c”,“d”,“b”]
lst.index(“b”)
1
lst.index(“e”)
Traceback (most recent call last):
File “”, line 1, in
ValueError: ‘e’ is not in list

7. lst.sort(key=None,reverse=True)使用该方法可以对列表lst进行排序，使用该方法会修改原列表，若要返回一个新的列表而不修改原列表，使用内置函数sorted( )。例如:

lst=[10,2,4,3,1,6,7,5]
lst.sort()
lst
[1, 2, 3, 4, 5, 6, 7, 10]
lst.sort(reverse=True)
lst
[10, 7, 6, 5, 4, 3, 2, 1]

8. lst.reverse( ) 使用该方法可以反转列表list中所有元素。例如:

lst=[3,6,8,1,9,2]
lst.reverse()
lst
[2, 9, 1, 8, 6, 3]

9. lst.copy( ) 使用该方法可以复制列表list中所有元素。例如:
   list1 = [1, 2, 3, 4, 2]
   list2 = list1.copy()
   list2.reverse()
   print(list1)
   print(list2)
   例2：
   从键盘输入一个正整数，然后以该整数作为长度生成一个列表并用随机数对列表元素进行初始化，然后用列表对象的成员方法对该列表进行各种操作。
   4.9.2 元组
   在python中，元组(tuple)与列表类似，它们同属于有序的序列类型。不同的是元组是不可变对象，元组一经创建，其元素便不能被修改。
   4.9.2.1 元组的基本操作
   元组的元素用逗号隔开，放在圆括号内。
   注意:当元组中只包含一个元素时，需要在元素后面添加逗号，以防运算时被当作括号。

tup1=(1)
print(type(tup1))

tup1=(1,)
print(type(tup1))

可以通过调用tuple( )函数来创建元组，通过调用tuple( )函数还可以将字符串和列表、集合、字典转为元组。例如:
tup1=tuple() # 创建空的元组
tup1
()
tup2=tuple(“hello python”)
tup2
(‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ’ ', ‘p’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’)
tup3 = tuple([1,2,3,4,5,6])
tup3
(1, 2, 3, 4, 5, 6)
set1 = {1, 2, 3, 4}
print(tuple(set1))

dict1 = {“world”: 1, “hello”: 2}
print(tuple(dict1))
print(tuple(dict1.keys()))

print(tuple(dict1.values()))
print(tuple(dict1.items()))
可以对元组进行加法和乘法运算
使用索引访问元组指定位置的元素
通过切片从元组中获取部分元素
使用关系运算符比较两个元组
使用成员运算符in来判断某个值是否存在于元组中
使用for循环遍历元组
使用内置函数len( )计算元组的长度等
由于元组是不可变对象，是不允许修改元组中的元素值，如果试图通过赋值语句修改元组中的元素，将会出现TypeError的错误，同样，是不允许删除元组中的元素的。但是可以使用del语句来删除整个元组。
例1：
元组基本操作示例:
4.9.2.1 元组封装与序列拆封
1.元组封装
元组封装是指以逗号分隔的多个值自动封装到一个元组中，例如:

x = “vb”,“python”,“java”
x
(‘vb’, ‘python’, ‘java’)
type(x)

2.序列拆封
序列拆封是元组封装的逆运算，可以用来将一个封装起来的元组对象自动拆分成若干个基本数据。例如:
x,y,z = (1,2,3)
print(x,y,z)
1 2 3
上面的序列拆分操作要求赋值运算符左边的变量数目与右边序列中包含的数据数目相同，否则会出现ValueError错误!
封装操作只能用于元组对象，而拆分操作不仅可以用于元组对象，还可以用于序列对象。
例1：
输入两个字符串并将其存入两个变量，然后交换两个变量的内容。
s1 = input(“请输入第一个字符串:”)
s2 = input(“请输入第二个字符串:”)
print(“s1={} s2={}”.format(s1, s2))
s1, s2 = s2, s1
print(“交换后的字符串”)
print(“s1={} s2={}”.format(s1, s2))

列表和元组之间可以互相转换
元组转列表使用内置函数list( )
列表转元组使用内置函数tuple( ) 请看下面的示例:

tuple1=(“hello”,“python”,1,2)
list1=list(tuple1)
list1
[‘hello’, ‘python’, 1, 2]
tuple2 = tuple(list1)
tuple2
(‘hello’, ‘python’, 1, 2)

4.9.3 集合
集合是一些不重复的无序组合，集合分为可变集合和不可变集合。集合不记录元素的位置，因为对集合不能进行索引和切片等操作。
4.9.3.1 创建集合
4.9.3.1.1创建可变集合
创建可变集合的最简单方法是使用逗号分隔一组数据并将他们放在一对花括号中。

set1={1,2,3,4,5,6}
type(set1)

集合中的元素可以是不同的数据类型，但是不能是可变的数据类型（列表，字典）因为集合的三大特征（确定性、互异性、无序性）中的确定性决定的。
set1={1,2,3,“hello”,“python”}
set1
{1, 2, 3, ‘hello’, ‘python’}
set2={1,2,[1,2,3]}
Traceback (most recent call last):
File “”, line 1, in
TypeError: unhashable type: ‘list’
set3={1,2,3,{“hello”:1}}
Traceback (most recent call last):
File “”, line 1, in
TypeError: unhashable type: ‘dict’
集合中不能包含重复的元素，因为集合的三大特征（确定性、互异性、无序性）中的互异性决定的。如果创建可变集合时使用了重复的数据，Python会自动删除重复的元素，例如:
set1={1,2,3,4,5,1,2}
set1
{1, 2, 3, 4, 5}
可变集合使用内置的set类来定义，使用集合类的构造函数set( )可以将字符串、列表和元组等类型转换为可变集合。例如:
set1=set()
set1
set()
set2=set([1,2,3,4,5,6])
set2
{1, 2, 3, 4, 5, 6}
set3=set((1,2,3,4,5,6))
set3
{1, 2, 3, 4, 5, 6}
set4=set((i for i in range(10)))
set4
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
创建空集合只能使用set( )而不能使用{ },如果使用{ }，则会创建一个空字典.
set1=set()
type(set1)

set2={}
type(set2)

4.9.3.1.2可变集合的操作
下列方法会修改原集合的内容，仅适用于可变集合.
1.set1.add(x) 该函数用于在集合set1中添加元素x，如:
set1={1,2,3,4,5,6}
set1.add(7)
set1
{1, 2, 3, 4, 5, 6, 7}
2.set1.update(set2,set3,…,setn)该函数把集合set2,set3,…setn拆分成单个数据项并将其添加到集合set1中，如下:
set1={1,2,3}
set1.update({4,5,6},{7,8,9})
set1
{1, 2, 3, 4, 5, 6, 7, 8, 9}
3.set1.remove(x) 该函数用于从集合set1中删除元素x，若x不存在于集合set1中，则会出现KeyError的错误。例如:
set1={1,2,3,4,5}
set1.remove(4)
set1
{1, 2, 3, 5}
set1.remove(6)
Traceback (most recent call last):
File “”, line 1, in
KeyError: 6
4.set1.pop( )该函数用于从集合set1中弹出一个元素，即删除并返回该元素，例如:
set1={1,2,3,4,5,6}
set1.pop()
1
set1.pop()
2
set1.pop()
3
set1.pop()
4
set1.pop()
5
set1.pop()
6
set1.pop()
Traceback (most recent call last):
File “”, line 1, in
KeyError: ‘pop from an empty set’
set1
set()
5.set1.clear( )该函数用于删除集合set1中的所有元素。例如:
set1={1,2,3}
set1.clear()
set1
set()
2.创建不可变集合
不可变集合可以调用frozenset( )函数来创建，格式如下:
frozenset([iterable])
其中的参数iterable为可选项，用于指定一个可迭代对象，例如列表、元组、可变集合、字典等。如果不提供参数，则会生成一个空集合。例如:
fz1=frozenset(range(10))
fz1
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
fz2=frozenset(“hello”)
fz2
frozenset({‘o’, ‘e’, ‘h’, ‘l’})
fz3=frozenset()
fz3
frozenset()
4.9.3.2 可变和不可变集合