Python学习笔记-Day7

今日大纲

一、基础数据类型补充

二、数据类型之间的转化

三、集合set

四、深浅copy

 

 

一、基础数据类型补充

1、tuple元组：如果一个元组只由一个数据组成，且没有逗号，那么该“元组”的数据类型就是该数据的数据类型

tu1 = (1)
tu2 = ("hello")
tu3 = ([1,2,3])
tu4 = ({1:1,2:2})    #元组中只有一个数据组成，该元组数据类型与该数据相同
print(type(tu1))    #<class 'int'>
print(type(tu2))    #<class 'str'>
print(type(tu3))    #<class 'list'>
print(type(tu4))    #<class 'dict'>
tu5 = (1,)       #有逗号，还是元组类型
print(type(tu5))      #<class 'tuple'>

2、list列表：

①列表可以相加

l1=[1,2,3]
l2=['alex','wusir']
l3=l1+l2
print(l3)

输出结果是：
[1, 2, 3, 'alex', 'wusir']

 

② 在循环一个列表时，删除列表中的某一元素时，该元素后面的元素都会向前进一位，后面元素的索引会改变。

    所以在循环一个列表时，最好不好对列表进行改变大小的操作（增和删）

例题：将列表中索引为奇数的元素删除

方法一、将列表中索引为偶数的元素加入到一个新的列表中

方法二、从列表后面开始删除

方法三、切片

l1=[11,22,33,44,55,66,77,88]
# 方法一、
l2 = []
for i in range(len(l1)):
    if i % 2 == 0:
        l2.append(l1[i])
print(l2)
# 方法二、
for i in range(len(l1),-1,-1):
    if i % 2 == 1:
        l1.pop(i)
print(l1)
# 方法三、
l3 = l1[::2]
print(l3)

3、字典

1、创建字典的三种方式：

① dic = {}

② dic = dict( {   } )

③ dic.fromkeys(可迭代对象，value)，value会被赋值可迭代对象里的每一个值

2、在循环一个字典时，对字典的键值对进行删除会报错。

例题：删除字典key中包含’k‘的键值对

dic={'key1':'value1','key2':'value2','k3':'v3','name':'alex'}
li =[]
for k in dic:
    if 'k' in k:
        li.append(k)
for i in li:
    dic.pop(i)
print(dic)

 

二、数据类型之间的转化

1、 int、str、bool之间的转化

2、str <-------> bytes

3、str <-------> list

　　① str ----> list：lis = str.split()

　　② list------>str：str = ’ ‘.join(list)

4、dict.keys()    dict.values()    dict.items ------->list

       list(dict.keys())、  list(dict.values())、list(dict.items())

5、tuple <------->  list

     tup = tuple(lis)

      lis = list(tup)

6、dict -------->list：只有字典中的key会转化成list，list不能转化成dict

 

三、集合set

set1 = {1,2,’wusie‘,(3,4)}

集合里面的元素必须是不可变的，只能是数字、字符串、bool值、元组，但是集合本身是可变的数据类型，集合里面的元素不能重复，集合是无序的。

主要用途：

　　　　①去重

　　　　②关系测试

1、集合的创建

set1 = {   }

set1 = set( {   } )

2、集合的增、删

①集合的增

set.add():将（）里的元素加入到集合中

set.update()：将（）里的元素迭代的增加到set中

set1={'alex','wusir','ritian','egon','barry'}
set1.add('女神')
print(set1)
set2={'alex','wusir','ritian','egon','barry'}
set2.update('女神')
print(set2)

结果是：
{'女神', 'wusir', 'alex', 'ritian', 'barry', 'egon'}
{'女', 'wusir', 'alex', '神', 'ritian', 'barry', 'egon'}

3、关系测试

① 交集

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1&set2)
print(set1.intersection(set2))
输出结果是：
{4, 5}
{4, 5}

② 并集

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1|set2)
print(set1.union(set2))
输出结果是：
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}

 

③ 反交集

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1^set2)
print(set1.symmetric_difference(set2))
输出结果是：
{1, 2, 3, 6, 7, 8}
{1, 2, 3, 6, 7, 8}

 

④ 差集

set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1-set2)
print(set1.difference(set2))
输出结果是：
{1, 2, 3}
{1, 2, 3}

 

⑤ 子集

set1={1,2,3}
set2={1,2,3,4,5,6}
print(set1<set2)#True
print(set1.issubset(set2))
输出结果是：
True

 

⑥ 超集

set1={1,2,3}
set2={1,2,3,4,5,6}
print(set2 > set1)
print(set2.issuperset(set1))
输出结果是：
True

 

四、深浅copy

1、赋值运算：等号两边的变量指向的内存地址是一样的

l1=[1,2,3]
l2=l1    #赋值运算，l2和l1指向的内存地址是一样的，l1改变的话l2也跟着改变
l1.append(666)
print(l2)
print(id(l1))
print(id(l2))


输出结果是：
[1, 2, 3, 666]
2830857511752
2830857511752

 

2、浅copy：

l2=l1.copy()

第一层的内存地址不一样，但是第二层的内存地址还是一样的。

例如：

l1=[1,2,3,[22,]]
l2=l1.copy()
l1.insert(0,'hello')
print(l2)      #第一层，l2与l1的内存地址不同没有变
l1[-1].append('taibai')
print(l2)       #第二层，l2和l1的内存地址相同，l2改变了

输出结果是：
[1, 2, 3, [22]]
[1, 2, 3, [22, 'taibai']]

3、深copy

import copy

l2 = l1.deepcopy

对于深copy来说，两个变量的内存地址是完全独立的，无论改变任何一个元素（无论多少层），另一个不会跟着改变

例如：

import copy
l1=[1,2,3,[22,]]
l2=copy.deepcopy(l1)   #深copy，不会改变l2的值
l1[-1].append('太白')
print(l2)

输出结果：
[1, 2, 3, [22]]

 

 

#切片是浅copy

 

转载于:https://www.cnblogs.com/tian-tian/p/9460375.html