系统学习python第四天 容器：列表 元组 字典 字符串

头几天脑子有点不太好使 ，思路不清晰没有捋出来咋写 这回补上

下方这次多图预警，这次知识点有点多：代码也比较多所以这次的博客会很长

第四天知识点

1.列表
列表 用 [] 定义，数据之间用逗号分隔。
列表 的特性，可以通过 下标修改对应位置上的数据
专门用于存储一串信息
name_list = [‘zhangxan’, ‘lisi’, ‘wangwu’]

列表不能使用超出范围的下标，否则会出现越界错误
info_tuple = ["张三", 18, 175]
print(info_tuple[3]) #IndexError: list index out of range

列表的增 删 改 查

增：列表.insert（索引，数据） 在指定位置插入数据
列表.append（数据） 在末尾追加数据
列表.extend（列表2） 将列表2的数据追加到列表

注意：在插入数据时，没有下标越界问题

如果指定下标超过元素正常范围，相当于追加

删：del列表[索引] 将删除指定索引的数据
列表.remove[数据] 删除第一个出现的指定数据
列表.pop[] 删除末尾数据
列表.pop（索引） 删除指定索引数据
列表.clear 清空列表

改：列表[索引]=数据 修改指定索引的数据

查：index()：列表.index（索引或数据）

count()：列表.count（数据）

in (掌握)：
          print(2 in l)
          print(22 in l)

          print(2 not in l)
          print(22 not in l)

not in： 与 in相反

统计：len(列表) 列表长度
列表.count（数据） 数据在列表中出现的次数

排序：列表.sort（） 升序排列
列表.sort（reverse=True） 降序排列
列表.reverse（） 逆序、反转
逆序是直接将原列表中的顺序进行逆转

循环遍历

遍历：从头到尾依次从列表中获取数据
迭代遍历：重复遍历，重复的在列表中拿出一个又一个元素

for 循环格式：

for 循环内部的使用变量 in 列表:
    print(循环内部的使用变量)

列表的应用场景：

1. 尽管列表可以储存不同类型的数据但是再实际开发中，更多的场景是列表储存相同类型的数据
2. 通过迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作

代码：可以粘贴复制 自己简单按顺序调试试一试

#   列表
# name_list = [1, 2, 'zhangsan']
# print(name_list.index('zhangsan')) # 查找zhangsan的索引位置
# name_list[0] = '红塔山'  # 修改索引0的数据  将[1, 2, 'zhangsan'] -->['红塔山', 2, 'zhangsan']
# print(name_list)  #  ['红塔山', 2, 'zhangsan']
# name_list.append('那么静')   #在列表的最后加入数据那么静 -->['红塔山', 2, 'zhangsan', '那么静']
# name_list.insert(1,'南京')  # 在列表的指定位置加入南京-->['红塔山', '南京', 2, 'zhangsan', '那么静']
# test_list = ['hahah', 'heihei']  # 定义一个新的列表
# name_list.extend(test_list)   #在列表中加入另一个指定的列表是在末尾
                             #['红塔山', '南京', 2, 'zhangsan', '那么静', 'hahah', 'heihei']
# name_list.remove(2) # 可以从列表中删除指定数据 当有多个相同对象时，
                      # 只删除第一个-->['红塔山', 2, 'zhangsan', '那么静', 'hahah', 'heihei']
# name_list.pop()     # 默认可以删除列表中最后一个元素删除-->['红塔山', 2, 'zhangsan', '那么静', 'hahah']
# name_list.pop(1)    # 可以指定要删除元素的索引-->['红塔山', 'zhangsan', '那么静', 'hahah']
# name_list.insert(2,'亲们') # 在列表的指定位置加入亲们-->['红塔山', 'zhangsan', '亲们' '那么静', 'hahah']
# name_list.clear() # 可以清空列表-->[]
# print(name_list)
# del test_list[1]  # 删除列表索引为1的数据 ['hahah', 'heihei']-->['hahah']
# print(test_list)
# del(test_list[1]) # 删除列表索引为1的数据 ['hahah', 'heihei']-->['hahah']
# print(test_list)
# del test_list       # 将整个列表删除 啥都没了
# print(test_list)    # 列表都没了 直接报错

# cl_list = ['宣和们', '红南京', '白塔山', '白塔山']
# list_len = len(cl_list)  #  列表中有多少个数据
# count = cl_list.count('白塔山')  #  某个数据出现的次数
# print("有 %d 次" % count)
# print("有 %d 个元素" % list_len)

