Python的数值和字符串

Python数据类型

1。数值 --类型：  1/整型

　　　　　　　　　2/长整型

　　　　　　　　   3/浮点型　　-- 0.0, 12.0, -18.8, 3e+7等

　　　　　　　　　4/复数型　　-- complex 

In []: 0x34al
Out[]: 842L

--0x34a --表示16进制
--l   --表示长整型

In []: 4e+
Out[]: 40000000.0

In []: type(4e+)
Out[]: float

--科学计数法

In []: b = "hello\nlulu"
In []: b
Out[]: 'hello\nlulu'

In []: print b
hello
lulu

--里面有换行符，会把它打印出来

In []: a = '''hello
   ...: lulu'''

In []: a
Out[]: 'hello\nlulu'

In []: print a
hello
lulu

---三重引号 -可以是双引号 也可以是单引号  --表解释 这样可以自动把换行符加载 ，不需要自己写

2. 字符串　　--是一个序列 -- 对于序列的操作  可以通过索引和切片

In []: b = 'oplkdj'

In []: b
Out[]: 'oplkdj'

In []: b[]
Out[]: 'o'

In []: b[]
Out[]: 'd'

In []: b[-]
Out[]: 'j'

In []: b[-]
Out[]: 'k'

==========================
/* 取两个字符 */
In []: b[]+b[]
Out[]: 'od'

In []: b[:]                --从第0个开始取到3个，第三个不显示
Out[]: 'opl'

In []: a = 'abcde'

In []: a
Out[]: 'abcde'

In []: a[:]
Out[]: 'b'

In []: a[:]
Out[]: 'abcde'

In []: a[:-]
Out[]: 'abcd'
--0到最后一个，但不取最后一个

In []: a[:]
Out[]: 'ab'
--[:]默认冒号左边为0

In []: a[-]
Out[]: 'e'

In []: a[:]
Out[]: 'bcde'
--从1号位取到最后

In []: a[:-]
Out[]: 'abcd'

In []: a[::-]
Out[]: 'edcba'

In []: a[::]
Out[]: 'abcde'

In []: a[::]
Out[]: 'ace'

In []: a[::]
Out[]: 'abcde'

In []: a[-:-]
Out[]: 'bc'

In []: a[-:-:-]
Out[]: 'dc'

/* 序列*/

In []: a
Out[]: 'abcde'

In []: len(a)
Out[]: 

In []: a + 'f'
Out[]: 'abcdef'
--连接两个序列

//重复序列元素
In []: a *
Out[]: 'abcdeabcdeabcdeabcdeabcde'

In []: '' *
Out[]: ''

//a为字符串，1为整数，数据类型不符合
In []: a +
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input--a1bd27f4633f> in <module>()
---->  a + 

TypeError: cannot concatenate 'str' and 'int' objects

====================================
//判断某元素是否存在某个变量中
In []: 'a' in a
Out[]: True

In []: a
Out[]: 'abcde'

In []: 'f' in a
Out[]: False

//不存在
In []: 'f' not in a
Out[]: True

In []: 'f' not in a+'f'
Out[]: False

====================================
//判断最大最小值
In []: a
Out[]: 'abcde'

In []: max(a)
Out[]: 'e'

In []: min(a)
Out[]: 'a'

====================================
//比较两个序列是否相等，小于则显示“-1”，大于则显示“1”
In []: cmp(a,'abcde')
Out[]: 

In []: cmp(a,'abcdef')
Out[]: -

In []: cmp(a,'ab')
Out[]: 

In []: cmp(a,'abcd')
Out[]: 

3. 列表

//基本模式
In []: list1 =[]

In []: type(list1)
Out[]: list

In []: list1
Out[]: []

In []: list2 = ['a',,(,),['hello','python']]

In []: list2
Out[]: ['a', , (,), ['hello', 'python']]

In []: type(list2)
Out[]: list

//元组数量
In []: len(list2)
Out[]: 

//list的第二个元素
In []: list2[]
Out[]: (,)

//替换列表的元素
In []: list2[] = 'b'

In []: list2[]
Out[]: 'b'

In []: list3 = ['linux']

In []: list2 + list3
Out[]: ['b', , (,), ['hello', 'python'], 'linux']

//往list中新增元素
In []: list3.append('fra')

In []: list3
Out[]: ['linux', 'fra']

In []: list1
Out[]: []

//删除某个list
In []: del list1

In []: list1
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input--8304c57391a2> in <module>()
---->  list1

NameError: name 'list1' is not defined

In []: list2
Out[]: ['b', , (,), ['hello', 'python']]

//删除某个元素
In []: del list2[-]
==================================
In []: list2
Out[]: ['b', , (,)]

In []: list2
Out[]: ['b', , (,), ]

//如果有两个重复的元素，就删除第一个
In []: list2.remove()

In []: list2
Out[]: ['b', (,), ]

4. 元组

In []: t = ('a',,(,))

In []: t
Out[]: ('a', , (,))

