【python基础篇】常用内置对象与操作_可以根据需要修改内置对象,如object和array

目录

学前准备

交互式编写代码

IDE编写代码

常用内置对象

数字常量

字符串常量和表达式

常用列表常量和操作

常见字典常量和操作

常见元组常量和运算

文件

对象GC与共享引用

学习小结

---

学前准备

在正式开始之前，你需要安装python软件，准备一款好用的IDE工具。墙裂推荐anaconda + pycharm，网上有很多安装教程的博客，这里就不再赘述了。

编写的方式有两种：一是在Dos界面写交互式编码，一是在IDE工具中进行编码

交互式编写代码

• 使用win+R调出“运行”对话框，输入cmd，再输入python即可进入“交互模式”
• IDE方式，我使用的是pycharm，在左下方，找到“python console”即可进入“交互模式”

交互模式的优点是，不需要刻意的使用“print”打印，也能自动打印，方便观察每一步的结果

>>> print 2 ** 8
256 
>>> 2 ** 8
256
>>> lumberjack = 'okay'
>>> lumberjack
'okay'

或者说打开文本编辑器，（使用win+R调出“运行”对话框，输入notepad回车即可），在文本中输入以下两行python语句，保存为spam.py。然后，我们用“python spam.py”命令运行该文件

### file: spam.py
print 2 ** 100
print 'Spam!'
 
>>> python spam.py
2 ** 100
'Spam!'

IDE编写代码

我们选择pycharm，即可开始代码练习，将代码明确保存为.py格式，使用菜单栏的“run”→“run...” 运行该代码

### file: threenames.py
a = 'dead'       
b = 'parrot'      
c = 'sketch'
print a, b, c
 
Output:dead parrot sketch

IDE中如果要观察每一步的结果，则需要Debug

---

常用内置对象

python内置对象优点

• 内置对象使程序更容易编写。例如，集合（列表）和搜索表（字典），可以马上使用
• 内置对象是扩展的组件。例如，堆栈数据结构也许会实现为管理和定制内置列表的类，而python内置了
• 内置对象往往比定制的数据结构更有效率。python的内置类型优化了用C实现数据结构的算法
• 内置对象是语言的标准的一部分。python借鉴了依靠内置工具的语言Lisp，汲取了C++编程框架的优点

内置对象

数字、字符串、元组具有不可变性，即对象创建后不能更改。

字符串、列表、元组都属于序列，可以对序列进行一些通用的操作，如索引、合并以及分片，同时每个内置对象也有特定的方法调用。

字典是唯一具有映射属性的对象，没有左右位置关系，支持键值对操作

关于多态的问题

操作符取决于被操作的对象，这就是多态。例如，‘a’+‘b’和1+2，输出的结果分别是ab和3。操作符是‘+’，由于被操作对象不同，输出的结果呈现不同的结果。

 

数字常量

python表达式操作符及程序

其他知识点

oct（十进制）、hex（十进制），分别表示八进制和十六进制

int（数字，进制）可以将八进制、十六进制的数字（字符串形式）转化为十进制

内置数学工具：math.pi，math.e，math.sin，math.sqrt（），abs（），x**y / pow（x，y），round（2.567，2）

集合：x=set（'abcda'），output ：{'c', 'd', 'b', 'a'}，可以看出集合中的元素是不重复且无序的。

 

字符串常量和表达式

单双引号字符串是一样的，"knight's"也可以表示为'knight\'s'或者"knight\"s"

用转义序列代表特殊字节

转义序列：反斜杠+特殊字节编码。例如，这里有五个字符的字符串，其中嵌入了一个换行符'\n'和一个制表符'\t'

>>>s = 'a\nb\tc'

字符串反斜线字符

字符串抑制转义

在字符串前面增加‘r’或是加入转义字符，如下所示

myfile = open（'C：\new\text.dat','w'）
myfile = open（r'C：\new\text.dat','w'）    #方法一
myfile = open（'C：\\new\\text.dat','w'）   #方法二

索引和分片

偏移量是从0开始的，负偏移看作是从结束处反向计数

>>> S = 'spam'
>>> S[0], S[-2]               # 索引
('s', 'a')
>>> S[1:3], S[1:], S[:-1]     # 分片
('pa', 'pam', 'spa')

扩展分片：第三个值表示步长

>>> S = 'abcdefghijklmnop'
>>> S[1:10:2]
'bdfhj'
>>> S[::2]
'acegikmo'
 
>>> S = 'hello'
>>> S[::-1]
'olleh'
 
>>> S = 'abcedfg'
>>> S[5:1:-1]
'fdec'

字符串的修改

在第4章我们提到过，字符串本身是不支持修改的，我们用如下的方法来进行修改：

>>> S = 'spam'
>>> S[0] = "x"
Raises an error!
 
