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

文章目录

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

代码仓库地址: /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)) # 5print(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)) # 2print(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 Pythonmy_str2 = my_str.replace("s", "x") # 替换所有print(my_str2) # Life ix xhort uxe Pythonmy_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 pythonprint(my_str.title()) # Life Is Short Use Pythonprint(my_str.lower()) # life is short use pythonprint(my_str.upper()) # LIFE IS SHORT USE PYTHON"""7.startswith，endswith"""# startswith：判断是否以某字符串开头，返回True或False# endswith：判断是否以某字符串结尾，返回True或Falseprint(my_str.startswith("Python")) # Falseprint(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, "你")) # 你你youprint("you".center(10, "你")) # 你你你you你你你你"""9.lstrip，rstrip，strip"""# lstrip：删除 字符串 左边的空白字符# rstrip：删除 字符串 右边的空白字符# strip：删除 字符串 两边的空白字符print(" str ".lstrip()) # strprint(" str ".rstrip()) # strprint(" str ".strip()) # str"""10.rfind，rindex：与find和index使用方法差不多，只不是过是从右边开始"""print(my_str.rfind("s")) # 15print(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()) # Trueprint("123".isdigit()) # Trueprint("abc123".isalnum()) # Trueprint(" ".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]) # 18print(list1[1:3]) # [18, '男']# 4.使用 for 循环输出列表for item in list1:print(item)# 5.使用 while 循环输出列表# 步骤：获取列表长度，定义下标变量，每循环获取一次元素下标就加1，直到下标小于列表的长度为止length = len(list1)i = 0while 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] = Andoxmy_list = ["张三", "李四", "王五"]my_list[2] = "Andox"print(my_list) # ['张三', '李四', 'Andox']"""3.查找元素：in, not in, index, count"""my_list = ["张三", "李四", "王五"]# in：判断元素是否在列表里# not in：判断元素是否不在列表里print("张三" in my_list) # Trueprint("张三" not in my_list) # False# index：返回要查找的元素在 my_list 中的下标，没有就报错，列表没有find方法# count：返回要查找的元素在 my_list 中的出现的次数，没有返回0print(my_list.index("王五")) # 2print(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("李四")) # Noneprint(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 = 1for 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：查询数量，没有返回0print(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"] = 20print(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!']复制 字符串、列表、元组in3 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) # Trueprint(1 not in my_dict1) # False"""内置方法 描述len(item) 计算容器中元素个数max(item) 返回容器中元素最大值min(item) 返回容器中元素最小值del item 删除变量"""print(len(my_dict1)) # 2print(max(my_dict1)) # 2print(min(my_dict1)) # 1del my_dict1"""比较运算符 描述> 判断左边的对象是否大于右边的对象(比较ascii码)< 判断左边的对象是否小于右边的对象(比较ascii码)"""# 注意，不能比较字典。print("9999999" > "qqqqq") # Falseprint([1, 2, 3] < [5, 9]) # True