精华内容
下载资源
问答
  • python 深浅复制

    2019-07-05 14:47:57
    深浅复制 要理解深浅拷贝,需先弄懂下面的概念 变量-引用-对象(可变对象...在Python中不可变对象指:一旦创建就不可修改的对象,包括字符串,元祖,数字 在Python中可变对象是指:可以修改的对象,包括:列表、字...

    深浅复制

    要理解深浅拷贝,需先弄懂下面的概念

    变量-引用-对象(可变对象,不可变对象)-切片-拷贝(浅拷贝,深拷贝)

    变量是一个系统表的元素,拥有指向对象的连接的空间

    对象是被分配的一块内存,存储其所代表的值

    引用是自动形成的从变量到对象的指针

    在Python中不可变对象指:一旦创建就不可修改的对象,包括字符串,元祖,数字

    在Python中可变对象是指:可以修改的对象,包括:列表、字典

    1、不可变对象赋值

     a的值发生变化,b的值不会跟着变化

    a = 1
    b = a
    print(a)
    print(b)
    a  = 3
    print(a)
    print(b)
    
    结果:
    1
    1
    3
    1

    2.可变对象赋值

    a的值发生变化,b的值也跟着变化

    a = [1,2]
    b = a
    print(a)
    print(b)
    a[0] = 3
    print(a)
    print(b)
    
    
    结果:
    [1, 2]
    [1, 2]
    [3, 2]
    [3, 2]

    3.深浅复制

    浅拷贝:只拷贝顶级的对象,或者说:父级对象

    深拷贝:拷贝所有对象,顶级对象及其嵌套对象。或者说:父级对象及其子对象

    import copy
    
    #第一种:如果字典只有顶级对象(没有带嵌套)
    d = {'name':'derek','age':'22'}
    c1 = copy.copy(d)       #浅拷贝
    c2 = copy.deepcopy(d)   #深拷贝
    
    print(id(d),id(c1),id(c2))   #5794912 5794984 31939824   三个不同对象
    
    d['age'] = 25
    print(d,c1,c2)
    #{'name': 'derek', 'age': 25}
    # {'name': 'derek', 'age': '22'}
    # {'name': 'derek', 'age': '22'}
    
    源对象修改值的时候,深浅拷贝的对象值没有改变
    
    
    import copy
    
    #第二种,字典中有嵌套
    d = {'name':{'first':'zhang','last':'derek'},
        'job':['IT','HR']}
    c1 = copy.copy(d)
    c2 = copy.deepcopy(d)
    print(id(d),id(c1),id(c2))    #31157416 31940256 35946856
    
    d['job'][0] = 'tester'
    print(d,c1,c2)
    # {'name': {'first': 'zhang', 'last': 'derek'}, 'job': ['tester', 'HR']}
    # {'name': {'first': 'zhang', 'last': 'derek'}, 'job': ['tester', 'HR']}
    # {'name': {'first': 'zhang', 'last': 'derek'}, 'job': ['IT', 'HR']}
    
    源对象修改值的时候,浅拷贝的值跟着改变,深拷贝的值没变
    复制代码

    结论:

    • 深浅拷贝都是对源对象的复制,占用不同的内存空间
    • 如果源对象只有一级目录的话,源做任何改动,不影响深浅拷贝对象
    • 如果源对象不止一级目录的话,源做任何改动,都要影响浅拷贝,但不影响深拷贝
    • 序列对象的切片其实是浅拷贝,即只拷贝顶级的对象
    展开全文
  • 大家好,我是一个学习Python的初学者,真正学习的时间不长,虽然跟着两个大佬混,但是实际上还是自学的状态,所以,有同样的自学的小同志可以在评论区和我互动互动。 此文章分为三部分,第一部分:列表、字符串,第...

    大家好,我是一个学习Python的初学者,真正学习的时间不长,虽然跟着两个大佬混,但是实际上还是自学的状态,所以,有同样的自学的小同志可以在评论区和我互动互动。
    此文章分为2部分,第一部分:列表、字符串、字典,第二部分:练习题

    1列表

    切片

    我学习了这么久,总结写来,列表绝大多数就是对列表的切片以及索引

    切片稍微理解起来会绕一点,接下来最好跟着我一起敲代码,有助于理解切片。

    '''以下代码可直接复制,无需注意中文
    先定义一个列表,再看下面的需求
    '''
    lis = [0,1,2,3,4,5,6,7,8,9] 
    

    现有以下需求:
    获取lis列表中元素[1]
    获取lis列表中元素 [0,2,4,6,8]

    '需求1:获取lis列表中元素`[1]'
    print(lis[1:2]) 
    '需求2:获取lis列表中元素 [0,2,4,6,8]'
    print(lis[0::2])
    

    看到这里, 或许第一个理解,但是第二个就理解不了了
    需求1lis[] 中,第一个数字为索引开始的地址,第二个数字为索引结束的位置
    需求2lis[] 中,第二个数字不写,就是索引列表中第一个数字后面的所有数字,第三个数字为步长,你可以理解为,间隔多少个取一个,默认为1

    索引

    索引这部分更多的是关键字,记住以下的 增、删、改、查 最好大家可以创建一个列表,敲一遍。

    列表
    pop() 按索引删除
    remove() 按元素去删
    clear() 清空列表变为空列表
    del 清除列表
    列表
    append() 增加到最后
    insent(索址, ‘插内容’) 添加到括号内的索引之后
    extend() 只能添加可迭代的字符串,并拆成最小元素添加到列表中
    列表 公共方法
    len(() 查找长度
    count() 查找出现的次数
    index() 查找索引,找不到报错
    sort() 排序,从小到大排序
    sort(reverse = True) 倒叙排序
    reverse() 反转列表的元素

    2 元祖

    元祖是 可哈希,也就是说,不可修改`元祖里面的元素,只能读取,不能修改

    tup = (1,2,3,4,['coxie','bigbear',5],'yan')
    

    如上面这元祖,元祖的元素是不可修改的,但是元祖内嵌套了一个列表,所以,可修改元祖内列表的值。

    3字典

    仔细回看了下我学习Python的笔记,字典最多的就是理解清楚嵌套。

    像一些概念型的知识,讲多了也不好理解,所以更多的可以在后面的练习题上查看。

    展开全文
  • 目录运算符python内置函数Python基础语言元组函数返回值函数参数 ...复制 字符串、列表、元组 in 3 in (1, 2, 3) True 元素是否存在 字符串、列表、元组、字典 not in 4 not in (1, 2, 3) True

    运算符

    运算符 Python 表达式 结果 描述 支持的数据类型
    + [1, 2] + [3, 4] [1, 2, 3, 4] 合并 字符串、列表、元组
    * ‘Hi!’ * 4 [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] 复制 字符串、列表、元组
    in 3 in (1, 2, 3) True 元素是否存在 字符串、列表、元组、字典
    not in 4 not in (1, 2, 3) True 元素是否不存在 字符串、列表、元组、字典

    +号

    "hello " + “itcast”
    ‘hello itcast’

    [1, 2] + [3, 4]
    [1, 2, 3, 4]

    (‘a’, ‘b’) + (‘c’, ‘d’)
    (‘a’, ‘b’, ‘c’, ‘d’)

    *号

    ‘ab’*4
    ‘ababab’

    [1, 2]*4
    [1, 2, 1, 2, 1, 2, 1, 2]

    (‘a’, ‘b’)*4
    (‘a’, ‘b’, ‘a’, ‘b’, ‘a’, ‘b’, ‘a’, ‘b’)

    in

    ‘itc’ in ‘hello itcast’
    True

    3 in [1, 2]
    False

    4 in (1, 2, 3, 4)
    True

    “name” in {“name”:“Delron”, “age”:24}
    True

    注意,in在对字典操作时,判断的是字典的键

    python内置函数

    Python包含了以下内置函数

    序号 方法 描述
    1 cmp(item1, item2) 比较两个值
    2 len(item) 计算容器中元素个数
    3 max(item) 返回容器中元素最大值
    4 min(item) 返回容器中元素最小值
    5 del(item) 删除变量

    cmp

    cmp(“hello”, “itcast”)
    -1

    cmp(“itcast”, “hello”)
    1

    cmp(“itcast”, “itcast”)
    0

    cmp([1, 2], [3, 4])
    -1

    cmp([1, 2], [1, 1])
    1

    cmp([1, 2], [1, 2, 3])
    -1

    cmp({“a”:1}, {“b”:1})
    -1

    cmp({“a”:2}, {“a”:1})
    1

    cmp({“a”:2}, {“a”:2, “b”:1})
    -1

    注意:cmp在比较字典数据时,先比较键,再比较值。

    len

    len(“hello itcast”)
    12

    len([1, 2, 3, 4])
    4

    len((3,4))
    2

    len({“a”:1, “b”:2})
    2

    注意:len在操作字典数据时,返回的是键值对个数。

    max

    max(“hello itcast”)
    ‘t’

    max([1,4,522,3,4])
    522

    max({“a”:1, “b”:2})
    ‘b’

    max({“a”:10, “b”:2})
    ‘b’

    max({“c”:10, “b”:2})
    ‘c’

    del
    del有两种用法,一种是del加空格,另一种是del()

    a = 1
    a
    1

    del a
    a
    Traceback (most recent call last):
    File “”, line 1, in
    NameError: name ‘a’ is not defined

    a = [‘a’, ‘b’]
    del a[0]
    a
    [‘b’]

    del(a)
    a
    Traceback (most recent call last):
    File “”, line 1, in
    NameError: name ‘a’ is not defined

    多维列表/元祖访问的示例

    tuple1 = [(2,3),(4,5)]
    tuple1[0]
    (2, 3)

    tuple1[0][0]
    2

    tuple1[0][2]
    Traceback (most recent call last):
    File “”, line 1, in
    IndexError: tuple index out of range

    tuple1[0][1]
    3

    tuple1[2][2]
    Traceback (most recent call last):
    File “”, line 1, in
    IndexError: list index out of range

    tuple2 = tuple1+[(3)]
    tuple2
    [(2, 3), (4, 5), 3]

    tuple2[2]
    3

    tuple2[2][0]
    Traceback (most recent call last):
    File “”, line 1, in
    TypeError: ‘int’ object is not subscriptable

    Python基础语言

    我们可以用id()来判断两个变量是否为同一个值的引用。 我们可以将id值理解为那块内存的地址标示。

    a = 1
    b = a
    id(a)
    13033816

    id(b) # 注意两个变量的id值相同
    13033816

    a = 2
    id(a) # 注意a的id值已经变了
    13033792

    id(b) # b的id值依旧
    13033816

    a = [1, 2]
    b = a
    id(a)
    139935018544808

    id(b)
    139935018544808

    a.append(3)
    a
    [1, 2, 3]

    id(a)
    139935018544808

    id(b) # 注意a与b始终指向同一个地址
    139935018544808
    在这里插入图片描述

    可变类型与不可变类型
    可变类型,值可以改变:
    列表 list
    字典 dict

    不可变类型,值不可以改变:
    数值类型 int, long, bool, float
    字符串 str
    元组 tuple

    元组

    Python的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。

    aTuple = (‘et’,77,99.9)
    aTuple
    (‘et’,77,99.9)

    <1>访问元组
    在这里插入图片描述
    <2>修改元组
    在这里插入图片描述
    说明: python中不允许修改元组的数据,包括不能删除其中的元素。

    <3>元组的内置函数count, index
    index和count与字符串和列表中的用法相同

    a = (‘a’, ‘b’, ‘c’, ‘a’, ‘b’)
    a.index(‘a’, 1, 3) # 注意是左闭右开区间
    Traceback (most recent call last):
    File “”, line 1, in
    ValueError: tuple.index(x): x not in tuple

    a.index(‘a’, 1, 4)
    3

    a.count(‘b’)
    2

    a.count(‘d’)
    0

    函数返回值

    在python中我们可不可以返回多个值?

    >>> def divid(a, b):
    ...     shang = a//b
    ...     yushu = a%b 
    ...     return shang, yushu
    ...
    >>> sh, yu = divid(5, 2)
    >>> sh
    5
    >>> yu
    1
    

    本质是利用了元组

    函数参数

    1.缺省参数
    调用函数时,缺省参数的值如果没有传入,则被认为是默认值。下例会打印默认的age,如果age没有被传入:

    def printinfo( name, age = 35 ):
       # 打印任何传入的字符串
       print "Name: ", name
       print "Age ", age
    
    # 调用printinfo函数
    printinfo(name="miki" )
    printinfo( age=9,name="miki" )
    
    
    #以上实例输出结果:
    #Name:  miki
    #Age  35
    #Name:  miki
    #Age  9

    注意:带有默认值的参数一定要位于参数列表的最后面。

    def printinfo(name, age=35, sex):
    … print name

    File “”, line 1
    SyntaxError: non-default argument follows default argument

    2.不定长参数
    有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,声明时不会命名。基本语法如下:

        def functionname([formal_args,] *args, **kwargs):
           "函数_文档字符串"
           function_suite
           return [expression]

    加了星号(*)的变量args会存放所有未命名的变量参数,args为元组;而加**的变量kwargs会存放命名参数,即形如key=value的参数, kwargs为字典。

    def fun(a, b, *args, **kwargs):
    … “”“可变参数演示示例”""
    … print “a =”, a
    … print “b =”, b
    … print “args =”, args
    … print "kwargs: "
    … for key, value in kwargs.items():
    … print key, “=”, value

    fun(1, 2, 3, 4, 5, m=6, n=7, p=8) # 注意传递的参数对应
    a = 1
    b = 2
    args = (3, 4, 5)
    kwargs:
    p = 8
    m = 6
    n = 7

    c = (3, 4, 5)
    d = {“m”:6, “n”:7, “p”:8}
    fun(1, 2, *c, **d) # 注意元组与字典的传参方式
    a = 1
    b = 2
    args = (3, 4, 5)
    kwargs:
    p = 8
    m = 6
    n = 7

    fun(1, 2, c, d) # 注意不加星号与上面的区别
    a = 1
    b = 2
    args = ((3, 4, 5), {‘p’: 8, ‘m’: 6, ‘n’: 7})
    kwargs:

    3.引用传参
    可变类型与不可变类型的变量分别作为函数参数时,会有什么不同吗?
    Python有没有类似C语言中的指针传参呢?

    def selfAdd(a):
    … “”“自增”""
    … a += a

    a_int = 1
    a_int
    1

    selfAdd(a_int)
    a_int
    1

    a_list = [1, 2]
    a_list
    [1, 2]

    selfAdd(a_list)
    a_list
    [1, 2, 1, 2]

    Python中函数参数是引用传递(注意不是值传递)。对于不可变类型,因变量不能修改,所以运算不会影响到变量自身;而对于可变类型来说,函数体中的运算有可能会更改传入的参数变量。

    展开全文
  • 元祖 元祖看起来和列表很相似,但是不包括方括号,因此,...复制代码但是如果想改变元祖里的一个项,会得到一个错误信息,如下所示: 为什么报错呢?因为元祖的一大特点就是不可更改,字符串和数字也是一样。虽然...

    元祖

    元祖看起来和列表很相似,但是不包括方括号,因此,一般这样定义和使用元祖:

    >>> tuple=1,2,3
    >>> tuple
    > (1, 2, 3)
    >>> tuple[0]
    > 1
    复制代码

    但是如果想改变元祖里的一个项,会得到一个错误信息,如下所示:

    为什么报错呢?因为元祖的一大特点就是不可更改,字符串和数字也是一样。虽然可以通过变量让它指向不同的字符串、数值或元祖内,但是不能改变数字本身。

    那么元祖是只能看,不能动的,要他有何用呢?

    一般来说,元祖的作用就是帮助创建临时集合,这些集合里存放着可能会用到的项,python中还有很多像元祖这样的组件,后面我们会进一步讲解。

    因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple。

    tuple的陷阱:当你定义一个tuple时,在定义的时候,tuple的元素就必须被确定下来,比如:

    >>> t = (1, 2)
    >>> t(1, 2)
    复制代码

    如果要定义一个空的tuple,可以写成():

    >>> t = ()
    >>> t()
    复制代码

    但是,要定义一个只有1个元素的tuple,如果你这么定义:

    >>> t = (1)
    >>> t1
    复制代码

    定义的不是tuple,是1这个数!这是因为括号()既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1。

    所以,只有1个元素的tuple定义时必须加一个逗号,来消除歧义:

    >>> t = (1,)
    >>> t(1,)
    复制代码

    Python在显示只有1个元素的tuple时,也会加一个逗号,以免你误解成数学计算意义上的括号。

    最后来看一个“可变的”tuple:

    >>> t = ('a', 'b', ['A', 'B'])
    >>> t[2][0] = 'X'
    >>> t[2][1] = 'Y'
    >>> t('a', 'b', ['X', 'Y'])
    复制代码

    这个tuple定义的时候有3个元素,分别是'a','b' 和一个list。不是说tuple一旦定义后就不可变了吗?怎么后来又变了?别急,我们先看看定义的时候tuple包含的3个元素:

    当我们把list的元素'A'和'B'修改为'X'和'Y'后,tuple变为:

    表面上看,tuple的元素确实变了,但其实变的不是tuple的元素,而是list的元素。tuple一开始指向的list并没有改成别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向'a',就不能改成指向'b',指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!

    理解了“指向不变”后,要创建一个内容也不变的tuple怎么做?那就必须保证tuple的每一个元素本身也不能变。

    编程练习

    请用索引取出下面list的指定元素:

    # -*- coding: utf-8 -*-
    L = [['Apple', 'Google', 'Microsoft'],['Java', 'Python', 'Ruby', 'PHP'],['Adam', 'Bart', 'Lisa']]
    > # 打印Apple:
    > print(?)
    > # 打印Python:
    > print(?)
    > # 打印Lisa:
    > print(?)
    复制代码

    下期给出答案。

    转载于:https://juejin.im/post/5af3f896f265da0b8d41f368

    展开全文
  • 一、数据类型1.Python的运算符1....复制运算符: = 、+=、-=、*= 、/=4.逻辑运算符 : and or not2.python的数据类型1.整型: a = 10 print(a) 在3中必须要加括号。2就不需要2.bool 型 :True和False3.浮点型:flo...
  • 变量作用域_集合_列表_字典_元祖变量作用域提升局部变量为全局变量globals, locals函数eval()函数exec()函数递归函数斐波那契数列内置数据结构(变量类型)list[列表]创建列表访问列表分片操作分片操作是生成一个新...
  • 使用所有标记为某个特定的,位置明确的元素复制,如x[1]=2 >>> x=[1,2,3,4] >>> x[2]=100 >>> x [1, 2, 100, 4] >>> 同时不能为一个位置不存在的元素进行复制,即赋值位置大于列表总长度 >>> x[100]=3 ...
  • ​​​​​​​4.*操作符:序列的复制 ​​​​​​​5.len(seq):获取序列中元素的个数 ​​​​​​​6.max(seq):获取序列中最大值 ​​​​​​​7.min(seq):获取序列中最小值 ​​​​​​...
  • *复制 in not in is not is [] 内置函数: lower() upper() repace() split() find() rfind() lfind() 查找指定字符串的位置 strip() rstrip() lstrip() 删除指定字符串 join() 连接字符串数组。将字符串的元素以...
  • 3.神复制和浅复制 1.字符串拼接 例: a='hello', b='python',c='!' 将a,b,c中的字符串连成一句话。 1.用+号 a+b+c 2.格式化字符串 % '%s %s %s' % (a,b,c) 3.''.join()方法,注意括号是要连接的(可以是列表,元祖)...
  • Python基础知识汇总

    多人点赞 2020-09-29 23:01:32
    1.Python的四个关键点 1.1数据 python常用数据类型有5类: (1) 字符串(String) ...从而复制列表,保持原列表L不变。 ② 元组(Tuple):元祖是不可变的,使用(),只有一个元素的元祖要加逗号: (9
  • python2020面试题

    2020-11-19 17:28:02
    深拷贝是将对象本身复制给另一个对象。这意味着如果对对象的副本进行更改时不会影响原对象。在 Python 中,我们使用 deepcopy()函数进行深拷贝,使用方法如下: 深拷贝-Python 面试问题及答案 浅拷贝是将对象的...
  • python基本数据类型 序列类型的自带方法 1.列表的常用方法 2.元祖的常用方法 3.字符串的常用方法 1.列表常用的方法 L.append(obj) #在列表末尾添加新的对象 L.clear() #清空列表 L.copy() #复制列表,不是同一个对象...
  • python 基本知识点汇总

    2020-08-13 18:23:43
    数值、字符串、元祖(tuple)采用的是复制方式(深拷贝) 即 python 引用全局变量 需要引用全局变量前加个 global demo: x = 5 print(5) def get(): global x x = x + 10 print(x) get() python 字典遍历 ...
  • python深浅拷贝

    2019-12-21 19:00:36
    一、涵义 浅拷贝(copy):拷贝父对象,不会拷贝对象的内部的子对象。...元祖中有可变数据类型的时候,是可以进行拷贝的。 2、浅拷贝:数据半共享(复制其数据独立内存存放,但是只拷贝成功第一层) l1 = [1,2,3...
  • 元组(Tuple)是任意对象的有序集合 ...属于不可变序列类型 不能在原处修改(因为他们是不可变的),但可以进行组合和复制,运算后会生成一个新的元素 创建空元祖 tup1 = () 元组中只包含一个元素时,需要在...
  • python面试题

    2020-02-24 12:11:05
    2.列表和元祖有什么区别?3. *args和**kwargs区别?4. 如何随机打乱列表中的元素,不引用额外内存空间?5.什么是闭包?6. //和\** 是什么符号? 1.深拷贝和浅拷贝的区别? 浅拷贝是将一个对象的引用赋给另一个对象,...
  • 利用 python 进行数据分析 numpy基础 基础 函数 说明 array 将输入数据(列表,元祖,数组或者其他序列类型)转化为ndarray,要么判断出dtype,要么显示指定dtype。默认直接复制输入数据 as...
  • python学习笔记(2)

    2020-10-29 19:50:41
    文章目录字符串字符串的表示字符串的下标和切片字符串的查找判断字符串的...复制元祖元祖的使用字典字典的使用字典的增删改查update方法字典的遍历字典的练习字典推导式集合集合的基本使用集合的高级使用集合的练习公共...
  • python入门总结

    2018-07-26 17:44:24
    1)序列:列表[]可修改、元祖()不可修改、字符串(是一个字符组成的序列) 1、分片:a[开始 : 结束 : 步长] &gt;&gt;&gt;num=[0,1,2,3,4,5,6,7,8,9] &gt;&gt;&gt;num[3:6] 原样复制:y=...
  • python 学习之路 python3 byte 与 str 互相转换 列表 元祖 列表的追加,查询,删除,更改,声明,反转,清空,合并,(深浅)复制,列表的长度
  • python的基础知识-冷门

    2019-10-08 20:19:27
    大部分python对象是可变的,e.g列表,字典,自定义的类。 字符串和元祖是不可变的。 pass用于占位符,py不允许有空代码块 range和xrange 生成整数列表 xrange比range效率高,但是xrange不会预先生成列表而是一...
  • **# 浅拷贝:python所执行的复制动作中,如果是基本类型的数据(数字,字符串),就在内存中重新见一个窝,如果不是基本数据类型(列表,元祖,字典),就不用重新建窝即可,而是标签引用原来的窝。 # .copy()则是浅...
  • Python学习4--字符串

    2016-12-03 17:36:00
    2.python中字符串,列表,元祖的相似性  (1)访问,都是用str[i]来访问第i+1个元素。  (2)切片,str[i:j]来截取其中的一部分。  (3)拼接,若要向其中插入一部分,都要使用str[:i]+str2+str[i:]。但是此过程...

空空如也

空空如也

1 2 3
收藏数 58
精华内容 23
关键字:

python元祖复制

python 订阅