python中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在Python中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
Python3中有六个标准的数据类型：
Numbers（数字）
Python3支持int（整形）、float（浮点数）、bool（布尔型）、complex（复数）。
数值类型的赋值和计算都是很直观的，就像大多数语言一样。内置的type()函数可以用来查询变量所指的对象类型。例如：
1 >>> a,b,c,d = 20,5.5,True,4+3j 2 >>> print(type(a),type(b),type(c),type(d)) 3 <class ‘int‘> <class ‘float‘> <class ‘bool‘> <class ‘complex‘> #用tpye()查看变量的数据类型 4 >>> exit()
数值运算：
1 >>> 1+2 #加法 2 3 3 >>> 3.1-1 #减法 4 2.1 5 >>> 2*3 #乘法 6 6 7 >>> 2/4 #除法 8 0.5 9 >>> 2//4 #取整 10 0 11 >>> 17%3 #取余 12 2 13 >>> 2**5 #乘方 14 32
ps：
String（字符串）
Python中的字符串str用单引号(‘‘)或双引号("")括起来，同时使用反斜杠(\)转义特殊字符。
>>> a = ‘Yes,he doesn\‘t‘ >>> print(a,type(a),len(a)) Yes,he doesn‘t <class ‘str‘> 14
如果你不想让反斜杠发生转义，可以在字符串前面添加一个r,表示原始字符串：
1 >>> print(‘C:\some\name‘) 2 C:\some 3 ame 4 >>> print(r‘C:\some\name‘) 5 C:\some\name 6 >>>
另外反斜杠可以作为续航符，表示上一行时下一行的延续，还可以使用"""..."""或者‘‘‘...‘‘‘跨越多行。
字符串可以使用+运算符串联接在一起，或者用*运算符重复：
1 >>> print(‘str‘+‘ing‘,‘my‘*3) 2 string mymymy
Python中的字符串有两种索引方式，第一种是从左往右，从0开始依次增加；从-1开始依次减少。
注意，没有单独的字符类型，一个字符就是长度为1的字符串。
1 >>> word = ‘Python‘ 2 >>> print(word[0],word[5]) 3 P n 4 >>> print(word[-1],word[-6]) 5 n P
还可以对字符串进行切片，获取一段字符串。用冒号分隔两个索引，形式为变量[头下标:尾下标]。
截取范围是前闭后开的，并且两个索引都可以省略；
1 >>> word = ‘ilovepython‘ 2 >>> word[1:5] 3 ‘love‘ 4 >>> word[:] 5 ‘ilovepython‘ 6 >>> word[5:] 7 ‘python‘ 8 >>> word[-10:-6] 9 ‘love‘ 10 >>>
注意：
List（列表）
List（列表）是Python中使用最频繁的数据类型。
列表是写在方括号之间、用逗号分隔开的元素列表。列表中元素的类型可以不相同：
>>> a = [‘him‘,23,554,‘her‘] >>> print(a) [‘him‘, 23, 554, ‘her‘]
和字符串一样，列表同样可以被索引和切片，列表被切片后返回一个包含所需元素的新列表。
列表还支持串联操作，使用+操作符：
1 >>> a = [1,2,3,4,5] 2 >>> a 3 [1, 2, 3, 4, 5] 4 >>> a + [6,7,8] 5 [1, 2, 3, 4, 5, 6, 7, 8]
与Python字符串不一样的是，列表的元素是可以改变的：
1 >>> a = [1,2,3,4,5,6] 2 >>> a[0] = 9 #取值，0表示列表的索引也叫下标 3 >>> a 4 [9, 2, 3, 4, 5, 6] 5 >>> a[2:5] 6 [3, 4, 5] 7 >>> a[2:5] = [13,14,15] 8 >>> a 9 [9, 2, 13, 14, 15, 6] 10 >>> a[2:5] = [] #删除2-5标志位的元素 11 >>> a 12 [9, 2, 6]
List内置方法
使用dir()可以查看看列表的内置方法：
1 >>> dir(a) 2 [‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__iadd__‘, ‘__imul__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__reversed__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘append‘, ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘]
详细的使用方法使用help(a)
常用的有‘append‘, ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘这些个：
Help on list object: class list(object) | list() -> new empty list | list(iterable) -> new list initialized from iterable‘s items | | Methods defined here: | | __add__(self, value, /) | Return self+value. | | __contains__(self, key, /) | Return key in self. | | __delitem__(self, key, /) | Delete self[key]. | | __eq__(self, value, /) | Return self==value. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getitem__(...) | x.__getitem__(y) <==> x[y] | | __gt__(self, value, /) | Return self>value. | | __iadd__(self, value, /) | Implement self+=value. | | __imul__(self, value, /) | Implement self*=value. | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | __iter__(self, /) | Implement iter(self). | | __le__(self, value, /) | Return self<=value. | | __len__(self, /) | Return len(self). | | __lt__(self, value, /) | Return self<value. | | __mul__(self, value, /) | Return self*value.n | | __ne__(self, value, /) | Return self!=value. | __new__(*args, **kwargs) from builtins.type | Create and return a new object. See help(type) for accurate signature. | | __repr__(self, /) | Return repr(self). | | __reversed__(...) | L.__reversed__() -- return a reverse iterator over the list | | __rmul__(self, value, /) | Return self*value. | | __setitem__(self, key, value, /) | Set self[key] to value. | | __sizeof__(...) | L.__sizeof__() -- size of L in memory, in bytes | append(...) | L.append(object) -> None -- append object to end | | clear(...) | L.clear() -> None -- remove all items from L | | copy(...) | L.copy() -> list -- a shallow copy of L | | count(...) | L.count(value) -> integer -- return number of occurrences of value | | extend(...) | L.extend(iterable) -> None -- extend list by appending elements from the iterable | | index(...) | L.index(value, [start, [stop]]) -> integer -- return first index of value. | Raises ValueError if the value is not present. | | insert(...) | L.insert(index, object) -- insert object before index | | pop(...) | L.pop([index]) -> item -- remove and return item at index (default last). | Raises IndexError if list is empty or index is out of range. | | remove(...) | L.remove(value) -> None -- remove first occurrence of value. | Raises ValueError if the value is not present. | | reverse(...) | L.reverse() -- reverse *IN PLACE* | | sort(...) | L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* | | ---------------------------------------------------------------------- | Data and other attributes defined here: | __hash__ = None (END)
append()追加
1 >>> name_list = [‘zk‘,‘dgs‘,‘xx‘] 2 >>> name_list 3 [‘zk‘, ‘dgs‘, ‘xx‘] 4 >>> name_list.append(‘wyj‘) 5 >>> name_list 6 [‘zk‘, ‘dgs‘, ‘xx‘, ‘wyj‘]
追加就是放到最后
index()索引值
查找name_list中zk的索引值
>>> name_list.index(‘zk‘) 0
从0开始查找找到一个就停止
count()统计
在name_list中在追加一个元素zk，然后统计zk元素的的个数：
1 >>> name_list 2 [‘zk‘, ‘dgs‘, ‘xx‘, ‘wyj‘] 3 >>> name_list.append(‘zk‘) 4 >>> name_list 5 [‘zk‘, ‘dgs‘, ‘xx‘, ‘wyj‘, ‘zk‘] 6 >>> name_list.count(‘zk‘) 7 2
extend()扩展
可以把两个列表和到一起
1 >>> name_list 2 [‘&‘, ‘dgs‘, ‘wyj‘, ‘zsm‘, 22] 3 >>> b = [1,2,3] 4 >>> name_list.extend(b) 5 >>> name_list 6 [‘&‘, ‘dgs‘, ‘wyj‘, ‘zsm‘, 22, 1, 2, 3]
insert()插入
在name_list列表中dgs中插入一个值：
1 >>> name_list 2 [‘zk‘, ‘dgs‘, ‘xx‘, ‘wyj‘, ‘zk‘] 3 >>> name_list.insert(2,‘zsm‘) 4 >>> name_list 5 [‘zk‘, ‘dgs‘, ‘zsm‘, ‘xx‘, ‘wyj‘, ‘zk‘] 6 >>>
pop()删除一个
1 >>> name_list 2 [‘zk‘, ‘dgs‘, ‘zsm‘, ‘xx‘, ‘wyj‘, ‘zk‘] 3 >>> name_list.pop() 4 ‘zk‘ 5 >>> name_list 6 [‘zk‘, ‘dgs‘, ‘zsm‘, ‘xx‘, ‘wyj‘]
可以发现删除的是最后的一个元素
remove()指定删除一个
现在指定删除xx这个元素：
1 >>> name_list 2 [‘zk‘, ‘dgs‘, ‘zsm‘, ‘xx‘, ‘wyj‘] 3 >>> name_list.remove(‘xx‘) 4 >>> name_list 5 [‘zk‘, ‘dgs‘, ‘zsm‘, ‘wyj‘]
reverse()反转
先查看name_list里面的元素，在反转可以看到name_list中的元素全部倒过来了：
1 >>> name_list 2 [‘zk‘, ‘dgs‘, ‘zsm‘, ‘wyj‘] 3 >>> name_list.reverse() 4 >>> name_list 5 [‘wyj‘, ‘zsm‘, ‘dgs‘, ‘zk‘]
sort()排序
在Python3中数据类型不一样无法排序，如下：
1 >>> name_list.append(‘&‘) 2 >>> name_list.append(22) 3 name_list 4 [‘wyj‘, ‘zsm‘, ‘dgs‘, ‘zk‘, ‘&‘, 22] 5 >>> name_list.sort() 6 Traceback (most recent call last): 7 File "<stdin>", line 1, in <module> 8 TypeError: unorderable types: int() < str() 9 >>> type(name_list[-1]) 10 <class ‘int‘> 11 >>> type(name_list[0]) 12 <class ‘str‘>
全是数字的方式：
1 >>> num_lsit = [321,534,765,23,768] 2 >>> num_lsit 3 [321, 534, 765, 23, 768] 4 >>> num_lsit.sort() 5 >>> num_lsit 6 [23, 321, 534, 765, 768]
扩展：
name_list中在插入一个元素zk，就有两个元素zk了，现在想把两个zk全部删除怎么办呢？
可以根据上面的方法，先去找一共有多少个元素zk，然后循环找到的个数，删除指定的。
1 >>> for i in range(name_list.count(‘zk‘)): #循环查找zk这个元素的次数 2 ... name_list.remove(‘zk‘) #指定删除zk元素 3 ... 4 >>> name_list 5 [‘&‘, ‘dgs‘, ‘wyj‘, ‘zsm‘, 22]
这样就把列表name_list中zk元素给删除了
Tuple（元组）
元组和列表类似，不同之处在于元组的元素不能修改。元组写在小括号里，元素之间用逗号隔开。
元组中的元素类型也可以不相同：
1 >>> a = (123,456,‘test‘,‘math‘) 2 >>> a 3 (123, 456, ‘test‘, ‘math‘) 4 >>> print(a,type(a),len(a)) 5 (123, 456, ‘test‘, ‘math‘) <class ‘tuple‘> 4
元组与字符串类似，可以被索引且下标索引从0开始，也可以进行截取切片。
其实可以把字符串看做一种特殊的元组。
1 >>> tup = (1,2,3,4,5,6) 2 >>> print(tup[0],tup[1:5]) 3 1 (2, 3, 4, 5) 4 >>> tup[0] = 11 #元组中的元素是不能修改的 5 Traceback (most recent call last): 6 File "<stdin>", line 1, in <module> 7 TypeError: ‘tuple‘ object does not support item assignment
虽然tuple的元素是不能修改的，但它可以包含可变的对象，比如list列表。
构造包含0个或1个元素的元组是个特殊的问题，所以有一些额外的语法规则：
1 >>> tup1 = () #空元组 2 >>> tup2 = (10) #用常规方法创建一个只有一个值元组的元素 3 >>> tup3 = (20,) 4 >>> print(tup1,type(tup1)) 5 () <class ‘tuple‘> 6 >>> print(tup2,type(tup2)) #可以看到这种方法创建的只是一个数据类型 7 10 <class ‘int‘> 8 >>> print(tup3,type(tup3)) #所以创建只有一个值的元组时需要在值的后面加上一个逗号 9 (20,) <class ‘tuple‘>
另外，元组也支持用+操作符：
1 >>> tup1 = (1,2,3) 2 >>> tup2 = (4,5,6) 3 >>> print(tup1+tup2) 4 (1, 2, 3, 4, 5, 6)
string、list和tuple都属于sequence（序列）
注意：
Sets（集合）
集合是一个无序不重复元素的集。
基本功能是进行成员关系测试和消除重复元素。
可以使用大括号或者set()函数创建set集合，注意：创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空的字典的。
1 >>> student = {‘Tom‘,‘Jim‘, ‘Mary‘, ‘Tom‘, ‘Jack‘, ‘Rose‘} #创建一个集合 2 >>> print(student) #自动去重 3 {‘Tom‘, ‘Jack‘, ‘Mary‘, ‘Rose‘, ‘Jim‘} 4 >>> ‘Rose‘ in student #测试成员有就为True 5 True 6 >>> ‘zk‘ in student #没有就为False 7 False 8 >>> 9 >>> a = set(‘aglajgljasgjasl‘) 10 >>> b = set(‘qwetoqurnajksdfhagshdsjf‘) 11 >>> a 12 {‘g‘, ‘j‘, ‘l‘, ‘a‘, ‘s‘} 13 >>> b 14 {‘u‘, ‘j‘, ‘q‘, ‘w‘, ‘o‘, ‘k‘, ‘f‘, ‘a‘, ‘h‘, ‘t‘, ‘r‘, ‘s‘, ‘d‘, ‘g‘, ‘e‘, ‘n‘} 15 >>> a - b #a和b的差集 16 {‘l‘} 17 >>> a | b #a和b的并集 18 {‘u‘, ‘q‘, ‘f‘, ‘a‘, ‘t‘, ‘r‘, ‘s‘, ‘d‘, ‘j‘, ‘w‘, ‘o‘, ‘k‘, ‘h‘, ‘g‘, ‘l‘, ‘e‘, ‘n‘} 19 >>> a & b #a和b的交集 20 {‘g‘, ‘j‘, ‘a‘, ‘s‘} 21 >>> a ^ b #a和b不同时存在的元素 22 {‘u‘, ‘q‘, ‘f‘, ‘t‘, ‘r‘, ‘d‘, ‘w‘, ‘o‘, ‘k‘, ‘h‘, ‘l‘, ‘e‘, ‘n‘} 23 >>>
Dictionarie（字典）
字典是Python中另一个非常有用的内置数据类型。
字典是一种映射类型（mapping type），它是一个无序的建：值对集合。
关键字必须使用不可变类型，也就是说list和包含可变类型的tuple不能做关键字。
在同一个字典中，关键字还必须互不相同。
1 >>> dic = {} #创建一个空的字典 2 >>> tel = {‘Jack‘:1557,‘Tom‘:1320,‘Rose‘:1886} 3 >>> tel 4 {‘Tom‘: 1320, ‘Jack‘: 1557, ‘Rose‘: 1886} 5 >>> tel[‘Jack‘] #通过key查询对应的值 6 1557 7 >>> del tel[‘Rose‘] #删除一个建值 8 >>> tel 9 {‘Tom‘: 1320, ‘Jack‘: 1557} 10 >>> tel[‘Mary‘] = 4127 #添加一个键值 11 >>> tel 12 {‘Tom‘: 1320, ‘Jack‘: 1557, ‘Mary‘: 4127} 13 >>> list(tel.keys()) #返回所有key组成的list 14 [‘Tom‘, ‘Jack‘, ‘Mary‘] 15 >>> sorted(tel.keys()) #按key排序 16 [‘Jack‘, ‘Mary‘, ‘Tom‘] 17 >>> ‘Tom‘ in tel #测试成员 18 True 19 >>> ‘Tom‘ not in tel 20 False 21 >>>
构造函数dict()直接从键值对sequence中构建字典，当然也可以进行推导，如下：
1 >>> dict([(‘sape‘, 4139), (‘guido‘, 4127), (‘jack‘, 4098)]) 2 {‘sape‘: 4139, ‘jack‘: 4098, ‘guido‘: 4127} 3 >>> {x: x**2 for x in (2, 4, 6)} 4 {2: 4, 4: 16, 6: 36} 5 >>> dict(sape=4139, guido=4127, jack=4098) 6 {‘sape‘: 4139, ‘jack‘: 4098, ‘guido‘: 4127}
另外，字典类型也有一些内置函数，例如clear()、keys()、values()等。
注意：
原文：http://www.cnblogs.com/allan-king/p/5086643.html
