目录
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循环
set1 = {1, 2, 3}
for element in set1:
print(f'集合的元素有：{element}')
"""
集合的元素有：1
集合的元素有：2
集合的元素有：3
"""集合的特点：
- 可以容纳多个数据
- 可以容纳不同类型的数据
- 数据是无序存储的（不支持下标索引）
- 不允许重复数据存在
- 可以修改（增加或删除元素）
- 支持for循环
7059
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
