python学习：列表、元组、字典、集合

一、列表LIST

列表的下标是从0开始的，最后一个元素的下标可以用 -1，取元素的时候”顾头不顾尾“。定义如下列表：

names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]

1、切片：

>>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]
>>> names[1:4]  #取下标1至下标4之间的数字，包括1，不包括4
['Tenglan', 'Eric', 'Rain']
>>> names[1:-1] #取下标1至-1的值，不包括-1
['Tenglan', 'Eric', 'Rain', 'Tom']
>>> names[0:3] 
['Alex', 'Tenglan', 'Eric']
>>> names[:3] #如果是从头开始取，0可以忽略，跟上句效果一样
['Alex', 'Tenglan', 'Eric']
>>> names[3:] #如果想取最后一个，必须不能写-1，只能这么写
['Rain', 'Tom', 'Amy'] 
>>> names[3:-1] #这样-1就不会被包含了
['Rain', 'Tom']
>>> names[0::2] #后面的2是代表，每隔一个元素，就取一个
['Alex', 'Eric', 'Tom'] 
>>> names[::2] #和上句效果一样
['Alex', 'Eric', 'Tom']

2、追加append：

>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy']
>>> names.append("我是新来的")
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

3、插入insert：

>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> names.insert(2,"强行从Eric前面插入")
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']

>>> names.insert(5,"从eric后面插入试试新姿势")
>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

4、修改：

