一、上节课程回顾:

1、id 地址的比较,字符串不能超过20 个

i="a"*21
j="a"*21
print(i is j)   #False

k="a"*20
h="a"*20
print(k is h)    #True

2、(1) id( ) 内存地址

       (2)== 比较的是值

             is 比较的是内存地址

    数字,字符串有小数据池

           int -5--256

       str : 1,不能有空格

                 2,长度不能超过20

                 3,不能有特殊字符如:#@。。。。。

3、 enumerate   枚举    iterable:str,list,tuple,dict,set

# for i in enumerate(iterable):
#     print(i)
# for i in enumerate(["barry","alex"]):
#     print(i)      #(0, 'barry')
                   # (1, 'alex')
# for index,i in enumerate(["barry","alex"]):
#     print(index,i)        #0 barry
                          #1 alex
# for index, i in enumerate(["barry", "alex"],100):
#     print(index, i)      #100 barry
                         #101 alex

4、编码

      bytes 是特殊的编码方式(特殊的str,区别在于前面多了一个b)类似于str list tupe 存在于python2 中 在python 中没有

   py3    

         str :表现形式  :s="alex"  实际编码方式:unicode

         bytes:表现形式:s=b"alex"   实际编码方式:utf-8,gbk,gb2312...

                                 s=b'\x2e\x2e\x2e\x2e\x2e\x24\e"

         unicode:所有字符(无论英文,中文等)1个字符,4个字节

          gbk:一个字符,英文1个字节,中文两个字节。

           utf-8:英文1个字节,欧洲:2个字节,亚洲3个字节。

面试题:  判断类型。。,在字符串后面加上 , 表现是元组类型

tu=(1)
tu1=("name")
print(tu,type(tu))     #1 <class 'int'>
print(tu1,type(tu1))   #name <class 'str'>
tu=(True)
tul=("name",)
tu2=("name")
print(tu,type(tu))       #True <class 'bool'>
print(tul,type(tul))     #('name',) <class 'tuple'>
print(tu2,type(tu2))     #name <class 'str'>

二、新内容

1、列表的循环  

     当循环列表时,如果在循环中删除某个或者某些元素,列表的个数改变,索引改变,容易出错。

删除列表中的偶数  (利用倒序删除的方法可以避免索引的改变)

# 方法一:
# li=[11,22,33,44,55]
# l2=[]
# for i in li:
#     if i %2==0:
#         l2.append(i)
# print(l2)
# 方法二:
# li=[11,22,33,44,55]
# del li[1::2]
# print(li)
# li=li[0::2]
# print(li)
# 方法三
# li=[11,22,33,44,55,66,77,88,99]
# for i in range(0,len(li)//2):
#     del li[i+1]
# print(li)
# 方法四(非常重要)
# li=[11,22,33,44,55,66,77,88,99]
# for i in range(len(li)-1,0,-1):
#     if i%2==1:
#         del li[i]
# print(li)
View Code

 2、fromkeys  (字典的补充)

dic=dict.fromkeys([1,2,3],"杨1")
dic1=dict.fromkeys("abc","杨1")
print(dic)           #{1: '杨1', 2: '杨1', 3: '杨1'}
print(dic1)         #{'a': '杨1', 'b': '杨1', 'c': '杨1'}
dic2=dict.fromkeys(["barry","alex"],[])
print(dic2)                 #{'barry': [], 'alex': []}
dic2["barry"].append(11)
dic2["alex"].append(22)
print(dic2)               #{'barry': [11, 22], 'alex': [11, 22]}

3、例题将键里面含有字母“k”的键值对删除

# 第一种方法:
dic={"k1":"barry","k2":"alex","name":"ritian"}
for i in dic.copy():
    if "k" in i:
        del dic[i]
print(dic)           #{'name': 'ritian'}
# 第二种方法:
dic={"k1":"barry","k2":"alex","name":"ritian"}
for i in list(dic.keys()):
    if "k" in i:
        del dic[i]
print(dic)         #{'name': 'ritian'}
# 方法三:
dic={"k1":"barry","k2":"alex","name":"ritian"}
dic2={}
for key,value in dic.items():
    if "k"not in key:
        dic2[key]=value
dic=dic2
print(dic)              #{'name': 'ritian'}
删除键中带有“k”的

4、转化

1、 int----->str:  str(int)

2、str------>int: int(str)  字符串必须全部由数字组成

3、bool ------->str: str(bool)

