python之旅 1-29 补充内容,深浅copy

#  l1 = [111,222,333,444,555] 将索引为奇数位的元素删除.

# l1 = [111,222,333,444,555]
# del l1[1::2]
# print(l1)

通过删除列表中的元素

# for i in range(len(l1)-1,0,-1):
#     if i%2==0:
#         del l1[i-1]
# print(l1)

通过循环列表,用range指代索引位置

for i in l1:
    if l1.index(i)%2==0:
        l2.append(i)
l1=l2
print(l1)

通过创建一个新列表l2,赋值给l1

注意:在循环一个列表时,如果要是删除某些或者某类元素,容易出错.因为每一次循环以后的元素所对应的索引都是变化的

fromkeys:

dic = dict.fromkeys(‘abc‘,‘alex‘)
print(dic)
dic1 = dict.fromkeys([1,2,3],[])
print(dic1)
dic1[1].append(‘alex‘)
print(dic1)

元祖转化成字典的一种方式

不可变数据类型:可哈希

dic = {‘k1‘:‘alex‘,‘k2‘:‘太白‘,‘k3‘:‘日天‘,‘name‘:‘wusir‘} ,删除列表中key中包含‘k‘的键值对

dic = {‘k1‘:‘alex‘,‘k2‘:‘太白‘,‘k3‘:‘日天‘,‘name‘:‘wusir‘}
l1=[]
for i in dic:
    if ‘k‘ in i:
        l1.append(i)
for i1 in l1:
    del dic[i1]
print(dic)

利用循环的方式删除字典中的键值对

注意:在循环一个字典时,如果要是删除某些或者某类键值对,容易出错.

数据类型之间的转化:

#int <---> str
#int <---> bool
#str <--->.bool
#      split
#str <------> list
#      join
# tuple <---> list
# l1 = [1,2,3]
# tu = tuple(l1)
# l2 = list(tu)
# print(tu,l2)

#将字典与列表的转化方式

dic = {‘k1‘:‘alex‘,‘k2‘:‘太白‘,‘k3‘:‘日天‘,‘name‘:‘wusir‘}
print(list(dic.items()))
print(list(dic.keys()))
print(list(dic.values()))

字典-->列表

python之集合,深浅copy

一,集合。

集合是无序的,不重复的数据集合,它里面的元素是可哈希的(不可变类型),但是集合本身是不可哈希(所以集合做不了字典的键)的。以下是集合最重要的两点:

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

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

1,集合的创建。

set1 = set({1,2,‘barry‘})
set2 = {1,2,‘barry‘}
print(set1,set2)  # {1, 2, ‘barry‘} {1, 2, ‘barry‘}

2,集合的增。

按 Ctrl+C 复制代码

按 Ctrl+C 复制代码

3,集合的删。

按 Ctrl+C 复制代码

按 Ctrl+C 复制代码

4,集合的其他操作:

  4.1 交集。(&  或者 intersection)

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

  4.2 并集。(| 或者 union)

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

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

  4.3 差集。(- 或者 difference)

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}

  4.4反交集。 (^ 或者 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}

  4.5子集与超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同,都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同,都是说明set2是set1超集。

5,frozenset不可变集合,让集合变成不可变类型。

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

二,深浅copy

1,先看赋值运算。

l1 = [1,2,3,[‘barry‘,‘alex‘]]
l2 = l1
l1.append(6)
print (l1,id(l1))
print (l2,id(l2))

赋值运算,id是不变的

对于赋值运算来说,l1与l2指向的是同一个内存地址,所以他们是完全一样的。

2,浅拷贝copy。

s1 = ‘alex‘
s2 = s1
s1 = ‘alex2‘
print(s1,id(s1))
print(s2,id(s2))

通过字符串浅拷贝

l1 = [1,2,3]
l2 = l1.copy()
l1.append(666)
print(l1,id(l1))
print(l2,id(l2))

通过列表的浅拷贝,他们的内存地址是独立的

l1 = [1,[22,33,],2,3]
l2 = l1.copy()
l1[1].append(666)
print(l1,id(l1),id(l1[1]))
print(l2,id(l2),id(l2[1]))

通过嵌套列表的浅copy

l1 = [1,2,3,[‘barry‘,‘alex‘]]
l2 = l1.copy()
print(l1,id(l1))  # [1, 2, 3, [‘barry‘, ‘alex‘]] 2380296895816
print(l2,id(l2))  # [1, 2, 3, [‘barry‘, ‘alex‘]] 2380296895048
l1[1] = 222print(l1,id(l1))  # [1, 222, 3, [‘barry‘, ‘alex‘]] 2593038941128print(l2,id(l2))  # [1, 2, 3, [‘barry‘, ‘alex‘]] 2593038941896
l1[3][0] = ‘wusir‘
print(l1,id(l1[3]))  # [1, 2, 3, [‘wusir‘, ‘alex‘]] 1732315659016
print(l2,id(l2[3]))  # [1, 2, 3, [‘wusir‘, ‘alex‘]] 1732315659016

对于浅copy来说,第一层创建的是新的内存地址,而从第二层开始,指向的都是同一个内存地址,所以,对于第二层以及更深的层数来说,保持一致性。

3,深拷贝deepcopy。

import copy
l1 = [1,2,3,[‘barry‘,‘alex‘]]
l2 = copy.deepcopy(l1)

