python入门（五）基础类型补充

基础类型补充

1. str

   #1.首字母大写
   name="alex"
   name=name.capitalize()
   print(name)
   #结果为 Alex
   
   #2.每个单词首字母大写
   name="alex wusir"
   name=name.title()#两个单词必须有间隔，没有间隔，计算机识别成一个单词
   print(name)
   #结果为 Alex Wusir
   
   #3.大小写反转
   name="Alex"
   name=name.swapcase()
   print(name)
   #结果为aLEX
   
   #4.居中--填充
   name="alex"
   name=name.center(5,"-")#要填充多少，填充的内容只能为一个字符
   print(name)
   #结果为：--alex--
   
   #5.查找 find index
   name="alex"
   name=name.find("x")#找到返回索引值 找不到返回-1
   print(name)
   #结果为 3
   name=name.find("b")
   print(name)
   #结果为 -1
   
   name="alex"
   name=name.index("x")#找到返回索引值，找不到报错
   print(name)
   #结果为：3
   name=name.index("b")
   print(name)
   #结果为：报错
   
   #6.拼接
   name="alex"
   name="_".join(name)#括号填写可迭代对象
   print(name)
   #结果为 "a_l_e_x"
   
   #7.格式化
   # %s f name.format
   print("haha%s"%"ss")
   #结果为 hahass
   haha="xx"
   name=f"alex{haha}"
   print(name)
   #结果为alexxx
   
   name="alex{}{}{}"
   name=name.format(1,2,3)
   print(name)
   #结果为 alex123
   name="alex{2}{1}{0}"
   name=name.format("a","b","c")
   print(name)
   #结果为 alexcba
   name="alex{a}{b}{c}"
   name=name.format(a=1,b=11,c=67)
   print(name)
   #结果为：alex11167
   
   # + * 开辟新的空间
   name="alex"
   name1="wusir"
   print(id(name))
   print(id(name1))
   print(id(name1+name2))
   #结果为：2230092731928
   #       2230093579352
   #        2230093619312
   

2. list(列表)

   • #定义方式
     a=list("123")#括号里放可迭代对象
     print(a)
     #结果为:["1","2","3"]
     
     #1.排序
     list=[4,2,3]
     list.sort()#排序 默认升序
     print(list)
     #结果为 [2,3,4] 
     
     list=[4,2,3]
     list.sort(reverse=True) #降序
     print(list)
     #结果为：[2,3,4]
     
     #2.反转
     list=[4,2,3]
     list.reverse()
     print(list)
     #结果为：[3,2,4]
     
     #面试题
     lst=[[]]
     new_list=lst*5 #结果为[[],[],[],[],[]]
     new_lst[0].append(10)#此时new_list[0]指向列表内存地址，此时列表添加一个元素 new_list[0]内存地址不变,因为引用都是[]，所以都改
     print(new_list)
     #结果为[[10],[10],[10],[10],[10]]
     
     lst = [1,[]]
     new_lst = lst * 5
     new_lst[0] = 10#指向 1 1为不可变元素 所以 当前new_lst[0]要指向10
     print(new_lst)
     #结果为[10,[],1,[],1[],1,[],1,[]]
     
     lst = [1,[]]
     new_lst = lst * 5
     new_lst[1] = 10
     print(new_lst)
     #结果为：[1,10,1,[],1,[],1,[],1[]]
     
     #3.列表的合并
     #方式一
     lst.extend(lst1)
     print(lst)
     #方式二
     print(lst+lst1)
     new_lst=lst*5
     print(id(new_lst[0]),id(new_lst[0]))
     #结果为：内存地址相同
     

3. tuple(元组)

   • tu=(12)#数据类型是（）中数据本身
     print(type(tu))
     #结果为 int
     
     tu=(12,)#数据类型为元组
     print(type(tu))
     #结果为：tuple
     #元组 + * 不可变共用,可变也共用
     

4. dict(字典)

   • #定义一个字典
     dic=dict(k=1,k1=2)
     print(dic)
     #结果为:{k:1,k1:2}
     
     #1.随机删除popitem
     dic={"key":1,"key2":2,"key3":56}
     print(dic.popitem())#返回的是被删除的键值对
     print(dic)
     #结果为：{"key":1,"key2":2} python3.6默认删除最后一个
     
     #2.批量添加键值对fromkeys
     dic={}
     dic.fromkeys("123",[23])#批量添加键值对{"1":[23],"2":[23],"3":[23]}
     print(dic)
     #结果为:{"1":[23],"2":[23],"3":[23]}
     
     dic = dict.fromkeys("123456789",1) # 批量添加键值对"键是可迭代对象",值 -- 会被共用
     dic["1"] = 18
     print(dic)
     #结果为：{'1': 18, '2': 1, '3': 1, '4': 1, '5': 1, '6': 1, '7': 1, '8': 1, '9': 1}
     #键["1"]对应值是 1 不可变数字 此时改变为18 这时只有 键["1"]指向18
     

5. set(集合)

   • set()#空集合
     {}#空字典
     #定义集合
     set("alex")#迭代添加
     

6. 布尔值(bool)

   • 哪些值为False
     bool:False
     int:0
     str:空字符串
     list:[]
     tuple:()
     dict:{}
     set:set()
     其他:None
     

7. 数据之间的转换

   • list tuple
     tuple list
     str list
     name="alex" name.spilt() 结果为列表
     name["1","2"] "_".join(name)#结果为字符串
     
     dict str
     dic={"1":2}
     print(str(dic),type(str(dic)))
     print(dict("{1:1}"))
      
     set - list
     list - set
     

8. python数据类型

   • 可变：list dict set 
     不可变: str int bool tuple
     有序: int str bool list tuple
     无序：dict set
     取值方式:
     索引：str list tuple
     直接:set int bool
     键:dict