一、 列表
列表：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) # 直接修改儿子，错的