列表和元组

发布时间：2020-12-14 04:43:25 所属栏目：大数据来源：网络整理

导读：昨日回顾 1 . 基本数据类型概述 int 整数 str 字符串 bool 布尔值 True,False list 列表 [] tuple 元组 () dict 字典存储key:value set 集合不重复 bytes 字节 2 . int 整数 bit_length() 求二进制长度 3 . bool 类型类型转换结论一: 把x转化成y类型. y(

昨日回顾

    1. 基本数据类型概述
        int 整数
        str 字符串
        bool 布尔值  True,False
        list 列表 []
        tuple 元组 ()
        dict 字典 存储key:value
        set 集合 不重复
        bytes 字节
    2. int 整数
        bit_length()  求二进制长度
    3. bool 类型
        类型转换
        结论一: 把x转化成y类型. y()
        结论二: 能表示False的数据有: 0,None,"",[],tuple(),set(),{}
    4. str 字符串
        索引: 下标从0开始的数字. 指示的是字符串中的每一个字符

        切片: 从源字符串中截取一部分内容作为新字符串
            s[start: end: step]
            start: 开始
            end: 结束. 取不到
            step: 步长,默认是1. 每step取一个. 通过符号来控制方向. +从左往右,-从右往左

        一大波操作:
            1. upper() 转化成大写
            2. strip() 去掉两端的空白(空格,n,t)
            3. replace(old,new) 把字符串中的old替换成new
            4. split() 字符串切割. 返回列表
            5. startswith() 判断是否以xxx开头
            6. find() 查找 如果找不到返回-1
            7. isdigit() 判断是否是数字组成
            8. len() 字符串长度

        字符串的 遍历(迭代)
        for c in s:
            print(c)

        迭代:可以一个一个的往外拿

        for 变量 in 可迭代对象:

今日内容

    1. 什么是列表
        定义: 能装对象的对象
        在python中使用[]来描述列表,内部元素用逗号隔开. 对数据类型没有要求

        列表存在索引和切片. 和字符串是一样的.

    2. 相关的增删改查操作(重点)
        添加:(记忆1,2)
            1. append() 追加
            2. insert(位置,元素) 插入指定元素到指定位置
            #3.extend(可迭代对象) 迭代添加 把传递进去的参数进行迭代,把每一项添加到列表的末尾  (这个了解)
        删除:(记忆1,2)
            1. pop(index) 根据索引删除 删除并返回索引项
            2. remove(元素)  根据元素删除 删除第一次出现的指定元素,如果元素不存在则报错(,没有返回值,打印的结果是None)
            #3.del 用切片或者索引删除 全局删除 不常用(是关键字???)
            #4.clear() 清空

        修改:
            索引修改
            lst[索引] = 元素  坑: 如果步长不是1. 元素的个数必须要和切片的个数一致
        查询:
            for循环.

    3. 列表的嵌套
        多个列表互相嵌套
    4. 列表的其他操作
        1. count(‘元素‘)  计数
        2. sort() 排序,改变原列表  reverse = True
        3. reverse() 翻转,改变原列表
        4. len() 求长度

    5. 什么是元组
        能装对象的对象. 不可变. 一旦确认好. 不可更改
        只读列表
        可以迭代

    6. 元组的嵌套
        和列表一样.都可以互相嵌套.
        元组的不可变: 指向不变

    7. range(重点,难点)
        数数
        range(n) 数学中的[0,n),前闭后开(前面能取到,后面不能取到)
        range(m,n) [m,n)
        range(m,n,p) [m,n) 每隔p取一个

        # 重点
        for i in range(len(lst)):
            i 是索引
            lst[i] 是元素


    预习:
        字典(新华字典)
        增删改查
        字典嵌套

        set集合

1. 列表

1.1 列表的介绍

列表是python的基础数据类型之一,其他编程语言也有类似的数据类型. 比如JS中的组,java中的数组等等. 它是以[ ]括起来,每个元素用‘,‘隔开而且可以存放各种数据类型:

 lst = [1,‘哈哈‘,"吼吼",[1,8,"百度"],("我","叫","元","组"),"abc",{"我 叫":"dict字典"},{"我叫集合","集合"}]

列表相比于字符串. 不仅可以存放不同的数据类型. 而且可以存放?量的数据. 32位 python可以存放: 536870912个元素,64位可以存放: 1152921504606846975个元素.而且列表是有序的(按照你保存的顺序),有索引,可以切片方便取值.

1.2 列表的索引和切片

列表和字符串一样也拥有索引:

lst = ["麻花藤","王剑林","马芸","周鸿医","向华强"] print(lst[0]) # 获取第一个元素
print(lst[1])
print(lst[2])

lst[3] = "流动强" # 注意. 列表是可以发生改变的. 这里和字符串不一样 
print(lst) # [‘麻花藤‘,‘王剑林‘,‘马芸‘,‘流动强‘,‘向华强‘]

s0 = "向华强"
s0[1] = "美" # TypeError: ‘str‘ object does not support item assignment 不允许改
print(s0)

列表的切片:

 lst = ["麻花藤","向华强"] print(lst[0:3]) # [‘麻花藤‘,‘马芸‘] 
print(lst[:3]) # [‘麻花藤‘,‘马芸‘]

print(lst[1::2])  # [‘王剑林‘,‘周鸿医‘] 也有步长
print(lst[2::-1])  # [‘?马芸‘,‘麻花藤‘] 也可以倒着取
print(lst[-1:-3:-2])  # 倒着带步长

2. 列表的增删改查

# 列表
lst = ["光头强",1,True,{},(1,),{123},["周杰伦","周杰","结论"]]
print(lst)

# 索引和切片
lst = ["天龙八部","西游记","红楼梦","银平煤","绿平煤"]

print(lst[3])
print(lst[-3])
print(lst)
print(lst[1:4]) # 切片，原来是什么类型. 得到的就是什么类型
print(lst[-1::-2]) # 倒着切


lst = ["凡人修仙传","诛仙","神墓"]
# 添加 append() 追加. 在后面添加
lst.append("看见")
lst.append("追风筝的人")

# 插入 insert(位置,元素),效率相对比较低
lst.insert(1,"琴帝")

# 迭代添加,把传递进去的参数进行迭代. 把每一项添加到列表的末尾
lst.extend(["胡辣汤","猪蹄子","猪头肉","五花肉"])

print(lst)


# # 删除
lst = ["斗破苍求","手机","爵迹","满城尽带黄金甲","三生三世十里桃花"]

# pop() 默认从后往前删
lst.pop()
# pop(索引) 按照索引位置删除
lst.pop(1)

# remove(元素)  移除
print(lst.remove("满城尽带黄金甲")) # 当元素不存在的时候会报错,没有返回值(结果是None)

# del lst[::2] # 用切片或者索引删除 不常用
lst.clear() # 清空.

print(lst)

# 修改
lst = ["苏秦","武大","武二","宝元","李诞","池子","王建国"]
lst[3] = "松江" # 通过索引修改  index out of range 索引下标越界
print(lst)
lst[1:3] = ["麻花藤"] # 迭代更新(不常用)
print(lst)
lst[1:5:2] = ["麻花藤","码云"]  # 坑: 如果步长不是1. 元素的个数必须要和切片的个数一致
print(lst)

lst = ["alex","wusir","胡辣汤"]
# 把列表中的wusir替换成大写 WUSIR
# 首先你要获取到2元素
# 变成大写
# 塞回去(必须要放回去)
lst[1] = lst[1].replace("wusir","WUSIR")
print(lst)

# 查询,列表是一个可迭代对象
lst = ["jay","wlh","lzw","wf"]
for item in lst: # item是lst中的每一项
    print(item)

for i in 123:  # ‘int‘ object is not iterable
    print(i)

View Code

1. 增

注意,list和str是不一样的. lst可以发生改变. 所以直接就在原来的对象上进?了操作

# 末尾添加  append
lst = ["麻花藤","林俊杰","周润发","周芷若"] 
print(lst)
lst.append("wusir")
print(lst)

lst = []
while True:
    content = input("请输入你要录?的员工信息,输入Q退出:") 
    if content.upper() == ‘Q‘:
        break
    lst.append(content)
print(lst)

# 插入  insert
lst = ["麻花藤","张德忠","孔德福"]
lst.insert(1,"刘德华") # 在1的位置插入刘德华. 原来的元素向后移动一位 
print(lst)

# 迭代添加  extend
lst = ["王志文","张一山","苦?无涯"] 
lst.extend(["麻花藤","麻花不疼"]) 
print(lst)

2. 删除

pop,remove,clear,del

lst = ["麻花藤","李嘉诚","王富贵"] 
print(lst)

deleted = lst.pop() # 删除最后一个 
print("被删除的",deleted)
print(lst)

# 按照索引位置删除,pop原意是弹出
el = lst.pop(2) # 删除2号元素 
print(el)
print(lst)

lst.remove("麻花藤") # 删除指定元素
print(lst)
# lst.remove("哈哈") # 删除不存在的元素会报错 
# # print(lst)

lst.clear()  # 清空list
print(lst)

# 切?删除 
del lst[1:3] 
print(lst)

3. 修改

索引切片修改

 # 修改
lst = ["太白","太黑","五色","银王","日天"] 
lst[1] = "太污" # 把1号元素修改成太污 
print(lst)

lst[1:4:3] = ["麻花藤","哇靠"] # 切片修改也OK. 如果步?长不是1,要注意. 元素的个数
print(lst)

lst[1:4] = ["李嘉诚个龟儿子"] # 如果切片没有步长或者步?是1. 则不用关心个数 
print(lst)

4. 查询

列表是一个可迭代对象,所以可以进行for循环

 for el in lst:
    print(el)

5. 其他操作

lst = ["太白","太白","日天","女神","alex","太白"]
print(lst.count("太白")) # 查看xxx元素出现的次数


lst = [1,12,22,2,33,4,5]
lst.sort() # 排序. 默认升序
lst.sort(reverse=True) # reverse 反向,降序
print(lst)

lst = ["赤木","樱木花道","流川枫","三井"]
lst.reverse() # 把列表翻转
print(lst)  # [‘三井‘,‘流川枫‘,‘樱木花道‘,‘赤木‘]

lst= [1,3,5,"胡辣汤"]
print(len(lst)) # 查看列表中元素的个数

list # 按住ctrl +鼠标左键查看源码

View Code

lst = ["太白","太白"] 
c = lst.count("太白") # 查询太白出现的次数 
print(c)

lst = [1,11,2]
lst.sort() # 排序. 默认升序  直接改变到原列表
print(lst)
lst.sort(reverse=True) # 降序   reserve是翻转,反向的意思
print(lst)

lst = ["太白","太白"] 
print(lst)
lst.reverse()  # 把列表的元素翻转
print(lst)

l = len(lst) # 列表的长度,即列表中元素的个数 
print(l)?

3. 列表的嵌套

lst = [["张艺谋","冯小刚","陈凯歌"],["李安","王家卫","王晶"],["abc","alex_wusir",["胡辣汤","c"]],"风扇哥"]]
print(lst[1][1][2])

