扩大
缩小

いらっしゃいませ

4.列表和元组

一. 列表 

列表的介绍     

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

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

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

 列表的索引和切片   

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

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])    # 倒着带步长

二. 列表的增删改查

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

1. append() 追加
2. insert(位置, 元素) 插入指定元素到指定位置
3 .extend()  迭代添加

lis = ["小白","小黑"]
lis.append("小钱") #添加append() 追加,在后面添加
print(lis)
lis.insert(1,"小黄") #insert(位置,元素),效率相对较低
print(lis)
lis.extend("小绿")#迭代添加,把传递进取的参数进行迭代放在最后
print(lis)
lis.extend(["小狗","12"])
print(lis)

删除

1. pop(index) 根据索引删除
2. remove(元素) 根据元素删除
3. clear() 清空列表

4.del 删除整行列表

lis = ["小白","小黑"]
lis.pop() #默认从后往前删
print(lis)

lis.remove("小钱")#移除
print(lis)

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

del lis[:2]#切片删除
print(lis)

修改:

索引修改
lst[索引] = 元素

lis = ["苏秦","武大","武二","元宝","佩奇"]
lis[2] = "wusir"
print(lis) #['苏秦', '武大', 'wusir', '元宝', '佩奇']
lis[1:2] = ["马化腾",123]
print(lis) #['苏秦', '马化腾', 123, 'wusir', '元宝', '佩奇']
lis[1:5:2] = ["小白","小黑"]
print(lis) #['苏秦', '小白', 123, '小黑', '元宝', '佩奇']
lis = ["alex","wusir","胡椒汤"]
lis[1] = lis[1].upper()
print(lis) #['alex', 'WUSIR', '胡椒汤']
lis[1] = lis[1].replace("wusir","WUSIR")
print(lis)#['alex', 'WUSIR', '胡椒汤']

查询

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

list = ["jay","wlh","lzw","wf"]
for i in list:#jay wlh lzw wf
    print(i)

for i in 123: #不能迭代TypeError: 'int' object is not iterable
    print(i)

lis = ["太白","太白","太黑","太白","女神"]
print(lis.count("太白")) #3

其他操作

1. count() 计数
2. sort() 排序 reverse = True
3. reverse() 翻转
4. len() 求长度

lis = ["太白","太白","太黑","太白","女神"]
print(lis.count("太白")) #3

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

lst = ["张三","李四","小吴","大白"]
lst.reverse() #把列表翻转
print(lst)#['大白', '小吴', '李四', '张三']
print(len(lst))#查看元素的个数

列表嵌套

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

# -*- coding:utf-8 -*-
lst = [["张艺谋", "冯小刚", "陈凯歌"], ["李安", "王家卫", "王晶"], ["周杰伦",["abc", "alex_wusir", ["胡辣汤", "c"]], "风扇哥"]]
print(lst[1][1][1]) #
lst[1][2] = "柯南"
print(lst)#[['张艺谋', '冯小刚', '陈凯歌'], ['李安', '王家卫', '柯南'], ['周杰伦', ['abc', 'alex_wusir', ['胡辣汤', 'c']], '风扇哥']]
lst[2][1][1]=lst[2][1][1].replace("_","$")
print(lst)#[['张艺谋', '冯小刚', '陈凯歌'], ['李安', '王家卫', '柯南'], ['周杰伦', ['abc', 'alex$wusir', ['胡辣汤', 'c']], '风扇哥']]

 元组和元组嵌套 

 元组

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

tu = ("DNF","LOL","王者荣耀","QQ飞车","炫舞",{},tuple(),[])
print(tu) #('DNF', 'LOL', '王者荣耀', 'QQ飞车', '炫舞', {}, (), [])
# tu[1] = "hehe"#报错TypeError: 'tuple' object does not support item assignment
#切片
print(tu[3:5])#('QQ飞车', '炫舞')
print(tu[3:7:2])#('QQ飞车', {})
tu = tuple() #固定写法
print(tu)#()
#元组中如果有一个元素
tu = (1) #不是元组
print(tu)#1
tu = (1,) #是元组
print(tu)#(1,)
tu = ("包子","火锅","水煮鱼")
#元组可迭代
for item in tu:
    print(item)#包子 火锅 水煮鱼
tu= (1,"哈哈","喝鸡汤",["忍者","神龟"])
# tu[3] = ["我是新列表"] #改变了指向,报错
tu[3].append("孙悟空") #元组没变 ,没有改变元组的指向
print(tu)#(1, '哈哈', '喝鸡汤', ['忍者', '神龟', '孙悟空'])

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

元组中如果只有一个元素. 一定要添加一个逗号, 否则就不是元组 

lst = ["周杰伦","王宝强","大风车","小白鼠"]
for item in lst:
    print(item)#周杰伦 王宝强 大风车 小白鼠

for i in range(len(lst)):
    print(i,lst[i]) #0 周杰伦 1 王宝强 2 大风车 3 小白鼠

 

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. append() 追加
            2. insert(位置, 元素) 插入指定元素到指定位置
            extend() #迭代添加
        删除:
            1. pop(index) 根据索引删除
            2. remove(元素)  根据元素删除
            3. clear() #清空列表
        修改:
            索引修改
            lst[索引] = 元素
        查询:
            for循环.
            count() #统计个数

    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] 元素
大概内容

 

 作业

4.列表和元组作业 

 

posted @ 2019-02-24 14:20  等待の喵  阅读(...)  评论(...编辑  收藏