第二章: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进制转换
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(布尔型)
序列: 列表(可变序列),字符串(不可变序列),元组(不可变序列)
字典: 无序,没有索引,通过键值对访问,键是不可变的。
集合: 无序,没有索引,没有重复元素,最大特定是去重,具有唯一性。
标签:10,lemon,apple,Python,数据类型,列表,字典,fruits1 From: https://www.cnblogs.com/hellokitty2/p/17589061.html