Python学习笔记 - day3 - 数据类型及运算符

Python的数据类型

　　计算机顾名思义就是可以做数学计算的机器，因此，计算机程序理所当然地可以处理各种数值。但是，计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。在Python中，能够直接处理的数据类型有以下几种：数值型、字符串型、列表型、元组型、字典型。

数值类型

　　顾名思义就是数字类型，但数字类型内部又分为：整型、浮点型、长整型、复数型

整数类型

　　整数类型的范围是2**32，其中包含正数和负数（2的31次方个正和2的31次方的个负数，所以它的范围是-2147483648 ——— 214748364。

　　PS:查看一个数据的类型使用type(数据)方法　　

In [1]: a=1
In [2]: type(a)
Out[2]: int    # int表示为整型
In [18]: type(2/1)
Out[18]: int

浮点型

　　浮点类型就是带小数点的，多余的位数会被四舍五入。

　　整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

In [3]: a=1.23
In [4]: type(a)
Out[4]: float　　# float表示的是浮点数
In [19]: type(2.0/1)
Out[19]: float

长整型

　　用l或L表示，当我们赋值的时候使用l可以把变量赋值为长整型，注意在Python3中已经取消了长整型这个格式。

In [11]: a=1299999999999999999999999999999999999999999
In [12]: type(a)
Out[12]: long　　　　#long表示长整型
In [13]: a
Out[13]: 1299999999999999999999999999999999999999999L
In [15]: a=123l
In [16]: type(a)
Out[16]: long
#只有python2.x中有长整型的概念，python3.x只有整型

复数型

　　用j表示，当我们赋值的时候使用j可以把变量赋值为复数型，python对复数提供内嵌支持。（其他大部分软件没有）

　　复数一般用于科学计算，我们日常一般不会使用，这里知道即可。

In [20]: type(123j)
Out[20]: complex   # 表示复数类型

字符串类型

　　字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。有三种方法定义字符串：单引号，双引号，三引号。

str='this is string'
str="this is string"
str='''this is string'''   #也可以是三个双引号，三个引号可以多行注释但是不能单双混合

其中三重引号除了能定义字符串以外，还可以表示注释。

字符串的基本操作

　　字符串是一个序列，可以通过索引和切片去操作

索引

　　类似数组的下标：

In [3]: a='1234567'
In [4]: a[0] -->#下标从0开始，0表示第一个数
Out[4]: '1'
In [5]: a[3] -->#表示第四个数
Out[5]: '4'

切片

　　类似shell变量的截取：

 1 In [14]: a='abcd'
 2 In [15]: a[0:2]
 3 Out[15]: 'ab'
 4 #从第0个开始截取2个字符，其中0可以省略
 5 
 6 
 7 In [14]: a='abcd'
 8 In [16]: a[:-1]
 9 Out[16]: 'abc'
10 #默认是从左往右（前往后），带减号，表示从右往左（后往前），-1表示最后一个字符(a='abcd',-1的值是d，也就是3，顾a[:-1]，就等于a[0:3])
11 
12 
13 In [14]: a='abcd'
14 In [17]: a[1:]
15 Out[17]: 'bcd'
16 #从1开始截取到最后
17 
18 
19 In [14]: a='abcd'
20 In [20]: a[::2]
21 Out[20]: 'aceg'
22 #步长为2，表示从0开始步长为2，(取0,2,4,6)
23 
24 
25 In [26]: a
26 Out[26]: 'abcdefg'
27 In [27]: a[-5:-1]
28 Out[27]: 'cdef'
29 #表示倒着取，从倒数第五个取到倒数第一个（不包含倒数第一，要想取可以使用a[-5:]）
30 
31 
32 In [29]: a
33 Out[29]: 'abcdefg'
34 In [30]: a[0:5:1]
35 Out[30]: 'abcde'
36 In [31]: a[0:5:2]
37 Out[31]: 'ace'
38 #从0开始取到第5个，步长为1，步长为2
39 
40 
41 In [32]: a
42 Out[32]: 'abcdefg'
43 In [34]: a[-1::-1]
44 Out[34]: 'gfedcba'
45 #从后往前取，步长为-1，表示每次倒着取1个，由于没有指定结尾，默认到最后，所以就把数字逆了过来。
46 
47 
48 In [36]: a
49 Out[36]: 'abcdefg'
50 In [38]: a[::2][:2]
51 Out[38]: 'ac'
52 #表示先每隔2个取出来，然后从头开始取2个。

字符串的切片操作

字符串的内置方法

　　字符串是Python中的主要数据类型，其内置了非常多的方法，主要方法如下：

1 # 功能：首字母大写
2 # 调用方式：string.capitalize() 
3 # 例： 
4 name = 'hello' name.capitalize() 
5 
6 #结果：
7 'Hello'

capitalize

1 # 3.x新增 字符串转换为小写，可以转换各种语言大小写（法语、德语...）
2 # 用法 ：string.casefold()
3 
4 例子： 
5 name = 'HELLO' 
6 name.casefold() 
7 
8 结果： 'hello'

