1、python的数据类型： 数值 字符串 列表 元组 字典；
数值类型包括； 整型(int) 长整型(long) 浮点型(float) 复数型 字符串；
可以通过type() 来查看是什么类型的；
注释：len()只支持 字符串类型,不支持浮点数和整数；
1:整型： 表示的数字,比如 0 100 -100 等； 整数又分为正整数和负整数；
整数范围： 2**32 次方；
In [8]: a = 123In [9]: type(a)Out[9]: intIn [10]: 2**32Out[10]: 4294967296In [11]: 2**31Out[11]: 2147483648
注释：整数的范围： -2147483648 到 2147483648 加起来刚好；4294967296
2：长整型 long 后面会加L； 或者是定义的值很大时, 或者在自定的数值后面加L也可以；
In [12]: a = 129999999999999999999999999999999999999In [14]: aOut[14]: 129999999999999999999999999999999999999LIn [15]: a = 100lIn [16]: aOut[16]: 100LIn [17]: type(a)Out[17]: long
3:浮点型；后面带小数点 0.0 12.0 -18.8 3e+7
In [18]: a = -0.18In [19]: type(a)Out[19]: floatIn [20]: a = 3e+7In [21]: type(a)Out[21]: float
4:复数型；后面加 j -3.14j
In [22]: a = -3.14jIn [23]: type(a)Out[23]: complex
5:字符串 str
给变量赋值字符串时,可以有三种方法: 单引号 双引号 三引号 /n 表示换行符；
注释：三引号可以用作定义字符串,也可以用作注释；再使用定义字符串时,必须是三个单引号,或者三个双引号,不能单双混用；
In [24]: a = 'abc'In [25]: type(a)Out[25]: strIn [26]: a = "abc"In [27]: type(a)Out[27]: str
/n 表示换行符；
In [33]: a = """hello\nworld"""In [34]: aOut[34]: 'hello\nworld'In [35]: print ahelloworldIn [30]: a = '''hello ...: world'''In [31]: aOut[31]: 'hello\nworld'In [32]: print(a)helloworld
注释：字符串时一个序列,那么针对序列操作的时候可以通过索引和切片来操作,
索引：第一个字符表示0,依次往后,最后一个字符可以用 -1 表示；
In [37]: aOut[37]: 'abcde'In [38]: a[0]Out[38]: 'a'In [39]: a[1]Out[39]: 'b'In [40]: a[4]Out[40]: 'e'In [41]: a[-1]Out[41]: 'e'
切片：比如我们需要去 ab 两个字符,当然可以用连接符 + 号 a[0]+a[1]
In [42]: a[0]+a[1]Out[42]: 'ab'In [43]: a[0:2]Out[43]: 'ab'In [44]: aOut[44]: 'abcde'
也可以使用切片的方式： a[0:2] 0表示a的下标 依次 2 表示 c 的下标,不过不显示；不过 0 也可以省略的； a[:2]
都可以省略表示全部内容； a[:]
a[::2] 表示步长值为 2 ，表示隔两步一取; 显示为 ace；
注释：a[-1] 表示e,最后一个字母,
也可以从后往前取,比如 a = abcde 如果取 bc 的话, 那就是 a[-4:-2]
In [58]: a = 'abcde'In [59]: aOut[59]: 'abcde'In [60]: a[-4:-2]Out[60]: 'bc'
默认是从左到右的；也可以从右到左的；比如 a = abcde 如果取 db 的话, 那就是 a[-2:-4:-1] -1 表示方向
In [61]: a = 'abcde'In [62]: a[-2:-4:-1]Out[62]: 'dc'
4、元组：序列包括字符串 列表 元组 ；
序列的主要特点就是可以使用 索引 操作 切片 操作； 索引是取某一个字符, 切片取一组字符；
序列的基本操作：
len() 求序列的长度；
+ 用来连接两个序列；
* 重复序列元素；
in 判断元素是否存在序列中；
max() 返回最大值；
min() 返回最小值；
cmp(x,y) 判断两个序列是否相等；
In [63]: a = 'abcde'In [64]: len(a) #求字符串长度;Out[64]: 5In [65]: a + 'f' #字符串相加;Out[65]: 'abcdef'In [69]: b = 5In [70]: b + 6 #数值相加;Out[70]: 11
如上图：len 可以用来求数据的长度；
+ 加号,可以用来序列相加；可以是同一类型相加(字符串相加 数值相加)，也可以不同类型( 字符串和数字相加)----不过需要转换一下；
In [84]: name = 'wo jin nian'In [85]: h = 'sui'In [86]: name + str(age) + hOut[86]: 'wo jin nian24sui'
# 号表示重复,后跟数字,表示重启的前面的多少次；
'#' * 50
Out[89]: '##################################################'in 判断元素是否在序列里；
判断 a 是否在 a 这个序列中, 存在则返回true， 不存在则返回flase； 已知 a = 'abcde'
In [91]: a= 'abcde'In [92]: 'a' in aOut[92]: TrueIn [93]: 's' in aOut[93]: False
还有not in 表示取反, 'f' not in a 表示 f 如果不在 a 这个序列里,则返回true, 如果在 则 返回flase；
In [94]: 'f' not in aOut[94]: TrueIn [95]: 'f' not in a+'f'Out[95]: False
max() 求最大值 min() 求最小值
In [99]: b = '12345'In [102]: type(b)Out[102]: strIn [100]: max(b)Out[100]: '5'In [101]: min(b)Out[101]: '1'
注释：max()和min() 只支持序列(字符串类型)
cmp(x, y) 比较两个序列是否相等； 如果 x > y 则返回正整数, x < y 返回负整数, x = y 返回0 ；In [113]: a= 'abcde'In [114]: cmp(a, 'abcde') # a 则表示上面的变量,它俩相等;所以返回是0 ;Out[114]: 0In [115]: cmp(a, 'abcdef') # a 小于右边的字符串,所以返回是负整数 -1 ;Out[115]: -1In [116]: cmp(a+'g', 'abcdef') # a 大于右边的字符串,所以返回是正整数 1 ;Out[116]: 1
注释：两个序列是否相等； 如果 x > y 则返回正整数, x < y 返回负整数, x = y 返回0 ；
5、元组() 可以存储一系列的值,和字符串一样是不可变的(里面的内容不可以改变)
如何定义元组呢？ 多个元素用 , 逗号分开；
t = ('a',1,(1,)) 表示里面存放的字符串 a 数字 1 , 又存放了元组 1 ;
In [119]: t = ('a',1,(1,))In [120]: tOut[120]: ('a', 1, (1,))In [121]: type(t)Out[121]: tuple 元组通常用于接受函数的返回值；如下；
定义t = (a, 'b', 'c') 这三个元素,其中a是表示之前定义的变量abcde,未加引号, b 和 c 表示字符串；
然后通过三个变量去接收这个值； first 第一个值 second 第二个值 third 第三个值；
In [122]: t = (a, 'b', 'c')In [123]: tOut[123]: ('abcde', 'b', 'c')In [127]: first, second, third = tIn [128]: firstOut[128]: 'abcde'In [129]: secondOut[129]: 'b'In [130]: thirdOut[130]: 'c' t.count
python里面的变量 字符串 序列 都称为对象；
元组和字符串一样属于序列类型,也可以通过序列和切片操作；
元组拆分；
t = ('a', 'b', 'c') A, B, C = t
6、列表：是一种有序项目的项目的数据结构,列表是可变数据类型的数据；
创建列表；
list = [] 创建空列表；
list2 = list() 通过list()函数来创建空列表；
list3 = ['a',1,2] 创建列表；
In [146]: list1 = [] #创建空列表;In [148]: type(list1)Out[148]: listIn [149]: list2 = list() #通过list函数来创建列表：In [150]: type(list2)Out[150]: listIn [151]: list2Out[151]: []In [152]: list3 = ['a',1,(1,),['hello', 'python']] #创建list列表;In [153]: list3Out[153]: ['a', 1, (1,), ['hello', 'python']]In [154]: len(list3)Out[154]: 4
列表的特性：列表的值时可变的；通过索引的方式把list3的值第 0 位 变成 a；
In [167]: list3Out[167]: ['b', 1, (1,), ['hello', 'python']]In [168]: list3[0]Out[168]: 'b'In [169]: list3[0] = aIn [170]: list3Out[170]: ['abcde', 1, (1,), ['hello', 'python']]
3、往空列表里追加： list2为之前创建的空列表； 通过 list2 = list() 函数创建；
给列表添加元素： list2.append( )
In [181]: list2.append('linux')In [182]: list2Out[182]: ['linux']In [183]: list3 + list2Out[183]: ['abcde', 1, (1,), ['hello', 'python'], 'linux'] 注释：然后可以把list3和list2 相加;
也可以重复之前的列表， 用 * 号； (list3) * 2 (list3+list2) * 2 先加再乘；
In [185]: (list3) * 2Out[185]: ['abcde', 1, (1,), ['hello', 'python'], 'abcde', 1, (1,), ['hello', 'python']]Out[186]: ['linux', 'linux']In [187]: (list3 + list2) * 2Out[187]: ['abcde', 1, (1,), ['hello', 'python'], 'linux', 'abcde', 1, (1,), ['hello', 'python'], 'linux']
6、删除列表中的元素：两种方式如下； del list2 表示删除真个list2 列表；
###可以使用help(list.remove)查看帮助等；
del list3[4] 需要知道它的下标才能够删除； 0 1 2 3 -l (最后表示 -1 )
list.remove(1) #默认删除是first第一个value；
In [204]: list3Out[204]: ['abcde', 1, (1,), ['hello', 'python']]In [205]: del list3[-1] #第一种方式,删除最后一个元素;In [206]: list3Out[206]: ['abcde', 1, (1,)]In [209]: list3.remove(1) #删除第一个元素;In [210]: list3Out[210]: ['abcde', (1,)]
7、查找； in
'a' in list3 表示 a 是否在这个列表,如果在,返回true,如果不在返回flase；
'a' not in list3 表示a 是否在这个列表,如果在,返回flase,不过则返回true；
In [210]: list3Out[210]: ['abcde', (1,)]In [211]: 'a' in list3Out[211]: FalseIn [215]: 'abcde' in list3Out[215]: TrueIn [216]: 'a' not in list3Out[216]: TrueIn [217]: 'abcde' not in list3Out[217]: False
修改字符； 列表 list3 的 0 位修改为 b ;
list3[0] = 'b'
In [218]: list3Out[218]: ['abcde', (1,)]In [219]: list3[0] = 'b'In [220]: list3Out[220]: ['b', (1,)]
list.insert 插入空的列表；
In [220]: list3Out[220]: ['b', (1,)]In [221]: list3.insert(1, list1)In [222]: list3Out[222]: ['b', [], (1,)]插入了一个空列表;
给空列表里写入值； list3[1].append('abc')
In [225]: list3[1].append('abc')In [226]: list3Out[226]: ['b', ['abc'], (1,)] 列表排序： list.sort
list3.sort()
In [227]: list3Out[227]: ['b', ['abc'], (1,)]In [228]: list3.sort()In [229]: list3Out[229]: [['abc'], 'b', (1,)]
反转(最后一位变成了第一位)； list.reverse
In [229]: list3Out[229]: [['abc'], 'b', (1,)]In [230]: list3.reverse()In [231]: list3Out[231]: [(1,), 'b', ['abc']]
list.pop 根据下标来删除,当时会返回一下当前值；
如我们删除list3 中下标为 1 的,使用 list.pop 不仅会删除,还会返回删除的这个值；
In [231]: list3Out[231]: [(1,), 'b', ['abc']]In [232]: list3.pop()Out[232]: ['abc']In [233]: list3Out[233]: [(1,), 'b']
注释：默认什么也不加,会删除最后一个；如上图例；
list.ectend，可迭代的,会把新增的追加列表里； list3.extend(range(5))
In [248]: range(5)Out[248]: [0, 1, 2, 3, 4]In [249]: list3.extend(range(5))In [250]: list3Out[250]: [(1,), 'b', 0, 1, 2, 3, 4]
list.exxend 会把元素迭代追加进去；
list3.exxtend('abcde')
In [255]: list3.extend('abcde')In [256]: list3Out[256]: [(1,), 'b', 0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e'] 也可以追加元组： list3.extend(('t1', 't2'))
注释：字符串 元组 列表 都是可迭代的对象；可迭代的可以通过for循环去访问；
list.count(value) 如果 判断这个value值在当前的列表里,则返回是一个整数,否则不在则返回0；
In [282]: list3Out[282]: [(1,), 'b', 0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']In [284]: list3.count('b')Out[284]: 2In [285]: list3.count('e')Out[285]: 1In [286]: list3.count('x')Out[286]: 0 list.index(value) 表示返回索引号；
In [287]: list3Out[287]: [(1,), 'b', 0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']In [288]: list3.index('b')Out[288]: 1In [289]: list3.index('d')Out[289]: 10In [290]: list3.index('e')Out[290]: 11
8、字典：是python里面的数据结构,字典的对象value是可变的,但是字典的键值key是不可变的,一个字典可以使用不同类型的键值(元组)；不能使用列表list,因为列表是可变的, 因为字典是hash 表显示是无序的；
可用来存储一个人年龄 身高 性别等；
当然字符串也可以存储的,但是如果有的姓名不是3个,那就取得不全的；
info = 'tom 180 man'
info[0:3]
'tom' 当然也可以存储元组里,但是元组一旦定义完之后,里面的元素就不能更改,那么如果增加联系人 等信息就无法添加了；当然也可以存储到列表里, 但是将来取数据也比较麻烦,通过下标来取,不知道索引就无法取了；
如下：先创建一个list1 list2 list3 并用zip函数把他们连接到一起；然后把这些信息放到字典里,然后取就很方便了；
In [298]: list1 = ['name', 'age']In [300]: list2 = ['tom','20']In [301]: list3 = ['mike','25']In [302]: list2Out[302]: ['tom', '20']In [303]: zip(list1, list2)Out[303]: [('name', 'tom'), ('age', '20')]In [304]: list1Out[304]: ['name', 'age']In [305]: list2Out[305]: ['tom', '20']In [306]: zip(list1, list3)Out[306]: [('name', 'mike'), ('age', '25')] 注释：zip函数会把两个列表合并,组成一个大的列表；
注释：列表 [ ] 元组 ( ) 字典 { } 字符串 ' '
字典的方法：
keys()
values()
items()
创建字典； dic { }
dic = {'a':1, 1:123} a 表示key 键值 1 表是 value 中间用冒号 ： 隔开；
In [307]: dic = {}In [308]: type(dic)Out[308]: dictIn [309]: dic = {'a':1, 1:123} #创建两对数据; key - value 对应;In [310]: dicOut[310]: {1: 123, 'a': 1} 2、那么用元组()作为key值来创建字典；如下；因为元组()是不可变的,可以用来当做key 键值； dc = {('a','b'):'hello'}
In [313]: dc = {('a','b'):'hello'}In [314]: type(dc)Out[314]: dictIn [315]: dcOut[315]: {('a', 'b'): 'hello'} 3、那么用list[]来作为key 值创建字典,不可以的,因为list是可变的；
In [317]: dc1 = {[1]:1}------------------------------------------------------------TypeError Traceback (most recent call last) in ()----> 1 dc1 = {[1]:1}TypeError: unhashable type: 'list' 注释：如上图例,所有list[ ] 不能当做字典的键值 key 来使用；
len(dic) 也可以看字典的长度；
4、字典的参数如下；
dic.key() 返回所有key值组成一个列表list并显示；
In [319]: dic.keys()Out[319]: ['a', 1, ('a', 'b')] dic.values() 返回所有value值组成一个列表list并显示；
In [320]: dic.values()Out[320]: [1, 123, 'hello']