python基础4 列表和元组

一、 列表

列表：python基础数据类型之一：其他语言中也有列表的概念，js 数组，可索引，可切片，可加步长
li = ['hello', 100, True, [1, 2, 3], {'name':'goodboy'},(22, 33)]
列表可以存储大量的数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。

注意：
字符串使用了字符串的方法后，形成的是新的字符串，与原字符串没有任何关系，
必须要用新的变量接收这个新的字符串，或者可以直接可以用print打印

列表使用列表的方法后，是对本身列表进行修改，所以不能直接打印

例如：

list1 = [9, 2, 7, 6, 1, 3]
print(list1.sort())  # 这样打印的结果是None

list1 = [9, 2, 7, 6, 1, 3]
list1.sort()
print(list1)  # 这样打印的结果才是排序后的结果，list1.sort()是对本身list1进行修改的操作
              #并不是新的列表
              #即先调用方法对本身(list1)
              # 进行修改，再使用修改后的list1

# 而字符串：
msg = 'hello'
print(msg.upper())  # 可以直接打印出大写的HELLO，因为调用了upper方法后
                    # 形成的是一个新的字符串，msg.upper()
                    # 代表一个新的字符串

二、 列表的索引，切片，步长(与字符串的索引，切片，步长相似)

存进去的数据是什么类型，拿出来的就是什么类型

li = ['hello', 100, True, [1, 2, 3], {'name':'goodboy'},(22, 33)]
print(li[0],type(li[0]))
print(li[1],type(li[1]))
print(li[2],type(li[2]))
print(li[:4])
print(li[::2])
print(li[-1:-4:-2])
print(li[-1:2:-2])

三、 列表的常用操作

# 增删改查和其他方法。

l1 = ['hello', 'hi', 'handsome', 'boy', 'is', 'me', 'jian']
# 增：
# append ：在末尾追加
l1.append('小老师')
print(l1.append([1, 2, 3]))
print(l1)

# 应用：
name_list = ['赵三', '李四']
while 1:
    username = input('请输入新员工姓名：').strip()
    if username.upper() == 'Q': break
    name_list.append(username)
print(name_list)

# insert：插入，选择在哪个位置插入
l1.insert(1, '小哥')
print(l1)

# extend：迭代着在末尾追加
l1.extend('abc')
l1.extend([111, 222, 333])
l1.extend(['shuai', 'ge'])
print(l1)

# 删除：
# pop：按照索引去删除(不写索引，默认删除最后一个)
# pop按照索引删除，有返回值(列表方法只有pop有返回值，返回的是被删除的元素，并不是返回一个列表)
ret = l1.pop(0)  # 删除第一个元素
ret2 = l1.pop()  # 删除最后一个元素
print(ret)  # 返回值
print(l1)  # 被删除了一个元素的列表l1

# remove：按照元素删除
l1.remove('hello')
print(l1)

# clear：清空
l1.clear()
print(l1)

# del：删除
# 1，可以按照索引删除
del l1[0]
print(l1)
# 2，可以按照切片删除（可以加步长）
del l1[:2]
del l1[3:]
del l1[1::2]
print(l1)
# 3，可以在内存级别删除整个列表
del l1
print(l1)

# 改：
# 按照索引改：
l1[2] = '男神'
l1[-1] = '泰迪'

# 按照切片改：先清空切片的内容，再把要添加的内容迭代加入进去
"""需要注意的是，切片和步长的改，新修改的值必须是可迭代的，比如: l1[:2] = 999 会报错"""
l1[:2] = 'sbsbsb'  # ['s', 'b', 's', 'b', 's', 'b', 'handsome', 'boy', 'is', 'me', 'jian']
l1[:4] = [11, 22, 33, 44, 55, 66, 77]  # [11, 22, 33, 44, 55, 66, 77, 's', 'b', 'handsome', 'boy', 'is', 'me', 'jian']
# 按照切片加步长：一一对应，即对应着改
l1[:3:2] = 'af'
print(l1)

# 查：
# 索引，切片，切片 + 步长
# for 循环
for i in l1:
    print(i)

# 其他方法：
print(len(l1))  # 查询总长度
print(l1.count('hello'))  # 某个元素出现的次数
# index：通过元素找索引
print(l1.index('hi'))

l2 = [5, 6, 7, 1, 4, 3, 2, 9]
# sort：从小到大排序
l2.sort()
print(l2)

l2.sort(reverse=True)  # 从大到小排序
print(l2)

l2.reverse()  # 反转，从最后一个倒着排序
print(l2)

四、 列表的嵌套

l3 = ['hello', 'jiange', ['handsome', 18, 'good'], 20]
# 1，找到hello的e元素。
# 方法一
s1 = l3[0]
print(s1[1])

# 方法二
s2 = l3[0][1]
print(s2)

# 2，将jiange变成大写。
w1 = l3[1]
w2 = w1.upper()
l3[1] = w2   # l3[1] = l3[1].upper()
print(l3)

# 3，给此列表['handsome', 18, 'good']追加一个元素, '脑残儿'
l3[2].append('脑残儿')
print(l3)