# 把王晶换成"贾樟柯"
lst[1][2] = "贾樟柯"
print(lst)

# $$$$$$$
# 降维操作 ["哈哈","hehe","houhou"] 一维  [[1,3],[12,5],[6,7,8]] 二维
# 数数
lst[2][1][1] = lst[2][1][1].replace("_","$")
print(lst)

View Code

采?降维操作.一层一层的看就好.

lst = [1,["马?疼",["可口可乐"],"王剑林"]] 

# 找到wusir
print(lst[2])

# 找到太白和wusir
print(lst[1:3]) 

# 找到太白的白字
print(lst[1][1])

# 将wusir拿到. 然后?字母大写. 再扔回去 
s = lst[2]
s = s.capitalize()
lst[2] = s
print(lst)
# 简写
lst[2] = lst[2].capitalize() # 注意:一定要再扔回去
print(lst)  

# 把太白换成太?
lst[1] = lst[1].replace("白","黑") 
print(lst)

# 把马虎疼换成马化疼
lst[3][0] = lst[3][0].replace("虎","化")
print(lst[3][0])

lst[3][1].append("雪碧") 
print(lst)

4. 元组和元组嵌套

# 元组用()表示,只读列表. 冯提莫
tu = ("DNF","LOL","王者荣耀","QQ飞车","炫舞",[])
print(tu)
# tu[1] = "呵呵" # 报错‘tuple‘ object does not support item assignment
print(tu)

