python 第四章 list列表+tuple元组+range范围

python 第四章

list 列表

# 列表 -- list  相当于一个容器
# 有序的，可变的，支持索引，可增删改
# 用于存储数据
# 支持的数据类型：str int bool list tuple dict set

# 定义一个列表
lst = ["a",123,True,[123],(1,),{"a":"b"},{"2"}] #用,号分割的是一个元素
print(lst)
# 输出["a",123,True,[123],(1,),{"a":"b"},{"2"}]

# 增加:append insert extend

# append 追加，在列表的最后位置添加元素
lst.append("add")
print(lst)
# 输出['a', 123, True, [123], (1,), {'a': 'b'}, {'2'}, 'add']

# insert 插入，根据索引插入位置(当数据量比较大的时候会影响效率)
lst.insert(2,"add2")
print(lst)
# 输出['a', 123, 'add2', True, [123], (1,), {'a': 'b'}, {'2'}]

# extend 迭代添加 除int，bool外都是可迭代类型
lst.extend("可迭代的内容")# str型
print(lst)
# 输出['a', 123, True, [123], (1,), {'a': 'b'}, {'2'}, '可', '迭', '代', '的', '内', '容']

lst.extend(("add","3"))# tuple型
print(lst)
# 输出['a', 123, True, [123], (1,), {'a': 'b'}, {'2'}, 'add', '3']


# 删：del pop remove clear

# del 可通过索引／切片／步长删除
# del 索引删除
del lst[0]
print(lst)
# 输出[123, True, [123], (1,), {'a': 'b'}, {'2'}]

# del 切片删除
del lst[0:3] # 从0开始到3的元素都删除
print(lst)
# 输出[[1, 23], (1,), {'a': 'b'}, {'2'}]

# del 步长删除
del lst[0:6:2]
print(lst)
# 输出[123, [1, 23], {'a': 'b'}, {'2'}]

# pop 默认删除第一个，通过索引删除
# pop 默认删除第一个
lst.pop()
print(lst)
# 输出['a', 123, True, [1, 23], (1,), {'a': 'b'}]

# pop 索引删除
lst.pop(2)
print(lst)
# 输出['a', 123, [1, 23], (1,), {'a': 'b'}, {'2'}]

# remove 元素名称删除
lst.remove(123)
print(lst)
# 输出['a', True, [1, 23], (1,), {'a': 'b'}, {'2'}]

# clear 清空
lst.clear()
print(lst)
# 输出[]

# 改 可通过索引／切片／步长改
# 索引
lst[1] = "add"
print(lst)
# 输出['a', 'add', True, [1, 23], (1,), {'a': 'b'}, {'2'}]

# 切片，可多可少，可一一对应
lst[1:2] = "b"
print(lst)
# 输出['a', 'b', True, [1, 23], (1,), {'a': 'b'}, {'2'}]
lst[1:4] = "c" #从第一个元素到第四个元素替换成一个元素
print(lst)
# 输出['a', 'c', (1,), {'a': 'b'}, {'2'}]
lst[1:4] = "d","e","f" #一一对应，修改三个元素
print(lst)
# 输出['a', 'd', 'e', 'f', (1,), {'a': 'b'}, {'2'}]
lst[1:4] = "a","b","c","d"
print(lst)
# 输出['a', 'a', 'b', 'c', 'd', (1,), {'a': 'b'}, {'2'}]

# 步长 步长不为一，需一一对应
# lst[1:4:2] = "a"
# 输出 提示错误ValueError: attempt to assign sequence of size 1 to extended slice of size 2
lst[1:4:2] = "a","b"
print(lst)
# 输出['a', 'a', True, 'b', (1,), {'a': 'b'}, {'2'}]

# 查：
# for 循环
# 循环输出每一个元素，需ptint 有缩进
for i in lst:
    print(i)
# 输出
# a
# 123
# True
# [1, 23]
# (1,)
# {'a': 'b'}
# {'2'}

# 只输出最后一个元素，print 无缩进
for i in lst:
    pass
print(i)
# 输出{"2"}


# 列表嵌套
lst = [1,"alex","春生","小东北","渣弟",
       ["大黑哥",["常鑫",["自行车"],"大煎饼","掉井盖","三金"],
    "冯强","海峰",["太白金星","女神","吴超",["肖锋"]]]]
print(lst[-1][1][1][0])


a = lst[-1][-1][-2]
print(a)
# 不管什么类型进行切片的时候获取都到都是源数据类型

