1.列表

  • 列表定义
    列表用来顺序存储相同或者不同类型数据的集合，列表内存储的元素是有序的，列表使用一对[ ]表示，列表中存储的每个值叫元素，元素之间使用逗号隔开
    ```python

    存储相同数据类型

    name_list=[“张三”,”李四”,”王五”]

    打印数据类型

    print(type(name_list))

print(name_list)

存储不同数据类型

info=[“张三”,”男”,20] print(info)

  2. -  向列表添加元素  
  3. ```python
  4. info_list=[["张三","男",20],["王五","男",16]]
  6. # 1.append()方法
  7. new_info=["李四","男",18]
  8. info_list.append(new_info)
  9. print(info_list)
  12. # 2.insert()方法
  13. new_info=["小美","女",18]
  14. info_list.insert(1,new_info)
  15. print(info_list)
  17. # 3.extend()方法
  18. new_infos=[["马六","男",18],["小黑","女",18]]
  19. info_list.extend(new_infos)
  20. print(info_list)
  22. # 4.使用+号拼接
  23. str_list1=["a","b","c"]
  24. str_list2=["e","f","g"]
  25. str_list3=str_list1+str_list2
  26. print(str_list3)

  • 修改列表中元素值 

    1. # 索引修改元素值
    2. info_list=["小美","女",20]
    3. #年龄涨一岁
    4. info_list[2]+=1
    5. print(info_list)

  • 查询列表中元素
    ```python

    根据索引查询

    info_list=[“小美”,”女”,20] name=info_list[0] sex=info_list[1] age=info_list[2] print(“姓名:{},性别:{},年龄:{}”.format(name,sex,age))

for循环遍历

for i in range(0,len(info_list)) print(info_list[i]) # 索引查询值

for item in info_list print(item) #直接遍历元素

while循环遍历

i=0 while i < len(info_list): print(info_list[i]) i+=1

  2. -  删除列表中元素  
  3. ```python
  4. # del删除指定下标的元素
  5. info_list=["小美","女",20]
  6. del info_list[2]
  7. print(info_list)
  10. # remove()方法
  11. info_list=["小美","女",20]
  12. info_list.remove("女")
  13. print(info_list)
  16. # pop()方法
  17. info_list=["小美","女",20]
  18. info_list.pop(1) # 根据指定索引删除
  19. print(info_list)
  21. info_list.pop() # 默认从列表的末尾删除一个元素
  22. print(info_list)
  • 列表切片
    ```python ‘’’ 语法格式 list[start:end:step] start：开始索引 end：结束索引 step：步长，默认是1

注：切片的截取范围是左闭右开 ‘’’

str_list=[“a”,”b”,”c”,”d”,”e”,”f”] print(str_list[:3]) #截取前三个 print(str_list[3:]) #截取后三个 print(str_lsit[1::2]) #从下标是1开始截取，步长是2

  2. -  列表元素排序  
  3. ```python
  4. num_list=[1,9,7,3,8,0]
  6. num_list.sort() #升序
  7. print(num_list)
  9. num_list.sort(reverse=True) #降序
  10. print(num_list)