# 元组也有索引和切片
print(tu[3:5])
print(tu[3:7:2])

# 元组有坑
# 空元组
tu = tuple() # 固定写法
# 元组中如果只有一个元素(括号不是元组的标志,逗号才是,有逗号就是元组)
tu = (1) # 不是元组   <class ‘int‘>
tu = (1,) # 这个是元组 <class ‘tuple‘>
print(type(tu))

# 好习惯: 写元组的时候末尾加个逗号

tu = ("锅包肉","酸菜炖粉条+五花肉","红烧鲤鱼","红烧肉")
# 元组也是可迭代的
for item in tu: # 可以使用for循环
    print(item)


tu = (1,"哈哈","胡辣汤",["忍者","神龟"])
# tu[1] = "呵呵" # 元组不可变
tu[3] = ["我是新列表"] # 改变了指向. 报错
tu[3].append("孙悟空") # 元组没改. 改的是元素内部 没有改变元组的指向. 不报错
print(tu)

tu = tuple()#空元组 的固定写法
tu = (1)# 不是元组,是 int,这里的()当成数学上的小括号,类似于(1+1)
tu = (1,)# 只有一个元素的时候,末尾必须加个逗号 此时才是元组
#好习惯: 写元组的时候末尾加个逗号

#可迭代  for
#元祖的的不可变,是内部元素的指向不可变.  是元组对内部元素的指向不变,但是内部的可变元素的内部是可变的

