列表和元组

昨日回顾

    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,0,"百度"], ("我","叫", "元", "组"), "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, 8,12,22,1,1,2,33,4,5]
lst.sort() # 排序. 默认升序
lst.sort(reverse=True) # reverse 反向, 降序
print(lst)

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

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

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

View Code

 

lst = ["太白", "太黑", "五色", "银王", "日天", "太白"] 
c = lst.count("太白") # 查询太白出现的次数 
print(c)

lst = [1, 11, 22, 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,2,3], [12,4,5], [6,7,8]] 二维
# 数数
lst[2][1][1] = lst[2][1][1].replace("_", "$")
print(lst)

View Code

 

采⽤降维操做.一层一层的看就好.

lst = [1, "太白", "wusir", ["马⻁疼", ["可口可乐"], "王剑林"]] 

# 找到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飞车", "炫舞", {}, tuple(), [])
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, 1, -2):  # 反着来,和切片同样
    print(num)

 

 

 

今日做业

今日做业