Python基础之day03-字符串,列表,元组,字典

文章目录

Python基础之day03-字符串,列表,元组,字典
- 一、字符串
- 二、下标与字符串切片
- 三、列表
- 四、元祖
- 五、字典
- 六、公用方法

代码仓库地址: https://gitee.com/andox_yj/python

一、字符串

介绍：双引号或者单引号中的数据，就是字符串string

字符串的基本操作

# 1.定义字符串
name1 = "Andox"
name2 = '张三'
# 2.字符串输入
str1 = input("请输入字符串:")
# 3.字符串输出
print(str1)

字符串的常见操作

my_str = "Life is short use Python""""1.find：返回my_str中找到sub字符串sub的最低索引，否则返回-1"""
# 使用：my_str.find(str, start=0, end=len(my_str))
print(my_str.find('is', 1, 10))  # 5
print(my_str.find('iss'))  # -1"""2.index：跟find()方法一样，只不过如果str不在 my_str 中会报一个异常."""
# 使用：my_str.index(str, start=0, end=len(my_str))
print(my_str.index("is", 1, 10))  # 5
# print(my_str.index("iss"))  # ValueError: substring not found"""3.count：返回 sub在start和end之间 在 my_str 里面出现的次数"""
# 使用：my_str.count(str, start=0, end=len(my_str))"""
print(my_str.count("e", 0, 20))  # 2
print(my_str.count("x"))  # 0"""4.replace：把 my_str 中的 str1 替换成 str2,如果 count 指定，则替换 count 个。"""
# 使用：my_str.replace(str1, str2,  count)
# 注意：替换后原字符串不变。如果要替换的str1找不到，则不替换，返回原字符串
my_str1 = my_str.replace("s", "x", 1)  # 替换1个
print(my_str1)  # Life ix short use Python
my_str2 = my_str.replace("s", "x")  # 替换所有
print(my_str2)  # Life ix xhort uxe Python
my_str3 = my_str.replace("yy", "x")  # 找不到就不替换，返回原字符串
print(my_str3)  # Life is short use Python"""5.split：使用sep作为分隔符字符串。如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串。将分开后的字符串放入列表返回"""
# 注意：替换后原字符串不变。如果要替换的seq找不到，则不分割，将原字符串放入列表中返回
# 使用：my_str.split(seq, maxsplit)
my_str1 = my_str.split("e", 1)  # 分割1个
print(my_str1)  # ['Lif', ' is short use Python']
my_str2 = my_str.split("e")  # 分割所有
print(my_str2)  # ['Lif', ' is short us', ' Python']
my_str3 = my_str.split("yy")  # 找不到就不分割，将原字符串放入列表中返回
print(my_str3)  # ['Life is short use Python']"""6.capitalize，title，lower，upper"""
# capitalize：把整个字符串的第一个字母大写，其余的小写
# title：把字符串的每个单词首字母大写，单词与空格区分，既第一个字符和空格后面的第一个字符大写，其余的小写
# lower：所有单词小写
# upper：所有单词大写
print(my_str.capitalize())  # Life is short use python
print(my_str.title())  # Life Is Short Use Python
print(my_str.lower())  # life is short use python
print(my_str.upper())  # LIFE IS SHORT USE PYTHON"""7.startswith，endswith"""
# startswith：判断是否以某字符串开头，返回True或False
# endswith：判断是否以某字符串结尾，返回True或False
print(my_str.startswith("Python"))  # False
print(my_str.endswith("Python"))  # True"""8.ljust，rjust，center"""
# ljust：填充字符串，使新字符串总长度为width，不够向右填充str
# rjust：填充字符串，使新字符串总长度为width，不够向左填充str
# center：填充字符串，使新字符串总长度为width，不够向左右填充str
# 注意：默认填充空格。只能填充一个字符，否则报错
# 使用：my_str.center(width, str)
print("you    ".ljust(10, "你"))  # you    你你你
print("     you".rjust(10, "你"))  # 你你     you
print("you".center(10, "你"))  # 你你你you你你你你"""9.lstrip，rstrip，strip"""
# lstrip：删除 字符串 左边的空白字符
# rstrip：删除 字符串 右边的空白字符
# strip：删除 字符串 两边的空白字符
print("    str    ".lstrip())  # str
print("    str    ".rstrip())  # str
print("    str    ".strip())  # str"""10.rfind，rindex：与find和index使用方法差不多，只不是过是从右边开始"""
print(my_str.rfind("s"))  # 15
print(my_str.rindex("s"))  # 15"""11.partition，rpartition，splitlines"""
# partition：把mystr以str分割成三部分,str前，str和str后
# rpartition：类似于 partition()函数,不过是从右边开始.
# 注意：返回的是元祖，如果没有找到，则补充两个空字符
print(my_str.partition("e"))  # ('Lif', 'e', ' is short use Python')
print(my_str.rpartition("eyy"))  # ('Life is short us', 'e', ' Python')"""12.splitlines：按照行分隔，返回一个包含各行作为元素的列表"""
print("abcd \n defg".splitlines())  # ['abcd ', ' defg']"""12.isalpha，isdigit，isalnum，isspace"""
# isalpha：判断字符串是否只有 字母
# isdigit：判断字符串是否只有 数字
# isalnum：判断字符串是否只有 字母 和 数字
# isspace：判断字符串是否只有 空格
print("abc".isalpha())  # True
print("123".isdigit())  # True
print("abc123".isalnum())  # True
print(" ".isspace())  # True"""14.join：把str1插入到join里的序列中的每个元素之间，结果返回一个字符串"""
str1 = "--"
print(str1.join(["Life", "is", "short", "use", "Python"]))  # Life--is--short--use--Python