View Code

元组: 俗称不可变的列表.又被称为只读列表,元组也是python的基本数据类型之一,用小括号括起来,?面可以放任何数据类型的数据,查询可以. 循环也可以. 切片也可以. 但就是不能改.

tu = (1,"李白","怎么黑")
print(tu)

print(tu[0])
print(tu[2])
print(tu[2:5]) # 切片之后还是元组

# for循环遍历元组 
for el in tu: 
    print(el)
# 尝试修改元组
# tu[1] = "?虎疼" # 报错 ‘tuple‘ object does not support item assignment

tu = (1,"呵呵")
# tu[2] = ["fdsaf"] # 这么改不行

tu[2].append("麻花藤") # 可以改了. 没报错 tu[2].append("王剑林")
print(tu)

关于不可变, 注意:

这里元组不可变的意思是子元素不可变,而子元素内部的子元素是可以改变的,这取决于子元素是否是可变对象.

关于元组的书写,注意:

元组中如果只有一个元素. 一定要添加一个逗号,否则就不是元组.元组的标志是逗号,而不是小括号

# type(对象) 是查看对象的数据类型

tu = (1)
print(type(tu))  # <class ‘int‘>

tu = (1,)
print(type(tu))  # <class ‘tuple‘>

tu = 1,print(type(tu))  # <class ‘tuple‘>

元组也有count(),index(),len()等方法. 可以?自己测试使?

5. range

i = 1
while i <=100:
    print(i)
    i += 1

 # range(参数)  [0,参数)
for i in range(20): #  range()可以被迭代 0-9
    print(i)

# range(参数1,参数2)  [参数1,参数2) 切片
for i in range(10,20):
    print(i)

# range(参数1,参数2,参数3)  [参数1,参数2) 每隔参数3个位置取一个
for i in range(10,20,3):
    print(i)

lst = ["周杰伦","动画城","大风车","随便加","宝宝","孟孟","萌萌","孟萌"]

for item in lst: # 只能拿到元素. 获取不到索引
    print(item)

for i in range(len(lst)): # i就是索引 lst[i]元素
    print(i,lst[i])

View Code

range可以帮我们获取到一组数据. 通过for循环能够获取到这些数据.

# range(start,end,step)前闭后开,类似于切片
# 只有一个参数的话,默认是作为end,从0开始的,步长为1

for num in range(10):
    print(num)

for num in range(1,10,2):
    print(num)

for num in range(10,-2):  # 反着来,和切片一样
    print(num)

今日作业

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!