Python-2-Python数据类型

 

2-1 字符串简单介绍

'A' + 'B' 字符串连接输出'AB'; 'Hello ' * 3 多次连接3次。

'Hello'[0] 取第一个字符；'Hello'[1] 取第二个字符；'Hello'[-1] 取最后一个字符；'Hello'[1:3] 从e开始取取2个字符el，1+2=3所以是[1:3]; 'Hello'[1:] 从第二个字符一直取到最后。

2-2 字符串基础操作（一）

1. strip()

格式：
String.strip([chars])

用法：
chars为空，默认去除头尾空白符（包括\n,\r,\t,'',即：换行、回车、制表符、空格）
chars不为空，函数会将chars拆成一个一个字符，去除头尾指定的字符。

注意：
a. 头尾开始剔除指定字符，直到遇到非匹配字符时便停止。
b. 返回的是去除头尾字符(或空白符)的string副本，string本身不会发生改变。

例子：

' \nabc123abc \r '.strip() //'abc123abc' 去除空格,制表符换行符
'abc123abc'.strip('12') //abc123abc 结果无变化
'123abc123'.strip('12') //'3abc123' 从原字符串中剔除了'12'
'123abc12'.strip('12') //'3abc' 首先从头部开始匹配，然后再从尾部开始匹配，匹配到的就删除了
'123abc123'.strip('21') //'3abc123' 写成21还是会匹配上，因为他是将21拆成1,2依次去匹配的，遇到不匹配的就输出了。
'12121212122121213abc123'.strip('21') //'3abc123' 所有匹配上的全删除
'4123abc123'.strip('21') //4123abc123 将21拆开，从首和尾看都不匹配，直接输出

2. lstrip() 和 rstrip()

格式：
String.lstrip([chars]) //left strip
String.rstrip([chars]) //right strip

同 strip() 只是只操作一边的。

2-3 字符串基础操作（二）

1. 判断字符串开头结尾字符

格式：
S.starstwith('L') //判断字符串是否是以L开头
S.endswith('n') //判断字符串是否是以n结尾

例子：

'apple'.startswith('a') //True
'apple'.endswith('e')   //True

2. 返回字符串中字符的位置

格式：
S.find('X') 找到这个字符返回下标，存在多个时返回第一个，不存在时返回-1.
S.index('X') 找到这个字符返回下标，存在多个时返回第一个，不存在时报错

例子：

'apple'.find('p')
'apple'.index('p') //1
'apple'.index('q') //报错

3. 字符串替换

格式：
S.replace(oldstr, newstr)

例子：

'lemon'.replace('m', 'mmm') //'lemmmon'
'lemon'.replace('lemon', 'apple') //'apple'

4. 字符串其它操作

格式：
len(S) 返回字符串长度
S.count('x') 查找某个字符在字符串里面出现的次数
S.upper() 将字符串中的小写字母转换为大写字母
S.lower() 将字符串中的大写字母转换为小写字母
S.center(n, '-') 把字符串放中间，两边用-补齐，n为字符串的长度，若n小于等于字符串长度，则返回原值

例子：

len('apple') //5
'apple'.count('p') //2
'apple'.upper() //'APPLE'
'APPLE'.lower() //'apple'
'apple'.center(11, '-') //'---apple---'
'apple'.center(5, '-') //'apple' 小于等于原字符串长度，直接返回原字符串

 

2-4 字符串进阶操作

1. 字符串格式化

方式有2钟：% 和 format

%用法：
%s 使用str()函数进行字符串转换
%d 转为十进制
%f 转为浮点数

%例子：

'hello %s, %s' %('apple', 'python') //'hello apple, python' 前面有多少个%s后面就要跟多少个字符串
'%d' %(3) //3
'I am %d years old' %(16) //'I am 16 years old'
'I am %(name)s, %(age)s years old' %{'name':'xiaoming', 'age':16} //'I am xiaoming, 16 years old' 在%s中间加变量名
'%f' %(3.14) //'3.140000' 默认6位小数
'%.3f' %(3.14) //'3.140'

format例子：

'hello {}'.format('world') //'hello world'
'{1},{0},{1},{1}'.format('hello','world') //'world,hello,world,world' 1和0代表的是后面字符串的序号
'hello {1} {0}'.format('lemon', 'python') //'hello python lemon' 前面可以指定次序
'I am {name},I am {age} years old'.format(name="xiaoming", age='8') //'I am xiaoming,I am 8 years old'

 