>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
>>> names[2] = "该换人了"
>>> names
['Alex', 'Tenglan', '该换人了', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']

5、删除：

三种方式：

a、del 列表[下标索引]

b、列表.remove("元素名称")

c、列表.pop[下标索引]，pop和del的区别在于pop会返回删除的元素，但是del无返回值 

>>> names
['Alex', 'Tenglan', '强行从Eric前面插入', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
>>> del names[2] 
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', '从eric后面插入试试新姿势', 'Tom', 'Amy', '我是新来的']
>>> del names[4]
>>> names
['Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> 
>>> names.remove("Eric") #删除指定元素
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', '我是新来的']
>>> names.pop() #删除列表最后一个值 
'我是新来的'
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
>>> names.pop(1) #删除指定位置的元素
Tenglan
>>> names
['Alex', 'Rain', 'Tom', 'Amy']

6、扩展extend：

>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
>>> b = [1,2,3]
>>> names.extend(b)
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy', 1, 2, 3]

7、拷贝：

>>> import copy
>>> names = ["Alex","Tenglan",["Eric",1000],"Rain","Tom","Amy"]
>>> name1=names.copy()
>>> name1
['Alex', 'Tenglan', ['Eric', 1000], 'Rain', 'Tom', 'Amy']
>>> name2 = copy.copy(names)
>>> name2
['Alex', 'Tenglan', ['Eric', 1000], 'Rain', 'Tom', 'Amy']
>>> name3=names[:]
>>> name3
['Alex', 'Tenglan', ['Eric', 1000], 'Rain', 'Tom', 'Amy']
>>> name4=list(names)
>>> name4
['Alex', 'Tenglan', ['Eric', 1000], 'Rain', 'Tom', 'Amy']

上面采取了4种方式对names列表进行了copy操作。
现在，我们来继续往下看：
>>> names
['Alex', 'Tenglan', ['Eric', 1000], 'Rain', 'Tom', 'Amy']
>>> name_copy=list(names)
>>> name_copy
['Alex', 'Tenglan', ['Eric', 1000], 'Rain', 'Tom', 'Amy']
>>> names[1]='张三'
>>> names
['Alex', '张三', ['Eric', 1000], 'Rain', 'Tom', 'Amy']
>>> name_copy
['Alex', 'Tenglan', ['Eric', 1000], 'Rain', 'Tom', 'Amy']
注意：这里我们把names列表copy了一个新的列表name_copy,然后我们更改了names表的第2个元素，从结果可以看出新列表name_copy的第2个元素并没有发生改变。

接着往下看：
>>> names[2][1]=7777
>>> names
['Alex', '张三', ['Eric', 7777], 'Rain', 'Tom', 'Amy']
>>> name_copy
['Alex', 'Tenglan', ['Eric', 7777], 'Rain', 'Tom', 'Amy']
注意：names列表的第3个元素也是一个列表，这里我们执行names[2][1]=7777后发现，names和name_copy两个列表的相应元素同时发生了改变。

这就是深度copy和浅度copy，上面的4中copy方式都是浅度copy，浅度copy只能copy第一层的元素，对于列表中含有的列表的元素，只是copy了这个子列表的一个内存地址而已。

如果要实现我们在改变names列表中列表的元素时，copy过来的列表的对应元素不发生变化，必须显示的进行深度copy，往下看：
>>>name_copy2=copy.deepcopy(names) --深度copy
42 >>>names[2][1]=1521
>>> names
['Alex', '张三', ['Eric', 1521], 'Rain', 'Tom', 'Amy']
>>> name_copy2
['Alex', '张三', ['Eric', 7777], 'Rain', 'Tom', 'Amy']

8、统计count：

统计某个元素在列表中出现的次数。

>>> names=(1,2,3,2,4,5,3,2,7,2,3)
>>> names.count(3)
3
>>> names.count(2)
4

9、排序sort、反转reverse：

>>> names = ["Alex","Tenglan",["Eric",1000],"Rain","Tom","Amy"]
>>> names.sort()  #排序
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'list' and 'str'
>>> names.pop(2)
['Eric', 1000]
>>> names
['Alex', 'Tenglan', 'Rain', 'Tom', 'Amy']
>>> names.sort() #排序
>>> names
['Alex', 'Amy', 'Rain', 'Tenglan', 'Tom']

>>> names.reverse() #反转
>>> names
['Tom', 'Tenglan', 'Rain', 'Amy', 'Alex']

列表的排序和反转对中文没有效果：

>>> names=['zhangsan','张三','章邯']
>>> names.sort()
>>> names
['zhangsan', '张三', '章邯']
>>> names=['张三','zhangsan','章邯']
>>> names.sort()
>>> names
['zhangsan', '张三', '章邯']
>>> names.append('阿三')
>>> names
['zhangsan', '张三', '章邯', '阿三']
>>> names.sort()
>>> names
['zhangsan', '张三', '章邯', '阿三']
>>> names.append('asan')
>>> names.sort()
>>> names
['asan', 'zhangsan', '张三', '章邯', '阿三']

10、获取下标index：

注意：只返回找到指定元素的第一个下标

>>> names
['asan', 'zhangsan', '张三', '章邯', '张三', '阿三']
>>> names.index('zhangsan')
1
>>> names.index('张三')
2

二、元组TUPLE

元组和列表其实差不多，只是元组一旦创建就不允许再修改，所以元组又叫做只读列表。

元组的定义：

names = （"Alex","Tenglan","Eric","Rain","Tom","Amy"）

元组只有两个方法：count、index、len

tu1 = ("Alex","Tenglan","Eric","Rain","Tom","Amy","Eric","Eric")
print(len(tu1))            # 8 计算元组中元素的个数
print(tu1.count('Eric'))   # 3 计算元组中有多少个指定的元素
print(tu1.index('Eric'))   # 2 查找第一次出现指定元素的位置,如果找不到则报异常
print(tu1.index('Eric', 3))   # 6 查找第一次出现指定元素的位置,如果找不到则报异常

print(tu1.index('Tenglan', 3))   # Error 查找第一次出现指定元素的位置,如果找不到则报异常
Traceback (most recent call last):
  File "D:/python/study/day01.py", line 14, in <module>
    print(tu1.index('Tenglan', 3))   # Error 查找第一次出现指定元素的位置,如果找不到则报异常
ValueError: tuple.index(x): x not in tuple

元组也可以切片：

tu1 = ("Alex","Tenglan","Eric","Rain","Tom","Amy")
print(tu1[0])    # Alex
print(tu1[-1])   # Amy
print(tu1[1:3])  # ('Tenglan', 'Eric')
print(tu1[:-1])  # ('Alex', 'Tenglan', 'Eric', 'Rain', 'Tom')
print(tu1[::])   # ('Alex', 'Tenglan', 'Eric', 'Rain', 'Tom', 'Amy')
print(tu1[::2])  # ('Alex', 'Eric', 'Tom')
print(tu1[::-1]) # ('Amy', 'Tom', 'Rain', 'Eric', 'Tenglan', 'Alex')

三、字典DICT

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

字典的特性：

1、键必须是唯一的，但值则不必。

2、Key必须是不可变数据类型（int，str，bool，tuple），但Value可以是任意数据类型（int，str，bool，tuple，list，dict，set）等

创建字典的几种方式：

# 方式1:
dic = dict((('one', 1),('two', 2),('three', 3)))
print(dic)  # {'one': 1, 'two': 2, 'three': 3}
dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic)  # {'one': 1, 'two': 2, 'three': 3}

# 方式2:
dic = dict(one=1,two=2,three=3)
print(dic)  # {'one': 1, 'two': 2, 'three': 3}

# 方式3:
dic = dict({'one': 1, 'two': 2, 'three': 3})
print(dic)  # {'one': 1, 'two': 2, 'three': 3}

# 方式4:
dic = dict(zip(['one', 'two', 'three'],[1, 2, 3]))
print(dic)

# 方式5: 字典推导式
dic = {k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
print(dic)

# 方式6:利用fromkey
dic = dict.fromkeys('abcd','dict')
print(dic)  # {'a': 'dict', 'b': 'dict', 'c': 'dict', 'd': 'dict'}

#很蛋疼，方式太多了记不住，直接用下面的方式不好吗？
dic = {'one': 1, 'two': 2, 'three': 3}
print(dic)  #{'one': 1, 'two': 2, 'three': 3}

字典常用的方法：

增

# 通过键值对直接增加
# 如果key存在，则会修改这个key对应的value，如果key不存在就增加
dic = {'name': '张三', 'age': 18}
dic['weight'] = 79  # weight键不存在，增直接增加此键值对
print(dic)

dic['name'] = '李四' # name这个键已经存在，则修改值为 李四
print(dic)

# 通过setdefault增加
# 如果key存在，则不做任何改变，如果key不存在就增加
# setdefault是有返回值的
dic.setdefault('height',180) # height 键不存在，则会增加此键值对
print(dic)

dic.setdefault('name','王五') # name键已经存在，则不会发生任何改变
print(dic)

ret = dic.setdefault('name') # setdefault有两个参数，如果只有key，则返回value
print(ret)

删

dic = {'name': '李四', 'age': 18, 'weight': 79, 'height': 180}

# pop，通过key来删除字典的键值对,有返回值，返回key对应的value
# 可以设置默认的返回值
ret = dic.pop('age')
print(ret) # 18

ret = dic.pop('wahaha',None)
print(ret,dic) # None {'name': '李四', 'weight': 79, 'height': 180}

ret = dic.pop('wahaha','QQXing')
print(ret,dic) # QQXing {'name': '李四', 'weight': 79, 'height': 180}

# popitem， 删除最后一个键值对
ret = dic.popitem()  # 返回值ret是一个元组
print(ret,dic)  # ('height', 180) {'name': '李四', 'weight': 79}

# del， 通过key删除，如果没有指定key，则会删除整个字典
dic = {'name': '李四', 'age': 18, 'weight': 79, 'height': 180}
del dic['weight']
print(dic)

del dic['wahaha'] # wahaha这个key不存在，会报错
Traceback (most recent call last):
  File "D:/python/study/day01.py", line 23, in <module>
    del dic['wahaha']
KeyError: 'wahaha'

del dic  # del 删除整个字典,打印会报错
print(dic) # NameError: name 'dic' is not defined

# clear, 清空字典
dic.clear()
print(dic)  # {}

改

# 通过设置键值对直接改，存在就改，不存在会增加
dic = {'name': '李四', 'age': 18}
dic['name'] = '王五'
print(dic)  # {'name': '王五', 'age': 18}

# update
dic = {'name': '李四', 'age': 18}
dic.update(weight = 79, height = 180)
print(dic) # {'name': '王五', 'age': 18, 'weight': 79, 'height': 180}

dic = {'name': '李四', 'age': 18}
dic.update([(1,'a'),(2,'B'),(3,'c')])
print(dic) # {'name': '李四', 'age': 18, 1: 'a', 2: 'B', 3: 'c'}

dic1 = {'name': '李四', 'age': 18}
dic2 = {'name': '王五', 'weight': 79, 'height': 180}
dic1.update(dic2) # 把dic2合并到dic1，dic1中有的就替换，没有的就新增
print(dic1) # {'name': '王五', 'age': 18, 'weight': 79, 'height': 180}
print(dic2) # {'name': '王五', 'weight': 79, 'height': 180}

查

dic = {'name': '王五', 'age': 18}

# 通过键查，直接用dic[key]。
# 注意：如果key不存在则会报错
ret = dic['name']
print(ret)  # 王五

# get，用dic.get(key)
# 如果key不存在则默认返回None，也可以指定一个默认的返回值，如“查无此键”
# 如果key存就返回对应value
ret = dic.get('name')
print(ret) # 王五

ret = dic.get('wahaha')
print(ret) # None

ret = dic.get('wahaha', '查无此键')
print(ret) # 查无此键

# dic.keys()，返回所有的key组成的一个列表，可转换成列表
ret = dic.keys()
print(ret) # dict_keys(['name', 'age'])
ret = list(ret)
print(ret)  # ['name', 'age']

# dic.values()，返回所有的value组成的一个列表
ret = dic.values()
print(ret) # dict_values(['王五', 18])
ret = list(ret)
print(ret)  # ['王五', 18]

# dic.items()，返回整个字典，返回值是一个列表，每个元素是字典的每个键值对形成的一个元组
ret = dic.items()
print(ret) # dict_items([('name', '王五'), ('age', 18)])
ret = list(ret)
print(ret)  # [('name', '王五'), ('age', 18)]

# 判断某个key是否存在
if 'name' in dic:
    print('key:name is exist')

# 循环打印字典
# 下面两种方式结果一样，但是第一种方式比第二种性能高很多。第二种在循环之前会把整个字典的键值对转成list都装入内存，数据量大时千万慎用。
for i in dic:
    print(i,dic[i])

# 效率极其低下
for k,v in dic.items():
    print(k,v)

# fromkeys，不知道哪里可以用到
dic = dict.fromkeys('abcd','小蜗')
print(dic) # {'a': '小蜗', 'b': '小蜗', 'c': '小蜗', 'd': '小蜗'}

dic = dict.fromkeys([1, 2, 3],'小蜗')
print(dic) # {1: '小蜗', 2: '小蜗', 3: '小蜗'}

四、集合set

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

set1 = {value01,value02,...}
或者
set(value)

1、创建集合

set1 = set()  # 定义一个空集合，用set()
print(set1,type(set1)) # set() <class 'set'>
set1.add('孙悟空')
set1.add('如来佛')
print(set1) # {'孙悟空', '如来佛'}

set2 = set('abc')
print(set2) # {'b', 'a', 'c'}

set3 = set(1,2,3)   # 报错
Traceback (most recent call last):
  File "D:/python/study/day01.py", line 11, in <module>
    set3 = set(1,2,3)
TypeError: set expected at most 1 arguments, got 3

2、增（add 、update）

set4 = set({2,4,6})

# 添加一个元素
set4.add(999)
print(set4) # {2, 4, 6, 999}

# 添加多个元素，迭代着增加。参数可以是（列表、元组、集合）
set4.update([44,55,66])  # 参数是列表
print(set4) # {2, 66, 4, 6, 999, 44, 55}

set4.update(('a','b'),('c','d'))  # 参数是元组
print(set4) # {'b', 'c', 2, 66, 4, 'd', 6, 999, 44, 'a', 55}

set4.update({'one','two'},{'three','four'})  # 参数是集合
print(set4) # {'b', 'c', 2, 66, 4, 'd', 6, 999, 'four', 44, 'three', 'one', 'a', 55, 'two'}

3、删（pop、remove、discard、clear、del）

set4 = {2, 66, 44, 6, 999, 55}

# pop，随机删除一个元素
ret = set4.pop()
print(set4) # {66, 6, 999, 44, 55}
print(ret) # 2

# remove，删除指定的元素，无返回值（返回None）。元素存在就删除，不存在会报错
ret = set4.remove(44)
print(set4) # {66, 4, 6, 999, 55}
print(ret) # None

ret = set4.remove(444) 
Traceback (most recent call last):
  File "D:/python/study/day01.py", line 59, in <module>
    ret = set4.remove(444) # 删除指定的元素，无返回值（返回None）
KeyError: 444

# discard，删除指定的元素，无返回值（返回None）。元素存在就删除，不存在无异常抛出
ret = set4.discard(66)
print(set4) # {66, 4, 6, 999, 55}
print(ret) # None

ret = set4.discard(666)
print(set4) # {66, 4, 6, 999, 55}
print(ret) # None

# clear，清空集合
set4.clear()
print(set4)

# del，删除集合
del set4
print(set4)  # del后，set4已经不存在了，print会抛出异常
Traceback (most recent call last):
  File "D:/python/study/day01.py", line 80, in <module>
    print(set4)
NameError: name 'set4' is not defined

4、集合的运算

list1 = [1,3,5,3,7,9,1,11]
list2 = [2,4,5,4,66,7,8,6,2,10]

#自动去重，无序
set1 = set(list1)
set2 = set(list2)
print(set1)  # {1, 3, 5, 7, 9, 11}
print(set2)  # {2, 4, 5, 6, 7, 8, 10}

# 交集
print(set1.intersection(set2)) # {5, 7}
print(set1 & set2) # {5, 7}

# 并集
print(set1.union(set2)) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}

# 差集,
print(set1.difference(set2)) # {11, 1, 3, 9}
print(set1 - set2) # {11, 1, 3, 9}

# 子集,父集
set3 = set([1,3,5])

print(set3.issubset(set1)) # True
print(set3 <= set1) # True

print(set1.issuperset(set3)) # True
print(set1 >= set3) # True

# 对称差集：去掉两者的共同元素后组成的集合
print(set1.symmetric_difference(set2)) # 1, 2, 66, 4, 6, 8, 3, 10, 9, 11}
print(set1 ^ set2) # 1, 2, 66, 4, 6, 8, 3, 10, 9, 11}

# 检查是否有相同的元素，如果两个集合没有任何相同的元素，则返回False
set4 = set({2,4,6})
print(set3.isdisjoint(set4)) # True
set4 = set({1,4,6})
print(set3.isdisjoint(set4)) # False

5、frozenset

不能被修改

t = frozenset('shop')
print(t) # frozenset({'s', 'h', 'p', 'o'})

 6、成员关系 (in, not in)

>>> 'k' in s
False
>>> 'k' in t
True
>>> 'c' not in t
True

7、集合等价/不等价

>>> s == t
False
>>> s != t
True
>>> u = frozenset(s)
>>> s == u
True
>>> set('posh') == set('shop')
True

五、购物车作业

需求（列表）：

1、启动程序后，让用户输入工资，然后打印商品列表

2、用户选择商品编号购买商品

3、用户选择商品后，检测余额是否够，如果余额够就直接扣款，如果不够就提醒

4、可随时退出，退出时打印已购买的上和余额

product_list = [('Iphone',5800),
                ('Mac Pro',9800),
                ('Bike',800),
                ('Watch',10600),
                ('Coffee',31),
                ('Alex Python',120)]
shopping_cart = []

salary = input("Input your salary: ")
if salary.isdigit():
    salary = int(salary)
    while 1:
        for item in product_list:
            print(product_list.index(item) + 1, item)

        user_choice = input("请选择需要购买的商品：").lower()
        if user_choice.isdigit():
            user_choice = int(user_choice)
            if user_choice > 0 and user_choice <= len(product_list):
                p_item = product_list[user_choice - 1]
                if p_item[1] <= salary:
                    shopping_cart.append(p_item)
                    salary = salary - p_item[1]
                    print("Added %s into shopping cart,your current balance is 33[31;1m%s33[0m"%(p_item[0], salary))
                else:
                    print("33[32;1m你的余额只剩下【%s】元，无法再购买任何商品!33[0m"%salary)
            else:
                print("你选择的商品不存在商品列表中！")
        elif user_choice == 'q':
            print("-------shopping cart--------")
            for index, item in enumerate(shopping_cart):
                print(item)
            print("Your current balance is :", salary)
            break
        else:
            print('Invalid Option...')