# cl = [9, 2, 5, 7, 1, 8, 4, 3, 0, 6]
# c2 = ['zhangsan', 'lisi', 'wangwu', '2', '9']
#  升序
# c2.sort()
# cl.sort()
#  降序
# c2.sort(reverse=True)
# cl.sort(reverse=True)
#  逆序（反转）
# c2.reverse()
# cl.reverse()
#
# print(c2)
# print(cl)

#列表遍历

c3 = ['张三', '李四', '王五', '赵六']

for c4 in c3:

    print("我的名字叫 %s" % c4)

#for 循环内部的使用变量 in 列表:
#    print(循环内部的使用变量)

# 实现列表逆序方法
def reverse_list(cl):
    # 定义一个空列表
    ret_l = []
    i = len(cl) - 1
    while i >= 0:
        ret_l.append(cl[i])  # s += c
        i -= 1

    return ret_l

print(reverse_list(cl))

元组
【元组不能被修改】
元组 使用 （）定义元组

元组表示多个元素组成的序列
用于储存一串信息，数据之间使用逗号分隔
元组的索引值从 0 开始的
元组有特定的应用场景

count()：某个数据在元组中出现的次数

index()：查找某一个数据在元组中对应的的索引下标位置

迭代遍历一个元组：

for 循环内部的使用变量 in 元组名：
    print(循环内部的使用变量)

第一种方式：for in

t = (1,2,3,4,5,'hello')
for v in t:
    print(v)

第二种
循环配合下标方式 一
len() 函数 是 length 的简写， 用来获取参数的长度（元素个数）

length = len(t)
for i in range(len(t)):  
    print(t[i])          # print（元组[]）通过索引取值，
                         # 如果[]内部的索引值一直在变则取得值也一直在变
                         # 这是print输出的就是元组的遍历

循环配合下标方式 二

i = 0
while i < len(t): # len(t) 这个元组内部有多少个数据， 比如有6个
    print(t[i])   # print（元组[]）通过索引取值，
                         # 如果[]内部的索引值一直在变则取得值也一直在变，[]括号内不的值就是从0 -6 的依次输入
                         # 这是print输出的就是元组的遍历
    i += 1

应用场景：
1.可以作为函数的参数或者返回值
2.格式字符串

  n = ('小明', 7, 2.1)
  print("%s %d %.1f" % n)
  
  m = (6, 7, 2.1)
  print("有 %d 个数据 %d %.1f "% m)
  s = "有 %d 个数据 %d %.1f "% m  # m 是元组 拼接字符串形成一个新的字符串
  print(type(s))

3.让列表不被修改，保护数据

元组和列表之间的转换
元组转列表：list（元组）

  t3 = (4, 5, 6)
  t4 = list(t3)
  print(t4)
  print(type(t4))

列表转元组：tuple（列表）

  tl = [1, 2, 3]
  t2 = tuple(tl)
  print(t2)
  print(type(t2))

元组的方法使用代码：

# info_tuple = ("张三", 18, 175, "张三", 15, "zhangsan")
# # print(info_tuple)
# # print(info_tuple[3])  #  # 元组也不能使用超出范围的下标，会出现越界错误
# s2_tuple = ()   # 空元组
# print (type(s2_tuple))
# sl = (1,)
# #注意:如果元组中只有一个元素,那么在定义时,需要加一个逗号
#
# print(info_tuple[0])  # 取值
#
# # 已经知道数据内容，希望知道数据在该院组中的索引
# print(info_tuple.index("张三"))   # 取索引
#
# print(info_tuple.count("张三"))  # 统计一个数据在元组中出现的次数
#
# print(len(info_tuple))   # 统计元组中包含数据的个数

字典
【字典使用 {} 定义字典】

格式：{key: value,…} 键值对 key–键，value–值

字典使用 键值对 存储数据，键值对之间使用逗号分隔
键 值 之间使用冒号分隔，键是唯一的，名字不能重复。值可以是任何数据类型，
但 键 只能使用字符串，数字或元组

列表式有序的数据集合
字典是’有序‘的数据集合 # 3.5版本以后的有序是指 定义顺序和显示顺序一致

字典的应用场景：

通常用于储存 “描述一个” ‘物体’ 的相关信息。{例：个人的信息…}
可以将多个字典放到同一个列表变量中，再进行一次遍历，在循环体内部针对每一个字典进行相同的处理

card_list（列表名） = [
    {"name": "小明",
     "age": 18},
    {"name":"李四",
     "age":19}
]