二、下标与字符串切片

下标介绍：下标就是对一个序列中的每个元素的一个编号，第一个元素的下标为0，依次往后排序

用法：对象[下标]

注意：下标不能超出对象元素的个数，如果超出就是截取到最后一个

    str1 = "Andox"print(str1[0])  # Aprint(str1[1])  # nprint(str1[2])  # dprint(str1[3])  # oprint(str1[4])  # x```

切片介绍：切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

切片用法：对象[起始:结束:步长]

切片规则：

切取规则为，从起始下标开始获取，到结束下标的前一个元素结束。既：包括开头不包括结尾
步长表示选取间隔。如果不需要可以不写步长
可以省略起始或结束，或起始结束都省略

str2 = "Andox"
# 截取下标1到下标4的前一个元素
print(str2[1:4])  # ndo
# 截取下标0到下标4的前一个元素，每次间隔两个
print(str2[0:4:2])  # Ad
# 截取下标0到指定下标结束
print(str2[:3])  # And
# 截取指定下标开始到最后结束
print(str2[2:])  # dox
# 截取所有元素
print(str2[:])  # Andox
# 在所有元素中间隔截取
print(str2[::2])  # Adx
# 步长为-号，既为逆序截取
print(str2[::-2])  # xdA
# 从倒数第4个元素开始截到取倒数第2个元素
print(str2[-4:-1])  # ndo

三、列表

列表简单使用

介绍：列表list可以用来存储多个不同类型的元素，包括字符串，列表，元祖，字典，对象等等…

格式：list1 = [元素1, 元素2, 元素3]

# 1.列表的定义
list1 = ["Andox", 18, "男"]
# 2.打印列表
print(list1)  # ['Andox', 18, '男']
# 3.使用 下标或者切片 打印列表
print(list1[1])  # 18
print(list1[1:3])  # [18, '男']
# 4.使用 for 循环输出列表
for item in list1:print(item)
# 5.使用 while 循环输出列表
# 步骤：获取列表长度，定义下标变量，每循环获取一次元素下标就加1，直到下标小于列表的长度为止
length = len(list1)
i = 0
while i < length:print(list1[i])i += 1

列表的增删改查与排序