4、 str--------->bool(str)    除了空字符串,剩下的都是True

5、 int———>bool  除了0,剩下的全是True

6、bool --------->int  True----->1   False------->0

7、str ---------->list   split

8、list--------->str()   join

9、tuple------->list    : list(tuple)

10、list------>tuple  :   tuple(list)

11、  str----->list     :    list(str)          print(list("abd"))     #['a', 'b', 'd']

12、list------->str :   str(list)

用布尔值 判断  0 {}  []  () set{}   ------->False

三、集合是无序的,不重复的数据集合,他里面的元素是可哈希的(不可变类型),但是集合本身是不可哈希的(所以集合做不了字典的键)

以下是几个重要的两点:

去重,把一个列表变成集合就自动去重了。

关系测试,测试两组数据之间的交集、差集、并集等关系。

1、利用集合和列表的相互转化,达到去重的目的

l=[1,1,2,2,3,4,5,5,5,56,7]
l=set(l)
l=list(l)
print(l)    #[1, 2, 3, 4, 5, 7, 56]

2、集合的创建

add     update迭代增加

集合的内部是无序的
set1={1,2}
# update:迭代增加
set1.update("A")
print(set1)     #{1, 2, 'A'}
set1.update(["老师"])
print(set1)       #{'老师', 1, 2, 'A'}
set1.update([1,2,3])
print(set1)       #{1, 2, 3, 'A', '老师'}

集合的删除  

remove   pop(有返回值)    clear   del

set1={"alex","barry",1,2,3}
set1.remove("alex")
print(set1)         #{1, 2, 3, 'barry'}
s=set1.pop()   #随机删除一个元素有返回值
print(set1)      #{2, 3, 'barry'}
print(s)         #1

set1.clear()  
print(set1)       set()     (set() 是空集合的表现)
del set1

集合是不能是不能更改的(因为是可哈希的,不可变的数据类型和str一样)

可以查,只能用for 循环的方式

 求集合的交集:   &    intersection  

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1&set2)                #{4, 5}
print(set1.intersection(set2))  #{4, 5}

求集合的并集:  |  union

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1| set2)           #{1, 2, 3, 4, 5, 6, 7, 8}      
print(set1.union(set2))    #{1, 2, 3, 4, 5, 6, 7, 8}

求集合的差集   -    diference

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1- set2)           #{1, 2, 3}
print(set1.difference(set2))    #{{1, 2, 3}

求集合的反交集 ^      symmetric_difference

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1^set2)         #{1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))    #{1, 2, 3, 6, 7, 8}

子集和超集:     。。。是。。。的超集issuperset      。。。是。。。的子集issubset

set1={1,2,3,4,5,6,7,8,9}
set2={4,5,6,7,8}
print(set1>set2)           #True    set1是set2的超集
print(set1.issuperset(set2))        #True    set1是set2的超集
print(set2<set1)             #True  set2 是 set1的子集
print(set2.issubset(set1))      #True  set2 是 set1的子集

frozenset 不可变集合  让集合变成不可变的类型

s=frozenset("barry")
print(s,type(s))   #frozenset({'r', 'y', 'b', 'a'}) <class 'frozenset'>

3、浅  copy

 在浅 copy 过程中只能在列表的第一层发挥作用,第二层还是相同的

l1=[1,2,3,4]
l2=l1.copy()
l1.append("barry")
print(l1,id(l1))     #[1, 2, 3, 4, 'barry'] 38485064
print(l2,id(l2))     #[1, 2, 3, 4] 38452040
l1=[1,2,[2,3,4],3,4]
l2=l1.copy()
l1[2].append("barry")
print(l1,id(l1),id(l1[2])) #[1, 2, [2, 3, 4, 'barry'], 3, 4] 35568456 35601480
print(l2,id(l2),id(l2[2])) #[1, 2, [2, 3, 4, 'barry'], 3, 4] 35601352 35601480

4、深copy   copy.deepcopy()

对于深copy来说,两个是完全独立的,改变任意一个的任何元素(无论多少层),另一个绝不改变

import copy
l1=[1,2,[2,3,4],3,4]
l2=copy.deepcopy(l1)
l1[2].append("barry")
print(l1,id(l1),id(l1[2]))     #[1, 2, [2, 3, 4, 'barry'], 3, 4] 35884040 35883848
print(l2,id(l2),id(l2[2]))     #[1, 2, [2, 3, 4], 3, 4] 35918152 35918088