代码收藏家 Python知识分享第五天
Python知识分享第五天
1.字符串介绍
"""
字符串介绍:
概述:
字符串是Python中非常常用的数据类型, 其值要用引号包裹.
定义格式:
s1 = 'abc'
s2 = "abc"
s3 = ''' abc ''' # 也可以是三对 双引号
索引介绍:
字符串可以看做是由 多个字符串起来 连成的一串数据, 所以, 字符串中的每个字符都是由自己的编号的.
编号: 也叫脚标, 下标, 索引 -> index(单词)
正向索引: 从左往右(从前往后)顺序, 从 0 开始标记.
逆向索引: 从右往左(从后往前)顺序, 从 -1 开始标记.
根据索引获取对应的字符:
字符串变量名[索引]
"""
# 1.演示如何定义字符串
s1 = 'abc'
s2 = "xyz"
s3 = '''张三
李四
王五
'''
# 2.语句里有单引号怎么定义
s5 = "I'm Tom"
s6 = 'I\'m Tom'
print(s3)
# 3.演示根据索引获取字符串内容
s7 = 'aasdfghjk'
print(s7[2]) # s
print(s7[-5]) # f
2.字符串切片
"""
字符串切片介绍:
概述:
字符串切片 = 从字符串中截取指定部分数据
格式:
字符串变量名[起始索引:结束索引:步长
格式解释:
1. 字符串的索引有正向和逆向之分,
正向: 从前往后(从左往右), 从0开始.
逆向: 从后往前(从右往左), 从-1开始.
2. 如果不写起始索引, 默认是: 0
3. 如果不写步长, 正向默认是: 1
4. 切片时, 关于起始索引和结束索引, 是: 包左不包右的, 也叫: 前闭后开.
如下的字符串, 索引介绍:
字符串值: a b c d e f g
正向索引: 0 1 2 3 4 5 6
逆向索引: -7 -6 -5 -4 -3 -2 -1
"""
# 1. 定义字符串.
s1 = 'abcdefg'
# 2. 字符串切片演示
# 场景1: 正向索引
print(s1[2:5:1]) # cde
print(s1[2:5]) # cde
print(s1[:6]) # abcdef
print(s1[:6:2]) # ace
print(s1[::3]) # defg
# 逆向索引
print(s1[-5:-1]) # cdef
print(s1[-5:-1:1]) # cdef 效果同上
print(s1[-1:-5:-1]) # gfde
print(s1[-3:]) # efg
# 注意: 获取数据的方向和步长方向不一致 获取不到值
print(s1[-5:-1:-1]) # 无数据
# 特殊写法 效果是把字符串内容反转
print(s1[::]) # 代表字符串本身
print(s1[::-1])
3.字符串查找函数
"""
字符串函数介绍:
概述:
就是Python解释器提供的 可以直接操作 字符串的一些 方法, 类似于别人写好的功能, 我们直接拿来调用即可.
函数介绍:
字符串变量名.find(子串, 起始索引, 结束索引) 找子串在原始字符串中第一次出现的位置(索引), 找不到返回-1.
字符串变量名.rfind(子串, 起始索引, 结束索引) 找子串在原始字符串中最后一次出现的位置(索引), 找不到返回-1.
字符串变量名.count(子串) 统计子串在原始字符串中出现的次数.
"""
# 定义字符串
s1 = 'hello and python and linux and python and java and python'
# 1.找python在s1字符串中第一次出现的位置
print(s1.find('python'))
print(s1.find('python', 11)) # 从索引11位置开始 查 python第一次出现的位置
print(s1.find('python', 12, 57)) # 从索引12开始到索引57结束
print(s1.find('python',1, 10)) # 匹配不到就返回-1
# 2. rfind() 招最后一次出现的位置
print(s1.rfind('python')) #51
# 3.字符串变量名.count(子串)
print(s1.count('python')) # 3
print(s1.count('c++')) # 0
4.字符串修改函数
"""
字符串修改相关函数介绍:
字符串变量名.replace(旧子串, 新子串, 个数) 用新串替换旧串, 不指定个数就是替换所有.
字符串变量名.split(切割符, 个数) 按照切割符切割原始字符串, 获取列表.
字符串连接符.join(列表) 用于把 列表 -> 拼接成 字符串的
字符串变量名.lower() 把字母转成小写形式
字符串变量名.upper() 把字母转成大写形式.
核心细节:
字符串属于不可变类型, 所以对于字符串的修改操作都是返回新的字符串值, 而原始字符串无任何改变.
"""
# 1.定义字符串
s1 = 'hello and python and world and sql'
# 2. 演示上述的相关函数
# 字符串变量名.replace(旧子串,新子串,个数)
s2 = s1.replace('and', '666')
print(s2)
print(s1.replace('and', '&', 2))
print(s1.replace('and', '&', 20))
# 字符串变量名.splite(切割符, 个数)
print(s1.split('and')) # ['hello ', ' python ', ' world ', ' sql']
print(s1.split('and', 2)) # ['hello ', ' python ', ' world and sql']
# 字符串连接符号.join(list1)
list1 = ['aa', 'bb', 'cc']
print(list1) # ['aa', 'bb', 'cc']
s2 = '#'.join(list1)
print(s2) # aa#bb#cc
# 字符串变量名.lower() 把字母转成小写
print(s1.lower())
# 字符串变量名.upper() 把字母转换成大写
print(s1.upper())
"""
判断函数相关:
isdigit() 判断字符串中是否都是数字, 是 -> True, 否则 -> False
"""
# 字符串判断函数
s1 = 'abc'
s2 = '345'
print(s1.isdigit()) # False
print(s2.isdigit()) # True
print('12.4'.isdigit()) # False
print('12'.isdigit()) # True
5.字符串相关练习
# 练习题1：输入一个字符串，打印所有奇数位上的字符(下标是1，3，5，7…位上的字符)
# 假设用户输入的 abcdef
s1 = 'abcdef'
# 思路一
for i in range(1, len(s1)):
if i % 2 != 0:
print(s1[i], end='\t')
print()
# 思路二
for i in range(1, len(s1), 2):
print(s1[i], end='\t')
print()
# 练习题2：给定一个字符串，如：mystr = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
# 使用所学的知识，从字符串中随机取出4个字符，生成验证码。
s1 = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
# 方式一:
s2, s3, s4, s5, s6 = '', '', '', '', ''
import random
for i in range(4):
s2 += s1[random.randint(0, len(s1) - 1)]
print(s2)
# 方式二: 用random模块里的 choice函数 随机从字符串内取一个字符
for i in range(4):
s3 += random.choice(s1)
print(s2)
# 方式三: 用random模块里的choices 后者sample函数
s4 = ''.join(random.choices(s1, k=4))
print(s4)
s5 = ''.join(random.sample(s1, k=4))
print(s5)
# 方式四 随机把字符串内容打散.
# # list1 = ['a', 'b', 'c', 'd', 'e']
# # # 随机置换, 相当于洗牌.
# # random.shuffle(list1)
# # print(list1)
code = ''
list1 = list(s1)
random.shuffle(list1)
code = ''.join(list1[:4])
print(code)
6.列表入门
"""
列表解释:
概述:
它属于容器类型的一种, 属于 可变类型, 一般用于 同时存储多个数据.
可以存储不同类型的数据, 也可以存储同类型的数据.
定义格式:
list1 = []
list2 = list()
list3 = [值1, 值2, 值3...]
根据索引, 获取列表的元素:
列表名[索引]
"""
i = 0
list = ['a', 've', 'cew', 'cea']
# 遍历list 方式一
while i < len(list):
print(list[i])
i += 1
# 方式二
for i in range(len(list)):
print(list[i])
# 方式三
for value in list:
print(value)
7.列表的增删改查
"""
列表的增删改查相关:
增:
append() 往末尾追加
insert() 往指定位置插入
删:
remove() 根据元素删除
pop() 根据索引删除
clear() 清空, 即: 删除所有
del 可以删除指定元素, 也可以把整个容器删除
改:
列表名[索引] = 值
查:
len() 长度
in 是否包含
not in 是否不包含
"""
my_list = ['aa', 'bb', 'cc', 'bb', 'aa', 'cc']
my_list.append('dd')
my_list.insert(2, '我是插到二号的数据')
# my_list.remove('aa') # 删除第1个匹配项.
# my_list.pop(2) # 删除索引为2的元素.
# del(my_list[2]) # 删除索引为2的元素.
# my_list.clear() # 清空列表, 等价于: 删除所有, 即: my_list = []
# del my_list # 相当于从内存中把 my_list列表摧毁, 等价于没有定义它.
print(f'my_list的长度是{len(my_list)}')
print(10 in my_list)
print('cc' in my_list)
print(10 not in my_list)
print('cc' not in my_list)
print(my_list)
8.列表的反转和排序
"""
列表反转 和 排序相关:
列表名.reverse() 反转列表元素
列表名.sort(reverse=False) 排序, reverse参数值: False(默认) -> 升序, True -> 降序
回顾:
列表 = 可变类型.
"""
# 1. 定义列表.
my_list = [11, 55, 22, 33, 66]
# 反转
my_list.reverse() # 修改原列表
my_list = my_list[::-1] # 切片
# 列表排序
my_list.sort()
my_list.sort(reverse=True)
print(my_list)
9.列表嵌套
"""
列表嵌套解释:
概述:
列表嵌套 = 1个列表的元素, 还是另1个列表.
格式:
my_list = [[值1, 值2...], [值3, 值4, 值5...], [值6, 值7...]...]
获取元素:
列表名[索引][索引]
"""
# 1. 定义列表, 记录三个班级的学生名.
name_list = [['胡歌', '彭于晏', '刘烨'], ['刘亦菲', '赵丽颖', '杨幂'], ['坤坤', '唱跳rap', '篮球']]
# 获取坤坤
print(name_list)
print(name_list[2])
print(name_list[2][0])
# 遍历嵌套列表
for chlid in name_list:
for value in chlid:
print(value, end='\t')
print()
10.列表嵌套案例
"""
需求:
1. 已知有stu_list列表, 记录了8个学生的 姓名信息.
2. 假设有3个教室.
3. 请将上述的8个学生, 随机分配到3个教室, 并打印结果.
"""
import random
# 1. 创建学生列表
stu_list = ['苏轼', '苏洵', '苏辙', '韩愈', '柳宗元', '欧阳修', '王安石', '曾巩']
# 2. 定义班级列表.
class_list = [[], [], []] # 三个教室: class_list[0], class_list[1], class_list[2]
for i in stu_list:
class_list[random.randint(0, 2)].append(i)
print(class_list)
for i in class_list:
print(i)
11.元组介绍
"""
元组(tuple)介绍:
概述:
它属于容器类型的一种, 可以同时存储多个元素, 因为元组属于 不可变类型, 所以其元素值不能发生改变, 例如: 增删改等...
定义格式:
t1 = ()
t2 = tuple()
t3 = (值1, 值2, 值3...)
t4 = (值1) # 这个不是元组, 而是在定义字符串.
t4 = (值1,) # 这个是元组, 即: 只有1个值的情况下, 最后要加逗号.
基本操作:
元组名[索引] 根据索引获取元组元素.
len(元组名) 获取元组长度
值 in 元组名 判断元组中是否有该元组.
值 not in 元组名 判断元组中是否没有该元组.
"""
t1 = ()
t2 = tuple()
t3 = ('坤坤', '唱', '跳', 'rap', '篮球', '小黑子')
t4 = (23) # 这个不是元组
t5 = ('小黑子',)
print(t1, type(t1)) # () <class 'tuple'>
print(t2, type(t2)) # () <class 'tuple'>
print(t3, type(t3)) # ('坤坤', '唱', '跳', 'rap', '篮球') <class 'tuple'>
print(t4, type(t4)) # 23 <class 'int'>
print(t5, type(t5)) # ('小黑子',) <class 'tuple'>
# 演示元组基本操作
print(f'元组的长度是{len(t3)}') # 元组的长度是6
print(f'元组的下标是3的元素是{t3[3]}') # 元组的下标是3的元素是rap
print('坤坤' in t3) # True
print('鸡' in t3) # False
print('小黑子' not in t3) # False
print('菜鸡' not in t3) # True
12.字典入门
"""
字典介绍:
概述:
容器类型的一种, 存储的是 键值对 数据, 属于: 可变类型.
格式:
dict1 = {}
dict2 = dict()
dict3 = {键:值, 键:值......}
特点:
键具有唯一性, 值可以重复.
增删改查:
增 和 改:
字典名[键] = 值 # 如果键存在, 就用新值覆盖旧值. 如果键不存在, 就直接添加该键值对.
删:
del 字典名[键] # 根据键删除 该键值对.
del 字典名 # 从内存中销毁该字典
查:
items()
keys()
values()
get() # 根据键 获取其 对应的值, 找不到就返回None.
"""
dist = {}
dist1 = dict()
dict3 = {'乔峰': '阿朱', '虚竹': '李清露', '杨过': '大雕'}
print(dist, type(dist))
print(dist, type(dist))
print(dist, type(dist))
# 增
dict3['段誉'] = '王语嫣'
dict3['慕容复'] = '王语嫣'
# 改
dict3['杨过'] = '小龙女'
# 删
del dict3['慕容复']
# dict3.clear()
# del dict3
# 查 根据key获取value 找不到就返回None.
print(dict3.get('慕容复')) # 王语嫣
print(dict3.get('虚竹')) # 李清露
print(dict3.get('段延庆')) # None
# 直接打印字典
print(dict3)坚持分享 共同进步 如有错误 欢迎指出
作者：kris0009