"""1.添加元素：append, extend, insert"""
# append：将一个元素添加到列表的最后
my_list = ["张三", "李四", "王五"]
my_list.append("赵六")
print(my_list)# extend：将一个序列中第一层的所有元素添加到另外一个列表中
# 注意：如果是字符串，则会将字符串中每个字符单独插入到元祖中
my_list = ["张三", "李四", "王五"]
my_list.extend(["阿Q", "Andox"])  # 添加列表
print(my_list)  # ['张三', '李四', '王五', '阿Q', 'Andox']my_list = ["张三", "李四", "王五"]
my_list.extend("阿Q")  # 添加字符串
print(my_list)  # ['张三', '李四', '王五', '阿', 'Q']# insert(index, object)：在指定位置index处插入一个元素object，原来index处和后面的元素往后移
my_list = ["张三", "李四", "王五"]
my_list.insert(1, "Andox")
print(my_list)  # ['张三', 'Andox', '李四', '王五']"""2.修改元素：将想要修改的元素用下标指出来后直接赋值即可"""
# 使用：my_list[2] = Andox
my_list = ["张三", "李四", "王五"]
my_list[2] = "Andox"
print(my_list)  # ['张三', '李四', 'Andox']"""3.查找元素：in, not in, index, count"""
my_list = ["张三", "李四", "王五"]
# in：判断元素是否在列表里
# not in：判断元素是否不在列表里
print("张三" in my_list)  # True
print("张三" not in my_list)  # False
# index：返回要查找的元素在 my_list 中的下标，没有就报错，列表没有find方法
# count：返回要查找的元素在 my_list 中的出现的次数，没有返回0
print(my_list.index("王五"))  # 2
print(my_list.count("王五"))  # 1"""4.删除元素：del, pop, remove"""
# del：根据下标进行删除
my_list = ["张三", "李四", "王五"]
del my_list[0]
print(my_list)  # ['李四', '王五']# pop：默认删除最后一个元素并且返回删除的元素，也可以删除指定下标，超出下标报错
my_list = ["张三", "李四", "王五"]
print(my_list.pop())
print(my_list)# remove：根据元素的值进行删除，如果没有要删除的值报错，没有返回值
my_list = ["张三", "李四", "王五"]
print(my_list.remove("李四"))  # None
print(my_list)  # ['张三', '王五']"""5.排序：sort, reverse"""
# sort：按照ASCII码的顺序对列表进行排序
my_list = ["张三", "2", "1", "Andox"]
my_list.sort()
print(my_list)  # ['1', '2', 'Andox', '张三']
# sort(reverse=True)：逆序排序
my_list = ["张三", "2", "1", "Andox"]
my_list.sort(reverse=True)
print(my_list)# reverse：将列表翻转
my_list = ["张三", "2", "1", "Andox"]
my_list.reverse()
print(my_list)  # ['Andox', '1', '2', '张三']

列表嵌套与案例

# 列表嵌套：既列表中的元素也是列表，可以多层嵌套
import randommy_list = [["张三", 18, "男"],["小红", 18, "小兰"]
]
"""1.列表嵌套的获取"""
print(my_list[0][1])  # 18"""2.列表嵌套的应用："""
# 有10名学生和三间教室，需要将这10名学生随机分配到这三间教室中去
# 定义三个列表来当做三间教室
class_room = [[], [], []]
# 定义一些学生
students_name = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', "I", "j"]
# 将学生随机放入三间教室里去
for student in students_name:class_room[random.randint(0, 2)].append(student)i = 1
for temp_class in class_room:print('教室%d的人数为:%d' % (i, len(temp_class)))i += 1print("分别为：", end="")for name in temp_class:print("%s" % name, end='')print("\r")print("-" * 20)

四、元祖

介绍：Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

注意：元祖不能增删改

"""1.定义元祖"""
my_tuple = ("Andox", 18, "男")"""2.访问元祖"""
# 下标访问元祖
print(my_tuple[0])  # Andox
# 切片访问元祖
print(my_tuple[0:3])  # ('Andox', 18, '男')
# for循环访问元祖
for item in my_tuple:print(item)"""3.count, index：index和count与字符串和列表中的用法相同"""
# count：查询数量，没有返回0
print(my_tuple.count("男"))  # 1
# index：返回下标，没有报错
print(my_tuple.index("男"))  # 2

