@Author : Roger TX (425144880@qq.com)

@Link : https://github.com/paotong999

一、数字

Python中数字有四种类型：整数、布尔型、浮点数和复数。

• int (整数)：如 1，只有一种整数类型 int，表示为长整型。
• bool (布尔)：布尔值只有True、False两种值，布尔值可以用and、or和not运算。
• float (浮点数)：如 1.23、3E-2
• complex (复数)：如 1 + 2j、 1.1 + 2.2j

二、字符串

• Python中单引号和双引号使用完全相同。
• 使用三引号('''或""")可以指定一个多行字符串。
• 转义符 '\'
• 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。
• 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• Python中的字符串不能改变。

Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：

>>>ord('A')
65
>>>ord('中')
20013
>>>chr(66)
'B'
>>>chr(25991)
'文'

Python 支持格式化字符串的输出 。

1、最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

#!/usr/bin/env python
 
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

2、还有一种用法是格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % ，format 函数可以接受不限个参数，位置可以不按顺序。

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
 
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

也可以向 str.format() 传入对象：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value))  # "0" 是可选的

3、数字格式化

• ^，<，> 分别是居中、左对齐、右对齐，后面带宽度
• : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充
• + 表示在正数前显示 +，负数前显示 -

下表展示了 str.format() 格式化数字的多种方法：

空值

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

三、列表

列表是Python中最基本的数据结构。
列表中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 'str', 3, {'key':'value'}, [1, 2, 3] ];

访问列表中的值

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符

print ("list1[0]: ", list1[0])
print ("list2[1:4]: ", list2[1:4])

list1[0]: Google
list2[1:5]: ['str', 3, {'key':'value'}]

更新列表

你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项

list = ['Google', 'Runoob', 1997, 2000];
list[2] = 123
list.append('Baidu')
print ("更新后的列表 : ",  list)

更新后的列表 : ['Google', 'Runoob', 123, 2000, 'Baidu']

删除列表元素

list = ['Google', 'Runoob', 1997, 2000]
del list[2]
print ("删除第三个元素 : ", list)

删除第三个元素 : ['Google', 'Runoob', 2000]

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

四、元组

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

单元素元组

>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>

>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

访问元组

同列表一样，使用下标索引来访问列表中的值

tup = (1, 2, 3, 4, 5, 6, 7 )
print ("tup[1:5]: ", tup[1:5])

tup[1:5]: (2, 3, 4, 5)

更新元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，形成一个新的新的元组

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

五、字典

字典是一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必，一个简单的字典实例：

dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}
print ("dict['Name']: ", dict['Name'])

dict['Name']: 小菜鸟

访问字典里的值

把相应的键放入熟悉的方括弧，如下实例:

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

dict['Name']: Runoob
dict['Age']: 7

修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对，如下实例:

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

dict['Age'] = 8;               # 更新 Age
dict['School'] = "菜鸟教程"  # 添加信息

print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

dict['Age']: 8
dict['School']: 菜鸟教程

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。删除一个字典用del命令，如下实例：

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典

六、集合

集合被称为set，与dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
要创建一个set，需要提供一个list作为输入集合：

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

• 传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，set本身是无序的。
• set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象。

通过add(key)方法可以添加元素到set中，通过remove(key)方法可以删除set中的元素。

七、数据类型与拷贝

1、Python的可变类型与不可变类型

之前在数据类型文章中有写过可变类型与不可变类型，这里我们再讨论一下，便于我们理解拷贝。

Python的主要的核心类型中，数字、字符串、元组是不可变的，列表、字典是可变的。
对不可变类型的变量重新赋值，实际上是重新创建一个不可变类型的对象，并将原来的变量重新指向新创建的对象
如果没有其他变量引用原有对象的话（即引用计数为0），原有对象就会被回收

(1) 不可变类型，如 int 类型，对浮点类型的值进行修改后，指向新的内存地址
i += 1 并不是真的在原有的 int 对象上+1，而是重新创建一个 value 为6的 int 对象，i引用自这个新的对象。通过id函数查看变量i的内存地址进行验证（使用 hex(id(i)) 可以查看16进制的内存地址）。

>>> i = 5
>>> id(i)
140243713967984
>>> i += 1
>>> id(i)
140243713967960

可以看到执行 i += 1 时，内存地址都会变化，因为int 类型是不可变的。

(2) 多个 int 类型的变量值相同时，它们内存地址也是相同的。

>>> i = 5
>>> j = 5
>>> id(i)
140656970352216
>>> id(j)
140656970352216
>>> k = 5
>>> id(k)
140656970352216
>>> x = 6
>>> id(x)
140656970352192
>>> y = 6
>>> id(y)
140656970352192

对于不可变类型int，无论创建多少个不可变类型，只要值相同，都指向同个内存地址。
同样情况的还有比较短的字符串。

(3) 多个浮点型的变量值相同时，它们并不是指向同个内存地址，这点和 int 类型不同。

>>> i = 2.5
>>> id(i)
140564351733040
>>> j = 2.5
>>> id(j)
140564351733016

(4) 可变类型的话，如 list 类型，在 append 之后，还是指向同个内存地址。

>>> a = [1, 2, 3]
>>> id(a)
4385327224
>>> a.append(4)
>>> id(a)
4385327224

(5) 当多个不可变类型的变量值相同时，它们并不是指向同个内存地址。

>>> a = [1, 2, 3]
>>> id(a)
4435060856
>>> b = [1, 2, 3]
>>> id(b)
4435102392

• 我们可以通过 b = a 的赋值语句，让他们指向同个内存地址
• 这个时候需要注意，因为a、b指向同个内存地址，而a、b的类型都是 List 可变类型，对a、b任意一个List进行修改，都会影响另外一个 List 的值。

2、Python的深拷贝与浅拷贝

Python中对象的赋值实际上是对象的引用。

当创建一个对象，然后把它赋给另一个变量的时候，Python并没有拷贝这个对象，而只是拷贝了这个对象的引用。

(1) 赋值：数据完全共享
= 赋值是在内存中指向同一个对象
如果是可变(mutable)类型，比如列表，修改其中一个，另一个必定改变
如果是不可变(immutable)类型，比如字符串，修改了其中一个，另一个并不会变

(2) 浅拷贝：数据半共享
copy.copy() 浅拷贝没有拷贝子对象，所以原始数据改变，子对象会改变

(3) 深拷贝：数据完全不共享
copy.deepcopy() 深拷贝包含对象的拷贝，所有原始对象的改变不会造成深拷贝里任何子元素的改变

import os,sys,math,copy

alist=[1,2,3,["a","b"]]

b=alist
c=copy.copy(alist)
d=copy.deepcopy(alist)

print (b)    #[1, 2, 3, ['a', 'b']]
print (c)    #[1, 2, 3, ['a', 'b']]
print (d)    #[1, 2, 3, ['a', 'b']]

alist.append(5)

print (b)    #[1, 2, 3, ['a', 'b'], 5]
print (c)    #[1, 2, 3, ['a', 'b']]
print (d)    #[1, 2, 3, ['a', 'b']]

alist[3].append('cccc')

print (b)    #[1, 2, 3, ['a', 'b', 'cccc'], 5]
print (c)    #[1, 2, 3, ['a', 'b', 'cccc']]
print (d)    #[1, 2, 3, ['a', 'b']]