casefold

1 # 功能：字符串转换为小写，只能转换英文字母
2 # 用法：string.lower() 
3 
4 例： 
5 name = 'World' 
6 name.lower() 
7 
8 结果： 
9 'world'

lower

1 # 功能：文本填充，width为字符串的总长度，str居中然后两端用fillcharacter填充，fillchar默认为空格
2 # 用法：str.center(width,filechar=None) 
3 
4 例: 
5 name = 'hello' 
6 name.center(7,'*')
7 
8 结果： 
9 *hello*

center

1 # 功能：sub为统计的字符串（子序列）,统计sub出现的次数，start为起始位置，end为结尾位置
2 # 用法：str.counter(sub,start=None,end=None) 
3 
4 例： 
5 name = 'hello' 
6 name.counter('l') 
7 
8 结果： 
9 2

counter

1 # 功能：以suffix为开头，返回bool值,start起始位置，end结束位置
2 # 用法：str.startswith(suffix,start=None,end=None) 
3 
4 例： 
5 name = 'Hello' 
6 name.startswith('H') 
7 
8 结果： 
9 True

startswith

1 # 功能：以suffix为结尾，返回bool值,start起始位置,end结束位置
2 # 用法：str.endswith(suffix,start=None,end=None) 
3 
4 例： 
5 name = 'world' 
6 name.endswith('d') 
7 
8 结果： 
9 True

endswith

 1 # 功能：找到tab键，然后对它做一个特殊的替换，20表示，两个\t之前的总和（开头没有的话，默认从开头开始）
 2 # 用法：str.expendtabs(20) 
 3 
 4 例： 
 5 name = 'a\tb\tc\t' 
 6 name.expendtabs(3) 
 7 
 8 结果： 
 9 'a b c' 
10 
11 解读：中间两个空格，算上单字符串和空格，总长度为3。

expendtabs

1 # 功能：找到sub在str中的位置，如果找到返回index（匹配到第一个），找不到返回-1
2 # 用法：str. find(sub,start=None,end=None) 
3 
4 例： 
5 name = 'hello' 
6 name.find('l') 
7 
8 结果： 
9 2

find

 1 # 功能：格式化字符串，位置占位符为{0},{1}
 2 # 用法：str.format() 
 3 
 4 例： 
 5 print("Hello {0},I'am {1}".format('daxin','20'))
 6 
 7 结果：
 8 Hello daxin,I'am 20
 9 
10 扩展：
11 可以命名占位符{name},{age},那么赋值的时候就需要 name=daxin,age=2

format

1 # 功能：格式化字符串，只不过传递的值是一个字典
2 # 用法：str.format_map() 
3 
4 例：接上个例子
5 print("hello {name},I am {age}".formar({'name':"daxin",'age'=20}))

format_map

1 # 功能：查询sub在str中的index，如果不存在，会报错
2 # 用法：str.index(sub) 
3 
4 例： 
5 name = 'hello world' 
6 name.index('w') 
7 
8 结果： 
9 6

index

1 # 功能：判断str中是否包含数字，字母，汉字等等，然后bool
2 # 用法：str.isalnum() 
3 
4 例： 
5 name = 'abc123你好' 
6 name.isalnum() 
7 
8 结果： 
9 True

isalnum

1 # 功能：判断字符串是否都为字母，返回bool类型
2 # 用法：str.isalpha()
3 
4 例： 
5 name = 'abc123' 
6 name.isalpha() 
7 
8 结果：
9 False

isalpha

1 # 功能：判断是否只包含阿拉伯数字,'123'
2 # 用法：str. isdecimal() 
3 
4 例： 
5 name = '123' 
6 name.isdecimal() 
7 
8 结果：
9 True

isdecimal

1 # 功能：只能认识阿拉伯数字、以及特殊符号的数字，'123','②'
2 # 用法：str. isdigit() 
3 
4 例: 
5 name = '123②二' 
6 name.digit() 
7 
8 结果：
9 False

isdigit

1 # 功能：只能认识阿拉伯数字、以及特殊符号的数字，以及中文数字'123','②','二'
2 # 用法：str. isnumerice() 
3 
4 例： 
5 name = '123②二' 
6 name.isnumerice() 
7 
8 结果：
9 True

isnumerice

1 # 功能：判断对象是否可以成为标识符（变量名）来用，不会判断关键字
2 # 用法：str.isidentifier() 
3 
4 例： 
5 name = '9hello' 
6 name.isidentifier() 
7 
8 结果：
9 False

isidentifier

1 # 功能：str是否都是小写,返回bool
2 # 用法：str. islower() 
3 
4 例： 
5 name = 'hello' 
6 name.islower() 
7 
8 结果：
9 True

islower

1 # 功能：str是否是大写，返回bool类型
2 # 用法：str. isupper() 
3 
4 例： 
5 name = 'HELLO' 
6 name.isuper() 
7 
8 结果： 
9 True