# 4，将'handsome'首字母大写。
s1 = l3[2][0].capitalize()
l3[2][0] = s1   # l3[2][0] = l3[2][0].capitalize()

# 为什么列表可以直接追加，而字符串要重新赋值呢
# 因为字符串的操作是形成新的字符串与原来的字符串没有任何关系
# 所以要把新的字符串重新赋值给指定的位置

# 列表的增删改都是对本身进行操作，所以本身已经被修改了，不需要重新赋值

# 例如：
l3[2][0].capitalize()   # 这里生成的是新的字符串，而本身l3[2][0]的字符串并没有修改
l3[2].append(666)       # 这里是直接对l3[2]这个列表进行追加，直接修改了l3[2]这个列表
print(l3)                # 结果是l3[2][0]并没有修改，而l3[2]则追加了 666
l3[2][0] = l3[2][0].capitalize()  # 把新的字符串赋值给l3[2][0]
print(l3)                 # 结果是l3[2][0]修改了

# 5，将18通过数字加1的方式变成19，并放回原处。
l3[2][1] = l3[2][1] + 1   # l3[2][1] += 1
print(l3)

五、range

range: 自定制的, 数字范围的, 可迭代对象, 类比成列表
range(起始, 结束, 步长)  # 其中，起始和步长可不写，那么起始默认为0，步长默认为1，且跟列表索引一样顾头不顾尾
range(1, 101)  # 从1开始到100
print(range(1, 101))

# range() 一般和 for 循环结合使用。
for i in range(5):
    print(i)  # 0 1 2 3 4

for i in range(1, 5):
    print(i)  # 1 2 3 4

for i in range(1, 5, 2):
    print(i)  # 1 3

for i in range(5, 1, -1):
    print(i)  # 起始数字比结尾数字大，那么使用反向步长，5 4 3 2

l1 = ['hello', 'hello', 'jiange', ['handsome', 18, 'good'], 20]

输出l1的所有元素的索引值
方法一：不好，因为有重名元素时会返回同一个值
for i in l1:
    print(l1.index(i))

方法二：
for i in range(0, len(l1)):
    print(i)

六、in not in

s1 = 'hello'
l1 = ['hello', 'hello', 'jiange', 'handsome', 18, 'good', 20]
print('h' in s1)  # True
print('he' in s1)  # True
print('heo' in s1)  # False
print('hello' not in l1)  # False
print('hello' in l1)  # True

# 注意：l1只是有两个 "hello" 元素，并不存在 ['hello', 'hello'] 这样的列表
print(['hello', 'hello'] in l1)  # False

七、元组

元组：只读列表，只允许查询，不允许增删改
应用场景： 一些非常重要的数据，不允许所有人修改的，放在元组中。

1、元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义
tup1 = (50,)

如果元组中只有一个数据，且没有逗号，那么该"元组"的数据类型与里面的数据类型一致,
只有一个数据的时候需要一个逗号消除歧义，该数据类型才是元组。
tu1 = (1)
print(tu1, type(tu1))  # 1 int

tu1 = (1,)
print(tu1, type(tu1)) # (1,) tuple

tu2 = ('hello')
print(tu2, type(tu2))  # hello str

tu2 = ('hello',)
print(tu2, type(tu2))  # ('hello',) tuple

2、元组中的元素值使不允许修改的，但可以对元组进行连接组合
tup1 = (12, 34)
tup2 = ('abc','xyz')

tup1[0] = 100  # 非法操作，元组中的元素是不允许被修改的，会报错

tup3 = tup1 + tup2  # python允许元组进行连接组合
print(tup3)  # (12, 34, 'abc', 'xyz')

3、元组中的元素是不允许删除的，但可以使用del语句来删除整个元组
del tup1

4、元组之间可以使用+和*，即允许元组进行组合连接和重复复制，运算后会生成一个新的元组
tup1 = (1, 2, 3)
tup2 = (3, 4, 5)
tup3 = tup1 + tup2
print(tup3)  # (1, 2, 3, 3, 4, 5)

tup4 = tup1 * 3
print(tup4)  # (1, 2, 3, 1, 2, 3, 1, 2, 3)

5、元组的查(没有增改，删只能删除整个元组)可用切片操作和for循环
索引，切片，切片+步长
tup1 = (1, 2, 3, 4, 5)
print(tup1[0])  #
print(tup1[:3])  # (1, 2, 3)
print(tup1[:3:2])  # (1, 3)

# for 循环
for i in tup1:
    print(i)

6、任意无符号的对象，以逗号隔开，默认为元组
a = 1, 2, 3, 'hello'
print(a)  # (1, 2, 3, 'hello')
print(type(a))  # <class 'tuple'>

7、方法：index,len,count
tup1 = (3, "a", "dog", [3, 4], 3)
print(tup1.index("a"))  #
print(len(tup1))  #
print(tup1.count(3))  #

8、儿子不能改，孙子可能可以改。(直接的元素就是儿子，元素里的元素是孙子)
tup1 = (1, 2, 3, [4], 5)
tup1[3].append(666)  # 孙子是列表，修改孙子，可以
print(tup1)
tup1.append(666)  # 直接修改儿子，错的