print(l1,id(l1))  # [1, 2, 3, [‘barry‘, ‘alex‘]] 2915377167816
print(l2,id(l2))  # [1, 2, 3, [‘barry‘, ‘alex‘]] 2915377167048

l1[1] = 222
print(l1,id(l1))  # [1, 222, 3, [‘barry‘, ‘alex‘]] 2915377167816
print(l2,id(l2))  # [1, 2, 3, [‘barry‘, ‘alex‘]] 2915377167048

l1[3][0] = ‘wusir‘
print(l1,id(l1[3]))  # [1, 222, 3, [‘wusir‘, ‘alex‘]] 2915377167240
print(l2,id(l2[3]))  # [1, 2, 3, [‘barry‘, ‘alex‘]] 2915377167304

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

原文地址:https://www.cnblogs.com/yimiflh/p/8375738.html

时间: 2024-10-09 08:07:04

python之旅 1-29 补充内容,深浅copy的相关文章

python--基础数据类型的补充与深浅copy

一 . join的用法 lst =['吴彦祖','谢霆锋','刘德华'] s = '_'.join(lst) print(s) # 吴彦祖_谢霆锋_刘德华 # join() "*".join("吴彦祖") # 吴*彦*祖 把传递进去的参数进行迭代. 获取到的每个元素和前面的*进行拼接. 得到的是字符串 split() 切割. 切割的结果是列表 二 . 对正在循环的列表或者字典的删除方法 列表和字典: 都不能在循环的时候直接删除 把要删除的内容记录在新列表中然后循环这

Python自动化开发学习15-css补充内容

上节回顾 上一节学习的内容,有一下几点,可以注意一下.或者说推荐这么做. class可以设置多个值-css样式重用 可以给一个标签设置多个class值,这样我们可以为每个class应用一种样式.标签有多个class的话,就为这个标签应用了多个样式.并且之后别的标签要求重用其中的部分样式,只需要设置那个class就好了.要设置多个class的值,只需要用空格隔开每个值即可.下面的例子分别设置了背景色.高度.宽度.外框,然后div的设置了多个class: <head> <meta chars

python之数据类型补充、集合、深浅copy

一.内容回顾 代码块: 一个函数,一个模块,一个类,一个文件,交互模式下,每一行就是一个代码块. is == id id()查询对象的内存地址 == 比较的是两边的数值. is 比较的是两边的内存地址. 小数据池: 前提:int,str,bool 1,节省内存. 2,提高性能和效率. 小数据池是什么? 在内存中,创建一个'池',提前存放了 -5 ~256 的整数,一定规则的字符串和bool值. 后续程序中,如果设置的变量指向的是小数据池的内容,那么就不会再内存中重新创建. 小数据池与代码块的关系

Python学习---JSON补充内容[中文编码 + dumps解析]

JSON补充内容[微信解决中文乱码,接上] import json # 英文显示 dic = {"hello": "world"} str = json.dumps(dic) # type(str) <class 'str'> str: {"hello": "world"} print("type(str)", type(str), 'str:', str) # 中文显示 r = {"

Python全栈__数据类型的补充、集合set、深浅copy

1.数据类型的补充 1.1 元组 当元组里面只有一个元素且没有逗号时,则该数据的数据类型与括号里面的元素相同. tu1 = ('laonanhai') tu2 = ('laonanhai') print(tu1, type(tu1)) print(tu2, type(tu2),) tu1 = (1) tu2 = (1,) print(tu1, type(tu1)) print(tu2, type(tu2)) tu1 = ([1, 2, 3]) tu2 = ([1, 2, 3],) print(t

开始 Python 之旅

开始 Python 之旅 课程来源 本课程基于 Python for you and me 教程翻译制作,其中参考了 Python tutorial 和 The Python Standard Library,并对原教程的内容进行了改进与补充. 相关链接地址如下: Python tutorial:http://www.pythondoc.com/pythontutorial3/index.html Python for you and me:http://pymbook.readthedocs.

python之集合、深浅copy、文件操作、函数初识

本节内容:集合.深浅copy.文件操作.函数初识 1.小知识点补充 2.编码二 3.集合 4.深浅copy 5.文件操作 6.函数的初识 1.小知识点补充                                                                                           1.1 小数据池====str.int 小数据池存在的意义就是节省内存 节省内存,位多个变量开辟一个共享空间(str和int) int:-5--256 int===

python深浅copy探究

引入 在python程序中,如果我们操作一个变量的值去做运算,而又想在下次调用时,仍使用原来的变量的值去做运算,那么我们我们就需要将这个变量去做备份,这就是本文所要探究的问题. 开始 变量-对象-引用: python中全部皆对象,Python中变量是指对象(甚至连type其本身都是对象,type对象)的引用,Python是动态类型,程序运行时候,会根据对象的类型来确认变量到底是什么类型. 我们有时候会见到这样一种情况: a = 1 b = a 这样做不就是把数据copy了一份吗,错,这样做只是在

Python自动化开发学习16-前端内容综合进阶

css补充 这里再补充几个css的知识点,下面会用到 最小宽度-min-width 设置元素的最小宽度.举例说明,比如设置一个百分比的宽度,那么元素的宽度的像素值是会随着页面大小而变化的.如果设置一个最小的像素宽度,那么当变化到最小值之后,不会继续变小.在下面的例子中,会出现滚动条,保证元素的宽度: <body> <div style="height: 80px;width: 100%;background-color: blue;min-width: 800px;"