for card_info（循环体内部使用的变量名称） in card_list:

    print(card_info)

字典的 增 删 改 查

统计字典中键值对的数量：len(字典名)

合并字典：字典名.update（放入要合并的新字典）
注意：如果合并的字典中已包含已存在的键值对，会覆盖原有的键值对

清空字典：字典名.clear()

字典的循环遍历

变量 k 是每一次循环中，获取到的键值对的key
for k in 字典名：
    print("%s - %s"% (k,字典名[k]))

方式一 for in

for k in xiaoming:
    print("%s - %s"% (k,xiaoming[k]))

方式二
keys()方法

print(d.keys())
for k in d.keys():
    print(f'keys  :{k} --> {d[k]}')

方式三
values() 方法

print(d.values())
for v in d.values():
    print(f'values: {v}')

方式 四
items()

print(d.items())

for item in d.items():
    print(f'items: {item[0]}--》{item[1]}')

for k,v in d.items():
    print(f'item: {k}--> {v}')

解包

item = (1,2,3,4,5,6)
a,b,c,d,e = item
print(a)
print(e)

字典练习（名片管理）
函数一: 建立名片-> 建立好的名片
函数二: 显示名片-> 接收谁打印谁

def creat_card():
    **# 使用字典来保存每张名片的数据
    # name,age,address**
    card = {}
    card['name'] = input('请输入姓名：')
    card['age'] = input('请输入年龄：')
    card['address'] = input('请输入地址：')
    return card
 **显示 名片字典内容函数**
def show_card(card):
    for k in card:
        print("%s--%s" % (k,card[k]))
 **测试**
show_card(creat_card())

集合
**作用：
利用集合的特性来对数据进行去除重复数据

定义：
	set(可遍历的对象)**

定义一个集合

s = {1,2,3,4,5,6,7,7,7}
print(s)

定义一个空集合
s = {} # 这种方式 是定义一个空字典，不是集合

s = set()
print(s)
print(type(s))   这个是定义集合

s = {1,2,3,4,5,6,7,7,7}

for v in s:
print(v)

注意： 集合是不支持下标的
print(s[0])

集合，列表，元组之间的相互转化

s = 'hello'

l = list(s)
print(l)

print(set(l))

print(set(s))

l1 = str(l) # __str__
print(l1,'-----',type(l1))
print(''.join(l))

