目录
eval函数
数值类型
字符串的三种定义方式
字符串的引号嵌套：
字符串拼接
字符串格式化——数字精度控制
字符串格式化——快速格式化
对表达式进行格式化
range语句
函数
global关键字
数据容器
列表
列表的查询方法
插入元素
追加元素
删除元素
删除某元素在列表中的第一个匹配项
清空列表内容
统计某元素在列表中的数量
统计列表中有多少元素
元组
字符串
字符串的替换
字符串的分割
字符串的规整操作
序列
序列的常用操作——切片
集合（set）
集合的常用操作——修改
添加新元素
移除元素
从集合中随机取出元素
取出2个集合的差集
消除2个集合的差集
2个集合合并
统计集合元素数量
集合的遍历
字典、映射
eval函数
s = '3.14+3'
print(s, type(s)) # 3.14+3 <class 'str'>
x = eval(s) # 使用eval函数去掉s这个字符串中左右的引号
print(x, type(x)) # 6.140000000000001 <class 'float'>
eval函数经常与input()函数一起使用，用来获取用户输入的数值
age = eval(input('请输入您的年龄：')) # input的结果是字符串类型，将结果转为int类型，相当于int(age)
print(age, type(age))
height = eval(input('请输入您的身高：'))
print(height, type(height))
hello = '北京欢迎你'
print(hello) # 北京欢迎你
print(eval('hello')) # 北京欢迎你
# print(eval('北京欢迎你')) # NameError: name '北京欢迎你' is not defined
# 同下一句：
# print(北京欢迎你)
数值类型
整数类型表示的数值是没有小数部分的数值，包含正整数、负整数和0
默认情况下都是十进制，没有引导符号；二进制引导符号为0b或0B；八进制引导符号为0o或0O;十六进制引导符号为0x或0X
浮点数类型表示带有小数点的数值，由整数部分和小数部分组成
注意：两个浮点类型的数在进行运算时，有一定的概率运算结果后面增加一些“不确定的”尾数
python中的复数与数学中的复数形式完全一致，由实部和虚部组成
在python中实数部分使用.real表示，虚数部分使用.imag表示
字符串的三种定义方式
单引号定义法：name='shen'
双引号定义法：name="shen"
三引号定义法：name='''shen'''
三引号定义法，和多行注释的写法一样，同样支持换行操作。使用变量接收它，就是字符串；不使用变量接收它，就可以作为多行注释使用
字符串的引号嵌套：
单引号定义法，可以内含双引号
双引号定义法：可以内含单引号
可以使用转义字符(\)来将引号解除引用，变成普通字符
name = '"黑马"'
print(name) # "黑马"
name = '黑马'
print(name) # 黑马
name = '''黑马'''
print(name) # 黑马
name = "\"黑马\""
print(name) # "黑马"字符串拼接
一般来说，字面量和变量或变量和变量之间会使用拼接
字符串无法通过+和整数进行拼接：
name = 'shen'
tel = 139
print('我是：' + name + ',我的电话是：' + tel)
#TypeError: can only concatenate str (not "int") to str
不只是整数，还有浮点数，以及其它类型，只能用于字符串本身
此时，需要字符串格式化，占位型拼接
%表示占位，s表示将变量变成字符串放入占位的地方
name = 'shen'
message = '我姓%s' % name # %表示占位，s表示将变量变成字符串放入占位的地方
print(message) # 我姓shen数字类型，也可以占位，此时，数字被转换为字符串：
Class = 2
avg_age = 18
message = "python%s班，平均年龄为：%s" % (Class, avg_age)
print(message) # python2班，平均年龄为：18多个变量占位，变量要用括号括起来，并按照占位的顺序填入
python中，支持非常多的数据类型占位：
最常用的是如下三类：
%s——将内容转换成字符串，放入占位位置
%d——将内容转换成整数，放入占位位置
%f——将内容转换成浮点型，放入占位位置
name = '传智播客'
setup_year = 2006
stock_price = 19.99
message = "%s,成立于：%d,今天的股价是：%f" % (name, setup_year, stock_price)
print(message) # 传智播客,成立于：2006,今天的股价是：19.990000
字符串格式化——数字精度控制
我们可以用辅助符号“m.n”来控制数据的宽度和精度
- m,控制宽度，要求是数字（很少使用），设置的宽度小于数字本身，不生效
- .n,控制小数点精度，要求是数字，会进行小数的四舍五入
- %5d:表示将整数的宽度控制在5位，如数字11，被设置为5d,就会变成：[空格][空格][空格]11，用三个空格补足宽度
- %5.2f:表示将宽度控制为5，将小数点精度设置为2
小数点和小数部分也算入宽度计算，如，对11.345设置了%7.2f后，结果是：[空格][空格]11.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为.35
- %.2f:表示不限制宽度，只设置小数点精度为2，如11.345设置为%.2f后结果是11.35
num = 11.345
print('数字11宽度限制5，结果是：%5d' % num) # 数字11宽度限制5，结果是： 11
print('数字11宽度限制1，结果是：%1d' % num) # 数字11宽度限制1，结果是：11
print('数字11.345不限制，小数精度2，结果是：%.2f' % num) # 数字11.345不限制，小数精度2，结果是：11.35
print('数字11.345宽度限制7，小数精度2，结果是：%7.2f' % num) # 数字11.345宽度限制7，小数精度2，结果是： 11.35
字符串格式化——快速格式化
目前通过%符号占位已经很方便，还能进行精度控制，是否有更方便的方式来解决问题？
通过语法：f"内容{变量}"的格式来快速格式化
name = '传智播客'
set_up_year = 2006
stock_price = 19.99
print(f'我是{name},我成立于{set_up_year},我今天的股票价格是{stock_price}')
# 我是传智播客,我成立于2006,我今天的股票价格是19.99
上述的19.99不做精度控制，原样输出
对表达式进行格式化
表达式：一条具有明确执行结果的代码语句
在无需使用变量进行数据存储的时候，可以直接格式化表达式，简化代码
range语句
range(num1,num2)获得一个从num1开始，到num2结束的数字序列（不含num2）
range(num1,num2,step)获得一个从num1开始，到num2结束的数字序列（不含num2），数字之间的步长，以step为准（step默认为1）
函数
函数：是组织好的，可重复使用的，用来实现特定功能的代码
提高了程序的复用性，减少重复性代码，提高开发效率
global关键字
使用global关键字可以在函数内部声明变量为全局变量
num = 200
def test_a():
print(f'test_a:{num}')
def test_b():
global num
num = 500
print(f'test_b:{num}')
test_a() # test_a:200
test_b() # test_b:500
print(num) # 500
数据容器
数据容器使用一个变量完成，一个容器可以容纳多份数据
容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等
数据容器根据特点的不同，如：是否支持重复元素；是否可以修改；是否有序等
分为5类，分别是：list(列表),tuple(元组),str(字符串),set(集合),dict(字典)
函数是一个封装的代码单元，可以提供特定功能，在python中，如果将函数定义为class(类)的成员，那么函数会称之为：方法
def add(x, y):
return x + y # 函数
class Student:
def add(self, x, y):
return x + y # 方法函数的使用：num = add(1, 2)
方法的使用：student = Student()
num = student. add(1, 2)
列表
列表的查询方法
查找某元素的下标，如果找不到，报错ValueError
语法：列表.index(元素)
index就是列表对象（变量）内置的方法（函数）
my_list = ['heima', 'python']
index = my_list.index('python')
print(f'python在列表中的下标是：{index}') # python在列表中的下标是：1
插入元素
语法：列表.insert(下标，元素)，在指定的下标位置，插入指定的元素
my_list = [1, 2, 4]
my_list.insert(2, 3)
print(my_list) # [1, 2, 3, 4]追加元素
语法：列表.append(元素)，将指定元素追加到列表的尾部
my_list = [1, 2, 3]
my_list.append(4)
print(my_list) # [1, 2, 3, 4]
my_list = [1, 2, 3]
my_list.append([4, 5, 6])
print(my_list) # [1, 2, 3, [4, 5, 6]]
my_list = [1, 2, 3]
my_list.append(4, 5, 6)
print(my_list) # TypeError: list.append() takes exactly one argument (3 given)
如果要追加多个元素，需要换方法：
语法：列表.extend(其他数据容器)，将其他数据容器中的内容取出，依次追加到列表尾部
my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list) # [1, 2, 3, 4, 5, 6]
删除元素
语法1：del 列表[下标]
my_list = ['heima', 'python']
del my_list[0]
print(f'列表删除元素后，结果是：{my_list}') # 列表删除元素后，结果是：['python']
语法2：列表.pop(下标)，可以得到返回值
my_list = ['heima', 'python']
element = my_list.pop(0)
print(f'通过pop方法取出元素后列表内容：{my_list},取出的元素是{element}')
# 通过pop方法取出元素后列表内容：['python'],取出的元素是heima删除某元素在列表中的第一个匹配项
语法：列表.remove(元素)
my_list = [1, 2, 3, 2, 3]
my_list.remove(2)
print(my_list) # [1, 3, 2, 3]清空列表内容
语法：列表.clear()
my_list = ['heima', 'python']
my_list.clear()
print(my_list) # []统计某元素在列表中的数量
语法：列表.count(元素)
my_list = [1, 2, 3, 2, 1]
print(my_list.count(1)) # 2统计列表中有多少元素
语法：len(列表)
可以得到一个int数字，表示列表内的元素数量
my_list = [1, 2, 3, 4, 5]
print(len(my_list)) # 5总结：
- 列表中的元素是有上限的
- 可以容纳不同类型的元素
- 数据是有序存储的（有下标序号）
- 允许重复数据存在
- 可以修改（删除或增加元素等）
元组
元组中的数据不可修改
t1 = (1, 'hello', True)
t2 = ()
t3 = tuple()
print(f't1的类型是{type(t1)},内容是{t1}')
# t1的类型是<class 'tuple'>,内容是(1, 'hello', True)
print(f't2的类型是{type(t2)},内容是{t2}')
# t2的类型是<class 'tuple'>,内容是()
print(f't3的类型是{type(t3)},内容是{t3}')
# t3的类型是<class 'tuple'>,内容是()
t4 = ('hello')
print(f't4的类型是{type(t4)},内容是{t4}')
# t4的类型是<class 'str'>,内容是hello#
t5 = ('hello',) # 后面有逗号
print(f't5的类型是{type(t5)},内容是{t5}')
# t5的类型是<class 'tuple'>,内容是('hello',)
元组的嵌套：
t6 = ((1, 2, 3), (4, 5, 6))
print(f't6的类型是{type(t6)},内容是{t6}')
# t6的类型是<class 'tuple'>,内容是((1, 2, 3), (4, 5, 6))t6 = ((1, 2, 3), (4, 5, 6))
num = t6[1][2]
print(num) # 6元组不可修改，否则直接报错！
但是，可以修改元组里的list的内容（修改元素、增加、删除、反转）
t7 = (1, 2, ['python', 'it'])
t7[2][1] = '黑马'
print(t7) # (1, 2, ['python', '黑马'])字符串
同元组一样，字符串是一个无法修改的数据容器
字符串的替换
语法：字符串.replace(字符串1，字符串2)
功能：将字符串内的全部：字符串1，替换为字符串2
注意：不是修改字符串本身，而是得到了一个新的字符串
my_str = 'python'
new_my_str = my_str.replace('p', 'y')
print(f'将字符串{my_str}进行替换后得到：{new_my_str}') # 将字符串python进行替换后得到：yython
字符串的分割
语法：字符串.split(分隔符字符串)
功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
注意：字符串本身不变，而是得到了一个列表对象
my_str = "hello my friend"
my_str_list = my_str.split(' ')
print(my_str_list) # ['hello', 'my', 'friend']
print(type(my_str)) # <class 'str'>
print(type(my_str_list)) # <class 'list'>字符串的规整操作
去前后空格
语法：字符串.strip()
my_str = " hello my friend "
new_my_str = my_str.strip() # 不传入参数，去除首尾空格
print(f'字符串{my_str}被strip后，结果：{new_my_str}')
# 字符串 hello my friend 被strip后，结果：hello my friend
my_str = "12hello my friend21"
new_my_str = my_str.strip('12') # 不传入参数，去除首尾空格
print(f'字符串{my_str}被strip后，结果：{new_my_str}')
# 字符串12hello my friend21被strip后，结果：hello my friend
作为数据容器，字符串有如下特点：
- 只能存储字符串
- 长度任意（取决于内存大小）
- 支持下标索引
- 允许重复字符串存在
- 不可以修改
- 支持for循环
序列
序列是指：内容连续、有序，可使用下标索引的一类数据容器
列表、元组、字符串，均可以视为序列
序列的常用操作——切片
序列支持切片，即：列表、元组、字符串，均支持切片操作
切片：从一个序列中，取出一个子序列
语法：序列[起始下标：结束下标：步长]
表示从序列中，从指定位置开始，依次取出元素，到指定的位置结束，得到一个新序列：
- 起始下标表示从何处开始，可以留空，留空视作从头开始
- 结束下标（不包含在内）表示何处结束，可以留空，留空视作截取到结尾
- 步长表示，依次取元素的间隔：步长n表示，每次跳过n-1个元素；步长为负数表示反向取（注意：起始下标和结束下标也要反向标记）
注意：此操作不会影响序列本身，而是会得到一个新的序列（列表，元组，字符串）
my_list = [0, 1, 2, 3, 4]
result = my_list[1:4:1] # 步长默认为1，所以可以省略不写;左闭右开区间
print(result) # [1, 2, 3]
my_tuple = (0, 1, 2, 3, 4)
result = my_tuple[:] # 起始下标和结束下标都省略不写
print(result) # (0, 1, 2, 3, 4)
my_str = "0123"
result = my_str[::2] # 步长为2
print(result) # 02
my_str = "0123"
result = my_str[::-1] # 步长为-1
print(result) # 3210——等同于将序列反转
my_list = [0, 1, 2, 3, 4]
result = my_list[4:1:-1] # 步长为-1
print(result) # [4, 3, 2]
集合（set）
列表和元组都具有一定的局限：它们都支持重复元素
如果场景需要对内容做去重处理，列表、元组、字符串就不方便了
而集合，最主要的特点就是：不支持元素的重复（自带去重功能），且内容无序
集合使用{}
my_set = {'python', 'heima', 'python'}
my_set_empty = set()
print(f'my_set的内容是：{my_set},类型是{type(my_set)}')
# my_set的内容是：{'heima', 'python'},类型是<class 'set'>
print(f'my_set_empty的内容是：{my_set_empty},类型是{type(my_set_empty)}')
# my_set_empty的内容是：set(),类型是<class 'set'>
集合的常用操作——修改
首先，集合是无序的（不是序列），所以集合不支持“下标索引访问”
但是，集合和列表一样，是允许修改的
添加新元素
语法：集合.add(元素)，将指定元素添加到集合内
结果：集合本身被修改，添加了新元素
my_set = {'python', 'heima'}
my_set.add('python')
my_set.add('传智教育')
print(f'my_set添加元素后结果是：{my_set}')
# my_set添加元素后结果是：{'传智教育', 'python', 'heima'}
移除元素
语法：集合.remove(元素)，将指定元素从集合内移除
结果：集合本身被修改，移除了元素
my_set = {'python', 'heima'}
my_set.remove('heima')
print(my_set) # {'python'}从集合中随机取出元素
语法：集合.pop()
功能：从集合中随机取出一个元素
结果：会得到一个元素的结果，同时集合本身被修改，元素被移除
my_set = {'python', 'heima'}
element = my_set.pop()
print(f'集合被取出元素是：{element},取出元素后，集合为：{my_set}')
# 集合被取出元素是：python,取出元素后，集合为：{'heima'}
取出2个集合的差集
语法：集合1.difference(集合2)
功能：取出集合1和集合2的差集（集合1有而集合2没有的）
结果：得到一个新集合，集合1和集合2不变
set1 = {1, 2, 3}
set2 = {1, 3, 5}
set3 = set1.difference(set2)
print(f'取出差集后，原有set1的内容：{set1},原有set2的内容{set2},二者之间的差集为：{set3}')
# 取出差集后，原有set1的内容：{1, 2, 3},原有set2的内容{1, 3, 5},二者之间的差集为：{2}
消除2个集合的差集
语法：集合1.difference_update(集合2)
功能：对比集合1和集合2，在集合1内删除和集合2相同的元素
结果：集合1被修改，集合2不变
set1 = {1, 2, 3}
set2 = {1, 3, 5}
set3 = set1.difference_update(set2)
print(f'消除差集后，集合1为：{set1},集合2为：{set2}')
# 消除差集后，集合1为：{2},集合2为：{1, 3, 5}2个集合合并
语法：集合1.unioon(集合2)
功能：将集合1和集合2组成新集合
结果：得到新集合，集合1和集合2不变
set1 = {1, 2, 3}
set2 = {1, 3, 5}
set = set1.union(set2)
print(f'两集合合并结果：{set}') # 两集合合并结果：{1, 2, 3, 5}
print(f'合并后集合1：{set1}') # 合并后集合1：{1, 2, 3}
print(f'合并后集合2：{set2}') # 合并后集合2：{1, 3, 5}
统计集合元素数量
set = {1, 2, 3, 4, 5, 3, 2, 1}
num = len(set)
print(f'集合里面有{num}个元素') # 集合里面有5个元素集合的遍历
集合不支持下标索引，不能用while循环，可以用for循环文章来源：https://www.toymoban.com/news/detail-851131.html
set1 = {1, 2, 3}
for element in set1:
print(f'集合的元素有：{element}')
"""
集合的元素有：1
集合的元素有：2
集合的元素有：3
"""集合的特点：文章来源地址https://www.toymoban.com/news/detail-851131.html
- 可以容纳多个数据
- 可以容纳不同类型的数据
- 数据是无序存储的（不支持下标索引）
- 不允许重复数据存在
- 可以修改（增加或删除元素）
- 支持for循环
字典、映射
到了这里，关于python补充的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