>>> S = S + 'SPAM!'
>>> S
'spamSPAM!'
>>> S = S[:4] + 'Burger' + S[-1]
>>> S
'spamBurger!'
 
>>> S = 'splot'
>>> S = S.replace('pl', 'pamal')
>>> S
'spamalot'

字符串转列表，列表转字符串

>>> S = 'spammy'
>>> L = list(S)
>>> L
['s', 'p', 'a', 'm', 'm', 'y']
 
>>> L[3] = 'x'                         # Works for lists, not strings
>>> L[4] = 'x'
>>> L
['s', 'p', 'a', 'x', 'x', 'y']
 
>>> S = ''.join(L)
>>> S
'spaxxy'

字符串方法实例：文本解析

>>> line = 'aaa bbb ccc'
>>> col1 = line[0:3]
>>> col3 = line[8:]
>>> col1
'aaa'
>>> col3
'ccc'
 
>>> line = 'aaa bbb ccc'
>>> cols = line.split()
>>> cols
['aaa', 'bbb', 'ccc']
 
>>> line = 'bob,hacker,40'
>>> line.split(',')
['bob', 'hacker', '40']
 
>>> line = "i'mSPAMaSPAMlumberjack"
>>> line.split("SPAM")
["i'm", 'a', 'lumberjack']

 

常用列表常量和操作

 

常见字典常量和操作

字典能用作稀疏数据的存取，这一点在实际生活中是经常用到的。

举出五种创建字典的方法

{'a'：0，'b'：1}
 
D = {}
D['a'] = 0
D['b'] = 1
 
dict('a'=0，'b'=1)
 
dict(['a'，0]，['b'，1])
 
dict(zip(['a'，'b']，[0，1]))

 

常见元组常量和运算

列表和元组的区别：列表提供可变性，元组提供不可变性。

 

文件

myfile = open('myfile'，'w')

参数‘w’是指写入。'r'是指读取，是默认值，‘a’是在文件尾部追加内容。

>>> D = {'a': 1, 'b': 2}
>>> F = open('datafile.pkl', 'wb')
>>> import pickle
>>> pickle.dump(D, F)                  # Pickle any object to file
>>> F.close()
 
>>> F = open('datafile.pkl', 'rb')
>>> E = pickle.load(F)                 # Load any object from file
>>> E
{'a': 1, 'b': 2}

以上是用pickle模块来储存python的原生对象

 

对象GC与共享引用

python中，类型是在运行过程中自动决定的，而不是通过代码去声明。

>>>a = 3

上面的代码反映了python语言中所有赋值的操作：

1. 创建一个对象来代表值3
2. 创建一个变量a，如果它还没有创建的话
3. 将变量与新的对象相连接

其中，a代表对象，3代表变量名。类型是属于对象的，而不是变量

关于对象的垃圾收集，我们给出如下的代码，每当一个变量名被赋予了一个新的对象，之前那个对象占用的空间就会被收回。

>>>a = 3
>>>a = 'spam'

共享引用

>>>a = 3
>>>b = a
>>>a = 'spam'

以上代码，只会改变a的值，b的值是不变的。在第4章，我们所介绍过的，整数是不可变的。

>>>L1 = [ 2，3，4]
>>>L2 = L1
>>>L1 = 24

以上代码，仍然只改变L1的值，L2的值也是不变的。L1的列表自身也是对象，就像整数和字符串一样，自身是不会被改变的。

>>>L1 = [ 2，3，4]
>>>L2 = L1
>>>L1[0] = 24

以上代码，L1和L2的值都被改为了[24，3，4]。L1列表中的元素是可以被改变的。如果我们不想L2发生改变，我们需要做如下改动

>>>L1 = [ 2，3，4] 
>>>L2 = L1[:]
>>>L1[0] = 24

L1[:]是对L1的对象的copy。字典D有两种的copy方法，分别是copy（）和deepcopy（）

共享引用和相等

>>>L = [ 1，2，3]
>>>M = L
>>>L == M
True
>>>L is M
True

>>>L = [ 1，2，3]
>>>M = [ 1，2，3]
>>>L == M
True
>>>L is M
False

"==操作符"，测试两个被引用的对象是否有相同的值，"is操作符"是在检查对象的同一性

>>>X = 42
>>>Y = 42
>>>X == Y
True
>>>X is Y
True

这里因为小的整数和字符串会被缓存并复用，所以is告诉我们X和Y是一个相同的对象。我们能查询python对于一个对象重复的引用次数，如下所示：

>>>import sys
>>>sys.getrefcount(42)
23

---

学习小结

随着python的发展，内置的对象操作或许还会扩展更多，也会更易用，我们需要不断学习，不断更新自己的知识。

送大家一句鸡汤：知识要用起来才会变成自己的，经验不在于多，而在于精。