五、字典

字典的简单使用
介绍：字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值key:value对用冒号:分割，每个键值之间用逗号,分割，整个字典包括在花括号 {} 中。

"""1.定义字典"""
my_dict = {"name": "Andox", "age": 18, "性别": "男"}"""2.添加元素"""
my_dict["phone"] = "157*********"
print(my_dict)  # {'name': 'Andox', 'age': 18, '性别': '男', 'phone': '157*********'}"""3.修改元素"""
my_dict["age"] = 20
print(my_dict["age"])  # 20"""4.删除元素"""
# del：按照键删除指定元素
del my_dict["phone"]
print(my_dict)  # {'name': 'Andox', 'age': 20, '性别': '男'}
# clear：清空字典里的所有键值对数据
my_dict.clear()
print(my_dict)  # {}
# del 删除整个字典
del my_dict
# print(my_dict)  # NameError：name 'my_dict' is not defined

访问字典的各种方法

my_dict = {"name": "Andox", "age": 18, "性别": "男"}"""1.全部输出"""
print(my_dict)  # {'name': 'Andox', 'age': 18, '性别': '男'}
"""2.根据键访问值,若键不存在会报错"""
print(my_dict["name"])  # Andox
"""3.len()：测量字典中，键值对的个数"""
print(len(my_dict))  # 3"""4.keys()：获取字典中的所有keys键"""
# 知识点补充
# type：该方法可以查看对象的数据类型
# 视图对象：可以用list()方法来转换为列表，视图对象不可以增删改，只能查看
#         视图对象是动态的，受字典变化的影响，如删除了字典的 key，视图对象转为列表后也跟着变化
keys_list = my_dict.keys()
print(keys_list)  # dict_keys(['name', 'age', '性别'])
print(type(keys_list))  # <class 'dict_keys'>
print(list(keys_list))  # ['name', 'age', '性别']
"""5.values()：获取字典中所有的value值，与获取键的返回值一样，都是视图集对象"""
values = my_dict.values()
print(values)  # dict_values(['Andox', 18, '男'])
"""6.items()：获取字典中所有键值对，与获取键的返回值一样，都是视图集对象"""
# 注意：视图集转换为列表后，每个键值对都单独在一个元祖里，元祖里的两个元素为键值
items = my_dict.items()
print(items)  # dict_items([('name', 'Andox'), ('age', 18), ('性别', '男')])"""7.遍历字典的key（键）"""
for key in my_dict:  # 循环字典时默认输出的是字典的keyprint(key)
for key in my_dict.keys():  # 指定输出keyprint(key)
"""8.遍历字典的value（值）"""
for value in my_dict.values():print(value)
"""9.遍历字典的键值对：返回每个键值对的元祖"""
for item in my_dict.items():print(item)  # ('name', 'Andox')
"""10.遍历字典的键值对时，对返回的元祖进行拆包"""
for key, value in my_dict.items():print(key, value)  # name Andox
"""11.遍历时带索引(枚举)：enumerate"""
# enumerate输出的第一个是当前元素的下标，第二个是实际的数据
for index, item in enumerate(my_dict.items()):print(index, item)  # 0 ('name', 'Andox')

六、公用方法

字符串，列表，元祖，字典的公用方法：

拼接
判断是否存在
内置方法

比较运算符

