第二章：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