2-5 Number(整型、浮点型与复数）

1. 进制转换

bin 向2进制转换
oct 向8进制转换
int 向10进制转换(注：python2中有int和long，python3中删除了long，但int和python2中的long含义相同了)
hex 向16进制转换

例子：

bin(10) //'0b1010'
oct(10) //'0o12'
int(10) //10
hex(10) //'0xa'

2. 浮点型

常见带小数的，如3.14、1.2、1.5等。
其它书写格式：10. 小数部分为0可不写；.12 整数部分为0可不写；2e-5 2乘以10的-5次方

10. //10.0
.12 //0.12
type(10) //int
type(10.0) //float
print(type(3+1)) //<class 'int'>
print(type(3+1.0)) //<class 'float'>
print(type(3/1)) //<class 'float'> python中相除默认返回浮点型
print(type(3//1)) //<class 'int'> 整除(求商)还是int型

3. 复数

complex([real[, imag]]) real是实部，必填参数，imag虚部，是可选参数。

complex(3) //(3+0j)
complex(3, 4) //(3+4j)
complex(3, 4).real //3.0
complex(3, 4).imag //4.0
complex('3+4j') //(3+4j) 加号两边不能有空格，否则执行报错

 

2-6 Number(数字)-布尔类型

用于判断条件是否成立，只有 True 和 False 两种返回值。不为0是True，为0 None 空时是False。小写的 true 和 false 都会报错。

int(True) //1
int(False) //0
isinstance(1, int) //True
isinstance(False, int) //True
bool(0) //False
bool(None) //False
bool('') //False
bool(' ') //True
bool() //False
bool([]) //空的列表返回False
bool({}) //空的集合返回False

 

2-7 列表的介绍及基本操作(一)

Python中常见的数据类型有很多种，常见的有列表、元组、字典。

a. 列表，可以把大量数据放在一起，进行集中处理。列表是'[]'包围的数据集合，不同成员以','分隔。列表中可以包含任何数据类型，列表通过下标索引其中成员。
b. 列表，是有序的序列，每个元素都分配一个下标索引，从0开始。

例子：

list() //[] 创建一个空列表
[] //[] 也可以直接使用方括号创建一个空列表
[1,] 或 [1] //创建只有一个元素的列表
[1, 2, 3, 4] //[1, 2, 3, 4] 创建4个元素的列表
['a', 1, 2, 3.14, [1, 2, 3]] //['a', 1, 2, 3.14, [1, 2, 3]] 列表中再创建一个列表

['a', 1, 2, 3.14, [1, 2, 3]][0] //'a' 获取列表中的首个元素
['a', 1, 2, 3.14, [1, 2, 3]][4] //[1, 2, 3] 取列表中的列表
['a', 1, 2, 3.14, [1, 2, 3]][4][2] //[1, 2, 3] 取列表中的列表中的元素

[1, 2] + [3, 4] //[1, 2, 3, 4] 列表之间的相加操作，但是不支持列表之间的相减操作

[1] * 5 //[1, 1, 1, 1, 1] 列表的相乘操作，列表也是不支持相除操作的
[1, 2] * 5 //[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

 

2-8 列表的介绍及基本操作(二)

列表进阶操作

list.count(X) 统计列表中X出现的次数，若不存在则返回0
list.append(X) 向列表尾部追加成员X
list.extend(L) 向列表尾部追加另外一个列表L
list.index(X) 返回参数X在列表中的序号，若不存在则报错
list.insert(index, object) 向列表指定位置插入数据
list.pop() 默认删除列表尾部成员，并返回删除的成员
list.remove(X) 删除列表中指定成员，若有多个则只删除第一个，若指定成员不存在则报错
list.reverse() 将列表中的成员顺序颠倒
list.sort() 将列表中的成员排序(要求成员间可排序，否则报错, 需要是同一数据类型)

例子：

a=[1, 2, 3, 4, 2]; a.count(2) //2 列表中2出现的次数
a=[1, 2, 3, 4, 2]; a.append(4); a //[1, 2, 3, 4, 2, 4]
a=[1, 2, 3, 4, 2]; a.append([5, 6, 7]); a //[1, 2, 3, 4, 2, [5, 6, 7]] 追加，直接是一个列表
a=[1, 2, 3, 4, 2]; a.extend([5, 6, 7]); a //[1, 2, 3, 4, 2, 5, 6, 7] 拓展，放在原来列表中
a=[1, 2, 3, 4, 2, 5, 6, 7]; d=['a', 'b', 'c']; a.insert(2, d); a //[1, 2, ['a', 'b', 'c'], 3, 4, 2, 5, 6, 7] 插入
a=[1, 2, 3]; a.pop(); a //[1, 2]
a=[1, 2, 3]; a.pop(1); a //[1, 3] 删除指定下标的数据，pop()的参数是下标
a=[11, 12, 33, 12]; a.remove(12); a //[11, 33, 12] 删除的直接是元素

 

2-9 元组（tuple）

元组基本形式：小括号'()'包围的数据集合，可以通过序号访问元素。
元组可以理解为一种特殊的列表
元组一旦创建，是不可变的。但是当元组元素为列表或字典数据类型时，列表或字典内的内容是可以变的。

例子：

() 或 tuple() //创建一个元组
(1, ) //创建只有一个元素的元组，逗号不可以省略，type((1))是int, type((1, ))是tuple。
a=(11, 22, 33); a[1] //22 访问元组元素
a=(11, 22, 33); a[1] = 10 //报错，元组元素不支持修改
a=(11, 22, 33, [4, 5, 6]); a[3][1] = 10; a //(11, 22, 33, [4, 10, 6]) 元组中元素是列表，列表中的内容可以更改

元组常见函数
len(tuple) //返回元组元素数量
max(tuple) //返回元组最大值
min(tuple) //返回元组最小值
tuple(seq) //将序列转为元组

例子：

a=(1, 2, 3, 4); len(a) //4
a=[1, 2, 3]; type(a) //list
a=[1, 2, 3]; type(a); b=tuple(a); type(b) //tuple 将list列表转换为tuple元组

 

2-10 Dict字典基本操作（一）

字典，是Python中比较常用的数据类型，每个成员以键值对的形式存在。
基本格式：大括号'{}'包围的数据集合。
字典是无序的，通过键访问成员，而不能通过序号位置。
字典的键是不可变的，如字符串、数字和元组数据类型，值可以为任意数据类型。
字典的键最好唯一，创建时若同一个键被赋值多次，则最后一个值被记住。

例子：

{} 或 dict{} //创建空字典
fruits = {'lemon': 5, 'apple': 10} //创建字典
fruits = {'lemon': 5, 'apple': 10}; fruits['lemon'] //根据key获取value
fruits = {'lemon': 5, 'apple': 10}; fruits['pear'] //通过字典中不存在的键访问，报错
fruits = {'lemon': 5, 'apple': 10}; fruits['lemon']=20; fruits //{'lemon': 20, 'apple': 10} 更改字典中的值
fruits = {'lemon': 5, 'apple': 10}; fruits['pear']=15; fruits //{'lemon': 5, 'apple': 10, 'pear': 15} 字典中新增一个成员
fruits = {'lemon': 5, 'apple': 10}; del fruits['lemon']; fruits //{'apple': 10} 删除字典中的成员
fruits = {'lemon': 5, 'apple': 10}; del fruits //将整个字典给删除，再访问字典就报错
fruits = {'lemon': 5, 'apple': 10}; fruits.clear(); fruits //{} 清空字典中的元素
fruits = {'lemon': 5, 'apple': 10, 'apple': 13}; fruits //{'lemon': 5, 'apple': 13} 键重复，最后一个值被记住

注意事项：
字典的键是不可变的，值可以是任意数据类型。键的数据类型可以为字符串、数字、元组，不可变数据类型，不能为列表类型。
字典的键最好唯一，创建时如果同一个键被赋值多次，最后一个值会被记住。

2-11 Dict字典基本操作（二）

字典常用函数

dict.copy() 复制字典
dict.get(key, default=None) 获取key对应的值，若key不存在则返回default
dict.items() 获取由键和值组成的迭代器
dict.keys() 获取键的迭代器
dict.values() 获取值的迭代器
dict.pop(key, [default]) 删除key:value的指定的成员对。若key不存在，则返回default
dict.popitem() 从字典末尾删除key:value, 并返回key:value
dict.update({key:value}) 从另一个字典更新成员（存在则覆盖，若不存在就创建）
dict.setdefault(key, default=None) 若字典存在key，则返回对应的值(不会覆盖原值)。若不存在，则建立一个key:default的字典成员。

例子：

fruits1 = {'lemon': 5, 'apple': 10}; fruits2 = fruits1; fruits2 //{'lemon': 5, 'apple': 10}
fruits1 = {'lemon': 5, 'apple': 10}; fruits2 = fruits1.copy(); fruits2 //{'lemon': 5, 'apple': 10}

fruits1 = {'lemon': 5, 'apple': 10}; fruits1.get('pear') //使用get没有的话默认返回None(就是返回空，啥也不打印)
fruits1 = {'lemon': 5, 'apple': 10}; fruits1['pear'] //直接使用这种方式去访问报错，若不想报错就用上面的get
fruits1 = {'lemon': 5, 'apple': 10}; fruits1.get('pear', 'Not exit') //'Not exit' 自己指定不使用默认返回的none

fruits1 = {'lemon': 5, 'apple': 10}; fruits1.items() //dict_items([('lemon', 5), ('apple', 10)]) 键和值都输出了
fruits1 = {'lemon': 5, 'apple': 10}; fruits1.keys() //dict_keys(['lemon', 'apple']) 获取键迭代器
fruits1 = {'lemon': 5, 'apple': 10}; fruits1.values() //dict_values([5, 10]) 获取值迭代器

fruits1 = {'lemon': 5, 'apple': 10}; fruits1.pop('lemon'); fruits1 //{'apple': 10} 从字典中弹出(删除)一个元素
fruits1 = {'lemon': 5, 'apple': 10}; fruits1.pop('pear', 'Not Exit') //'Not Exit' 弹出一个不存在的键会报错，加个default就不会报错了
fruits1 = {'lemon': 5, 'apple': 10}; fruits1.popitem() //('apple', 10) 从末尾删除一个元素并返回其值。字典empty后还删除也报错。

fruits1 = {'lemon': 5, 'apple': 10}; fruits1.update({'apple':15}); fruits1 //{'lemon': 5, 'apple': 15} 
fruits1 = {'lemon': 5, 'apple': 10}; fruits1.update({'pear':15}); fruits1 //{'lemon': 5, 'apple': 10, 'pear': 15}

fruits1 = {'lemon': 5, 'apple': 10}; fruits1.setdefault('apple', 9); fruits1 //{'lemon': 5, 'apple': 10}
fruits1 = {'lemon': 5, 'apple': 10}; fruits1.setdefault('pear', 9); fruits1 //{'lemon': 5, 'apple': 10, 'pear': 9}

2-12 Set集合类型

集合(set)是一个无序的，不重复的数据集合。由于是无序的，不能通过序号(下标)访问。
集合(set)与字典比较相似，都是无序的数据集合。字典通过键访问成员，而集合无法通过键访问成员。
可以使用 '{}' 或 set() 创建集合。
集合具有唯一性，重复成员会自动被删除。

len(S) 集合的长度
in 判断元素是否在集合中
- 求集合差集
& 求交集
| 求并集

例子：

set() //创建一个空集合，不能使用{}创建一个空集合，因为{}创建出来的是一个字典，使用 type({}) type(set()) 可看。
a={1, 2, 3}; a[0] //报错
a={1, 2, 3, 2, 1}; a //{1, 2, 3}
c=['lemon','apple', 'pear', 'apple', 'apple']; set(c) //{'apple', 'lemon', 'pear'} 使用集合对列表去重
a={1, 2, 3}; 1 in a //True 判断1是否在集合中
a={1, 2, 3, 4, 5}; b={4, 5, 6}; a-b //{1, 2, 3} 求集合的差集
a={1, 2, 3, 4, 5}; b={4, 5, 6}; a&b //{4, 5} 求集合交集
a={1, 2, 3, 4, 5}; b={4, 5, 6}; a|b //{1, 2, 3, 4, 5, 6} 求集合并集

 

2-13 Python基本数据类型总结

数字：int float complex(复数) bool(布尔型)

序列: 列表（可变序列），字符串（不可变序列），元组（不可变序列）

字典: 无序，没有索引，通过键值对访问，键是不可变的。

集合: 无序，没有索引，没有重复元素，最大特定是去重，具有唯一性。

 

2-14 补充

1. 将小数转换为百分数

num1 = 0.75
num2 = 0.85
print('%.2f%% %.1f%%' % (num1*100, num2*100)) #75.00% 85.0%