"""
运算符    Python 表达式            结果     描述            持的数据类型
+       [1, 2] + [3, 4]   [1, 2, 3, 4]    合并          字符串、列表、元组
*        ['Hi!'] * 2      ['Hi!', 'Hi!']  复制          字符串、列表、元组
in  3    in (1, 2, 3)          T rue      元素是否存在    字符串、列表、元组、字典
not in   4 not in (1, 2, 3)     True      元素是否不存在   字符串、列表、元组、字典
"""
my_dict1 = (1, 2)
my_dict2 = (2, 3)
print(my_dict1 + my_dict2)  # (1, 2, 2, 3)
print(my_dict2 * 3)  # (2, 3, 2, 3, 2, 3)
print(1 in my_dict1)  # True
print(1 not in my_dict1)  # False"""内置方法              描述
len(item)              计算容器中元素个数
max(item)              返回容器中元素最大值
min(item)              返回容器中元素最小值
del item               删除变量
"""
print(len(my_dict1))  # 2
print(max(my_dict1))  # 2
print(min(my_dict1))  # 1
del my_dict1"""
比较运算符             描述>       判断左边的对象是否大于右边的对象(比较ascii码)<       判断左边的对象是否小于右边的对象(比较ascii码)
"""
# 注意，不能比较字典。
print("9999999" > "qqqqq")  # False
print([1, 2, 3] < [5, 9])  # True

Python基础之day03-字符串,列表,元组,字典相关推荐

【数据分析】python基础必修2—字符串/列表/元组/集合/字典
目录 1.字符串 2.列表 list 2.1list操作练习 3.元组 tuple 4.集合 set 4.1集合间的运算 5.字典 1.字符串声明一个字符串 # 声明一个字符串# 单引号声明 s = ...
Python 字符串/列表/元组/字典之间的相互转换 - Python零基础入门教程
目录一.字符串 str 与列表 list 1.字符串转列表 2.列表转字符串二.字符串 str 与字典 dict 1.字符串转字典 2.字典转字符串三.列表 list 与字典 dict 1.列表 ...
python 高级变量类型（列表/元组/字典/字符串）
前言 Python 中数据类型可以分为数字型和非数字型数字型整型 (int) 浮点型(float) 布尔型(bool) 真 True 非 0 数 -- 非零即真假 False 0 复数型 ...
python列表添加元素的三种方法定义集合数据对象_（1） List，tuple，dictionary，Python语法基础集,一,之,列表,元组,字典,集合...
Python序列(列表.元组.字典.集合) 一.列表(List)与列表推导式 (一)列表(list) 1.列表是Python内置可变序列 (列表中元素可增加删除或修改): 2.列表元素放在一对中括号 ...
python字符串转换元组_python 字符串,列表,元组,字典相互转换
1.字典 dict = {'name': 'Zara', 'age': 7, 'class': 'First'} 字典转为字符串,返回: {'age': 7, 'name': 'Zara', 'cla ...
【python基础】——数据类型（列表、字典、集合）
骏马金龙--python语法基础 python基础变量与运算符号 // % ** 意义整除整除取余幂次方数据种类 #mermaid-svg-7nSRRijcYFCYwTDr .label{ ...
day02 格式化输出运算符编码字符串列表元组字典 set集合深浅拷贝
day02学习大纲一. 格式化输出: %s 占位字符串 %d 占位数字 "xxx%sx %sxx" % (变量, 变量) 二. 运算符: a+=b a = a + b and 并 ...
Python 基础（二）[列表，字典，文件操作]
本章内容: 列表 & 元组操作字符串操作字典操作集合操作文件操作字符编码与转码 Python 语言从未如此性感! 列表 Python中最基本的数据结构 Python有6个序列的内 ...
4.Python基础语法(数字运算/字符串/列表/元组/字典/集合)
4.1 数字运算编程是将问题数据化的一个过程,数据离不开数字,Python的数字运算规则与我们学习的四则运算规则是一样的,即使不使用Python来编写复杂的程序,也可以将其当作一个强大的计算器.打开 ...
mysql cbrt函数_基础方法或属性: 列表,元组,字典,字符串,集合及内置函数等(注:只有英文名)...
列表 list append clear copy count extend index insert pop remove reverse sort 元组 tuple count index 字典 ...

Python基础之day03-字符串,列表,元组,字典

Python基础之day03-字符串,列表,元组,字典

文章目录

一、字符串

二、下标与字符串切片

三、列表

四、元祖

五、字典

六、公用方法

Python基础之day03-字符串,列表,元组,字典相关推荐

最新文章

热门文章