isupper

1 # 功能：把str转换为大写
2 # 用法：str.upper()
3 
4 例： 
5 name = 'hello' 
6 name.upper() 
7 
8 结果：
9 'HELLO'

upper

1 # 功能：判断对象是否可以被打印（不包含隐藏字符，例如\n,这种打印不出来的，就会返回False）
2 # 用法：str.isprintable()
3 
4 例：
5 name = 'hello\n' 
6 name.isprintable() 
7 
8 结果： 
9 False

isprintable

1 # 功能：判断对象是否是空格
2 # 用法：str.isspace()
3 
4 例： 
5 name = ' ' 
6 name.isspace() 
7 
8 结果：
9 True

isspace

1 # 功能：判断对象是否是标题，既首字母大写（既每个单词的首字母大写）
2 # 用法：str.stitle() 
3 
4 例： 
5 name = 'Hello World' 
6 name.istitle() 
7 
8 结果： 
9 True

istitle

 1 # 功能：连接，用于把可迭代对象的每个元素用 什么 连接起来，可迭代对象的元素必须是str
 2 # 用法：'分隔符'.join(iterable)
 3 
 4 例1： 
 5 a = 'hello' 
 6 '*'.join(a) 
 7 结果： 
 8 h*e*l*l*o
 9 
10 例2： 
11 '*'.join([ str(i) for i in range(10)])

join

1 # 功能：左填充，fillchar为填充的字符
2 # 用法：str.ljust(width,fillchar=None) 
3 
4 例：
5 name = 'hello' 
6 name.ljust(10,'*') 
7 
8 结果：
9 *****hello

ljust

1 # 功能：右填充，fillchar为填充的字符
2 # 用法：str.rjust(width,fillchar=None)
3 
4 例： 
5 name = 'hello' 
6 name.rjust(10,'*') 
7 
8 结果：
9 hello*****

rjust

1 # 功能：左去除，既删除左边的空格换行符和制表符
2 # 用法：str.lstrip() 
3 
4 例： 
5 name = '*hello*' 
6 name.lstrip('*') 
7 
8 结果： 
9 'hello*'

lstrip

1 # 功能：右去除，既删除右边的空格换行符和制表符
2 # 用法：ste.rstrip() 
3 
4 例： 
5 name = '*hello*' 
6 name.rstrip('*') 
7 
8 结果： 
9 '*hello'

rstrip

 1 # 功能：创建对应关系，既a对应1，b对应2，c对应3
 2 # 用法：str.maketrans('abc','123') 
 3 
 4 例: 
 5 m = str.maketrans('abc','123')
 6 name = 'abc123'
 7 v = name.translate(m)
 8 print(v)
 9 
10 结果：
11 '123123'

maketrans

1 # 功能：和maketrans连用，用来表示按照什么规则进行翻译解释,例子如上
2 # 用法：str.translate()

translate

1 # 功能：根据split进行分割，从左开始，只分割遇到的一个split，并且保存分隔符，返回的对象为元祖
2 # 用法：str.partition('split') 
3 
4 例： 
5 name = 'Hello|World' 
6 name.partition('|')
7 
8 结果：
9 ('hello','|','World')

partition

1 # 功能：字符串的替换,把src替换为dst，counter为替换几次
2 # 用法：str.replice('src','dst',counter=None)
3 
4 例： 
5 name = 'Hello World' 
6 name.replice('H','h') 
7 
8 结果： 
9 'hello World'

replice

1 # 功能：右查找，既丛字符串的右边开始查找sub，并返回它对应的index
2 # 用法：str.rfind('sub') 
3 
4 例： 
5 name = 'hello' 
6 name.rfind('l') 
7 
8 结果： 
9 3

rfind

1 # 功能：从右边查找sub的index，如果sub在str对象中不存在，那么会报valueError异常
2 # 用法：str.rindex('sub') 
3 
4 例：
5 name = 'hello' 
6 name.rindex('l') 
7 
8 结果： 
9 3

rindex

1 # 功能：既从右边开始，对找到的第一个split进行分割，返回值为元祖（包含分隔符）
2 # 用法：str.rpatition('split') 
3 
4 例： 
5 name = 'hello' 
6 name.rpatition('l') 
7 
8 结果：
9  ('hel','l','o')

rpatition

 1 # 功能：把字符串默认从左开始对象使用split进行分割，默认会对所有分割符进行分割，num可以指定分隔符的个数
 2 # 用法：str.split('split',num=None) 
 3 
 4 例1： 
 5 name = 'hello world' 
 6 name.split('l') 
 7 结果： 
 8 ['he','','o wor','d']
 9 
10 例2： 
11 name = 'hello world' 
12 name.split('l',1) 
13 结果： 
14 ['he','lo world']

split

