Python语言中，数据以对象的形式出现，无论是Python提供的内置对象，还是使用Python语言创建的对象。

程序-〉模块-〉语句-〉表达式-〉处理对象

为何区分对象类型

1 不同类型对象运算规则不同

2 不同类型对象在计算机内表示方式不同

3 为何区分整数与浮点数

 浮点数表达能力更强

 浮点数有精度损失

 CPU有专门的浮点运算部件

>>> print(3.3==1.1*3)

False

内置对象一览

对象类型例子

数字123，12.5，5+10j

字符串'hello world!'，"Python is best."

元组(5,'spam',12,'A')

列表[1,2,[3,4,'haha'],5]

字典{'abc':123,'efg':456,'qwer':'1234'}

集合{1,2,3,4,5} ，set('hello world!')

文件myfile = open('test.py','r')

其他None，布尔型

数字

int（整型）

　　在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647

　　在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

long（长整型）

　　跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。

　　注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。

float（浮点型）

　　浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。

complex（复数）

　　复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

字符串

字符串(String)是一个字符的序列，用于记录文本信息。序列中的元素包含一个从左到右的顺序，可以根据它们的相对位置进行存储和读取，其他类型的序列包括列表和元组。

注：不可变序列只能通过位置读取，不能存储（字符串和元组是不可变序列）。

三种定义方式:

单引号括起来

s = 'hello world'

双引号括起来

s = "hello world"

