以下是部分总结

  1. 字符串

     #!/usr/bin/env pyhton3
 ​
 #在解释器直接输出时，反斜杠('\')并不总是被转义
 #例
 >>> '"Isn\'t," they said.'
 '"Isn\'t," they said.'
 >>> print('"Isn\'t," they said.')
 '"Isn't," they said.'
 ​
 #特殊字符只有在print中才会被转义,例如 \n
 #例
 >>> s = "First line. \nSecond line."
 >>> s
 'First line. \nSecond line.'
 >>> print(s)
 First line. 
 Second line.
 ​
 #如果不希望前置\的字符被转义成特殊字符，可以使用原始字符串，在引号前面加r即可
 #例
 >>> print('C:\some\name')
 C:\some
 ame
 >>> print(r'C:\some\name')
 C:\some\name
 ​
 #字符串跨行输入，可以使用三引号: """..."""
 #字符串可以用+合并(粘到一起)，也可以用*重复
 ​
 #字符串支持索引(下标访问)，第一个字符的索引是0
 #注意：pyhton的字符串和列表既可以从前往后访问，也可以从后往前访问
 #例   a  b  c  d  e  f  g 
 #下标  0  1  2  3  4  5  6
 #下标 -7 -6 -5 -4 -3 -2 -1
 ​
 #除了索引字符串还支持切片。
 #索引可提取单个字符，切片则提取字符串
 #例
 >>> word = 'Pyhton'
 >>> word[0:2]
 'Py'
 >>> word[2:5]
 'hto'
 #切片的默认值很有用；省略开始索引时，默认值为0，省略结构索引时，默认值为到字符串的结尾
 #例
 >>> word[:2]
 'Py'
 >>> word[4:]
 'on'
 >>> word[-2:]
 'on'
 #注意：输出结果包含切片开始，但不包含切片结束。因此S[:i] + S[i:]总是等于S
 #索引越界会报错，但切片会自动处理越界
 >>> word[42]
 Traceback (most recent call last):
   File "<pyshell#18>", line 1, in <module>
     word[42]
 IndexError: string index out of range
 >>> word[4:42]
 'on'
 #!!! Python的字符串时不能修改的，是immutable的，因此为字符串中的某个索引位置赋值会报错
 #要生成不同的字符串，应新建一个字符串
 >>> 'J' + word[1:]
 'Jyhton'
 >>> word[:2] + 'py'
 'Pypy'
 #内置函数len(返回字符串的长度)
 #注意：len()可以求python中所有类型的长度
 #例如 字符串、链表、数组、集合、字典大小
 #python常用数据结构
 #   list(列表)    类似于C++中的数组
 #   set(集合) 类似于C++中的set
 #   dit(字典) 类似于C++中的map
 ​
 >>> s = 'super'
 >>> len(s)
 5

列表

Pyhon支持多种复合数据类型，可将不同值组合一起。

最常用的是列表，是用方括号标注，逗号分隔的一组值。

  • 列表可以包含不同类型的元素，但在 一般情况下，各个元素的类型相同

     >>> squares = [1,4,9,16,25]
 >>> squares
 [1, 4, 9, 16, 25]
 >>> a = [1,2.0,'yxc']
 >>> a
 [1, 2.0, 'yxc']

  • 和字符串一样，列表也支持索引和切片

  • 直接复制列表————以下切片操作会返回列表的浅拷贝

     >>> squares[:]
 [1, 4, 9, 16, 25]

  • 列表还支持合并操作

     >>> squared + [36,49,64,81,100]
 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]                    

  • 与字符串不同的是，列表是可变(mutable)类型的，其内容可以改变

     >>> cubes = [1,8,27,65,125]
 >>> 4 ** 3
 64
 >>> cubes[3] = 64
 >>> cubes
 [1, 8, 27, 64, 125]

  • append()方法可以在列表结尾添加新元素————或者使用'+='

     >>> cubes.append(216)
 >>> cubes.append(7**3)
 >>> cubes
 [1, 8, 27, 64, 125, 216, 343]
     >>> x = [1,5,6]
 >>> x+= [7]
 >>> x
 [1, 5, 6, 7]

  • 为切片赋值可以改变列表大小，甚至清空整个列表

     >>> letters = ['a','b','c','e','f','g']
 >>> letters
 ['a', 'b', 'c', 'e', 'f', 'g']
 >>> letters[2:5] = ['C','D','E']
 >>> letters
 ['a', 'b', 'C', 'D', 'E', 'g']
 >>> letters[2:5] = []
 >>> letters
 ['a', 'b', 'g']
 >>> letters[:] =[]
 >>> letters
 []

  • 内置函数len()也支持列表

    >>> letters = ['a','b','c','d']
>>> len(letters)
4

  • 列表还可以嵌套列表(创建包含其他列表的列表)————当作C++中的二维数组

    >>> a = ['a','b','c']
>>> n = [1,2,3]
>>> x = [a,n]		#x有两个元素，a列表，和n列表
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

  • 浅拷贝！！！

    • >>> x = [1,2]
      >>> y = [3,4]
      >>> a = [x,y] #实际上只是起了个别名
      >>> a
      [[1, 2], [3, 4]]
      >>> b = a #浅拷贝，类似于C++中的指针
      >>> b[0] ='abc' #改变b列表中的第一个元素————实际上是改变a列表中的第一个元素
      >>> a
      ['abc', [3, 4]]

    • 真正复制列表方法

      >>> b = a[:] #浅拷贝

    • 上图中，原列表的元素所指的值(的地址)相同，a与b列表中的x,y元素地址不同

      • 示例一

        >>> x = [1,2]
>>> y = [3,4]
>>> a = [x,y]
>>> a
[[1, 2], [3, 4]]
>>> b = a[:]
>>> b
[[1, 2], [3, 4]]
>>> b[0] = 'abc'	#只对b列表中的元素(整体)改动，不影响a列表，因为a与b列表中x,y的地址不同
>>> b
['abc', [3, 4]]
>>> a
[[1, 5], [3, 4]]

      • 示例二

        >>> x = [1,2]
>>> y = [3,4]
>>> a = [x,y]
>>> a
[[1, 2], [3, 4]]
>>> b = a[:]
>>> b
[[1, 2], [3, 4]]
>>> b[0][1] = 5 	#若对b列表中元素所对应的列表进行操作，则会改变b元素所对应的列表的值
>>> b
[[1, 5], [3, 4]]
>>>

  • 深拷贝！！！

    • 深拷贝中，会将a列表中每个元素及其对应列表进行递归

      • a列表中所有元素及其元素的对应的列表全部被复制到b列表中

      • 于是无论b列表怎么变化，都不会影响a列表

    • 缺点：

      • 过于耗时

      • 递归对象(直接或间接包含对自身引用的复合对象)，可能导致递归循环

      • 由于深拷贝会复制所有内容，因此可能会过多复制(复制了原本并不需要复制的数据)

    • 使用方法

      >>> import copy 	#注意需要导入copy库
>>> x = [1,2]
>>> y = [3,4]
>>> a = [x,y]
>>> a
[[1, 2], [3, 4]]
>>> b = copy.deepcopy(a) 	#进行深拷贝———— 浅拷贝: b.copy.copy(a)
>>> b
[[1, 2], [3, 4]]
>>> b[0][1] = 10
>>> b
[[1, 10], [3, 4]]
>>> a
[[1, 2], [3, 4]]