In []: type(t)
Out[]: tuple            //元组

In []: t1 = ()

In []: type(t1)
Out[]: int

In []: t1 = (,)

In []: type(t1)
Out[]: tuple

//加上 逗号，则表示为元组

In []: t = (a, 'b', 'c')

In []: t
Out[]: ('abcde', 'b', 'c')

// a为变量， 显示时 将变量数值替换

In []: first, second, third = t

In []: first
Out[]: 'abcde'

In []: second
Out[]: 'b'

In []: third
Out[]: 'c'

In []: t.count('b')
Out[]: 

In []: t.count('bc')
Out[]: 

In []: t.count('abc')
Out[]: 

In []: t
Out[]: ('abcde', 'b', 'c')

--- 如果在元组里存在此元素 ，显示“” ，不存在显示“"

//插入列表
In []: list1
Out[]: []

In []: list3
Out[]: ['linux', 'fra']
//(元素的位置，  添加的元组)
In []: list3.insert(, list1)

In []: list3
Out[]: ['linux', 'fra', []]

In []: list2
Out[]: ['b', (,), ]

In []: list2.insert(, list1)

In []: list2
Out[]: ['b', [], (,), ]

/* 给列表排序 */
In []: list3.sort()

In []: list3
Out[]: [[], 'fra', 'linux']

/* 给列表反转，最后一个变成第一个 */
In []: list2.reverse()

In []: list2
Out[]: [, (,), [], 'b']

In []: list2.reverse()

In []: list2
Out[]: ['b', [], (,), ]

In []: list1 = [(,),'fra','linux']

In []: list1
Out[]: [(,), 'fra', 'linux']

In []: range()
Out[]: [, , , , ]

In []: list1.extend(range())

In []: list1
Out[]: [(,), 'fra', 'linux', , , , , ]

In []: list1.extend('abc')

In []: list1
Out[]: [(,), 'fra', 'linux', , , , , , 'a', 'b', 'c']

In []: list1.extend(('t1','t2'))

In []: list1
Out[]: [(,), 'fra', 'linux', , , , , , 'a', 'b', 'c', 't1', 't2']

5. 字典

In []: info = 'Tom 180 Male'

In []: info[:]
Out[]: 'om'

In []: info[:]
Out[]: 'Tom'

/*
    在列表中，取到3，但不会显示3。

    在字典中，取到几，就会显示几号位。
*/

In []: list1 = ['name', 'age']

In []: list2 = ['tom', '']

In []: list3 = ['mike',]

In []: zip(list1, list2)
Out[]: [('name', 'tom'), ('age', '')]

In []: zip(list1, list3)
Out[]: [('name', 'mike'), ('age', )]

In []: dic = {}

In []: type(dic)
Out[]: dict

In []: dic = {'a':, :}

In []: dic
Out[]: {: , 'a': }

In []: dic = {'a':, :, ('a','b'):'hello'}

In []: len(dic)
Out[]: 

//获取所有keys
In []: dic.keys()
Out[]: ['a', , ('a', 'b')]

//获取所有values
In []: dic.values()
Out[]: [, , 'hello']

//获取keys的值
In []: dic.get()
Out[]: 

In []: dic
Out[]: {: , 'a': , ('a', 'b'): 'hello'}

//修改某个keys的values
In []: dic['a'] = 

In []: dic
Out[]: {: , 'a': , ('a', 'b'): 'hello'}

In []: dic[('a', 'b')] = 'linux'

In []: dic
Out[]: {: , 'a': , ('a', 'b'): 'linux'}

//在外部定义一个keys和它的values
In []: dic.get('b', 'python')
Out[]: 'python'

//是否有keys
In []: dic.has_key('a')
Out[]: True

In []: dic.has_key('b')
Out[]: False

//将每一个keys与values都以元组形式展现
In []: dic.items()
Out[]: [('a', ), (, ), (('a', 'b'), 'linux')]

In []: dic
Out[]: {: , 'a': , ('a', 'b'): 'linux'}

//拷贝
In []: dic1 = dic.copy()

In []: dic1
Out[]: {: , 'a': , ('a', 'b'): 'linux'}

In []: dic
Out[]: {: , 'a': , ('a', 'b'): 'linux'}

//更新，则最前面加入新的
In []: dic
Out[]: {: , 'a': , ('a', 'b'): 'linux'}

In []: dic1 = {:, :}

In []: dic.update(dic1)

In []: dic
Out[]: {: , : , : , 'a': , ('a', 'b'): 'linux'}

//打包后，将其以字典形式呈现
In []: zip(list1, list2)
Out[]: [('name', 'tom'), ('age', '')]

In []: dict(zip(list1, list2))
Out[]: {'age': '', 'name': 'tom'}

/*
     以下两种，作用相同，给某个keys赋值*/

In []: dict([('a', ), ('b', )])
Out[]: {'a': , 'b': }

In []: dic.fromkeys('ab',)
Out[]: {'a': , 'b': }