Python基础知识点六万字总结，爆肝一周熬夜完成建议收藏
Posted 五包辣条！
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python基础知识点六万字总结，爆肝一周熬夜完成建议收藏相关的知识，希望对你有一定的参考价值。
大家好，我是辣条。
今天给大家带来Python基础知识点的总结，不夸张的说我一周才写完，这才是第一弹，如果大家喜欢记得三连呦，我会火速更新下一弹，争取把这个系列做完，希望得到大家的支持。
目录
注释
-
注释的分类
-
单行：
# 注释内容，快捷键ctrl+/ -
多行：
""" 注释内容 """或''' 注释内容 '''
-
-
解释器不执行注释内容
注释分为两类：==单行注释== 和 ==多行注释==。
-
单行注释
只能注释一行内容，语法如下：
# 注释内容-
多行注释
可以注释多行内容，一般用在注释一段代码的情况， 语法如下：
"""
第一行注释
第二行注释
第三行注释
"""
'''
注释1
注释2
注释3
'''快捷键： ==ctrl + /==
变量
变量就是一个存储数据的的时候当前数据所在的内存地址的名字而已。
标识符
标识符命名规则是Python中定义各种名字的时候的统一规范，具体如下：
-
由数字、字母、下划线组成
-
不能数字开头
-
不能使用内置关键字
-
严格区分大小写
命名习惯
-
见名知义。
-
大驼峰：即每个单词首字母都大写，例如：
MyName。 -
小驼峰：第二个（含）以后的单词首字母大写，例如：
myName。 -
下划线：例如：
my_name。
认识数据类型
检测数据类型的方法：
type()
a = 1
print(type(a)) # <class 'int'> -- 整型
b = 1.1
print(type(b)) # <class 'float'> -- 浮点型
c = True
print(type(c)) # <class 'bool'> -- 布尔型
d = '12345'
print(type(d)) # <class 'str'> -- 字符串
e = [10, 20, 30]
print(type(e)) # <class 'list'> -- 列表
f = (10, 20, 30)
print(type(f)) # <class 'tuple'> -- 元组
h = 10, 20, 30
print(type(h)) # <class 'set'> -- 集合
g = 'name': 'TOM', 'age': 20
print(type(g)) # <class 'dict'> -- 字典
输出
作用：程序输出内容给用户
print('hello Python')
age = 19
print(age)
# 需求：输出“今年我的年龄是19岁”格式化符号
| 格式符号 | 转换 |
|---|---|
| ==%s== | 字符串 |
| ==%d== | 有符号的十进制整数 |
| ==%f== | 浮点数 |
| %c | 字符 |
| %u | 无符号十进制整数 |
| %o | 八进制整数 |
| %x | 十六进制整数（小写ox） |
| %X | 十六进制整数（大写OX） |
| %e | 科学计数法（小写'e'） |
| %E | 科学计数法（大写'E'） |
| %g | %f和%e的简写 |
| %G | %f和%E的简写 |
转义字符
-
\\n：换行。 -
\\t：制表符，一个tab键（4个空格）的距离。
结束符
print('输出的内容', end="\\n")在Python中，print()， 默认自带
end="\\n"这个换行结束符，所以导致每两个
输入
在Python中，程序接收用户输入的数据的功能即是输入。
input("提示信息")输入的特点
-
当程序执行到
input，等待用户输入，输入完成之后才继续向下执行。 -
在Python中，
input接收用户输入后，一般存储到变量，方便使用。 -
在Python中，
input会把接收到的任意用户输入的数据都当做字符串处理。
转换数据类型
| 函数 | 说明 |
|---|---|
| ==int(x [,base ])== | 将x转换为一个整数 |
| ==float(x )== | 将x转换为一个浮点数 |
| complex(real [,imag ]) | 创建一个复数，real为实部，imag为虚部 |
| ==str(x )== | 将对象 x 转换为字符串 |
| repr(x ) | 将对象 x 转换为表达式字符串 |
| ==eval(str )== | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| ==tuple(s )== | 将序列 s 转换为一个元组 |
| ==list(s )== | 将序列 s 转换为一个列表 |
| chr(x ) | 将一个整数转换为一个Unicode字符 |
| ord(x ) | 将一个字符转换为它的ASCII整数值 |
| hex(x ) | 将一个整数转换为一个十六进制字符串 |
| oct(x ) | 将一个整数转换为一个八进制字符串 |
| bin(x ) | 将一个整数转换为一个二进制字符串 |
转换数据类型常用的函数
-
int()
-
float()
-
str()
-
list()
-
tuple()
-
eval()
运算符
算数运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 | 1 + 1 输出结果为 2 |
| - | 减 | 1-1 输出结果为 0 |
| * | 乘 | 2 * 2 输出结果为 4 |
| / | 除 | 10 / 2 输出结果为 5 |
| // | 整除 | 9 // 4 输出结果为2 |
| % | 取余 | 9 % 4 输出结果为 1 |
| ** | 指数 | 2 ** 4 输出结果为 16，即 2 * 2 * 2 * 2 |
| () | 小括号 | 小括号用来提高运算优先级，即 (1 + 2) * 3 输出结果为 9 |
赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 赋值 | 将=右侧的结果赋值给等号左侧的变量 |
复合赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| += | 加法赋值运算符 | c += a 等价于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等价于 c = c- a |
| *= | 乘法赋值运算符 | c *= a 等价于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等价于 c = c / a |
| //= | 整除赋值运算符 | c //= a 等价于 c = c // a |
| %= | 取余赋值运算符 | c %= a 等价于 c = c % a |
| **= | 幂赋值运算符 | c ** = a 等价于 c = c ** a |
比较运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 判断相等。如果两个操作数的结果相等，则条件结果为真(True)，否则条件结果为假(False) | 如a=3,b=3，则（a == b) 为 True |
| != | 不等于 。如果两个操作数的结果不相等，则条件为真(True)，否则条件结果为假(False) | 如a=3,b=3，则（a == b) 为 True如a=1,b=3，则(a != b) 为 True |
| > | 运算符左侧操作数结果是否大于右侧操作数结果，如果大于，则条件为真，否则为假 | 如a=7,b=3，则(a > b) 为 True |
| < | 运算符左侧操作数结果是否小于右侧操作数结果，如果小于，则条件为真，否则为假 | 如a=7,b=3，则(a < b) 为 False |
| >= | 运算符左侧操作数结果是否大于等于右侧操作数结果，如果大于，则条件为真，否则为假 | 如a=7,b=3，则(a < b) 为 False如a=3,b=3，则(a >= b) 为 True |
| <= | 运算符左侧操作数结果是否小于等于右侧操作数结果，如果小于，则条件为真，否则为假 | 如a=3,b=3，则(a <= b) 为 True |
逻辑运算符
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与"：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。 | True and False， 返回 False。 |
| or | x or y | 布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值。 | False or True， 返回 True。 |
| not | not x | 布尔"非"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not True 返回 False, not False 返回 True |
条件语句
假设一个场景：
其实这里所谓的判断就是条件语句，即条件成立执行某些代码，条件不成立则不执行这些代码。
语法
if 条件:
条件成立执行的代码1
条件成立执行的代码2
......
if...else...
作用：条件成立执行if下方的代码; 条件不成立执行else下方的代码。
if 条件:
条件成立执行的代码1
条件成立执行的代码2
......
else:
条件不成立执行的代码1
条件不成立执行的代码2
......
实例：工龄判断
age = int(input('请输入您的年龄：'))
if age < 18:
print(f'您的年龄是age,童工一枚')
elif (age >= 18) and (age <= 60):
print(f'您的年龄是age,合法工龄')
elif age > 60:
print(f'您的年龄是age,可以退休')拓展：
age >= 18 and age <= 60可以化简为18 <= age <= 60。
if嵌套
if 条件1：
条件1成立执行的代码
条件1成立执行的代码
if 条件2：
条件2成立执行的代码
条件2成立执行的代码
应用：猜拳游戏
需求分析：
-
参与游戏的角色
-
玩家
-
手动出拳
-
-
电脑
-
随机出拳
-
-
-
判断输赢
-
玩家获胜
玩家 电脑 石头 剪刀 剪刀 布 布 石头 -
平局
-
玩家出拳 和 电脑出拳相同
-
-
电脑获胜
-
随机做法：
-
导出random模块
-
random.randint(开始,结束)
"""
提示：0-石头，1-剪刀，2-布
1. 出拳
玩家输入出拳
电脑随机出拳
2. 判断输赢
玩家获胜
平局
电脑获胜
"""
# 导入random模块
import random
# 计算电脑出拳的随机数字
computer = random.randint(0, 2)
print(computer)
player = int(input('请出拳：0-石头，1-剪刀，2-布：'))
# 玩家胜利 p0:c1 或 p1:c2 或 p2:c0
if (player == 0 and computer == 1) or (player == 1 and computer == 2) or (player == 2 and computer == 0):
print('玩家获胜')
# 平局：玩家 == 电脑
elif player == computer:
print('平局')
else:
print('电脑获胜')三目运算符
三目运算符也叫三元运算符。
语法如下：
值1 if 条件 else 值2快速体验：
a = 1
b = 2
c = a if a > b else b
print(c)
循环
循环的作用：让代码更高效的重复执行。
循环的分类
在Python中，循环分为while和for两种，最终实现效果相同。
while的语法
while 条件:
条件成立重复执行的代码1
条件成立重复执行的代码2
......
while的应用
计算1-100累加和
分析：1-100的累加和，即1 + 2 + 3 + 4 +….，即前两个数字的相加结果 + 下一个数字( 前一个数字 + 1)。
i = 1
result = 0
while i <= 100:
result += i
i += 1
# 输出5050
print(result)注意：为了验证程序的准确性，可以先改小数值，验证结果正确后，再改成1-100做累加。
计算1-100偶数累加和
分析：1-100的偶数和，即 2 + 4 + 6 + 8....，得到偶数的方法如下：
-
偶数即是和2取余结果为0的数字，可以加入条件语句判断是否为偶数，为偶数则累加
-
初始值为0 / 2 , 计数器每次累加2
方法一：条件判断和2取余数则累加
# 方法一：条件判断和2取余数为0则累加计算
i = 1
result = 0
while i <= 100:
if i % 2 == 0:
result += i
i += 1
# 输出2550
print(result)方法二：计数器控制
# 方法二：计数器控制增量为2
i = 0
result = 0
while i <= 100:
result += i
i += 2
# 输出2550
print(result)while循环嵌套
故事梗概：有天女朋友又生气了，惩罚：说3遍“媳妇儿， 我错了”，这个程序是不是循环即可？但如果女朋友说：还要刷今天晚饭的碗，这个程序怎么书写？
while 条件:
print('媳妇儿， 我错了')
print('刷晚饭的碗')但如果女朋友还是生气，把这套惩罚要连续3天都执行，有如何书写程序？
while 条件:
while 条件:
print('媳妇儿， 我错了')
print('刷晚饭的碗')while 条件1:
条件1成立执行的代码
......
while 条件2:
条件2成立执行的代码
......总结：所谓while循环嵌套，就是一个while里面嵌套一个while的写法，每个while和之前的基础语法是相同的。
for循环
语法
for 临时变量 in 序列:
重复执行的代码1
重复执行的代码2
......else
循环可以和else配合使用，else下方缩进的代码指的是==当循环正常结束之后要执行的代码==。
while...else
需求：女朋友生气了，要惩罚：连续说5遍“媳妇儿，我错了”，如果道歉正常完毕女朋友就原谅我了，这个程序怎么写？
i = 1
while i <= 5:
print('媳妇儿，我错了')
i += 1
print('媳妇儿原谅我了...')思考： 这个print是不是没有循环也能执行？
语法
while 条件:
条件成立重复执行的代码
else:
循环正常结束之后要执行的代码示例
i = 1
while i <= 5:
print('媳妇儿，我错了')
i += 1
else:
print('媳妇原谅我了，真开心，哈哈哈哈')
for...else
语法
for 临时变量 in 序列:
重复执行的代码
...
else:
循环正常结束之后要执行的代码所谓else指的是循环正常结束之后要执行的代码，即如果是break终止循环的情况，else下方缩进的代码将不执行。
示例
str1 = 'itheima'
for i in str1:
print(i)
else:
print('循环正常结束之后执行的代码')总结
-
循环的作用：控制代码重复执行
-
while语法
while 条件:
条件成立重复执行的代码1
条件成立重复执行的代码2
......-
while循环嵌套语法
while 条件1:
条件1成立执行的代码
......
while 条件2:
条件2成立执行的代码
......-
for循环语法
for 临时变量 in 序列:
重复执行的代码1
重复执行的代码2
......-
break退出整个循环
-
continue退出本次循环，继续执行下一次重复执行的代码
-
else
-
while和for都可以配合else使用
-
else下方缩进的代码含义：当循环正常结束后执行的代码
-
break终止循环不会执行else下方缩进的代码
-
continue退出循环的方式执行else下方缩进的代码
-
字符串
字符串是 Python 中最常用的数据类型。我们一般使用引号来创建字符串。创建字符串很简单，只要为变量分配一个值即可。
a = 'hello world'
b = "abcdefg"
print(type(a))
print(type(b))注意：控制台显示结果为
<class 'str'>， 即数据类型为str(字符串)。
字符串输出
print('hello world')
name = 'Tom'
print('我的名字是%s' % name)
print(f'我的名字是name')字符串输入
在Python中，使用input()接收用户输入。
-
代码
name = input('请输入您的名字：') print(f'您输入的名字是name') print(type(name)) password = input('请输入您的密码：') print(f'您输入的密码是password') print(type(password))
切片
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
语法
序列[开始位置下标:结束位置下标:步长]注意
-
不包含结束位置下标对应的数据， 正负整数均可；
-
步长是选取间隔，正负整数均可，默认步长为1。
体验
name = "abcdefg"
print(name[2:5:1]) # cde
print(name[2:5]) # cde
print(name[:5]) # abcde
print(name[1:]) # bcdefg
print(name[:]) # abcdefg
print(name[::2]) # aceg
print(name[:-1]) # abcdef, 负1表示倒数第一个数据
print(name[-4:-1]) # def
print(name[::-1]) # gfedcba修改
所谓修改字符串，指的就是通过函数的形式修改字符串中的数据。
-
replace()：替换
-
语法
字符串序列.replace(旧子串, 新子串, 替换次数)注意：替换次数如果查出子串出现次数，则替换次数为该子串出现次数。
-
快速体验
mystr = "hello world and itcast and itheima and Python"
# 结果：hello world he itcast he itheima he Python
print(mystr.replace('and', 'he'))
# 结果：hello world he itcast he itheima he Python
print(mystr.replace('and', 'he', 10))
# 结果：hello world and itcast and itheima and Python
print(mystr)注意：数据按照是否能直接修改分为==可变类型==和==不可变类型==两种。字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。
-
split()：按照指定字符分割字符串。
-
语法
字符串序列.split(分割字符, num)注意：num表示的是分割字符出现的次数，即将来返回数据个数为num+1个。
-
快速体验
mystr = "hello world and itcast and itheima and Python"
# 结果：['hello world ', ' itcast ', ' itheima ', ' Python']
print(mystr.split('and'))
# 结果：['hello world ', ' itcast ', ' itheima and Python']
print(mystr.split('and', 2))
# 结果：['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']
print(mystr.split(' '))
# 结果：['hello', 'world', 'and itcast and itheima and Python']
print(mystr.split(' ', 2))注意：如果分割字符是原有字符串中的子串，分割后则丢失该子串。
-
join()：用一个字符或子串合并字符串，即是将多个字符串合并为一个新的字符串。
-
语法
字符或子串.join(多字符串组成的序列)-
快速体验
list1 = ['chuan', 'zhi', 'bo', 'ke']
t1 = ('aa', 'b', 'cc', 'ddd')
# 结果：chuan_zhi_bo_ke
print('_'.join(list1))
# 结果：aa...b...cc...ddd
print('...'.join(t1))-
capitalize()：将字符串第一个字符转换成大写。
mystr = "hello world and itcast and itheima and Python"
# 结果：Hello world and itcast and itheima and python
print(mystr.capitalize())注意：capitalize()函数转换后，只字符串第一个字符大写，其他的字符全都小写。
-
title()：将字符串每个单词首字母转换成大写。
mystr = "hello world and itcast and itheima and Python"
# 结果：Hello World And Itcast And Itheima And Python
print(mystr.title())-
lower()：将字符串中大写转小写。
mystr = "hello world and itcast and itheima and Python"
# 结果：hello world and itcast and itheima and python
print(mystr.lower())-
upper()：将字符串中小写转大写。
mystr = "hello world and itcast and itheima and Python"
# 结果：HELLO WORLD AND ITCAST AND ITHEIMA AND PYTHON
print(mystr.upper())判断
所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False。
-
startswith()：检查字符串是否是以指定子串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
-
语法
字符串序列.startswith(子串, 开始位置下标, 结束位置下标)-
快速体验
mystr = "hello world and itcast and itheima and Python "
# 结果：True
print(mystr.startswith('hello'))
# 结果False
print(mystr.startswith('hello', 5, 20))-
endswith()：：检查字符串是否是以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
-
语法
字符串序列.endswith(子串, 开始位置下标, 结束位置下标)-
快速体验
mystr = "hello world and itcast and itheima and Python"
# 结果：True
print(mystr.endswith('Python'))
# 结果：False
print(mystr.endswith('python'))
# 结果：False
print(mystr.endswith('Python', 2, 20))-
isalpha()：如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False。
mystr1 = 'hello'
mystr2 = 'hello12345'
# 结果：True
print(mystr1.isalpha())
# 结果：False
print(mystr2.isalpha())-
isdigit()：如果字符串只包含数字则返回 True 否则返回 False。
mystr1 = 'aaa12345'
mystr2 = '12345'
# 结果： False
print(mystr1.isdigit())
# 结果：False
print(mystr2.isdigit())-
isalnum()：如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False。
mystr1 = 'aaa12345'
mystr2 = '12345-'
# 结果：True
print(mystr1.isalnum())
# 结果：False
print(mystr2.isalnum())-
isspace()：如果字符串中只包含空白，则返回 True，否则返回 False。
mystr1 = '1 2 3 4 5'
mystr2 = ' '
# 结果：False
print(mystr1.isspace())
# 结果：True
print(mystr2.isspace())总结
-
下标
-
计算机为数据序列中每个元素分配的从0开始的编号
-
-
切片
序列名[开始位置下标:结束位置下标:步长]-
常用操作方法
-
find()
-
index()
-
列表
思考：有一个人的姓名(TOM)怎么书写存储程序？
答：变量。
思考：如果一个班级100位学生，每个人的姓名都要存储，应该如何书写程序？声明100个变量吗？
答：列表即可， 列表一次性可以存储多个数据。
列表的格式
[数据1, 数据2, 数据3, 数据4......]列表可以一次性存储多个数据，且可以为不同数据类型。
列表的常用操作
列表的作用是一次性存储多个数据，程序员可以对这些数据进行的操作有：增、删、改、查。
查找
下标
name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) # Tom
print(name_list[1]) # Lily
print(name_list[2]) # Rose函数
-
index()：返回指定数据所在位置的下标 。
-
语法
列表序列.index(数据, 开始位置下标, 结束位置下标)-
快速体验
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2)) # 1注意：如果查找的数据不存在则报错。
-
count()：统计指定数据在当前列表中出现的次数。
name_list = ['Tom', 'Lily', 'Rose']
print(name_list.count('Lily')) # 1-
len()：访问列表长度，即列表中数据的个数。
name_list = ['Tom', 'Lily', 'Rose']
print(len(name_list)) # 3判断是否存在
-
in：判断指定数据在某个列表序列，如果在返回True，否则返回False
name_list = ['Tom', 'Lily', 'Rose']
# 结果：True
print('Lily' in name_list)
# 结果：False
print('Lilys' in name_list)-
not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False
name_list = ['Tom', 'Lily', 'Rose']
# 结果：False
print('Lily' not in name_list)
# 结果：True
print('Lilys' not in name_list)-
体验案例
需求：查找用户输入的名字是否已经存在。
name_list = ['Tom', 'Lily', 'Rose']
name = input('请输入您要搜索的名字：')
if name in name_list:
print(f'您输入的名字是name, 名字已经存在')
else:
print(f'您输入的名字是name, 名字不存在')增加
作用：增加指定数据到列表中。
-
append()：列表结尾追加数据。
-
语法
列表序列.append(数据)-
体验
name_list = ['Tom', 'Lily', 'Rose']
name_list.append('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming']
print(name_list)列表追加数据的时候，直接在原列表里面追加了指定数据，即修改了原列表，故列表为可变类型数据。
-
注意点
如果append()追加的数据是一个序列，则追加整个序列到列表
name_list = ['Tom', 'Lily', 'Rose']
name_list.append(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
print(name_list)-
extend()：列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表。
-
语法
列表序列.extend(数据)-
快速体验
2.1 单个数据
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend('xiaoming')
# 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
print(name_list)2.2 序列数据
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend(['xiaoming', 'xiaohong'])
# 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
print(name_list)-
insert()：指定位置新增数据。
-
语法
列表序列.insert(位置下标, 数据)-
快速体验
name_list = ['Tom', 'Lily', 'Rose']
name_list.insert(1, 'xiaoming')
# 结果：['Tom', 'xiaoming', 'Lily', 'Rose']
print(name_list)删除
-
del
-
语法
del 目标快速体验
删除列表
name_list = ['Tom', 'Lily', 'Rose']
# 结果：报错提示：name 'name_list' is not defined
del name_list
print(name_list)删除指定数据
name_list = ['Tom', 'Lily', 'Rose']
del name_list[0]
# 结果：['Lily', 'Rose']
print(name_list)-
pop()：删除指定下标的数据(默认为最后一个)，并返回该数据。
-
语法
列表序列.pop(下标)-
快速体验
name_list = ['Tom', 'Lily', 'Rose']
del_name = name_list.pop(1)
# 结果：Lily
print(del_name)
# 结果：['Tom', 'Rose']
print(name_list)-
remove()：移除列表中某个数据的第一个匹配项。
-
语法
列表序列.remove(数据)-
快速体验
name_list = ['Tom', 'Lily', 'Rose']
name_list.remove('Rose')
# 结果：['Tom', 'Lily']
print(name_list)-
clear()：清空列表
name_list = ['Tom', 'Lily', 'Rose']
name_list.clear()
print(name_list) # 结果： []修改
-
修改指定下标数据
name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'aaa'
# 结果：['aaa', 'Lily', 'Rose']
print(name_list)-
逆置：reverse()
num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
# 结果：[8, 6, 3, 2, 5, 1]
print(num_list)-
排序：sort()
-
语法
列表序列.sort( key=None, reverse=False)注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）
-
快速体验
num_list = [1, 5, 2, 3, 6, 8]
num_list.sort()
# 结果：[1, 2, 3, 5, 6, 8]
print(num_list)复制
函数：copy()
name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
# 结果：['Tom', 'Lily', 'Rose']
print(name_li2)
列表嵌套
所谓列表嵌套指的就是一个列表里面包含了其他的子列表。
应用场景：要存储班级一、二、三三个班级学生姓名，且每个班级的学生姓名在一个列表。
name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]思考： 如何查找到数据"李四"？
# 第一步：按下标查找到李四所在的列表
print(name_list[2])
# 第二步：从李四所在的列表里面，再按下标找到数据李四
print(name_list[2][1])
总结
-
列表的格式
[数据1, 数据2, 数据3]-
常用操作方法
-
index()
-
len()
-
append()
-
pop()
-
remove()
-
-
列表嵌套
name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]
name_list[2][1]
元组
思考：如果想要存储多个数据，但是这些数据是不能修改的数据，怎么做？
答：列表？列表可以一次性存储多个数据，但是列表中的数据允许更改。
num_list = [10, 20, 30]
num_list[0] = 100==一个元组可以存储多个数据，元组内的数据是不能修改的。==
定义元组
元组特点：定义元组使用==小括号==，且==逗号==隔开各个数据，数据可以是不同的数据类型。
# 多个数据元组
t1 = (10, 20, 30)
# 单个数据元组
t2 = (10,)注意：如果定义的元组只有一个数据，那么这个数据后面也好添加逗号，否则数据类型为唯一的这个数据的数据类型
t2 = (10,)
print(type(t2)) # tuple
t3 = (20)
print(type(t3)) # int
t4 = ('hello')
print(type(t4)) # str元组的常见操作
元组数据不支持修改，只支持查找，具体如下：
-
按下标查找数据
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) # aa-
index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index方法相同。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.index('aa')) # 0-
count()：统计某个数据在当前元组出现的次数。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1.count('bb')) # 2-
len()：统计元组中数据的个数。
tuple1 = ('aa', 'bb', 'cc', 'bb')
print(len(tuple1)) # 4注意：元组内的直接数据如果修改则立即报错
tuple1 = ('aa', 'bb', 'cc', 'bb')
tuple1[0] = 'aaa'但是如果元组里面有列表，修改列表里面的数据则是支持的，故自觉很重要。
tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple2[2]) # 访问到列表
# 结果：(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple2[2][0] = 'aaaaa'
print(tuple2)总结
-
定义元组
t1 = (10, 20, 30)
t2 = (10,)-
常用操作方法
-
index()
-
len()
-
字典
思考1： 如果有多个数据，例如：'Tom', '男', 20，如何快速存储？
答：列表
list1 = ['Tom', '男', 20]思考2：如何查找到数据'Tom'？
答：查找到下标为0的数据即可。
list1[0]思考3：如果将来数据顺序发生变化，如下所示，还能用list1[0]访问到数据'Tom'吗？。
list1 = ['男', 20, 'Tom']答：不能，数据'Tom'此时下标为2。
思考4：数据顺序发生变化，每个数据的下标也会随之变化，如何保证数据顺序变化前后能使用同一的标准查找数据呢？
答：字典，字典里面的数据是以==键值对==形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可。
创建字典的语法
字典特点：
-
符号为==大括号==
-
数据为==键值对==形式出现
-
各个键值对之间用==逗号==隔开
# 有数据字典
dict1 = 'name': 'Tom', 'age': 20, 'gender': '男'
# 空字典
dict2 =
dict3 = dict()注意：一般称冒号前面的为键(key)，简称k；冒号后面的为值(value)，简称v。
字典常见操作
增
写法：==字典序列[key] = 值==
注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。
dict1 = 'name': 'Tom', 'age': 20, 'gender': '男'
dict1['name'] = 'Rose'
# 结果：'name': 'Rose', 'age': 20, 'gender': '男'
print(dict1)
dict1['id'] = 110
# 'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110
print(dict1)注意：字典为可变类型。
删
-
del() / del：删除字典或删除字典中指定键值对。
dict1 = 'name': 'Tom', 'age': 20, 'gender': '男'
del dict1['gender']
# 结果：'name': 'Tom', 'age': 20
print(dict1)-
clear()：清空字典
dict1 = 'name': 'Tom', 'age': 20, 'gender': '男'
dict1.clear()
print(dict1) # 改
写法：==字典序列[key] = 值==
注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对。
查
值查找
dict1 = 'name': 'Tom', 'age': 20, 'gender': '男'
print(dict1['name']) # Tom
print(dict1['id']) # 报错如果当前查找的key存在，则返回对应的值；否则则报错。
get()
-
语法
字典序列.get(key, 默认值)注意：如果当前查找的key不存在则返回第二个参数(默认值)，如果省略第二个参数，则返回None。
-
快速体验
dict1 = 'name': 'Tom', 'age': 20, 'gender': '男'
print(dict1.get('name')) # Tom
print(dict1.get('id', 110)) # 110
print(dict1.get('id')) # Nonekeys()
dict1 = 'name': 'Tom', 'age': 20, 'gender': '男'
print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])values()
dict1 = 'name': 'Tom', 'age': 20, 'gender': '男'
print(dict1.values()) # dict_values(['Tom', 20, '男'])items()
dict1 = 'name': 'Tom', 'age': 20, 'gender': '男'
print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])
总结
-
定义字典
dict1 = 'name': 'Python', 'age': 30
dict2 =
dict3 = dict()-
常见操作
-
增/改
-
字典序列[key] = 值-
查找
-
字典序列[key]
-
keys()
-
values()
-
items()
-
集合
创建集合
创建集合使用或set()， 但是如果要创建空集合只能使用set()，因为用来创建空字典。
s1 = 10, 20, 30, 40, 50
print(s1)
s2 = 10, 30, 20, 10, 30, 40, 30, 50
print(s2)
s3 = set('abcdefg')
print(s3)
s4 = set()
print(type(s4)) # set
s5 =
print(type(s5)) # dict特点：
集合可以去掉重复数据；
集合数据是无序的，故不支持下标
集合常见操作方法
增加数据
-
add()
s1 = 10, 20
s1.add(100)
s1.add(10)
print(s1) # 100, 10, 20因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作。
-
update(), 追加的数据是序列。
s1 = 10, 20
# s1.update(100) # 报错
s1.update([100, 200])
s1.update('abc')
print(s1)删除数据
-
remove()，删除集合中的指定数据，如果数据不存在则报错。
s1 = 10, 20
s1.remove(10)
print(s1)
s1.remove(10) # 报错
print(s1)-
discard()，删除集合中的指定数据，如果数据不存在也不会报错。
s1 = 10, 20
s1.discard(10)
print(s1)
s1.discard(10)
print(s1)-
pop()，随机删除集合中的某个数据，并返回这个数据。
s1 = 10, 20, 30, 40, 50
del_num = s1.pop()
print(del_num)
print(s1)查找数据
-
in：判断数据在集合序列
-
not in：判断数据不在集合序列
s1 = 10, 20, 30, 40, 50
print(10 in s1)
print(10 not in s1)总结
-
创建集合
-
有数据集合
s1 = 数据1, 数据2, ...-
无数据集合
s1 = set() -
-
常见操作
-
增加数据
-
add()
-
update()
-
-
删除数据
-
remove()
-
discard()
-
-
公共操作
运算符
| 运算符 | 描述 | 支持的容器类型 |
|---|---|---|
| + | 合并 | 字符串、列表、元组 |
| * | 复制 | 字符串、列表、元组 |
| in | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 元素是否不存在 | 字符串、列表、元组、字典 |
+
# 1. 字符串
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3) # aabb
# 2. 列表
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3) # [1, 2, 10, 20]
# 3. 元组
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(t3) # (10, 20, 100, 200)*
# 1. 字符串
print('-' * 10) # ----------
# 2. 列表
list1 = ['hello']
print(list1 * 4) # ['hello', 'hello', 'hello', 'hello']
# 3. 元组
t1 = ('world',)
print(t1 * 4) # ('world', 'world', 'world', 'world')in或not in
# 1. 字符串
print('a' in 'abcd') # True
print('a' not in 'abcd') # False
# 2. 列表
list1 = ['a', 'b', 'c', 'd']
print('a' in list1) # True
print('a' not in list1) # False
# 3. 元组
t1 = ('a', 'b', 'c', 'd')
print('aa' in t1) # False
print('aa' not in t1) # True公共方法
| 函数 | 描述 |
|---|---|
| len() | 计算容器中元素个数 |
| del 或 del() | 删除 |
| max() | 返回容器中元素最大值 |
| min() | 返回容器中元素最小值 |
| range(start, end, step) | 生成从start到end的数字，步长为 step，供for循环使用 |
| enumerate() | 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。 |
len()
# 1. 字符串
str1 = 'abcdefg'
print(len(str1)) # 7
# 2. 列表
list1 = [10, 20, 30, 40]
print(len(list1)) # 4
# 3. 元组
t1 = (10, 20, 30, 40, 50)
print(len(t1)) # 5
# 4. 集合
s1 = 10, 20, 30
print(len(s1)) # 3
# 5. 字典
dict1 = 'name': 'Rose', 'age': 18
print(len(dict1)) # 2del()
# 1. 字符串
str1 = 'abcdefg'
del str1
print(str1)
# 2. 列表
list1 = [10, 20, 30, 40]
del(list1[0])
print(list1) # [20, 30, 40]max()
# 1. 字符串
str1 = 'abcdefg'
print(max(str1)) # g
# 2. 列表
list1 = [10, 20, 30, 40]
print(max(list1)) # 40min()
# 1. 字符串
str1 = 'abcdefg'
print(min(str1)) # a
# 2. 列表
list1 = [10, 20, 30, 40]
print(min(list1)) # 10range()
# 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):
print(i)
# 1 3 5 7 9
for i in range(1, 10, 2):
print(i)
# 0 1 2 3 4 5 6 7 8 9
for i in range(10):以上是关于Python基础知识点六万字总结，爆肝一周熬夜完成建议收藏的主要内容，如果未能解决你的问题，请参考以下文章
爆肝一周面试10多家中大厂后的万字总结——❤️JavaWeb篇❤️（建议收藏）