tuple 元组

# 元组 -- tuple
# 有序，不可变，支持索引
# 用于存储一些重要信息
# 在配置文件中使用
# 是不可变的列表

# 定义方式：
tu = (1,"a",True,[1,2,3])
print(tu)
# 输出 (1, 'a', True, [1, 2, 3])

# 查询：索引、for循环
# 索引查询
print(tu[0:3])
# 输出 (1, 'a', True)

# for 循环
# 元素一一输出
for i in tu:
    print(i)
# 输出
# 1
# a
# True
# [1, 2, 3]

# 只输出最后一个元素
for i in tu:
    pass
print(i)
# 输出 [1, 2, 3]

range 范围

# !/usr/bin/python
# -*- coding: utf-8 -*-
# @File    : 03 range.py
# @time    : 2019-07-0911:58
# @Author  : zhangshan33

# range -- 范围
# 特点：顾头不顾尾

# range 在python3和python2中的区别
# python3 中的range是一个可迭代对象，写的怎么样打印出来就是怎样
# 获取成列表：
print(list(range(0,10)))# 转成列表的时候顾头不顾尾
# 输出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# python2 中的range返回的是一个列表

# range获取范围
# 转成列表的时候顾头不顾尾
# 正序
print(list(range(10))) #头不写，默认从0开始，步长不写，默认为1 [0:10:1]
# 输出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(0,10)))# 从0算到9
# 输出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(0,10,3)))# 按步长输出
# 输出 [0, 3, 6, 9]
# 倒序（必须加步长）
print(list(range(10,0,-3)))# 倒序输出
# 输出[10, 7, 4, 1]

# range 范围一般与for循环使用
# 使用for和range循环打印100～1
for i in range(100,0,-1):
    print(i)
# 输出100-1

# 循环打印1-100 的奇数
for i in range(1,100,2):
    print(i)

# 不能与while使用，会形成死循环
while range(0,10):
    print(1)

# 循环打印三次"请输入姓名"将三次结果打印到列表中
# for循环
lss = []
for i in range(0,3):
    u = input("请输入姓名：")
    lss.append(u)
print(lss)

lss = []
for i in range(3):
    lst.append(input("请输入姓名:"))
print(lss)

# while循环
lss = []
count = True
while count:
    u = input("请输入姓名：")
    lss.append(u)
    if len(lss) == 3:
        count =False
print(lss)

今日总结

# 
# 列表：list
# 定义方式：
# lst = [,,,,]
# 有序，可变的，可索引的，支持增删改查
# 作用：存储数据的，支持很多种数据类型
# 列表元素：用,号隔开
# 
# 
# 
# 增：
# append    追加
# insert    插入  需要声明位置  尽量不要用
# extend    迭代添加 可迭代内容
# 
# 删：
# pop
# 弹 默认删除最后一个元素
# 通过指定索引进行删除
# 删除有返回值，返回被删除的元素
# remover
# 移除 通过元素名字进行删除，删除第一个
# clear
# 清空
# del lst      默认全部删掉
# del lst[1:10:2] 可通过索引／切片／步长删除
# 
# 
# 
# 改
# 索引
# 切片会补位，多了补位，少了也补位，用逗号隔开
# 步长不为1的必须一一对应，不然会报错
# 
# 查
# for 循环
# lst = ["abc",123,"efg",True,"您好"]
# for i in lst:
#     print(i)
# 
# 
# 列表的嵌套
# [[]]
# 取值通过索引进行取值，一层一层的进行查找
# 不管什么类型进行切片按照源类型输出
# 
# 
# 元组：tuple
# 定义的方式：
# tu = (1,"alex",[1,2,3])
# 用于存储一些比较重要的信息
# 不可变的列表
# 用于配置文件中
# 有序，不可变
# 不能增删改
# 只能查，支持索引和for查看
# for i in tu:
#     print(i)
# 
# range--范围
# 
# python3 中的range是一个可迭代对象
# 写的怎么样打印出来就是怎样
# 获取成列表：
# list(range(0,10)) 转成列表的时候顾头不顾尾
# python2 中的range返回的是一个列表
# 
# range(起始位置,终止位置)  --  [起始位置:终止位置]
# range(终止位置)  --  [:终止位置]
# range(起始位置,终止位置,步长)  --  [起始位置:终止位置:步长]
# 
# range和for配合使用
# range(起始位置，终止位置)
# 终止位置
# 步长

元组小结