字符串字符串：可以使用一对单引号、双引号、三引号、三个双引号来定义
def defined_str():
print(’’) # 空字符串
print("")
print(’’’’’’)
print("""""")
def defined_str_space():
print(’ ‘)# 带一个空格的字符串
print(" ")
print(’’’ ‘’’)
print(""" “”")

定义一个函数，用来使用下标访问字符串
字符串同样可以索引来获取字符串中指定位置的字符，索引基数从 0 开始

def use_index_access_str():
s1 = 'abcde'
s2 = '01234'
print(s1[0])
print(s1[2])
print(s1[4])

print(s2[0])
print(s2[2])
print(s2[4])

# print(s1[5]) # IndexError: string index out of range  # 字符串下标越界

# 字符串不允许通过下标来修改字符串中的内容
# 字符串是不允许修改的，因为字符串是一个不可变对象
# s2[2] = '9'  # TypeError: 'str' object does not support item assignment

切片
字符串切片

现有一个字符串，想得到 该字符串的第3到5个字符

def str_slice(src_s, start,stop):
    # 要返回的切片后的结果
    s = ''
    i = 0
    while i < len(src_s):
        if i >= start and i < stop:
            s += src_s[i]
        i += 1

    return s
    print(str_slice('0123456789', 3, 5))

字符串切片

s = '0123456789'

print(s[0:5:1])
print(s[0:5:2])
print(s[3:6])   # 默认步长可以不写，默认为1
print(s[:5])    # 开始索引也可以不写，默认从头开始
print(s[5:])    # 结束也可以不写，默认到最后
print(s[:])     # 全默认，默认截取整串
print(s)
print(s[10:20])     # 切片时不会出现下标越界错误

切片的下标还可是以负数

负数是，是从右向左切片，起始下标为 -1

print(s[-1:-5])
print(s[-1:-5:-1])

特殊需要记住的切片方式

使用切片实现字符串逆序

print(s[::-1])

字符串的操作

A 查找
s = ‘Hello World Hello World Hello Python’
定义的变量s 把字符串储存在s中
print(s.find(’’))–> print(变量.方法(‘某个字串’,区间))
字符串.find(‘子串’) 查找 某一个子串在这个字符串当中的位置
找不到子串时,返回-1

字符串.find(‘子串’,8,20) 查找某一个子串在一个区间内下标 8到20的区间

字符串.index(‘子串’) 查找 跟find()方法一样，只不过如果str不在 mystr中会报一个异常.
print(s.index(’’))

字符串.rfind(‘子串’) 查找 类似于 find()函数，不过是从右边开始查找
print(s.rfind(’’))

字符串.rindex(‘子串’) 查找 类似于 index()，不过是从右边开始.
print(s.index(’’))

字符串.replace(‘子串1’,‘子串2’) 替换 将子串1替换成子串2 替换时默认替换 所有的 符合 的子串
替换时默认替换

print(s.replace(‘子串1’,‘子串2’,3)) 最后的参数三表示替换个数

字符串.count('子串’1,5) 统计计数 统计某一个子串在一个区间内下标 1到5的区间内出现的次数

字符串.count(“abc”) #统计小字符串第一次出现的次数，如果小字符串不存在count方法会显示 0

print(s.count(‘子串’,区间)):

B 分割

如果在分割字符串时，需要使用任何空白进行分割，那么参数中，什么也不需要写

split(‘子串’) 分割 在子串处分割一个字符串，输出的是列表 需要注意有分隔符，且每个都会生效
print(s.spilt(‘子串’))
print(s.split(‘子串’,1)) 参数一是 要分割的条件字符串，
参数二是 最大分割次数

splitlines() 只识别换行（\n）为分隔符

partition(‘子串’) 只会在子串处分割且成三部分,且输出一个元组

C 连接
join
join(‘要加入的字符’.join(s)) join() 使用当前字符串连接参数中的每个元素
每个元素后面插入要加入的字符,构造出一个新的字符串

D 判断

startswith() 判断是否以指定字符串开头

print(‘13800138000’.startswith(‘138’)) 判断字符串’13800138000’是不是以’138’为开头的字符串

endswith() 判断是否以指定字符串结尾
isupper() 判断是不是大写字母

print(‘hello’.isupper())
print(‘Hello’.isupper())
print(‘HELLO’.isupper())

islower() 判断是不是小写字母

print(‘hello’.islower())
print(‘Hello’.islower())
print(‘HELLO’.islower())

isdigit() 判断是不是数字字符

print(‘HELLO’.isdigit())
print(‘123’.isdigit())
print(‘abc123’.isdigit())
print(‘123abc’.isdigit())

isalpha() 判断是不是字母

print(‘hello’.isalpha())
print(‘Hello’.isalpha())
print(‘HELLO’.isalpha())
print(‘123’.isalpha())
print(‘abc123’.isalpha())

isalnum() 判断是不是字母或数字字符

print(‘HELLO’.isalnum())
print(‘123’.isalnum())
print(‘abc123’.isalnum())
print(‘abc 123’.isalnum())

isspace() 判断是不是空白字符，包含 空格，换行符\n，制表符\t，回车\r (理解)注意’'空字符串不是空白字符

print(’’.isspace())
print(’ ‘.isspace())
print(’\t’.isspace())
print(’\n’.isspace())

E 字符串转换

s = ‘Hello world Python JAVA asdfhaslkjf’
upper() 转换成大写 print(s.upper())

lower() 转换成小写 print(s.lower())

title() 将每个单词的首字符号大写 print(s.title())

capitalze() 将第一个单词的手字符转换成大写 print(s.capitalze)

F 对齐

center() 按给定宽度居中显示
rjust() 右对齐
ljust() 左对齐
s = ‘Hello’
print(s)
print(’|’ + s.center(11) + ‘|’) 居中

print(’|’ + s.rjust(11) + ‘|’) 右对齐

print(’|’ + s.ljust(11) + ‘|’) 左对齐

G 去除空白

strip() 去除两端空白 print(’|’ + s.strip() + ‘|’)

lstrip() 去除左侧空白 print(’|’ + s.rstrip() + ‘|’)

rstrip() 去除右侧空白 print(’|’ + s.lstrip() + ‘|’)

字符串的倒序输出

s = 'hello'
def revers_str(s):
     # 定义一个空字符串，用来拼接
     ret_s = ''
    i = len(s) - 1  #  i = 下标值，len(s) 求的是字符串的长度，
                    #  下标值是从0开始数的，所以下标值就等于字符串长度减一
    while i >= 0:
         ret_s = ret_s + s[i]
         i -= 1

    return ret_s

print(revers_str(s))