2.元组

  • 元组使用一对小括号表示 

    1. #定义元组
    2. tp=(1,2,3)
    3. #定义空元组
    4. tp_none=()

  • 元组与列表区别

    • 相同点：都是可以顺序存储相同数据类型或者不同数据类型的元素
    • 不同点：元组被定义后不能修改其中元素，元组不支持添加，修改，删除元素操作
  • 查询元组中元素
    ```python info_tp=(“小美”,”女”,20)

索引查询

name=info_tp[0] sex=info_tp[1] age=info_tp[2] print(“姓名:{},性别:{},年龄:{}”.format(name,sex,age))

for循环遍历

for item in info_tp print(item) #元素直接遍历

while循环遍历

i=0 while i < len(info_tp): print(info_tp[i]) i+=1

  2. <a name="tcYfx"></a>
  3. ### 3.字典
  5. -  字典定义<br />字典主要用于存储key-value键值对形式的数据，字典使用一对{ }表示，一个元素就是一个键值对，多个元素之间使用逗号隔开。  
  6. ```python
  7. #定义字典
  8. info_dict={"name":"张三","sex":"男","age":20}
  9. print(info_dict)

  • 向字典中添加键值对 

    1. info_dict={"name":"张三","sex":"男","age":20}
    2. info_dict["tel"]="13056785678"
    3. print(info_dict)

  • 修改字典中键值对
    ```python info_dict={“name”:”张三”,”sex”:”男”,”age”:20}

age=info_dict.get(“age”,0) print(“原age:{}”.format(age))

info_dict[“age”]=18 age=info_dict.get(“age”,0) print(“修改后age:{}”.format(age))

  2. -  查询字典中键值对  
  3. ```python
  4. # 根据key查询值（不存在的key会报错）
  5. info_dict={"name":"张三","sex":"男","age":20}
  6. age=info_dict["age"]
  7. print("age:{}".format(age))
  10. # 根据get()函数查询
  11. info_dict={"name":"张三","sex":"男","age":20}
  12. age=info_dict.get("age") #key存在
  13. print("age:{}".format(age))
  16. tel=info_dict.get("tel") #key不存在
  17. print("tel:{}".format(tel))
  20. tel=info_dict.get("tel","10000") #key不存在,给默认值
  21. print("tel:{}".format(tel))

  • 删除字典中键值对 

    1. info_dict={"name":"张三","sex":"男","age":20}
    2. del info_dict["age"]
    3. print(info_list)

  • 遍历字典
    ```python info_dict={“name”:”张三”,”sex”:”男”,”age”:20}

根据key遍历

for key in info_list.keys(): print(“{}:{}”.format(key,info_list[key]))

根据value遍历

for value in info_list.values(): print(value)

根据键值对

for item in info_list.items(): print(“item:”,item) print(“key:”,item[0]) print(“value:”,item[1])

for key,value in info_list.items(): print(“{}:{}”.format(key,value)

  2. <a name="Xhx6N"></a>
  3. ### 4.集合
  5. -  集合定义<br />集合使用类型set，集合用于无序存储相同或者不同数据类型的元素，集合使用一对{ }表示，与字典不同集合内的值不是键值对，是单独的数值。 
  6. -   
  7. ```python
  8. #集合定义
  9. id_set={"1","2","3"}
  10. #打印类型
  11. print(type(id_set))
  13. print(id_set)
  • set函数创建集合
    ```python

    列表或者元组使用set()创建集合

    id_list=[“a”,”b”,”c”,”a”] id_list_set=set(id_list) print(id_list_set)

id_tuple=(“a”,”b”,”c”,”a”) id_tuple_set=set(id_tuple) print(id_tuple_set)

字符串

str_set=set(“hello”) print(str_set) #按字母拆分并去重

  2. -  集合中使用in和not in  
  3. ```python
  4. id_set={"a","b","c"}
  6. # in
  7. id="c"
  8. for id in id_set:
  9.    print("{}存在".format(id))
  12. # not in
  13. id="f"
  14. for id not in id_set:
  15.    print("{}不存在".format(id))
  • 向集合中添加元素
    ```python id_set={“a”,”b”,”c”}

add()方法

id_set.add(“d”) print(id_set)

update()方法

id_set.update([“d”,”d”]) #列表 print(id_set)

id_set.update((“e”,”f”)) #元组 print(id_set)

new_id_set={“aa”,”bb”} id_set.update(new_id_set) #添加集合 print(id_set)

id_set.update([“cc”,”dd”],[“ff”,”ee”]) #多个列表 print(id_set)

id_set.update(“aaaaaaa”) # 字符串,拆分,去重 print(id_set)

  2. -  删除集合中的元素  
  3. ```python
  4. # remove()方法
  5. id_set={"a","b","c"}
  6. id_set.remove("a") #存在a删除不报错
  7. print(id_set)
  8. id_set.remove("a") #不存在a删除报错
  11. # discard()方法
  12. id_set={"a","b","c"}
  13. id_set.discard("a") #存在a删除不报错
  14. print(id_set)
  15. id_set.discard("a") #不存在a删除不报错
  16. print(id_set)
  19. # pop()方法
  20. id=id_set.pop()
  21. print(id_set)
  22. print("被删除元素:",id)
  • 集合中的交集、并集、差集操作
    ```python

    交集(&、intersection() )

    num_set1={1,2,3} num_set2={2,3,4} num_set3=num_set1&num_set2 # 使用&运算求交集 num_set4=num_set1.intersection(num_set2) # 使用intersection方法求交集 print(num_set3) print(num_set4)

并集(|、union() )

num_set1={1,2,3} num_set2={2,3,4} num_set3=num_set1|num_set2 # 使用|运算求并集 num_set4=num_set1.union(num_set2) # 使用union方法求并集 print(num_set3) print(num_set4)

差集(-、difference() )

num_set1={1,2,3} num_set2={2,3,4} num_set3=num_set1-num_set2 # 使用-运算求差集 num_set4=num_set1.difference(num_set2) # 使用difference方法求差集 print(num_set3) print(num_set4) ```

  • 当才华还配不上野心，就静下来学习