python基础，列表，元组，集合，字典

相信很多小伙伴，初学python的时候对 列表啦，集合，元组，字典不太了解(本人其实也是一样迷糊的），所以今天写一篇关于列表，集合，元组，字典的博客 希望大家喜欢！

• 1 列表

  • 1.1列表的概念

    列表是一种存储大量数据的存储模型。　
    

  • 1.2列表的特点

     列表具有索引的概念，可以通过索引操作列表中的数据。
     列表中的数据可以进行添加、删除、修改、查询等操作。
    

  • 1.3列表的基本语法

     创建列表：			变量名 = [数据1，数据2，……]
     获取列表数据：	变量名[索引]
      修改列表数据：	变量名[索引] = 值
    

• 1.4 列表的常用方法

方法名	功能	参数	返回值
append(data) 关键词：追加	在列表的末尾添加数据	data:加入到列表中的数据	None
insert(idx,data) 关键词：插入	在列表的指定位置插入数据， 如果索引位置超过列表数据总量 ，数据将插入到列表末尾	idx:插入数据的索引位置 data:加入列表中的数据	None
extend(model) 关键词：追加全部	在列表的末尾添加参数对象 中的所有数据	model:保存有数据的存储模型， 该模型接受列表、元组、集合类型的对象	None
remove(data) 关键词：删除	从列表中删除指定的数据， 如果数据不存在将报错	data:要从列表中删除的数据	None
pop(idx) 关键词：获取删除	从列表中获取并删除指定索 引位置上的数据，如果索引值 从列表中获取并删除指定索引 位置上的数据，如果索引值超过 列表数据总量将报错	idx:要从列表中获取的数据对应的索引位置	获取到的数据
clear() 关键词:情况	清空列表中的数据	无	None
index(data) 关键词：查询位置	查询列表中指定数据对应的 索引，如果数据不存在将报错	data:在列表中要查询的数据	查询数据第一次出现的索引
count(data) 关键词：统计数量	统计列表中指定数据出现的数量	data:在列表中要统计数量的数据	统计数据出现的次数

• 元组

  • 2.1元组的概念

     元组是一种存储固定数据的存储模型 
    

  • 2.2元组的特点

    元组具有索引的概念，可以通过索引操作元组中的数据元组中的数据可以进行查询操作，但不能进行添加、  除、修改操作。
    

  • 2.3元组的基本语法

    创建元组：			变量名 = （数据1，数据2，……）
    获取元组数据：	变量名[索引]
    

• 2.4 元组常用方法

方法名	功能	参数	返回值
index(data) 关键词：查询位置	查询元组中指定数据对应的 索引，如果数据不存在将报错	data:在元组中要查询的数据	查询数据第一次出现的索引
count(data) 关键词：统计数量	统计元组中指定数据出现的数量	data:在元组中要统计数量的数据	统计数据出现的次数

• 2.5注意事项

  元组中的数据如果是非引用类型数据，不允许修改
  元组中的数据如果是引用类型对象，该对象不允许替换，而对象的属性值可以发生改变
  

• 2.6 元组的特殊应用

自动组包：将多个数据赋值给一个变量时，多个数据将包装成一个元组，将元组赋值给变量，该过程称为自动组包。
　　　　应用场景：设置返回值为多个值
　　　　　　return 1,2,3 等同于 return (1,2,3)
　　　　应用场景：动态字符串赋值传值方式
　　　　　　print(“坐标%d,%d” % (10,20))
自动解包：将元组赋值给多个变量时，如果元组数据的数量与变量的数量相同，元组将被自动拆分成多个值，并赋值给对应变量，该过程称为自动解包。
　　　　 场景：多个变量接收返回值
　　　　　　a,b,c = func()等同于 a,b,c = (1,2,3)等同于a,b,c = 1,2,3
　　　　场景：动态字符串赋值取值方式
　　　　　　print(“坐标%d,%d” % (10,20)) 将10给第一个%d,将20给第二个%d

• 3集合

  • 3.1集合的概念

  集合是一种存储大量无序不重复数据的存储模型。
  

  • 3.2 集合的特点

    集合没有索引的概念。集合中的数据可以进行添加、删除等操作。
    

  • 3.3 集合的基本语法

  创建集合：			变量名 = {数据1，数据2，……}
  

  • 3.4集合常用方法

  方法名	功能	参数	返回值
  add(data 关键词：添加	在集合中添加数据	data:加入到集合中的数据	None
  remove(data) 关键词：删除	从集合中删除指定的数据，如果数据不存在将报错	data:要从集合中删除的数据	None
  pop() 关键词：获取删除	从集合中获取并删除第一个数据	无	获取到的数据
  clear() 关键词：清空	清空集合中的数据	无	None

  • 4. 字典

    • 4.1字典的概念

      字典是一种使用“键值对结构”存储数据的存储模型。
      

    • 4.2 字典的特点

      字典不具有索引的概念，字典使用键key代替索引，可以通过键操作字典中存储
      的数据值value。字典可以根据键key进行数据的添加、删除、修改、查询操作。
      

    • 4.3 字典的基本语法

    创建字典：			变量名 = {键1：值1，键2：值2，……}
    添加数据：			变量名[键] = 值	（字典中没有对应的键）	
    获取数据：			变量名[键]
    修改数据：			变量名[键] = 值	（字典中存在对应的键）
    

• 4.4 字典的常用方法

  方法名	功能	参数	返回值
  pop(key) 关键词：删除获取	从字典中删除指定键key对应的键值对， 如果键key不存在将报错	key:要删除的值 value对应的键key	被删除的值value
  popitem() 关键词：删除	从字典中删除指定键key对应的键值对， 如果键key不存在将报错	key:要删除的键值对对应的键key	被删除的键值对，以元组的形式返回
  clear() 关键词：清空	清空字典中的数据	无	None
  update(dict) 关键词：更新数据	使用新字典中的数据对原始字典数据进行更新 dict：新字典对象 None
  get(key) 关键词：获取	根据键key查询字典中对应的值， 如果键key不存在将返回None	key:要查询的键key	根据键key在字典中查询的值value
  keys() 关键词：获取键列表	获取字典中所有的键key组成的列表数据	无	由所有键组成的列表
  values() 关键词：获取值列表	获取字典中所有的键值对列表数据 无	由键值对组成的列表，键值对的格式是元组数据
  items() 关键词：获取键值对列表	获取字典中所有的键值对列表数据	无	由键值对组成的列表，键值对的格式是元组数据

  • 4.5 注意事项

字典中的键是唯一的

• 字典的作用

   1.当需要存储少量数据，并且期望在编程期以最快的速度获取单个数据，	推荐选择字典。
   2.当需要使用非对象格式保存单个对象的属性值，推荐选择字典。
  

  • 5 格式转换

  	转换成列表	转换成元组	转换成集合
  列表list	——	tuple（列表对象）	set（列表对象）
  元组tuple	list(元组对象）	——	set（元组对象）
  集合set	list（集合对象）	tuple（集合对象）	——

• 斗地主案例

"""
案例斗地主
分析：
1.扑克牌作为对象呈现
2.创建未发牌的牌堆的列表
3.创建三个玩家牌堆的列表
4.创建底牌的元组
5.最原始的牌堆初始化，将54张牌加入到牌堆
6.创建洗牌操作
7.创建发牌操作
"""
import random
class Poke:
    pokes = []
    player1 = []
    player2 = []
    player3 = []
    last = None
    def __init__(self,flower,num):
        self.flower = flower
        self.num = num

    def __str__(self):
        return "%s%s" % (self.flower,self.num)

    # 初始化牌
    @classmethod
    def init_pokes(cls):
        flowers = ("♠","♥","♣","♦")
        nums = ("2","3","4","5","6","7","8","9","10","J","Q","K","A")
        kings = {"big":"大王","small":"小王"}
        for flower_ in flowers :
            for num_ in nums:
                p = Poke(flower_,num_)
                cls.pokes.append(p)
        cls.pokes.append(Poke(kings["big"],""))
        cls.pokes.append(Poke(kings["small"], ""))

    #洗牌
    @classmethod
    def wash(cls):
        # 洗牌是从牌堆中找出一张固定的牌，与随机的一张牌交换位置
        # 迭代牌堆，找出一张牌
        # 产生随机数，作为被交换牌
        # 交换
        for idx in range(54):
            idxx = random.randint(0,53)
            cls.pokes[idx],cls.pokes[idxx] = cls.pokes[idxx],cls.pokes[idx]

    #发牌
    @classmethod
    def send_poke(cls):
        for _ in range(0,17):
            cls.player1.append(cls.pokes.pop(0))
            cls.player2.append(cls.pokes.pop(0))
            cls.player3.append(cls.pokes.pop(0))
        # 将剩余的3张牌做成底牌last
        cls.last = tuple(cls.pokes)

    # 临时方法：展示牌堆
    @classmethod
    def show(cls):
        for poke in cls.pokes:
            print(poke ,end=" ")
        print()

    @classmethod
    def show_player(cls):
        print("玩家1",end = ":")
        for poke in cls.player1:
            print(poke, end=" ")
        print()
        print("玩家2", end=":")
        for poke in cls.player2:
            print(poke, end=" ")
        print()
        print("玩家3", end=":")
        for poke in cls.player3:
            print(poke, end=" ")
        print()
        print("底牌", end=":")
        for poke in cls.last:
            print(poke, end=" ")
        print()

Poke.init_pokes()
# Poke.show()
Poke.wash()
# Poke.show()
Poke.send_poke()
Poke.show_player()