三引号括起来("""或''')

s = """this is a test

hello world."""

用转义序列代表特殊字符

\\ --反斜线（保留\）

\' --单引号

\" --双引号

\n  --换行

\t  --水平制表符

\v --垂直制表符

\r --回车

抑制转义

>>>s = r'D:\tmp\a.txt'

>>>s

'D:\\tmp\\a.txt'

基本运算

长度（len()函数）

拼接（+）

重复（*）

成员运算符（in）

示例：

计算字符串中元音字母数目

def vowels_count(s):

         ret= 0

         foritem in s:

                   ifitem in 'aeiouAEIOU'：

                            ret+=1

         returnret

索引与分片

Python语言中索引是按照最前面的偏移量进行编码，索引的起始位置为0。

例如：

>>>s = 'Hello'

>>>s[0]

'H'

>>>s[2]

'l'

Python语言支持反向索引，从最后一个开始，其索引值是-1

>>>s[-1]

'o'

>>>s[-2]

'l'

分片操作，从序列对象中提取一部分。一般形式为X[I,J]，表示从序列对象X中提取从偏移为I,直到但不包括J的内容。

例如：

>>>s[1:3]

'el'

>>>s[1:-1]

ell

分片操作中，左边界默认为0，右边界默认为序列长度，这样可以在分片时省略左右边界。

例如：

>>>s[:-1]

'Hell'

>>>s[2:]

'llo'

>>>s[:]

'Hello'

扩展分片，可选的第三个索引，用于步进。形式X[I,J,K]，表示对序列X从偏移I，直到偏移J-1，每隔K个元素提取一个对象。K默认值为1。

例如：

>>>s='abcdefghijklmnopqrstuvwxyz'

>>>s[1:10:3]

'beh'

>>>s[::4]

'aeimquy'

>>>s[::-1]

'zyxwvutsrqponmlkjihgfedcba'

>>>s[5:1:-2]

'fd'

字符串方法

replace(old,new,count=-1) 替换子串

find(sub) 寻找子串，找到返回子串位置，否则返回-1

split(sep) 字符串切分，根据sep切分为字符串数组

更多方法：

>>> dir(str)

['__add__', '__class__', '__contains__',

'__delattr__', '__dir__', '__doc__', '__eq__',

'__format__', '__ge__', '__getattribute__',

'__getitem__', '__getnewargs__', '__gt__',

'__hash__', '__init__',

'__init_subclass__', '__iter__', '__le__', '__len__', '__lt__',

'__mod__', '__mul__', '__ne__', '__new__',

'__reduce__','__reduce_ex__',

'__repr__', '__rmod__', '__rmul__',

'__setattr__', '__sizeof__', '__str__',

'__subclasshook__', 'capitalize',

'casefold', 'center', 'count', 'encode', 'endswith',

'expandtabs', 'find', 'format',

'format_map', 'index', 'isalnum', 'isalpha',

'isascii', 'isdecimal', 'isdigit',

'isidentifier', 'islower', 'isnumeric', 'isprintable',

'isspace', 'istitle', 'isupper', 'join',

'ljust', 'lower', 'lstrip', 'maketrans', 'partition',

'replace', 'rfind', 'rindex', 'rjust',

'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines',

'startswith', 'strip', 'swapcase', 'title',

'translate', 'upper', 'zfill']

字符串比较

 按顺序依次比较每个位置上的字符，如果相同就比较下一个，如果不同大小关系就由这两个字符的大小关系决定。

字符串格式化format方法

{}的格式 {field name,align

width.precision type}

print("PI is {}".format(math.pi))

print("PI is

{:4.2f}".format(math.pi))

列表与元组

内建数据结构，用来存储一系列元素，列表与元组的区别是，元组是不可变对象，不能修改，列表可以修改。

元组：

t = (1,2,3,4,5)

列表

l = [1,2,3,4,5]

列表和元组与字符串一样，都是有序序列，所以列表和元组与字符串有很多相同点：

1 索引运算[]

2 切片[:]

3 拼接和重复 + *

4 成员运算 in

5 长度 len

6 循环迭代 for

与字符串只能包含字符不同，列表和元组可以包含多种类型的对象。

列表的方法

append() #追加

extend() #扩充

pop() #删除

remove() #删除

sort() #排序

reverse() #逆序

列表赋值

a = [1,2,3,4]

b = a

b[1] = 100

b = [:]

b[1] = 100

嵌套列表

x = [[1,2,3,[4,5,6],[7,8,9]]]

len(x) = ?

len(x[1]) = ?

列表解析

列表解析：由原列表创建新列表的简单方法。列表解析语法是从集合理论表示法中的一种结构衍生出来的，也就是对集合中的每个元素应用某一种运算。

 [表达式 for 变量 in 列表 if 条件]

例如生成x平方的序列：

 ist= []

 forx in range(1,10)

         ist.append(x**2)

 print(ist)

列表解析：

 ist= [x**2 for x in range(1,10)]

使用列表解析求输入数字x的因数和

 例如输入6 ，因数和为1+2+3+6 = 12

 sum([i for i in range(1,x+1) if x%i == 0])

字典与集合

字典：一系列“键-值（key-value）”对

通过“键”查找对应的“值”

 电话本，字典

 java中的Map

(HashTable,HashMap)

创建字典

 使用{}创建字典

 使用:指明键：值对

 myDict = {'小李':87977111,'李明':13598881112,'小丁':98761221}

 字典中的键必须是不可变的且不可重复，值可以是任意类型。

访问字典

 使用[]运算符，键作为索引

 print(myDict['小李'])

 增加新的键值对：

 myDict['小王']=17621231232

字典运算符和方法

 len

 keyin myDict

 forkey in myDict

myDict.items() #全部键值对

myDict.keys() #全部键

myDict.values() #全部值

myDict.clean() #清空字典

示例：

计算一个字符串中每个字母出现的次数

count = {}

for i in 'hello world':

         ifi in count:

                   count[i]+= 1

         else:

                   count[i]= 1

集合（Set）

无序不重复元素集

和字典类似，但是只有“键”没有“值”

创建

 x =set()

 x ={key1,key2,...}

添加和删除

 x.add()

 x.remove()

集合的运算符

-  差集

& 交集

| 并集

!= 不等于

== 等于

in 成员

for key in set 枚举

文件

计算机中由操作系统管理的具有名字的存储数据的基本单元。

内置open函数

open(file, mode='r', encoding=None)

file -- 文件名

mode --模式 r读； w写； a追加； b 二进制模式；t文本模式；+ 同时读写

encoding --编码（只对文本模式有效，默认取系统编码，可参考codesc模块）

文件对象的方法：

file.read()                                      --把整个文件读入单一字符串

file.read(N)                          --读取N个字节到一个字符串

file.readline()                      --读取下一行（包括换行符）

file.readlines()                    --读取整个文件到字符串列表（可迭代对象）

file.write(aString)              --写入字符串到文件

file.writelines(aList)                   --把列表内所有字符串写入文件

file.close()                           --关闭文件

file.flush()                            --输出缓冲区刷新到硬盘

file.seek(N)                         --文件指针向后跳转到偏移量N处

注：目前的Python解释器在回收文件对象时，会自动关闭文件，这意味着并不需要总是手动关闭文件，但这并不是语言定义的一部分，所以手动调用close方法关闭文件是个好习惯。