走进python三千章，自信人生二百年——python学习笔记_编写一个程序,将值’x’、’o’、1.345e10和35分别存储到不同的变量中-CSDN博客

本文链接：https://blog.csdn.net/qq_45830728/article/details/130784254

python 学习笔记

一、 print语句

1.可以输出数字

print(666)

2.可以输出字符串

print('right')
print("right")

3.含有运算符的表达式，且会计算表达式的结果

print(6 + 6)

*4.将数据输出文件中 1.注意所指定的盘符存在 2.使用file=fp,否则会读成a，数据会无法进入

fp = open('D:/text.txt', 'a+')  # “a+”表示若没有文件则新建文件，存在就在文件内容的后面继续输出
print('少 年 何 妨 梦 摘 星,敢 挽 桑 弓 射 玉 衡 !', f1ile=fp)
fp.close()

5.不进行换行输出（输出内容在一行当中）

print('Hello', 'My', 'Python')

6.语句换行

print("少 年 何 妨 梦 摘 星\
 敢 挽 桑 弓 射 玉 衡")

二、语句注释

""
print("少 年 何 妨 梦 摘 星\
 敢 挽 桑 弓 射 玉 衡")
"""
''''''print("少 年 何 妨 梦 摘 星\
 敢 挽 桑 弓 射 玉 衡")'''

三、缩进（不可用TAB键，应使用空格键完成操作）

if True:
    print("如果为真，输出：")
    print("true")
else:
    print("否则，输出：")
    print("false")

四、数据类型

1.数字类型(number)

整型（int）可以用二进制-

浮点型（float）

复数型（complex）

布尔型（bool）布尔型是一种比较特殊的整型，它只有True和False两种值，分别对应1和0，它主要用来比较和判断，所得结果叫做布尔值。

2.字符串类型(String)

3.列表类型(List)

4.元组类型(Tuple)

5.字典类型(Dict)(Dictionary)

6.集合类型(Set)

7.检测数据类型Python中内置了检测数据类型的函数type()。它可以对不同类型的数据进行检测

d = 10
print(type(d))

8.除此之外，还可以使用函数isinstance()判断数据是否属于某个类型

print(isinstance(d, int))
print(isinstance(d, float))

9. python常见关键词

关键字	描述
and	逻辑运算符
as	创建别名
assert	用于调试
break	跳出循环
class	定义类
continue	继续循环的下一个迭代
def	定义函数
del	删除对象
elif	在条件语句中使用，等同于 else if
else	用于条件语句
except	处理异常，发生异常时如何执行
False	布尔值，比较运算的结果
finally	处理异常，无论是否存在异常，都将执行一段代码
for	创建 for 循环
from	导入模块的特定部分
global	声明全局变量
if	写一个条件语句
import	导入模块
in	检查列表、元组等集合中是否存在某个值
is	测试两个变量是否相等
lambda	创建匿名函数
None	表示 null 值
nonlocal	声明非局部变量
not	逻辑运算符
or	逻辑运算符
pass	null 语句，一条什么都不做的语句
raise	产生异常
return	退出函数并返回值
True	布尔值，比较运算的结果。
try	编写 try…except 语句
while	创建 while 循环
with	用于简化异常处理
yield	结束函数，返回生成器
seed()	初始化随机数生成器
getstate()	返回随机数生成器的当前内部状态
setstate()	恢复随机数生成器的内部状态
getrandbits()	返回表示随机位的数字
randrange()	返回给定范围之间的随机数
randint()	返回给定范围之间的随机数
choice()	返回给定序列中的随机元素
choices()	返回一个列表，其中包含给定序列中的随机选择
shuffle()	接受一个序列，并以随机顺序返回此序列
sample()	返回序列的给定样本
random()	返回 0 与 1 之间的浮点数
uniform()	返回两个给定参数之间的随机浮点数
triangular()	返回两个给定参数之间的随机浮点数，您还可以设置模式参数以指定其他两个参数之间的中点
betavariate()	基于 Beta 分布（用于统计学）返回 0 到 1 之间的随机浮点数
expovariate()	基于指数分布（用于统计学），返回 0 到 1 之间的随机浮点数，如果参数为负，则返回 0 到 -1 之间的随机浮点数。
gammavariate()	基于 Gamma 分布（用于统计学）返回 0 到 1 之间的随机浮点数
gauss()	基于高斯分布（用于概率论）返回 0 到 1 之间的随机浮点数
lognormvariate()	基于对数正态分布（用于概率论）返回 0 到 1 之间的随机浮点数
normalvariate()	基于正态分布（用于概率论）返回 0 到 1 之间的随机浮点数
vonmisesvariate()	基于 von Mises 分布（用于定向统计学）返回 0 到 1 之间的随机浮点数
paretovariate()	基于 Pareto 分布（用于概率论）返回 0 到 1 之间的随机浮点数
weibullvariate()	基于 Weibull 分布（用于统计学）返回 0 到 1 之间的随机浮点数。

五、运算符

1.常用运算符

运算符	描述	示例
+	相加	a + b
-	相减	a - b
*	相乘	a * b
/	相除	a / b
%	取模	a % b
**	幂	a**b 表示 a 的 b 次幂
//	取整	9 // 4 结果为 2
==	是否相等	a == b
!=	是否不等于	a != b
>	是否大于	a > b
>=	是否大于等于	a >= b
<=	是否小于等于	a <= b
=	简单的赋值运算符	a = b + c
+=	加法赋值运算符	a += b 等效于 a = a + b
-=	减法赋值运算符	a -= b 等效于 a = a - b
*=	乘法赋值运算符	a = b 等效于 a = a b
/=	除法赋值运算符	a /= b 等效于 a = a / b
%=	取模赋值运算符	a %= b 等效于 a = a % b
**=	幂赋值运算符	a = b 等效于 a = a b
//=	取整除赋值运算符	a //= b 等效于 a = a // b
&	与	a & b
\|	或	a \| b
^	异或	a ^ b
~	取反	~a
<<	左移动	a << 3
>>	右移动	a >> 3
and	布尔类型与	a and b
or	布尔类型或	a or b
not	布尔类型非	not a
is	判断两个标识符是否引用同一个对象	a is b
is not	判断两个标识符是否引用不同对象	a is not b

2. 运算符优先级

运算符	描述（由上至下对应优先级由高到低）
**	幂运算
~ + -	取反、正号、负号
* / % //	乘、除、取模、取整除
+ -	加法、减法
>> <<	右移、左移
&	与
^ \|	异或、或
<= < > >=	比较运算符
== !=	是否等于、是否不等于
= % = / = // = -= += = *=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not and or	逻辑运算符

3、赋值运算符的使用

a, b = 5, 2
a += b
print(a, b)
a -= b
print(a, b)
a *= b
print(a, b)
a /= b
print(a, b)
a **= b
print(a, b)
a //= b
print(a, b)

4、比较运算符的使用

print(1 == 1)
print(1 == 2)
print(1 == True)
print(0 == False)
print(1.0 == True)
print(0.0 == False)
print((0.0 + 0.0j) == False)

5、逻辑运算符的使用

print(0 and 4)
print(False and 4)
print(1 and 4)
print(1 or 4)
print(True or 4)
print(0 or 4)
print((4 <= 5) and (4 >= 3))
print((4 >= 5) or (4 <= 3))
print(not 1)

6、位运算符的使用

a, b = 7, 8
print(bin(a))  # 二进制形式111
print(bin(b))  # 二进制形式1000
print(bin(a & b))
print(bin(a | b))
print(bin(a ^ b))
print(bin(~a))
print(bin(a << 2))
print(bin(a >> 2))

7、成员运算符的使用

A = [1, 2, 3, 4]  # 列表
print(1 in A)
print(0 in A)
print(1 not in A)
print(0 not in A)

8、身份运算符的使用

a: int
a = b = 10  # a,b都为10
print(a is b)
print(a is not b)
b = 20  # b修改为20
print(a is b)
print(a is not b)

9、小案例

从键盘输入一个3位整数，计算并输出其百位、十位和个位上的数字，程序运行时，从键盘输入356

x = int(input("请输入一个三位整数："))
g = x // 1 % 10  # 个位数
s = x // 10 % 10  # 十位数
b = x // 100 % 10  # 百位数
print('百位：', b, '十位：', s, '个位：', g)

六.顺序结构

1.对象的布尔值

以下对象的布尔值为False
*Flase
*数值()
*None
*空字符串
*空列表
*空元组
*空字典
*空集合
其他对象的bool值均为True

print('-------------------------------------------')
print(bool(False))  # False
print(bool(0))  # False
print(bool(0.0))  # False
print(bool(None))  # False
print(bool(''))  # False
print(bool(""))  # False
print(bool([]))  # 空列表
print(bool(list()))  # 空列表
print(bool(tuple()))  # 空元组
print(bool({}))  # 空字典
print(bool(dict()))  # 空字典
print(bool(set()))  # 空集合
print('-----------以上对象的布尔值为False--------------')

七、条件语句

1.if语句

‘’’
if语句用于在程序中有条件地执行某些语句，格式如下:
if条件表达式：
语句块#当条件表达式为True时，执行语句块
‘’’

1.1 if 语句用法

score = 90
if score >= 60:
    print("优秀!")
print("您的分数%d" % score)

2.if-else语句

if-else语句用于根据条件表达式的值决定执行那块代码，其语法格式如下:
if条件表达式：
语句块 1 # 当条件表达式为True时，执行语句块1
else:
语句块 2 # 当条件表达式为False时，执行语句块2

2.1 if-else 语句用法

score = 80
if score >= 60:
    print("优秀")
else:
    print("加油！")
    print("您的分数为：%d" % score)

3.if-elif 语句

‘’’
在程序中多重判断可以通过 if-elif 语句实现，其语法格式如下：
if 条件表达式1:
语句块 1 #当条件表达式1为True时，执行语句块1
elif 条件表达式2:
语句块 2 #当条件表达式2为True时，执行语句块2
…
elif 条件表达式n:
语句块 n #当条件表达式n为True时，执行语句块n
‘’’

3.1 if—elif语句用法

score = 80
if 90 <= score <= 100:
    print("成绩爆表")
elif 80 <= score < 90:
    print("成绩优秀")
elif 60 <= score < 80:
    print("成绩合格")
elif 0 <= score < 60:
    print("成绩堪忧")
print("您的成绩为:%d" % score)

4. if-elif-else 语句

‘’’
此外 if-elif 语句后还可以使用 else语句
用来表示if-elif语句中有条件不满足时执行的语句块，其语法格式如下
if 条件表达式1:
语句块 1 #当条件表达式1为True时，执行语句块1
elif 条件表达式2:
语句块 2 #当条件表达式2为True时，执行语句块2
…
else 条件表达式n:
语句块 n #当以上条件表达式均为False时，执行语句块n
‘’’

4.1 if-elif-else语句的使用

score = 120
if 90 <= score <= 100:
    print("成绩爆表")
elif 80 <= score < 90:
    print("成绩优秀")
elif 60 <= score < 80:
    print("成绩合格")
elif 0 <= score < 60:
    print("成绩堪忧")
else:
    print("成绩有误")
print("您的成绩为:%d" % score)

5 if 语句嵌套

‘’’
if 语句嵌套是指if、if-else中的语句块可以是if或if-else语句，其语法格式如下：
（一） if 语句
if 条件表达式1:
if 条件表达式2: #嵌套if语句
语句块2
if 条件表达式3: #嵌套if-else语句
语句块3
else:
语句块4
(二) if-else语句
if 条件表达式1:
if 条件表达式2: #嵌套if语句
语句块2
else:
if 条件表达式3: #嵌套if-else语句
语句块3
else:
语句块4
‘’’

5.1 if嵌套语句的用法

a, b, c = 5, 8, 3
if a >= b:
    if a >= c:
        print("a,b,c中最大的值为：%d" % a)
    else:
        print("a,b,c中最大的值为：%d" % c)
else:
    if b >= c:
        print("a,b,c中最大的值为：%d" % b)
    else:
        print("a,b,c中最大的值为：%d" % c)

八、循环语句

1.内置函数range()

当遍历数字序列时，可以使用range()函数
（1）第一种创建方式，只有一个参数（小括号中只给了一个数）

r = range(10)  # [0,1,2,3,4,5,6,7,8,9],默认为从0开始，默认相差1称为步长
print(r)  # range(0,10)
print(list(r))  # 用于查看range对象中的整数序列  ———>list是列表的意思

（2）第二种创建方式，给了两个参数（小括号中给了两个数）

r = range(1, 10)  # 指定了起始值，从1开始，到10结束（不包括10），默认步长为1
print(list(r))  # [1,2,3,4,5,6,7,8,9]

（3）第三种创建方式，给了三个参数（小括号中给了三个数）

r = range(1, 10, 2)
print(list(r))  # [1,3,5,7,9]

（4）判断指定的整数在序列中是否存在 in，not in

print(10 in r)  # False,10不在当前的r这个整数序列中
print(9 in r)  # True,  9在当前的r这个整数序列中
print(10 not in r)  # True
print(9 not in r)  # False
sum = 0
for i in range(1, 101):
    sum += 1
    print("1 + 2 + ··· + 100 = %d" % sum)

2.while语句

‘’’
在while语句中，当条件表达式为True时，就重复执行语句块；当条件表达式为False时，就结束执行语句块。while语句的语法格式如下：
While条件表达式:
语句块 # 此处语句块也称循环体
‘’’

while语句的用法

i, sum = 1, 0  # 实现1~100的累加
while i < 101:
    sum += 1
    i += 1
    print("1 + 2 + ··· + 100 = %d" % sum)

3.for语句

for语句的用法：

for word in "python":
    print(word)

4.while与for嵌套

(1) while语句中嵌套while语句九九乘法表

i = 1
while i < 10:
    j = 1
    while j <= i:
        print("%d*%d=%-3d" % (i, j, i * j), end='')
        j += 1
    i += 1
    print(end='\n')

(2) while语句中嵌套for语句九九乘法表

i = 1
while i < 10:
    for j in range(1, i + 1):
        print("%d*%d=%-3d" % (i, j, i * j), end='')
    i += 1
    print(end='\n')

（3）for语句中嵌套while语句九九乘法表

for i in range(1, 10):
    j = 1
    while j <= i:
        print("%d*%d=%-3d" % (i, j, i * j), end='')
        j += 1
    print(end='\n')

(4) for语句中嵌套for语句九九乘法表

for i in range(1, 10):
    for j in range(1, i + 1):
        print("%d*%d=%-3d" % (i, j, i * j), end='')
    print(end='\n')

5.break语句

break语句可以使程序立即退出循环，转而执行该循环的下一条语句。
如果break语句出现在嵌套循环中的内层循环中，则break语句只会跳出当前层的循环。

i = 0
while True:
    i += 1
    print("第%d次循环开始" % i)
    if i == 3:
        break
        print("第%d此循环结束" % i)
    print("整个循环结束")

6.continue语句

i = 0
while i < 3:
    i += 1
    print("第%d次循环开始" % i)
    if i == 2:
        continue
    print("第%d次循环结束" % i)
print("整个循环结束")

7. else语句

‘’’
else语句除了可以与if语句搭配使用外，还可以与while语句，for语句搭配使用，
当条件不满足时执行else语句块，它只在循环结束后执行。
‘’’

（1）for语句搭配else语句的用法

for n in range(1, 3):
    print("第%d次循环" % n)
else:
    print("循环结束")

(2) for语句中存在break语句

for n in range(1, 4):
    print("第%d次循环" % n)
    if n == 2:
        break
    else:
        print("循环结束")
print("程序结束")

8.pass语句

for n in range(1, 3):
    pass
    print("暂时没有思路")
print("程序结束")

练习：程序输出1~100的质数

print('以下是100以内的质数:')
for num in range(2, 101):  # ramge函数生成2~100之间的整数，使用for语句遍历这些整数，
    if all(num % i != 0 for i in range(2, num)):  # 对每个整数进行判断是否是质数，
        print(num)  # （仅能被1和自身整除的整数），使用all()函数和一个生成器表达式进行判断，
        # 如果一个数能被2到（n-1）之间的任意数整除，则返回False，否则返回True，最后如果这个数是质数则将这个数输出sum=0
sum = 0
for i in range(2, 100):  # 循环迭代i 2->100
    for j in range(2, i):  # 第二次循环迭代j 2->i-,判断i 是否能被j整除
        if i % j == 0:  # 如果i能被j整除，说明i不是质数，跳出循环
            break
    else:  # 如果第二层for循环正常结束，说明i为质数，将它加到sum上
        sum += i
print("100以内质数的和为：", sum)  # 输出质数之和

九、字符串

1. 使用单引号标识字符串

'别让世俗淹没生活的浪漫与热爱 ！'

2.使用双引号标识字符串

"别让世俗淹没生活的浪漫与热爱 ！"

3. 使用三引号标识字符串

'''
别让世俗淹没生活的浪漫与热爱
'''
"""
别让世俗淹没生活的浪漫与热爱
"""

4. 字符串不可以被修改但是可以被截取

str = "xiaoqian is a programmer."
print(str[0:14] + "gril")

5.、转义字符

1.换行\n

print('Hello\nWord')

2.回车\r

print('Hello\rWord')  # word将hello覆盖了

3.水平制表符\t

print('Hello\tWord')

4.退格\b

print('Hello\bWord')  # \b是退一格，将o退没了
print('http:\\www.baidu.com')
print('他说:"别让世俗淹没生活的浪漫与热爱 ！"')

5.原字符，不希望转义字符起作用，就是用原子符。在原子符之前加上r或R

print(r'别让世俗淹没生活的浪漫\n与热爱')

6.注意事项，最后一个字符不能是反斜杠

如：

print（ｒ＇别让世俗淹没生活的浪漫\n与热爱\＇）

print('ｒ''别让世俗淹没生活的浪漫\n与热爱\')

6.字符串的输出

print("666")

7.常用的格式化符号

格式符号	转换
%s	格式化字符串
%c	格式化字符
%i	格式化有符号十进制整数
%d	格式化整数
%u	格式化无符号十进制整数
%o	格式化八进制整数
%x	格式化十六进制整数（小写字母）
%X	格式化十六进制整数（大写字母）
%e	用科学计数法格式化浮点数
%E	作用和%e一样
%f	格式化浮点实数
%g	％f和％e的简写
%G	％f和％E的简写
%%	输出%

8.字符串的输入

input("666")

9.字符串的索引与切片

字符串可以通过运算符[]进行索引与切片，字符串中每个字符都对应两个编号（也称下标)字符串str正向编号从0开始，
代表第一个字符，依次往后，字符串str负向编号从-1开始，代表最后一个字符，依次向前。因为编号可正可负，所以字符串中的
某个字符可以有两种方法索引。

str=("cong cong na nian")
      0123456789

str = "cong cong na nian"

（1）单个字符

print(str[10])
print(str[6])  # 空格也是字符
print(str[66])  # IndexError: string index out of range  字符超出索引范围
print(str[-2])

(2)多个字符切片

print(str[0:4])  # 类似于range()函数的使用,默认步长为1
print(str[:5])  # 等价于str[0:5:1]
print(str[:])  # 整个字符串
print(str[2:4:2])  # 索引2，4两个字符，步长为2
print(str[2:8:-2])  # - 表示反方向取，步长为2，从8开始到2，一般不常用

10.字符串的运算

运算符	说明
+	字符串连接
*	重复字符串
[]	索引字符串中的字符
[:]	对字符串进行切片
in	如果字符串中包含给定字符，返回True
not in	如果字符串中包含给定字符，返回False
r或R	原样使用字符串

11.字符串的运算

str1, str2 = "青春的颜色", "一抹绚烂"
print(str1 + str2)
print(3 * (str1 + str2))
if "季节" in "季节更替":
    print("注意身体！")
else:
    print("各自安好！")

12.字符串常用函数

（1）大小写转换

函数	说明
upper()	将字符串中所有小写字母转换为大写
lower()	将字符串中所有大写字母转换为小写
capotalize()	将单词的首字母大写
title()	将每个字符串中单词的首字母大写

name = "time"
str = input("请输入用户名(不区分大小写)：")
if str.lower() == name:
    print("欢迎用户%s登录" % name)
else:
    print("用户名错误！")

(2)判断字符

函数	说明
isupper()	如果字符串中包含至少一个区分大小写的字符，并且所有这些（区分大小写）字符都是大写，则返回True，否则返回False
islower()	如果字符串中包含至少一个区分大小写的字符，并且所有这些（区分大小写）字符都是小写，则返回True，否则返回False
isalpha()	如果字符串至少有一个字符并且所有字符都是字母，则返回True，否则返回False
isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字，则返回True，否则返回False
isspace()	如果字符串中只包含空白，则返回True，否则返回False
istitle()	如果字符串是标题化的，则返回True，否则返回False

八.列表

列表的概念：列表是python以及其他语言中最常用的数据类型之一。python中常用括号[]来创建列表
‘’
student = [20190101, “李四”, 18, 99.5]

(1)列表的创建

‘’’
列表是由一组任意类型的值组合而成的序列，组成列表的值称为元素，每个元素之间用逗号隔开，具体示例如下：‘’’

list1 = [1, 2, 3, 4, 5]  # 元素为int型
list2 = ['你好', '我的世界', '!']  # 元素为string型
list3 = ['李四', 18, 99.5]  # 元素为混合型
list4 = ['你好', ['张三', 18, 99.5]]  # 列表嵌套列表
'''此外还可以创建一个空列表'''
list5 = []  # 空列表
(2)  # 列表的简单使用
name, age, score = '小千', 98.5
list1 = [name, age, score]
print(list1)
name, age, score = '小峰', 20, 100
print(list1)
print(name, age, score)
list1[0] = name
print(list1)

(3)list()函数的用法

list1 = list("qianfeng")
list2 = list(range(1, 5))
list3 = list(range(5))
list4 = list(range(1, 5, 2))
print(list1)
print(list2)
print(list3)
print(list4)

	range()函数
range(start,end)	返回一系列整数从start开始，到end-1结束，相邻两个整数差1
range(end)	返回一系列整数从0开始，到end-1结束，相邻两个整数差1
rnage（start,end,step)	返回一系列整数从start开始，相邻两个整数差step，结束整数不超过end-1

（4）列表的索引

list1 = [1, 2, 3, 4, 5, 6, 7, 8]
list1[4]
list1[-4]

（5）列表的切片

list1 = [1, 2, 3, 4, 5, 6, 7, 8]
print(list1[2:6])
print(list1[2:6:2])
print(list1[:6])
print(list1[2:])
print(list1[-6:-2])
print(list1[-6:-2:2])
print(list1[::-2])

(6)列表的遍历

‘’’
1、通过while循环遍历列表

通过while循环遍历列表，需要使用len()函数，该函数可以获取序列中元素的个数

print(len('helloword'))  # 9
list = [1, 2, 3, 4]  # 4
print(len(list))

lsit = ['青春', '短暂', '需珍惜']
length, i = len(list), 0
while i < length:
    print(list[i])
    i += 1

2.通过for循环遍历列表

只需将列表名放在for语句中in关键词之后

list = ['青春', '短暂', '需珍惜']
for value in list:
    print(value)

(7) 列表的运算

运算符	说明
+	列表连接
*	重复列表元素
[ ]	索引列表中的字符
[ : ]	对列表行切片
in	如果列表中包含给定元素，返回True
not in	如果列表中包含给定元素，返回False

list1, list2 = ['青春', '短暂'], ['需珍惜']
print(3 * list2)
print(list1 + list2)
print("短暂" in list2)
print("青春" in list1)
name1, name2 = list1[0:]
name3, neme4 = list1
print(name1, name2, name3, name4)

(8)修改元素

修改列表中的元素只需索引需要修改的元素并对其赋新值即可

list1, list2 = ['青春', '短暂', '需珍惜'], ['!!!']
list1[0], list[1] = 'www.baidu,com', 'www.qq.com'
print(list1)
list1[1:] = list2[0:2]
print(list1)

（9）添加元素

函数	说明
append(obj)	在列表末尾添加元素obj
extend(seq)	在列表末尾一次性添加另一个序列seq中的多个元素
insert(inddex,obj)	在元素obj插入列表的index位置处

lis1, lis2 = ['青春'], ['别留遗憾']
lis1.append('短暂')
print(lis1)
lis1.extend(lis2)
print(lis1)
lis2.insert(1, '!')
print(lis2)

(10) 删除元素

删除函数

函数	说明
pop（index=-1）	删除列表中index处的元素(默认的为index=-1).并返回该元素的值
remove(obj)	删除列表中第一次出现的obj元素
clear( )	删除(清空)列表中的所有元素，（不释放内存空间）
del( )	用del[索引数] 函数删除指定索引数的元素或删除整个变量(将元素完全删除，并释放内存空间，且不可恢复)

复制函数

copy()	将当前的列表复制一份相同的列表，新列表与旧列表内容相同，但内存空间不同

#  在列表中删除与复制元素
lis3 = ['缘分', '随遇', '而安', '即可']
lit1 = lis3.pop()
print(lis3, lit1)
lit1 = lis3.pop(2)
print(lis3, lit1)
lis3.append('!!!')
print(lis3)
lis3.remove('!!!')
print(lis3)
lis3.clear()
print(lis3)
lit2 = ['春风', '不解风情', '吹动', '少年', '的心']
lis3.extend(lit2)
print(lis3)
del lis3[1]
print(lis3)
lit3 = lis3.copy()
print(lit3)

（11）查找元素位置

index()函数可以从列表中查找出某个元素第一次出现的位置,其中obj表示需要查找的元素，start表示查找范围的起始处，end表示查找范围的结束处(不包括该处)。
其语法格式如下

index(obj,start=0,end=-1)

# 查找列表中元素的值
list2 = ['教育', '学堂', '程序员', '学堂']
print(list2.index('学堂'))
print(list2.index('学堂', 2))
print(list2.index('学堂', 1, 3))
print(list2[2:-1])

（12）元素排序

如果需要对列表中的元素进行排序，则可以使用sort()函数对列表操作时，reverse()函数可以将列表中的元素反转（也称为逆序)

list3 = [5, 9, 4, 7, 1, 8, 2]
list3.sort()
print(list3)
list3.sort(reverse=True)
print(list3)

list4 = ['教育', '学堂', '程序员']
list4.reverse()
print(list4)

(13)统计元素个数

count()函数可以统计列表中某个元素的个数

list4 = ['教育', '学堂', '程序员', '学堂']
print(list4.count('学堂'))

(14)列表推导式

[表达式1 for k in L if 表达式2]
等价于：
list=[]
for k in L :
   if 表达式2:
       list.append(表达式1)

l1 = sum([n for n in range(1, 101) if n % 2 != 0])
print(l1)
lit4 = ['春风', '不解风情', '吹动', '少年', '的心']
lit5 = [l for l in lit4 for i in range(2)]
print(lit5)

九、元组

元组与列表类似，也是一种序列，不同之处在于元组中元素不能被改变，并且使用小括号中的一系列元素

（1）元组的创建

创建元组的语法非常简单，只需用逗号将元素隔开

tuple1 = (1, 2, 3, 4)
tuple2 = ('青春', 18, 100)
tuple3 = ()  # 创建空元组
tuple4 = (1,)  # 创建只有一个元素的元组 注意此处逗号必须添加，如果省略，则相当于 在一个普通括号内输入了一个值。此处添加逗号后，就通知解释器，这是一个元组

(2) 元组的索引

元组可以使用下标索引来访问元组中的一个元素，也可以使用切片访问多个元素
注意不能通过下标索引修改元组中的元素,因为元组中元素不能被修改。

(3)元组的遍历

元组的遍历与列表的遍历类似，都可以通过for循环实现

# for循环

tuple5 = ('春风', '不解风情', '吹动', '少年', '的心')
for name in tuple5:
    print(name)

#  while 循环

k, cd = 0, len(tuple5)
while k < cd:
    print(tuple5[k], end=' ')
    k += 1

(4) 元组的运算

运算符	说明
+	元组连接
*	重复元组元素
[ ]	索引元组中的字符
[ : ]	对元组行切片
in	如果元组中包含给定元素，返回True
not in	如果元组中包含给定元素，返回False

(5)元组与列表转换

list()函数可以将元组转换为列表，而tuple()函数可以将列表转换为元组

tuple6 = ('春风', '不解风情', '吹动', '少年', '的心')
list6 = list(tuple6)
print(list6)
tuple7 = tuple(list6)
print(tuple7)

（6）元组的修改

不可直接修改,可将需要修改的元组转换为列表，通过修改列表的方法修改，完成后再转换回元组

练习：1.六位评委打分，去除最低分和最高分平均成绩为最终成绩

df = []  # 创建空列表用以储存数据
for i in range(1, 7):  # 对六位评委输入成绩进行遍历
    num = float(input('%d号评委打分：' % i))
    df.append(num)  # 将得分添加到列表中
min = min(df)  # 找到列表中得最大值
max = max(df)  # 找到列表中得最小值
df.remove(min)  # 去除最小值
df.remove(max)
a = sum(df) / len(df)
print('学生的成绩为：%.2f' % a)

练习：2求100~999所有的水仙花数

# (1) 使用for循环
for i in range(100, 1000):
    # 取百位数字 123//100=1
    x = i // 100
    # 取十位数字 123//10%10=2
    y = i // 10 % 10
    # 取个位数字
    z = i % 10
    if x ** 3 + y ** 3 + z ** 3 == i:
        print('%d是水仙花数' % i)
#  (2) 使用while循环
n = 100
while n < 1000:
    x = n // 100
    y = n // 10 % 10
    z = n % 10
    if x ** 3 + y ** 3 + z ** 3 == n:
        print('%d是水仙花数' % n)
    n += 1

练习：3.成绩评测系统

while True:
    score = int(input('请输入分数'))
    # 定义退出
    if score == 1:
        print('结束检测')
        break
    if 90 <= score <= 100:
        print("学神：成绩爆表！")
    elif 80 <= score < 90:
        print("学霸：成绩优秀！")
    elif 60 <= score < 80:
        print("学民：成绩及格！")
    elif 0 <= score < 60:
        print("学渣：成绩堪忧！")
    else:
        print("成绩有误！")
    print("您的分数为%d" % score)

十、字典

（1）字典的概念

字典是由元素构成，其中每个元素都是一个键值对

注意：1.字典中的元素是以键值对的形式出现的。
2.键不能重复，而值可以重复。
3.键是不可变数据类型，而值可以是任意数据类型。

(2)字典的创建

dict1 = {}  # 创建一个空字典
print(dict1)

# 第一种 方式
a1 = [('青春', '奋斗'), ('name', 'everyone')]
dict2 = dict(a1)
print(dict2)

# 第二种 方式
d = dict(name='time', key='like')
print(d)

# 第三种 方式
dict3 = {'name': 'me', ('my', '青春'): 'miss'}
print(dict3)

(3)计算元素的个数（通过len()函数来获取）

dict3 = {'name': 'me', ('my', '青春'): 'miss'}
print(len(dict3))

(4) 访问元素值

列表与元组是通过下标索引访问元素值，字典则是通过元素的键来访问值

# 第 1 种：直接通过键来访问值
dict3 = {'name': 'me', ('my', '青春'): 'miss'}
print(dict3['name'])
# print(dict3[6])   #访问不存在的键会报错

#  第 2 种：使用get()函数访问
dict3 = {'name': 'me', ('my', '青春'): 'miss'}
print(dict3.get('my'))
print(dict3.get('6'))  # 访问不存在的键会返回 NONE

（5）修改元素值（通过键修改值）

dict4 = {'name': 'me', ('my', '青春'): 'miss'}
dict4['name'] = 'she'
print(dict4)

（6）添加元素

# 第一种 ：通过修改值时，如果键不存在，则会在字典中添加该键值对，默认添加到末尾
dict4 = {'name': 'me', ('my', '青春'): 'miss'}
dict4[('if',)] = '有那么一首歌'
print(dict4)

# 第二种:通过update()函数修改某键对应的值或添加元素 ,默认添加到末尾
dict5 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
h = {33: '四季'}
dict5.update(h)
print(dict5)

（6）删除元素

a.删除字典中的元素可以通过 “del字典名[键]”实现，会释放内存空间

k = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
del k['name']
print(k)

b.通过clear()函数删除（清空）字典中所有元素，不会释放内存空间

k1 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
k1.clear()
print(k1)

c.popitem()函数可以随机返回并删除最后一个元素，返回后以元组的形式输出

k2 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
i = k2.popitem()
print(i, k2)

d.pop()函数可以根据指定的键删除元素

k3 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
o = k3.pop(('my', '青春'))
print(o, k3)

(7)复制字典，通过copy()函数来实现

k4 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
p = k4.copy()
print(p)

(8) 成员运算 (in , not in)

k4 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
print('name' in k4)
print(('if',) not in k4)

(9)设置默认键值对,使用setdefault(键,值)函数如果键值对不在字典中，则会自动添加到末尾

k5 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌'}
u = k5.setdefault('wayback', 'home')
print(u, k5)

(10) 获取字典中所有键通过keys()函数可以获取字典中所有键

# 1.
k6 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌', 'wayback': 'home'}
print(k6.keys())
# 2.
for key in k6.keys():
    print(key, end=' ')
# 3.
for key in k6:
    print(key, end=' ')

（11）获取字典中所有的值通过values()函数可以获取字典中所有值

k6 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌', 'wayback': 'home'}
# 1.
print(k6.values())
# 2. 通过for循环
for value in k6.values():
    print(k6)

(12)获取字典中所有的键值对通过items()函数可以获取字典中所有的键值对

k6 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌', 'wayback': 'home'}
# 1.
print(k6.items())
# 2. 通过for循环
for item in k6.items():
    print(k6)

(13)遍历字典中的所有键值对

k6 = {'name': 'me', ('my', '青春'): 'miss', ('if',): '有那么一首歌', 'wayback': 'home'}
for key, value in k6.items():
    print('key = %s,value = %s' % (key, value))

(14) 练习题

lis = [{'姓名': '张三', '年龄': 15, '分数': 77},
       {'姓名': '李四', '年龄': 16, '分数': 89},
       {'姓名': '老王', '年龄': 17, '分数': 91},
       {'姓名': '老林', '年龄': 18, '分数': 98},
       {'姓名': '小张', '年龄': 19, '分数': 99},
       {'姓名': '小马', '年龄': 20, '分数': 100}]
n = len(lis)
for i in range(n - 1):
    for j in range(n - i - 1):
        if lis[j]['分数'] < lis[j + 1]['分数']:
            lis[j], lis[j + 1] = lis[j + 1], lis[j]
'''使用了两层循环，外层循环控制排序次数，内层循环用来在相邻的元素中比较'分数'键的大小。
如果发现逆序，则将相邻的元素交换位置。通过多次交换，将最大的元素逐渐冒泡到最右侧，
最终实现了按照'分数'键进行降序排序的目的。'''
for k in lis:  # 使用遍历对列表中的内容逐行打印
    print(k)
#
n = len(lis)
for i in range(n - 1):
    for j in range(n - i - 1):
        if lis[j]['年龄'] < lis[j + 1]['年龄']:
            lis[j], lis[j + 1] = lis[j + 1], lis[j]
for l in lis:  # 使用遍历对列表中的内容逐行打印
    print(l)

十一、集合

概念：集合是由一组无序排列且不重复的元素组成的。
.集合使用大括号表示，元素类型可以是数字类型，字符串，元组但不能是列表和字典。
使用大括号创建的集合属于可变集合，既可以添加或删除元素，此外,还存在一种不可变集合，即不允许添加或删除元素。

set1 = {2, [0, '2']}  # 错误，集合中有列表
set2 = {2, {'A', 8}}  # 错误，集合中有字典
set3 = {2, ('name', 6)}  # 正确，元素包含元组

(1)添加元素

①.add()函数

set4, set5 = {'青', '春'},{'是', '那么', '美好'}
set4.add(',')
print(set4)

②.update()函数

set4.update(set5)
print(set4)

(3) 删除元素

集合中删除元素可以使用remove()，discard()函数,clear()函数
set.remove(要删除的元素) #删除不存在的元素会报错
set.discard(要删除的元素) # 删除不存在的元素不会报错
set.clear() 清空集合，不释放内存空间

set6 = {1, 2, 3, 4, 5}
set6.remove(3)
print(set6)
set6.discard(4)
print(set6)
set6.remove(6)
print(set6)
set6.discard(9)
print(set6)
set6.clear()
print(set6)

(4) 集合间的运算

运算	说明
x in set1	检测x是否在集合set1中
set1 == set2	判断集合是否相等
set1 <= set2	判断set1是否是set2的子集
set < set2	判断set1是否是set2的真子集
set >= set2	判断set1是否是set2的超集

# 取2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取差集后，原有set1的内容：{set1}")
print(f"取差集后，原有set2的内容：{set2}")


# 消除2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果：{set1}")
print(f"消除差集后，集合2结果：{set2}")

# 2个集合合并为1个
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果：{set3}")
print(f"合并后集合1：{set1}")
print(f"合并后集合2：{set2}")

(5) 集合常用功能总结

编号	操作	说明
1	集合.add(元素)	集合内添加一个元素
2	集合.remove(元素)	移除集合内指定的元素
3	集合.pop()	从集合中随机取出一个元素
4	集合.clear()	将集合清空
5	集合1.difference(集合2)	得到一个新集合，内含2个集合的差集原有的2个集合内容不变
6	集合1.difference_update(集合2)	在集合1中，删除集合2中存在的元素集合1被修改，集合2不变
7	集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素原有的2个集合内容不变
8	len(集合)	得到一个整数，记录了集合的元素数量

（6）集合的遍历

集合不支持下标索引，不能用while循环
可以用for循环

set1 = {1, 2, 3, 4, 5}
for element in set1:
    print(f"集合的元素有：{element}")

（7）统计集合元素数量len()

set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量有：{num}个")

（8）集合的存储原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4JNUftTZ-1687660802300)(null)]

（9）元素必须可哈希

因存储原理，集合的元素必须是可哈希的值，即：内部通过通过哈希函数把值转换成一个数字。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RtH997LG-1687660802193)(null)]

目前可哈希的数据类型：int、bool、str、tuple，而list、set是不可哈希的。

总结：集合的元素只能是 int、bool、str、tuple 。

转换成功

v1 = [11,22,33,11,3,99,22]
v2 = set(v1)
print(v2) # {11,22,33,3,99}

转换失败

v1 = [11,22,["alex","eric"],33]
v2 = set(v1) # 报错 
print(v2)

（10）查找速度特别快

因存储原理特殊，集合的查找效率非常高（数据量大了才明显）。

低

user_list = ["武沛齐","alex","李璐"]
if "alex" in user_list:
    print("在")
else:
    print("不在")
    
    
user_tuple = ("武沛齐","alex","李璐")
if "alex" in user_tuple:
    print("在")
else:
    print("不在")

效率高

user_set = {"武沛齐","alex","李璐"}
if "alex" in user_set:
    print("在")
else:
    print("不在")

（11）对比和嵌套

类型	是否可变	是否有序	元素要求	是否可哈希	转换	定义空
list	是	是	无	否	list(其他)	`v=[]或v=list()`
tuple	否	是	无	是	tuple(其他)	`v=()或v=tuple()`
set	是	否	可哈希	否	set(其他)	`v=set()`

data_list = [
    "alex",
    11,
    (11, 22, 33, {"alex", "eric"}, 22),
    [11, 22, 33, 22],
    {11, 22, (True, ["中国", "北京"], "沙河"), 33}
]

注意：由于True和False本质上存储的是 1 和 0 ，而集合又不允许重复，所以在整数 0、1和False、True出现在集合中会有如下现象：

v1 = {True, 1}
print(v1)  # {True}

v2 = {1, True}
print(v2)  # {1}

v3 = {0, False}
print(v3)  # {0}

v4 = {False, 0}
print(v4)  # {False}

十二、函数

(1) 变量作用域

变量作⽤域指的是变量⽣效的范围，主要分为两类：局部变量和全局变量。

局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部⽣效

def testA():
  a = 100 
  print(a)  
    
  testA() # 100 
  print(a) # 报错：name 'a' is not defined

变量a是定义在 testA 函数内部的变量，在函数外部访问则⽴即报错。

全局变量

所谓全局变量，指的是在函数体内、外都能⽣效的变量。

思考：如果有⼀个数据，在函数A和函数B中都要使⽤，该怎么办？

答：将这个数据存储在⼀个全局变量⾥⾯

 #定义全局变量a 
 a = 100 
def testA():
    print(a) # 访问全局变量a，并打印变量a存储的数据
def testB():
    print(a) # 访问全局变量a，并打印变量a存储的数据

testA() # 100
testB() # 100

思考： testB 函数需求修改变量a的值为200，如何修改程序

 a= 100 

def testA():
   print(a)

def testB():
   a = 200 
   print(a) 
 
testA() # 100
testB() # 200 
print(f'全局变量a = {a}') # 全局变量a = 100

思考：在 testB 函数内部的 a = 200 中的变量a是在修改全局变量 a 吗？

答：不是。观察上述代码发现，15⾏得到a的数据是100，仍然是定义全局变量a时候的值，⽽没有返回testB 函数内部的200。综上： testB 函数内部的 a = 200 是定义了⼀个局部变量。

思考：如何在函数体内部修改全局变量？

a = 100

def testA():
    print(a)
def testB():
    # global 关键字声明a是全局变量量
    global a
    a = 200
    print(a)
testA()  # 100
testB()  # 200
print(f'全局变量量a = {a}')  # 全局变量量a = 200

（2）多函数程序执行流程

一般在实际开发过程中，一个程序往往由多个函数组成，并且多个函数共享某些数据，如下所示：

共用全局变量量

# 1. 定义全局变量量
glo_num = 0

def test1():
    global glo_num
    # 修改全局变量量
    glo_num = 100

def test2():
    # 调⽤用test1函数中修改后的全局变量量
    print(glo_num)
    

# 2. 调⽤用test1函数，执⾏行行函数内部代码：声明和修改全局变量量
test1()
# 3. 调⽤用test2函数，执⾏行行函数内部代码：打印
test2()  # 100

返回值作为参数传递

def test1():
    return 50

def test2(num):
    print(num)

# 1. 保存函数test1的返回值
result = test1()

# 2.将函数返回值所在变量量作为参数传递到test2函数
test2(result)  # 50

（3）函数的返回值

思考：如果⼀个函数如些两个return (如下所示)，程序如何执行？

def return_num():
    return 1
    return 2

result = return_num()
print(result)  # 1

答：只执行了了第一个return，原因是因为return可以退出当前函数，导致return下⽅方的代码不不执行。

思考：如果一个函数要有多个返回值，该如何书写代码？

def return_num():
    return 1, 2

result = return_num()
print(result)  # (1, 2)

注意：

return a, b写法，返回多个数据的时候，默认是元组类型。
return后⾯面可以连接列列表、元组或字典，以返回多个值。

（4）函数的参数

1 .位置参数

位置参数：调⽤用函数时根据函数定义的参数位置来传递参数。

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年年龄是{age}, 性别是{gender}')

user_info('TOM', 20, '男')

注意：传递和定义参数的顺序及个数必须⼀致。

2 .关键字参数

函数调⽤用，通过“键=值”形式加以指定。可以让函数更更加清晰、容易易使⽤用，同时也清除了了参数的顺序需求。

def user_info(name, age, gender):
    print(f'您的名字是{name}, 年年龄是{age}, 性别是{gender}')

user_info('Rose', age=20, gender='⼥女女')
user_info('⼩小明', gender='男', age=16)

注意：函数调⽤用时，如果有位置参数时，位置参数必须在关键字参数的前⾯面，但关键字参数之间不不存在先后顺序。

3 .缺省参数

缺省参数也叫默认参数，⽤用于定义函数，为参数提供默认值，调⽤用函数时可不不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调⽤用）。

def user_info(name, age, gender='男'):
    print(f'您的名字是{name}, 年年龄是{age}, 性别是{gender}')

user_info('TOM', 20)
user_info('Rose', 18, '⼥女女')

注意：函数调⽤用时，如果为缺省参数传值则修改默认参数值；否则使⽤用这个默认值。

4.不定长参数

不定长参数也叫可变参数。⽤用于不确定调用的时候会传递多少个参数(不传参也可以)的场景。

*P 传递

def user_info(*args):
    print(args)

# ('TOM',)
user_info('TOM')
# ('TOM', 18)
user_info('TOM', 18)

注意：传进的所有参数都会被args变量量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型

**P 传递

def user_info(**kwargs):
    print(kwargs)

# {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM', age=18, id=110)

注意：以字典的形式传递

（5）总结

变量量作⽤用域

全局：函数体内外都能⽣生效

局部：当前函数体内部⽣生效

函数多返回值写法
函数的参数

位置参数形参和实参的个数和书写顺序必须⼀一致

关键字参数写法： key=value,特点：形参和实参的书写顺序可以不不⼀一致；关键字参数必须书写在位置参数的后⾯面

缺省参数 1 return 表达式1, 表达式2…

缺省参数就是默认参数
写法： key=vlaue
不定长位置参数
收集所有位置参数，返回⼀个元组
不定长关键字参数
收集所有关键字参数，返回⼀一个字典
引用：Python中，数据的传递都是通过引用

十三、.可变和不可变类型

所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变。

可变类型

列表
字典
集合

2.不可变类型

整型
浮点型
字符串
元组