个人博客导航页（点击右侧链接即可打开个人博客）：大牛带你入门技术栈
1、python的数据类型： 数值 字符串 列表 元组 字典；
数值类型包括； 整型(int) 长整型(long) 浮点型(float) 复数型 字符串；
可以通过type() 来查看是什么类型的；
注释：len()只支持 字符串类型,不支持浮点数和整数；
1:整型： 表示的数字,比如 0 100 -100 等； 整数又分为正整数和负整数；
整数范围： 2**32 次方；
In [8]: a = 123
In [9]: type(a)
Out[9]: int
In [10]: 2**32
Out[10]: 4294967296
In [11]: 2**31
Out[11]: 2147483648
注释：整数的范围： -2147483648 到 2147483648 加起来刚好；4294967296
2：长整型 long 后面会加L； 或者是定义的值很大时, 或者在自定的数值后面加L也可以；
In [12]: a = 129999999999999999999999999999999999999
In [14]: a
Out[14]: 129999999999999999999999999999999999999L
In [15]: a = 100l
In [16]: a
Out[16]: 100L
In [17]: type(a)
Out[17]: long3:浮点型；后面带小数点 0.0 12.0 -18.8 3e+7
In [18]: a = -0.18
In [19]: type(a)
Out[19]: float
In [20]: a = 3e+7
In [21]: type(a)
Out[21]: float
4:复数型；后面加 j -3.14j
In [22]: a = -3.14j
In [23]: type(a)
Out[23]: complex5:字符串 str
给变量赋值字符串时,可以有三种方法: 单引号 双引号 三引号 /n 表示换行符；
注释：三引号可以用作定义字符串,也可以用作注释；再使用定义字符串时,必须是三个单引号,或者三个双引号,不能单双混用；
In [24]: a = 'abc'
In [25]: type(a)
Out[25]: str
In [26]: a = "abc"
In [27]: type(a)
Out[27]: str
/n 表示换行符；
In [33]: a = """hello\nworld"""
In [34]: a
Out[34]: 'hello\nworld'
In [35]: print a
hello
world
In [30]: a = '''hello
...: world'''
In [31]: a
Out[31]: 'hello\nworld'
In [32]: print(a)
hello
world
注释：字符串时一个序列,那么针对序列操作的时候可以通过索引和切片来操作,
索引：第一个字符表示0,依次往后,最后一个字符可以用 -1 表示；
In [37]: a
Out[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]: a
Out[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]: a
Out[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]: 5
In [65]: a + 'f' #字符串相加;
Out[65]: 'abcdef'
In [69]: b = 5
In [70]: b + 6 #数值相加;
Out[70]: 11
如上图：len 可以用来求数据的长度；
+ 加号,可以用来序列相加；可以是同一类型相加(字符串相加 数值相加)，也可以不同类型( 字符串和数字相加)----不过需要转换一下；
In [84]: name = 'wo jin nian'
In [85]: h = 'sui'
In [86]: name + str(age) + h
Out[86]: 'wo jin nian24sui'
# 号表示重复,后跟数字,表示重启的前面的多少次；
'#' * 50
Out[89]: '##################################################'
in 判断元素是否在序列里；
判断 a 是否在 a 这个序列中, 存在则返回true， 不存在则返回flase； 已知 a = 'abcde'
In [91]: a= 'abcde'
In [92]: 'a' in a
Out[92]: True
In [93]: 's' in a
Out[93]: False
还有not in 表示取反, 'f' not in a 表示 f 如果不在 a 这个序列里,则返回true, 如果在 则 返回flase；
In [94]: 'f' not in a
Out[94]: True
In [95]: 'f' not in a+'f'
Out[95]: Falsemax() 求最大值 min() 求最小值
In [99]: b = '12345'
In [102]: type(b)
Out[102]: str
In [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]: 0
In [115]: cmp(a, 'abcdef') # a 小于右边的字符串,所以返回是负整数 -1 ;
Out[115]: -1
In [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]: t
Out[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]: t
Out[123]: ('abcde', 'b', 'c')
In [127]: first, second, third = t
In [128]: first
Out[128]: 'abcde'
In [129]: second
Out[129]: 'b'
In [130]: third
Out[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]: list
In [149]: list2 = list() #通过list函数来创建列表：
In [150]: type(list2)
Out[150]: list
In [151]: list2
Out[151]: []
In [152]: list3 = ['a',1,(1,),['hello', 'python']] #创建list列表;
In [153]: list3
Out[153]: ['a', 1, (1,), ['hello', 'python']]
In [154]: len(list3)
Out[154]: 4列表的特性：列表的值时可变的；通过索引的方式把list3的值第 0 位 变成 a；
In [167]: list3
Out[167]: ['b', 1, (1,), ['hello', 'python']]
In [168]: list3[0]
Out[168]: 'b'
In [169]: list3[0] = a
In [170]: list3
Out[170]: ['abcde', 1, (1,), ['hello', 'python']]
3、往空列表里追加： list2为之前创建的空列表； 通过 list2 = list() 函数创建；
给列表添加元素： list2.append( )
In [181]: list2.append('linux')
In [182]: list2
Out[182]: ['linux']
In [183]: list3 + list2
Out[183]: ['abcde', 1, (1,), ['hello', 'python'], 'linux']
注释：然后可以把list3和list2 相加;
也可以重复之前的列表， 用 * 号； (list3) * 2 (list3+list2) * 2 先加再乘；
In [185]: (list3) * 2
Out[185]: ['abcde', 1, (1,), ['hello', 'python'], 'abcde', 1, (1,), ['hello', 'python']]
Out[186]: ['linux', 'linux']
In [187]: (list3 + list2) * 2
Out[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]: list3
Out[204]: ['abcde', 1, (1,), ['hello', 'python']]
In [205]: del list3[-1] #第一种方式,删除最后一个元素;
In [206]: list3
Out[206]: ['abcde', 1, (1,)]
In [209]: list3.remove(1) #删除第一个元素;
In [210]: list3
Out[210]: ['abcde', (1,)]
7、查找； in
'a' in list3 表示 a 是否在这个列表,如果在,返回true,如果不在返回flase；
'a' not in list3 表示a 是否在这个列表,如果在,返回flase,不过则返回true；
In [210]: list3
Out[210]: ['abcde', (1,)]
In [211]: 'a' in list3
Out[211]: False
In [215]: 'abcde' in list3
Out[215]: True
In [216]: 'a' not in list3
Out[216]: True
In [217]: 'abcde' not in list3
Out[217]: False
修改字符； 列表 list3 的 0 位修改为 b ;
list3[0] = 'b'
In [218]: list3
Out[218]: ['abcde', (1,)]
In [219]: list3[0] = 'b'
In [220]: list3
Out[220]: ['b', (1,)]
list.insert 插入空的列表；
In [220]: list3
Out[220]: ['b', (1,)]
In [221]: list3.insert(1, list1)
In [222]: list3
Out[222]: ['b', [], (1,)]
插入了一个空列表;给空列表里写入值； list3[1].append('abc')
In [225]: list3[1].append('abc')
In [226]: list3
Out[226]: ['b', ['abc'], (1,)]
列表排序： list.sort
list3.sort()
In [227]: list3
Out[227]: ['b', ['abc'], (1,)]
In [228]: list3.sort()
In [229]: list3
Out[229]: [['abc'], 'b', (1,)]
反转(最后一位变成了第一位)； list.reverse
In [229]: list3
Out[229]: [['abc'], 'b', (1,)]
In [230]: list3.reverse()
In [231]: list3
Out[231]: [(1,), 'b', ['abc']]
list.pop 根据下标来删除,当时会返回一下当前值；
如我们删除list3 中下标为 1 的,使用 list.pop 不仅会删除,还会返回删除的这个值；
In [231]: list3
Out[231]: [(1,), 'b', ['abc']]
In [232]: list3.pop()
Out[232]: ['abc']
In [233]: list3
Out[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]: list3
Out[250]: [(1,), 'b', 0, 1, 2, 3, 4]list.exxend 会把元素迭代追加进去；
list3.exxtend('abcde')
In [255]: list3.extend('abcde')
In [256]: list3
Out[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]: list3
Out[282]: [(1,), 'b', 0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']
In [284]: list3.count('b')
Out[284]: 2
In [285]: list3.count('e')
Out[285]: 1
In [286]: list3.count('x')
Out[286]: 0
list.index(value) 表示返回索引号；
In [287]: list3
Out[287]: [(1,), 'b', 0, 1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e']
In [288]: list3.index('b')
Out[288]: 1
In [289]: list3.index('d')
Out[289]: 10
In [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]: list2
Out[302]: ['tom', '20']
In [303]: zip(list1, list2)
Out[303]: [('name', 'tom'), ('age', '20')]
In [304]: list1
Out[304]: ['name', 'age']
In [305]: list2
Out[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]: dict
In [309]: dic = {'a':1, 1:123} #创建两对数据; key - value 对应;
In [310]: dic
Out[310]: {1: 123, 'a': 1}2、那么用元组()作为key值来创建字典；如下；因为元组()是不可变的,可以用来当做key 键值； dc = {('a','b'):'hello'}
In [313]: dc = {('a','b'):'hello'}
In [314]: type(dc)
Out[314]: dict
In [315]: dc
Out[315]: {('a', 'b'): 'hello'}3、那么用list[]来作为key 值创建字典,不可以的,因为list是可变的；
In [317]: dc1 = {[1]:1}
------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-317-c906c08b610a> in <module>()
----> 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']附Java/C/C++/机器学习/算法与数据结构/前端/安卓/Python/程序员必读/书籍书单大全：
（点击右侧 即可打开个人博客内有干货）：技术干货小栈
=====>>①【Java大牛带你入门到进阶之路】<<====
=====>>②【算法数据结构+acm大牛带你入门到进阶之路】<<===
=====>>③【数据库大牛带你入门到进阶之路】<<=====
=====>>④【Web前端大牛带你入门到进阶之路】<<====
=====>>⑤【机器学习和python大牛带你入门到进阶之路】<<====
=====>>⑥【架构师大牛带你入门到进阶之路】<<=====
=====>>⑦【C++大牛带你入门到进阶之路】<<====
=====>>⑧【ios大牛带你入门到进阶之路】<<====
=====>>⑨【Web安全大牛带你入门到进阶之路】<<=====
=====>>⑩【Linux和操作系统大牛带你入门到进阶之路】<<=====天下没有不劳而获的果实，望各位年轻的朋友，想学技术的朋友，在决心扎入技术道路的路上披荆斩棘，把书弄懂了，再去敲代码，把原理弄懂了，再去实践，将会带给你的人生，你的工作，你的未来一个美梦。
516
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