1 # 功能：把字符串从右开始使用split进行分割，在不指定num的情况下和split相同
2 # 用法：str.rsplit('split',num=None) 
3 
4 例： 
5 name = 'hello world' 
6 name.rsplit('l',1) 
7 
8 结果：　
9 ['hello wor','d'］

rsplit

1 # 功能：以什么为分行符，功能等同于split('\n')
2 # 用法：str.splitlines(keepends=None) 
3 
4 例： 
5 name = 'hello\nworld' 
6 name.splitlines('\n')

splitlines

1 # 功能：去除两边的string,默认是移除空格换行及制表符。
2 # 用法：str.strip('string')
3 
4 例： 
5 name = ' hello ' 
6 name.strip() 
7 
8 结果： 
9 'hello'

strip

1 # 功能：大小写转换，既把对象的大写转换为小写，小写转换为大写
2 # 用法：str. swapcase() 
3 
4 例： 
5 name = 'Hello' 
6 name.swapcase() 
7 
8 结果： 
9 'hELLO'

swapcase

1 # 功能：把单词的首字母换成大写
2 # 用法：str.title() 
3 
4 例： 
5 name = 'hello' 
6 name.title() 
7 
8 结果： 
9 'Hello'

title

1 # 功能：在字符串的左边填充0，width为总长度
2 # 用法：str.zfill(width)
3 
4 例： 
5 name ='hello' 
6 name.zfill(10) 
7 
8 结果： 
9 '00000hello'

zfill

 1 # 功能：把字符串转换为二进制（字节类型），encodinf=UTF-8,表示转换的时候按照UTF-8进行编码
 2 # 用法：str.encode(encoding = 'UTF-8') 
 3 
 4 例： 
 5 name = '你好'　　　
 6 name.encode(encoding='UTF-8') 
 7 
 8 结果： 
 9 b'\xe4\xbd\xa0\xe5\xa5\xbd'
10 
11 扩展：
12 也可以用其他的编码类型如：gbk

encode

PS：

# format补充
print('{} * {} = {:5}'.format(1,2,3)  # 这里说的括号中的:5表示当前元素替换占用5个位置
print('{} * {} = {:<5}'.format(1,2,3)  # 这里的<表示左对齐，默认情况下是右对齐，当前这里也可以用>表示右多对齐

# 对齐符下的括号嵌套
print('{} * {} = {:>{}}'.format(1,2,3, 2 if True else 3)  # 这里按照括号边界来区分，很明显嵌套在括号里面的的占位符是4。
# 如果不是用在对齐符中，那么就无法进行嵌套

序列类型

　　字符串、列表和元组都是序列的一种，序列的两个主要特点是索引操作符和切片操作符

　　索引操作符让我们可以从序列中抓取要给特定的项目

　　切片操作符让我们能够获取序列的一个切片，即一部分操作

序列类型的基本操作方法

　　序列同样支持索引和切片操作，但是字符串、列表、元组的索引和切片又有些许不通

len()

　　计算字符串的长度

In [7]: a='123'
In [8]: len(a)
Out[8]: 3
In [9]: len('123')
Out[9]: 3

+

　　加号在这里并不是加减乘除的意思，而是用来连接两个序列

In [10]: a
Out[10]: '123'
In [11]: a + '4'
Out[11]: '1234'
#字符串和数字不能连接到一起

*

　　重复序列元素（字符串的时候）

In [18]: '#' * 10
Out[18]: '##########'
#当变量为数字的时候就为乘了。

in

　　判断元素是否在序列中

In [23]: a = 'abcd'
In [24]: 'a' in a
Out[24]: True
#当字符串在某个序列中的时候返回真，否则返回假（not in表示不在）

max(),min()

　　求最大值和最小值

In [25]: max(a)
Out[25]: 'd'
In [26]: min(a)
Out[26]: 'a'
In [27]: a
Out[27]: 'abcd'

　　注意：如果对字符进行对比，程序内部会把字符转换成ascii码对应的数字进行比较。

1 >>> ord('a')
2 97
3 >>> ord('b')
4 98
5 >>> ord('c')
6 99
7 >>>

字符转换成ascii码对应的数字

cmp()

　　比较两个序列是否相等

#若相等则返回0，若前大于后则返回正数，若后大于前则返回负数
In [30]: cmp("123","456")
Out[30]: -1
In [33]: cmp("789","456")
Out[33]: 1
In [34]: cmp("456","456")
Out[34]: 0


#注意cmp的比较是从左向右开始比对的，大于就返回1，小于就返回-1，等于就继续向后比对
In [43]: cmp('5','456')
Out[43]: 1
In [44]: cmp('45','456')
Out[44]: -1
In [45]: cmp('455','456')
Out[45]: -1
In [46]: cmp('457','456')
Out[46]: 1

元组概念

元组（类型为 tuple）和列表十分相似

元组和字符串一样是不可变的

元祖的特点

　　元组可以存储一系列的值，使用括号来定义。

　　元组通常用在用户定义的函数能够安全的采用一组值的时候，即被使用的元组的值不会改变，不可变的含义是：不能改变这个值中的某个字符。

　　元祖也通常用来接收函数的返回值。

In [8]: a='123456'
In [9]: a[-1]
Out[9]: '6'
In [10]: a[-1]=1
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-10-1ad23d7f375d> in <module>()
----> 1 a[-1]=1
TypeError: 'str' object does not support item assignment
In [11]:
#变量a是可以被定义成任何值的，但是不能在定义之后，修改里面的值，如果想要修改就需要重新定义这个变量
In [11]: a='123451'
In [13]: a[-1]
Out[13]: '1'

定义一个元组

使用()来表示定义的是元组，但是如果元组里面的值只有一个的话，需要加在值后面加上，（逗号），表示是一个元组。

另外，元组中可以同时储存不同类型的数据，也可以引用其他元组。

In [18]: t=(1)
In [19]: type(t)
Out[19]: int
In [20]: t=(1,)
In [21]: type(t)
Out[21]: tuple     # tuple表示元组类型

#引用其他元组
In [22]: a=(1,2,3)
In [23]: t=('123',a)
In [24]: t
Out[24]: ('123', (1, 2, 3))

#通过索引只引用某一个值
In [27]: t=('123',a[1])
In [28]: t
Out[28]: ('123', 2)

元祖的基本操作方法

　　元组和其他数据类型相同，它支持的操作如下。

元祖的拆分

通过变量去接收元组中的值

In [34]: a=('123','456')
In [35]: first,second=a 　　--> # 定义first接收元组的第一个值，second接收元组的第二个值
In [36]: first
Out[36]: '123'
In [37]: second
Out[37]: '456'
#注意接收值的变量要与元组中的值的个数保持一致，若元组中有3个值，必须定义三个变量去接收，否则无法接收（当元组中有两个值的时候，用一个变量去接不会报错，但是也还是用元组的形式表达）

　　PS：假如元祖中有三个元素，那么我们可以定义3个变量来接受元祖的值，如果元祖中有4个元素，那么我们只能通过定义1个或者定义4个来接受，定义1个就等于元祖复制，定义4个才表示接受元素

　　PS：如果我们不想要某个元素的时候，可以使用_,来获取，分割元组的时候可以有如下操作。

1 >>> a = ('a','b','c','d')
2 >>> a,b,_,d = a
3 >>> a
4 'a'
5 >>> b
6 'b'
7 >>> d
8 'd'
9 >>>

_忽略部分元素的方法

元组的方法

如果安装了ipython可以通过tab键查看元组的方法，如果没有安装，就需要使用dir(元组名)去查看了

# 会列出一些内饰的属性，和方法
>>> dir(a)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']
>>>
# 已__开头的先忽略，后面会讲，所以可以看到有两个方法。

# 使用help查看使用方法
In [3]: help(a.count)
count(...)
T.count(value) -> integer -- return number of occurrences of value


# a.count(value)  用来统计value在元组中出现的次数，不存在返回0。
In [4]: a=('1','2','3')
In [7]: a.count("4")
Out[7]: 0
In [8]: a.count("1")
Out[8]: 1
 

# a.index(value) 用来返回value在元组中的索引，如果value不在元组中，则会报错。如果有多个，默认返回第一个（可以指定从哪个索引开始查找到某个索引结束，指定范围区间）
In [4]: a=('1','2','3')
In [9]: a.index('1')
Out[9]: 0
In [10]: a.index('3')
Out[10]: 2
>>> t1
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')
>>> t1.index('a',5,7)
6

列表类型

　　列表(类型为 list)是处理一组有序项目的数据结构，即可以在列表中存储一个序列的项目。

　　列表是可变类型的数据，创建列表使用[]中括号。

列表的基本操作

　　list是一种有序的集合，可以随时添加和删除其中的元素。它的方法有很多，这里列举主要的方法。

创建一个空的列表

# 1、创建一个空列表
list1 = []
list2 = list()   # 工厂函数

# 2、创建列表并赋值
list3 = ['a',1,2]

# 3、列表可以包含变量，元组，列表等
In [15]: a=123
In [16]: b=['123',a,(1,),["hello","python"]]
In [17]: b
Out[17]: ['123', 123, (1,), ['hello', 'python']]
In [24]: len(b)
Out[24]: 4
#一共有4个变量

# 4、列表的值是可以改变的
In [25]: b
Out[25]: ['123', 123, (1,), ['hello', 'python']]
In [26]: b[0]
Out[26]: '123'
In [27]: b[0]=456
In [29]: b
Out[29]: [456, 123, (1,), ['hello', 'python']]

列表的追加

　　使用append在list的后面（右边）

In [30]: a=[]
In [31]: type(a)
Out[31]: list
In [32]: a.append("linux")   
In [33]: a
Out[33]: ['linux']

列表的组合

　　使用+，对多个列表进行拼接

In [32]: a = [456, 123, (1,)]
In [33]: b = [['hello', 'python'], 'linux']
In [34]: b + a
Out[34]: [456, 123, (1,), ['hello', 'python'], 'linux']
In [35]: (b + a) * 2 # 重复2次
Out[35]:[456, 123, (1,), ['hello', 'python'], 'linux', 456, 123, (1,), ['hello', 'python'], 'linux']
>>>

列表的删除

　　使用list的remove方法删除一个元素

In [38]: b = [456, 123, (1,), ['hello', 'python'],'love']
In [39]: b.remove('love')
In [40]: b
Out[40]: [456, 123, (1,), ['hello', 'python']]
#直接移出元素名，如果有两个，则默认删除匹配的第一个。

In [55]: b
Out[55]: [123, 456, ['hello', 'python'], '123', (1,)]
In [56]: del b[0]
In [57]: b
Out[57]: [456, ['hello', 'python'], '123', (1,)]
#如果知道变量的索引可以直接通过del来进行删除，del还可以直接删除变量

列表的反转

　　使用list的reverse方法进行原地倒序。

In [41]: b = [456,123, (1,),['hello', 'python']]
In [42]: b.reverse()
In [43]: b
Out[43]: [['hello', 'python'], (1,), 123, 456]

列表的插入

　　使用list的insert进行数据的插入

In [47]: b
Out[47]: [456, 123, (1,), ['hello', 'python']]
In [48]: b.insert(0,'123')    
In [49]: b
Out[49]: ['123', 456, 123, (1,), ['hello', 'python']]
# 在索引0的位置插入一个元素‘123’

查找列表中变量

In [62]: b
Out[62]: [456, ['hello', 'python'], '123', (1,)]
In [63]: '123' in b
Out[63]: True
In [65]: "a" in b
Out[65]: False
# 存在返回True,否则返回False

变量的修改

In [68]: b
Out[68]: [456, ['hello', 'python'], '123', (1,)]
In [69]: b[0]='123'
In [70]: b
Out[70]: ['123', ['hello', 'python'], '123', (1,)]
# 修改b的索引0的元素值为‘123’

列表里面嵌入列表，并插入数据

In [71]: b=[] # 定义一个空列表
In [72]: a=[b,'123','456']
In [73]: a
Out[73]: [[], '123', '456']
In [74]: a[0].append("linux")  # 向签到的b（空列表）中插入数据
In [75]: a
Out[75]: [['linux'], '123', '456']

删除并列出列表中的某个值

　　不加下标，表示删除并打印最后一个值，使用list的pop方法，弹出并打印指定的索引元素，如果不指定元素，则从右开始依次弹出一个

In [75]: a
Out[75]: [['linux'], '123', '456']
In [76]: a.pop(1)
Out[76]: '123'
In [77]: a
Out[77]: [['linux'], '456']

添加可迭代的值

　　可迭代：可以理解为可以使用for循环等，挨个取出的值的列表

　　列表，字符串，序列，元组都属于可迭代的对象

In [125]: a
Out[125]: [1, 3, 5, 7, 9]
In [126]: a.extend('2468')
In [127]: a
Out[127]: [1, 3, 5, 7, 9, '2', '4', '6', '8']
In [128]: b=(1,2,3,4)
In [129]: a.extend(b)
In [130]: a
Out[130]: [1, 3, 5, 7, 9, '2', '4', '6', '8', 1, 2, 3, 4]
In [131]:
In [131]: c=123
In [132]: a.extend(c)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-132-49130b702eb2> in <module>()
----> 1 a.extend(c)
TypeError: 'int' object is not iterable
In [133]: # c是int型，不是可迭代，所以会报类型错误。

列表的组合

　　zip()，可以把两个列表组合成一个，前一个列表去一个，后列表取一个

In [5]: list1=['Name','age']
In [6]: list2=['Tom',20]
In [7]: zip(list1,list2)
Out[7]: [('Name', 'Tom'), ('age', 20)]

字典类型

使用大括号定义，是Python中唯一的映射类型（哈希表）

字典对象是可变的，但是字典的键必须使用不可变对象，一个字典中可以使用不同类型的key。像元组，字符串等都是不可变的，都可以作为key。而列表是可变的，无法作为key。key是唯一的

字典的方法

　　字典有很多的方法，这里仅列举常用的方法，其他方法可以使用dir(dict)查看

1. keys() 获取字典的key
2. values() 获取字典中所有的values
3. items() 把字典转换成列表
4. get() 如果字典中有该key，则返回key值，如果没有，则返回空，也可以自己定义返回值
5. dic.get('Name','python')，如果存在name，则返回values，否则返回Python　　
6. has_key('key') 判断key的是否存在，存在返回True，否则返回False　　
7. dic1 = dic.copy() 拷贝字典到一个新的字典中去　　
8. clear() 清除字典中的元素　　
9. pop() 删除一个key，同时打印该key的value，如果key不存在，则返回keyerror，或者指定返回值 dic.pop('name',True)
10. update() 把一个字典更新（添加）到另一个字典中　　
11. fromkeys(s,value) 把序列s，作为字典的key，如果不给value，则默认是none，如果指定value，那么所有key对应的值都为value

字典的操作示例　　

　　上面列举了字典的常用方法，下面对部分方法进行举例

创建字典

dic={}
a=dict()
dict(x=10,y=20)
dict([('a',10),('b',20)])
# 使用dict函数时，必须是以元组的形式创建。

把数据存入字典

　　把数据添加到字典中

dic = {}
dic['name'] = 'daxin'
dic['age'] = 18

for 循环打印字典

for i in d1:print i,d1[i]
# 取出字典中的key，同时可以根据key来取出value

for k,v in d1.items():print k,v
# 把字典的值转换为列表，然后利用k和v来接受列表中元组的key和value

# for 循环的知识将在下一章进行讲解

字典练习

读取键盘输入，存入到字典中，并打印

#!/usr/bin/env python
# _*_coding:utf-8_*_
# __time__: 2017/10/17 22:54
# __author__: daxin
# __file__: text.py∂


info = dict()
name = raw_input('Please input name: ')
age = raw_input('Please input age: ')
sex = raw_input('Please input sex: ')
info['name'] = name
info['age'] = age
info['sex'] = sex
print info.items()
for k, v in info.items():
    print "%s:%s " % (k, v)

PS：以上代码示例均在Python 2.7上进行测试！ Python 3.x 会有区别！

类型转换

　　注意虽然在Python中有很多的数据类型，但是这些类型是可以相互转换的，那么就要用到了俗称工厂函数的东西：str、list、dict、tuple等等。

str()：用于把整型、浮点型等转换为字符串
list()：用于把一个可迭代对象转换为列表
dict()：把一个可迭代对象（每次迭代返回两个数据），转换为字典
tuple（）：把一个可迭代对象转换为元组

# 1、 把数字转换成字符串
>>> a = 10
>>> type(a)
<class 'int'>
>>> b = str(a)
>>> type(b)
<class 'str'>
>>> print(b)
10

# 2、把list转换成字符串
>>> a = ['h','e','l','l','o']
>>> ''.join(a)
'hello'
>>> 
# 注意list转换为字符串要使用join，不能用str

# 3、使用dict转换字典
>>> c = [(1,2),(3,4)]
>>> dict(c)
{1: 2, 3: 4}
>>>

注意：

　　工厂函数，还可以直接用来创建一个空对象。

>>> d = dict()
>>> d
{}
>>> e = str()
>>> e
''
>>> f = list()
>>> f
[]
>>>

运算符表达式

　　python运算符：赋值运算符、算数运算符、关系运算符、逻辑运算符

　　python表达式：是将不同的数据（包括变量、函数）用运算符号按一定规则连接起来的一种式子。

赋值运算符

　　= 表示赋值，当把数字赋值给一个变量的时候不用加引号，而赋值字符串给变量的时候就需要加引号了，否则python认为你赋值的是另一个变量。

　　=：x=3 ,y='abc'

　　+= ：x+=2，表示x=x+2

　　-=：x-=2，表示x=x-2

　　*=：x*=2,表示x=x*2

　　/=：x/=2，表示x=x/2

　　%=：x%=2，表示取余，x对2取余数，加入x=6，那么取余为0

PS：Python下不用指定变量的类型，它会自动根据你赋值的类型来定，使用type(x) 来查看变量的类型。

算数运算符

　　+ 加用来计算数字，如果字符串、列表等相加，等于是把两个对象拼到一起

　　- 减

　　* 乘

　　/ 除，4/3,默认是整除，为了得到小数，可以把其中一个变量变成浮点型，4.0/3或4/3.0

　　// 表示只取整数，4.0/3 答案是1.33333，如果用4.0//，因为取整则，答案是1

　　% 取余数

　　** 表示乘方 2**3 表示2的3次方

关系运算符

　　返回值为布尔值：true or false

　　> 1>2,值是false

　　< 1<2,值是true

　　>= 1>=2,值是false　　

　　<= 1<=2,值是true

　　== 1==2，值是flase

　　!= 1!=2,值是true

逻辑运算符

　　返回值为布尔值：true or false

　　and：逻辑与，只要有1个是false那么值就是false，1==2 and 1<2 ，值是false， 1!=2 and 1<2，值是true

　　or：逻辑或,只要有一个是true那么值就是true，1=2 and 1<2 ，值是true

　　not：逻辑非，取反 not 1<2，值是true

其他特殊符号

　　in/no in 成员测试，测试一个元素是否在一个序列中

　　is /is not 统一性的测试

练习

写一个四则运算器，从键盘读取数字可以使用input()或raw_input()

input()函数，一般用来接收数字，当我们输入字符串的时候，它会报错，如果需要用字符串那么需要用引号引起来

raw_input()函数，一般用来接收字符串，当我们输入数字的时候，它也会用引号引起来，表示是字符串

input方式

#!/usr/bin/env python
# _*_coding:utf-8_*_
# __time__: 2017/10/17 22:54
# __author__: daxin
# __file__: text.py∂

num1 = input("Please input a number:")    
num2 = input("Please input a number:")     
print " %s + %s = %s " % (num1,num2,num1+num2)  
print " %s - %s = %s " % (num1,num2,num1-num2)
print " %s * %s = %s " % (num1,num2,num1*num2)
print " %s / %s = %s " % (num1,num2,num1/num2)

raw_input

#!/usr/bin/env python
# _*_coding:utf-8_*_
# __time__: 2017/10/17 22:54
# __author__: daxin
# __file__: text.py∂

num1 = int(raw_input("Please input a number:"))    
num2 = int(raw_input("Please input a number:"))     
print " %s + %s = %s " % (num1,num2,num1+num2)  
print " %s - %s = %s " % (num1,num2,num1-num2)
print " %s * %s = %s " % (num1,num2,num1*num2)
print " %s / %s = %s " % (num1,num2,num1/num2)

小结

#把input输入的数字保存到变量num1中
#把input输入的数字保存到变量num2中
#print打印，%s表示字符串型占位符，占位符需要用“”引起来，前面几个占位符，就需要用传递几个值。外面的％　表示后面是传递的值，多个值用括号括起来
#由于raw_input是以字符串格式存储的，所以如果输入的数字并且需要计算，那么就需要强制转换为整型（int）
#这里如果求余，需要使用%，但是%和占位符的%会产生冲突，为了格式化这个符号，可以使用%%来表示

关于Print的小技巧

　　在print中或者字符串定义的时候使用r模式，可以方便的输出带有特殊符号的字符串或提示信息。

print(r'hello \nworld')
# 打印时，并不会去解释\n，而是直接会输出\n

str = r'hello \nworld'
# 存入的变量字符串，也不会去解释\n。

　　由于数据类型比较多，每个类型的方法也比较多，很多我们都记不过来，所以这里我们只需要记住常用的方法，其他的方法可以使用帮助来查询。

　　这里主要使用三种方式进行查询：

dir()：获取对象的方法
help()：获取对象的方法以及用法说明
PyCharm：按住command点击类型，即可查看源码。从源码中查看对象类型的方法。

>>> help(dict)
Help on class dict in module builtins:

class dict(object)
 |  dict() -> new empty dictionary
 |  dict(mapping) -> new dictionary initialized from a mapping object's
 |      (key, value) pairs
 |  dict(iterable) -> new dictionary initialized as if via:
 |      d = {}
 |      for k, v in iterable:
 |          d[k] = v
 |  dict(**kwargs) -> new dictionary initialized with the name=value pairs
 |      in the keyword argument list.  For example:  dict(one=1, two=2)
 |  
 |  Methods defined here:
 |  
 |  __contains__(self, key, /)
 |      True if D has a key k, else False.
 |  
 |  __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.
 |  
 |  __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.
 |  
 |  __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).
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      D.__sizeof__() -> size of D in memory, in bytes
 |  
 |  clear(...)
 |      D.clear() -> None.  Remove all items from D.
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
 |  
 |  fromkeys(iterable, value=None, /) from builtins.type
 |      Returns a new dict with keys from iterable and values equal to value.
 |  
 |  get(...)
 |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.
 |  
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
 |  
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  
 |  popitem(...)
 |      D.popitem() -> (k, v), remove and return some (key, value) pair as a
 |      2-tuple; but raise KeyError if D is empty.
 |  
 |  setdefault(...)
 |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None


>>> dir(dict)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
>>>

注意：

　　__开头的是Python的内置方法，这个在类的时候，大部分会讲到。

posted @ 2017-10-18 22:34 SpeicalLife 阅读(863) 评论(0) 编辑收藏举报

刷新页面返回顶部

Dahlhin's Record

Python学习笔记 - day3 - 数据类型及运算符

Python的数据类型

数值类型

整数类型

浮点型

长整型

复数型

字符串类型

字符串的基本操作

索引

切片

字符串的内置方法

序列类型

序列类型的基本操作方法

len()

+

*

in

max(),min()

cmp()

元组概念

元祖的特点

定义一个元组

元祖的基本操作方法

元祖的拆分

元组的方法

列表类型

列表的基本操作

创建一个空的列表

列表的追加

列表的组合

列表的删除

列表的反转

列表的插入

查找列表中变量

变量的修改

列表里面嵌入列表，并插入数据

删除并列出列表中的某个值

添加可迭代的值

列表的组合

字典类型

字典的方法

字典的操作示例

创建字典

把数据存入字典

for 循环打印字典

字典练习

类型转换

运算符表达式

赋值运算符

算数运算符

关系运算符

逻辑运算符

其他特殊符号

练习

input方式

raw_input

小结

关于Print的小技巧

公告

字典的操作示例　　