元组（tuple)
元组和列表是类似的
列表是可变的有序序列，元组是不可变的
使用元组的情况：数据元素确定 且不会在发生变化 且不可修改
比如： 1 3 5 7 8 10 12
元组的数据标记是（） 列表是[]
提高运算符优先级使用（）
注意： 一元组[元组中有1个数据]定义的时候 元素后面必须加上逗号，否则会识别成提高表达式优先级 就不是无组类型的
eg:
nums = (11)
nums1 = (11,)
print (type (nums), type (nums1)) # <class 'int'> <class 'tuple'>当给一个变量 赋值的时候使用逗号分隔开多个数据 这个多个数据进行打包的操作，打包成元组赋值给变量
values = 1，2，3，4，43，234
print(type(values)) #<class 'tuple'> 解包： 把一个容器中多个数据赋值给多个变量
a,b = (22,33)
print(a,b)
将位置和该位置的元素组合成元组 放在一个新的容器A中 这个A就是一个二维容器
for item in enumerate([33,22,23,13,32]):
print(item) #(0, 33) (1, 22) (2, 23) (3, 13) (4, 32)字符串是容器型数据，里面的元素都是字符[长度为1的字符串]
'a' 'b' '' '1'
不可变的有序序列
获取的操作：
1.字符串数据.find(子串)
查找子串第一次出现的位置
2.字符串数据.rfind(子串)
查找子串最后一次出现的位置
3.字符串数据.count(子串)
统计子串出现的次数
转换的操作
将字符串中的相关符号进行转换[因为字符串不可变。产生的数据是影响不了原本的数据 都是产生的是一个新的数据]
字符串数据.upper() 将字母变为大写
字符串数据.lower() 将字母变为小写
字符串数据.swapcase() 将大写变为小写 将小写变为大写
字符串数据.title() 每个单词首字母大写 单词: 没连接在一起的就视作一个新的单词
字符串数据.capitalize() 首字母大写 其他小写
s = 'hello everyone'
new_s = s.upper()
print(new_s)#HELLO EVERYONE
new_s1 = new_s.lower()
print(new_s1)#hello everyone
new_s2 = new_s.title()
print(new_s2) # Hello Everyone
new_s3 = new_s2.swapcase()
print(new_s3)#hELLO eVERYONE
new_s4 = new_s3.capitalize()
print(new_s4)#Hello everyone判断的操作
1. 是否以指定内容开头
字符串数据.startswith(指定内容)
2. 是否以指定内容结尾
字符串数据.endswith(指定内容)
3. 判断是否是纯数字
字符串数据.isdigit()
4. 判断字符串的内容是否为纯字母
字符串数据.isalpha()
5. 判断字符串的内容是否为数字或字母
字符串数据.isalnum()
6. 判断字符串中的字母是否为大写
字符串数据.isupper()
7. 判断字符串中的字母是否为小写
字符串数据.islower()
s = 'Hello Everyone'
print(s.startswith('H'))#True
print(s.endswith('one'))#True
print(s.isalnum()) # False
print(s.isalpha()) # False
print(s[0].isupper()) # True
print(s[-3:].islower()) # True
print('123'.isdigit())
print('abc12'.isdigit())
字符串的切割与拼接
切割： 字符串数据.split(切割符) 将指定切割符为切割点 把字符串分为N份 结果是一个列表，存储多个子串 拼接： '拼接符'.join(容器型数据) 使用拼接符将容器中的元素拼接到一起 注意：容器中的元素必须是字符串类型的 底层实现的时候 使用的是 +号运算 +在字符串中完成的字符串拼接 只能拼接字符串类型的
data = "hello my age is 18, my birthday is September 5th."
print(data.split(' '))
#['hello', 'my', 'age', 'is', '18,', 'my', 'birthday', 'is', 'September', '5th.']
print(data.split('e'))
nums = [18, 34, 56, 71, 29]
# 使用+号将其拼接在一起
# print('+'.join(nums))
# TypeError: sequence item 0: expected str instance, int found
# 人家期待的是字符串 但是获取的却是整型
# 拼接之前转化成字符串
# str(nums) # 将传进的数据转化为字符串 ====> '[18, 34, 56, 71, 29]'
str_nums = [str(ele) for ele in nums] # ['18', '34', '56', '71', '29']
print('+'.join(str_nums)) # 18+34+56+71+29
字符串可视化
在指定宽度中居中显示 字符串.center(宽度，占位符) 在指定宽度中居左显示 字符串.ljust（宽度，占位符） 在指定宽度中居右显示 字符串.rjust(宽度，占位符)
将未知的数据格式化拼接在字符串文本中
目的：将非字符串类型的数据与字符串类型的数据进行拼接
方式1 将数据转化为字符串类型
print('年龄' + str(17))
方式2 使用字符串中% 运算符
先生成文本 在未知的位置使用占位进行占位，在对字符串进行%，给占位的符号赋值
占位符
%s --- 可以填充任意类型的数据
%d --- 填充的是整型数据
可以单独在进行格式化操作
%05d ===> 10 ===> 显示的时候为 00010
%f --- 填充的浮点型数据
可以再单独格式化
%.nf === n 代表的是保留小数的为位数
%.3f ===> 3.1415926 ===> 显示为 3.142
year = 2020
month = 4
if month in (4,6,9,11):
day = 30
elif month in (1,3,5,7,8,10,12):
day = 31
else:
if(year % 4 == 0 and year % 100 != 0 ) or (year % 400 == 0):
day = 29
else:
day = 28
# 有几个占位符 就赋予几个值 值和占位符之间是一一对应的
content = '%s年%s月有%s天' % (year,month,day)
print(content)
# 学号 显式的时候按照6位来显式
sid = 1
# 姓名
name = '张三'
# 年龄
age = 17
# 成绩 显式的时候保留一位小数
score = 89.65
info = '学号为%06d的%s，年龄是%s, 考试成绩为%.1f' % (sid, name, age, score)
print(info)
# 方式3： 字符串数据.format(变量名，变量名，...)
"""
先生成字符串文本数据，未知数据的地方使用 {}进行占位 调用字符串的format操作 给占位符进行赋值
有几个占位符 传递就有几个值
如果对数据有特殊的格式 在{}操作
{:0nd} 按照n位填充
{:.nf} 保留n位小数
"""
info1 = '学号为{:06d}的{}, 年龄是{}, 考试成绩为{:.1f}'.format(sid, name, age, score)
print(info1)
方式4： 是方式3的简化 使用f修饰字符串
f修饰完字符串 可以直接在{}的位置填充对应的数据值
要修饰数据 {数据:0nd} {数据:.nf}
info2 = f'学号为{sid:06d}的{name}, 年龄是{age}, 考试成绩是{score:.1f}'
print(info2)
字典
会给每一个数据设置标记， 通过标记名获取对应的数据值
字典是使用键值对进行数据的存储，是通过键定位值的，要求键是不允许重复的，键的内容一旦确定不允许发生变换
字典是无序的可变序列
无序：代表元素没有位置编号，也就是没有下标，只能通过键获取值
可变： 数据值可以修改 可以增加新的键值时 删除键值对
air_temp= {'7点': 16,'9点': 19,'10点': 20,'12点': 25,'15点': 27}
print(air_temp)
# 获取数据的话通过标记名取值
print(air_temp.get('12点'))
# 如果键不存在就报错
# print(air_temp['11点'])
# KeyError: '11点'
# 获取数据值推荐方式
print(air_temp.get('7点'), air_temp.get('11点')) # 26 None
# 获取键值对的个数
print(len(air_temp)) # 6
# 添加新的键值对
air_temp.setdefault('19点', 20) # 影响的是原数据
print(air_temp)
# 移除键值对
air_temp.pop('10点')
print(air_temp)
# 修改
air_temp['12点'] = 18
print(air_temp)
# air_temp.clear()遍历
直接遍历字典 遍历的是字典中的键 [直接对字典进行成员操作 获取的是键]
for ele in air_temp:
print(ele, air_temp.get(ele))
# 等价于
print(air_temp.keys()) # 字典中所有的键 dict_keys(['7点', '9点', '12点', '15点', '19点'])
for k in air_temp.keys():
print(k)# 单独拿值
print(air_temp.values()) #dict_values([16, 19, 18, 27, 20])
for v in air_temp.values():
print(v)# 获取字典中键值组合
print(air_temp.items()) #dict_items([('7点', 16), ('9点', 19), ('12点', 18), ('15点', 27), ('19点', 20)])
for item in air_temp.items():
print(item)词频统计
词/字符/数字 出现的个数 或者对数据进行归类
'''
统计每个字符出现的字数 字符-个数 ===》 使用字典类型展示数据
思路：
1.遍历字符串 获取每个字符
2.把字符出现的个数存储字典中 字符与个数的信息 【字符为键 个数为值】
把遍历的字符作为键 个数作为值存放与字典中
'''s = 'good good study day day up'
count_dict = {} # 空字典 因为不知道最终有多少个键值对
for ch in s: # 遍历获取每个字符
# 逻辑
if ch not in count_dict: # 直接对字典使用成员运算 获取的是键
# 代表第一次出现
count_dict.setdefault(ch, 1)
else:
# 次数+1
count_dict[ch] = count_dict.get(ch) + 1
print(count_dict)归类
nums = [19, 27, 38, 41, 25, 66, 24, 32, 51]
# 偶数为一类 奇数为一类
# 字典中会有两组键值对 值为什么是[] 因为偶数是什么 有多少个不知道 奇数是什么 有多少个 也不知道
# 但是肯定是多个的 所以放一个可变的容器
classify_dict = {'even': [], 'odd': []}遍历
for ele in nums:
if ele % 2 == 0:
classify_dict['even'].append(ele)
else:
classify_dict['odd'].append(ele)
print(classify_dict)
# 每一类的数据的个数
classify_dict1 = {'even': 0, 'odd': 0}
# 遍历
for ele1 in nums:
if ele1 % 2 == 0:
classify_dict1['even'] += 1
else:
classify_dict1['odd'] += 1
print(classify_dict1)字典数据的过滤
dict0 = {'hello': 1, 'nice': 3, 'to': 2, 'meet': 2, 'you': 2, 'too': 1, 'good': 1, 'fine': 1}
print(dict0)
#找到次数为1的单词信息
new_dict = {}
for k,v in dict0.items():
if v== 1:
new_dict.setdefault(k,v)
print(new_dict)
# 字典推导式 注意：字典中存放的是键值对 key:value
print({k: v for k, v in dict0.items() if v == 1})# 单词中包含e的词频信息
print({k: v for k, v in dict0.items() if 'e' in k})
扫一扫
1639
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
